2024年黑马程序员java培训就业班笔记总结.doc

Day09总结：
上午：
1、 final核心字：
Eg:代码实现：
Class Fu
{
Final void method()
{
//code...访问低层代码
}
}
Class Zi extends Fu
{
Void method()

{
Sop("haha");
}
}
以上代码体现出继承的弊端，因为父类的method的措施访问了系统的低层代码。当子类对其覆写，就不会去访问父类的meth的措施，直接用自己的method这么就出现了代码的不严谨性，因此此时需要用final核心字进行修饰。
注意为何不把类加final修饰，因为也许该类中会出现诸多功效。有些是不需要被覆写的。有些是被调用的。因此只能依照自己所需对对应的组员进行修饰。
2、 Final的特点：
1、 final是一个修饰符，能够修饰类、措施、变量(组员变量、局部变量)
2、 Final修饰的类不能够被继承。
3、 Final修饰的措施不能够被覆盖。
4、 Final修饰的变量是一个常量，只能被赋值一次。是为了增强阅读性，只要数据是固定的，就将这个数据用一个名称来表示，并用final修饰。常量名称都是大写字母，多个单词组成时用下划线来分隔。
代码体现：
Eg:
Class Zi
{
Static final int num=90;
//必须对变量进行初始化，不懂得要最后化哪个值，因此必须对它进行初始化。加静态也是同样的，同样的道理，并且被初始化，此时静态和final没有必然的联系。当变量被final修饰时，阐明变量已经是一个常量值，此时不能被修饰，能够用static来修饰。
Public stati double PI=3.14;
Void method()
{
Final int x=4;
X=8;
Sop(num);//既然是在操作一个固定的值。为何不把4直接写在此处，假如这么做的的话，阅读性极差，你根本就不懂得它所代表什么？为了增强阅读性，此时数据是不变化的，因此我们需要给它起个名字，并且用final来修饰。这么的话它也是固定的不变的。
注意：被final修饰的数值只能被覆写一次，并且修饰的常量名所有大写，多个单词组成时用下划线进行分隔。Eg:final int PERSON_AGE=4;
}
}
3、 抽象类：
特点：
1、 没有措施体的措施，称为抽象措施，必须存储在抽象措施类中，抽象措施和抽象类必须用abstract核心字来修饰，
2、 抽象类不能够被实例化，为何？因为调用抽象措施没故意义？为何？因为它连措施体都不存在？
3、 抽象类必须由其子类将抽象类中的抽象措施都覆盖后其子类才能够被实例化，否则该子类还是抽象类。
Eg:
Abstract class Demo
{
Abstract void show();
}
Class SubDemo extends Demo

Void show(){}
//此时把父类中抽象措施覆盖，此时才能被实例化。
}
例如水果，它就是抽象的，不详细它包括各种各样的水果，每种水果有它自己的体现。

抽象类包括的问题？
1、 抽象类中是否能够定义非抽象的措施？
能够 首先抽象类是一个类，类是用来描述事物，只不过描述事物过程中有些信息不详细，抽象类和一般类异同点：
相同：抽象类和一般类都用于描述事物，都能够定义组员。
不一样：抽象类中能够定义抽象组员函数，（抽象要么修饰类要么修饰函数）而一般类不能够。
抽象类不能够实例化，一般类能够实例化。
2、 抽象类中是否有结构函数？
有，并且抽象类虽然自身不能够被实例化，不过其子类覆盖了所有的抽象措施后，是能够实例化的。因此抽象类的结构函数是用于给其子类对象进行实例化。
3、 抽象类一般都是一个父类？
是、因为需要子类去覆盖父类中的抽象措施。
代码体现：
Abstract class Demo{
Abstract voif show1();
Abstract void show2();
}
Abstract class SubDemo extends Demo
{
Void show1();
}
Class Test extends SubDmeo
{
Void show2();
}

4、 抽象类中可不能够不定义抽象措施？
能够；看上去没有什么意义，其实有点意义，就是不让这个类创建对象，为何不让创建？
代码体现：
interface InterTest//这是一个测试接口，有4种测试方式。
{
void test1();
void test2();
void test3();
void test4();
}
abstract class InterTestImpl implements InterTest//用这个类进行所有的空实现。不过创建对象是毫无意义的。因此用抽象。
{
public void test1(){}
public void test2(){}
public void test3(){}
public void test4(){}
}
class Test2 extends InterTestImpl
{
public void test2(){}
}
class Test3 extends InterTestImpl
{
public void test3(){}
}
/*
class InterTestImpl implements InterTest
{
public void test2()//
{
sop("testimpl test2");
}
public void test1(){}//这么做实现太麻烦。代码重复。怎样改进？
public void test3(){}
public void test4(){}
}
*/

5、 抽象核心字 不能够和那些核心字共存？
Final：修饰了类是一个最后类，不能够被继承，然后abstract修饰的类必须是父类，需要被继承、冲突、非法的修饰符组合，abstract 和final
Static:抽象措施被static修饰，就具备了能够被类名直接调用的的特点，不过抽象措施被调用没故意思。
Priavte：因为抽象措施被私有，无法被覆盖。

代码体现： 雇员实例：
需求：企业中程序员有姓名、工号、薪水、工作内容。
项目经理除了姓名、工号、薪水、尚有奖金、工作内容
进行数据建模
做问题领域的分析就是找出问题领域的对象。

分析:
在这个问题领域中有两个对象：
程序员：
属性：姓名，工号，薪水
行为：工作内容
项目经理：
属性：姓名、工号、薪水、奖金
行为：工作内容。

这时候不能用项目经理去继承程序员。因为职能不一样，不过有共性，只能抽取。
就有了员工：
属性：姓名，工号，薪水
行为：工作内容

*/
abstract class Employee
{
private String name;
private String id;
private double pay;
Employee(String name,String id,double pay)
{
this.name=name;
this.id=id;
this.pay=pay;
}
public abstract void work();//工作内容是无法懂得的。
}
class Programmer extends Employee
{
Programmer(String name,String id,double pay)
{
super(name,id,pay);
}
public void work()
{
System.out.println("code");
}

}

class Manager extends Employee
{
private double bonus;
Manager(String name,String id,double pay)
{
super(name,id,pay);
this.bonus=bonus;
}
public void work()
{
System.out.println("manage");
}
}
4、 接口：
格式：interface{}
体现特点：
1、 里面的措施都是抽象的。
2、 接口中的组员都有固定的修饰符，最常见的组员：全局常量抽象措施。只是最常见，不代表只有它们没有其他的，
全局常量，共有的不需要对象，直接用接口调用的，不可变的。
体现形式：Public static final
抽象措施：public abstract
3、 接口的组员都是public的。
4、 接口是不能够创建对象的。就相称于是抽象的特殊体现形式。（不过有区分和抽象类）
5、 类与类之间是继承关系，类与接口之间是实现关系。
6、 接口的出现能够多实现，防止了单继承的不足。
7、 一个类在继承一个类的同时，还能够实现多个接口、
8、 接口与接口之间是继承关系，并且能够多继承，以为接口的措施都没有主体。
思想特点：
1、 对外暴露的规则。
外设要介入计算机中，因为计算机外面提供了接口，这就是规则。
2、程序的功效扩展
3、减少了耦合性
4、用来多实现
结合电脑主板的思想进行论述，它是个规则，。对外提供的规则
它提升了我们功效的扩展性，减少了耦合性。
主板和声卡：主板使用规则，声卡实现规则。

与抽象类的区分：抽象类有单继承的不足，接口没有

5、 java对多继承记住改良，以多现实接口的方式来体现。
差异：多继承因为父类中有相功效时，会导致不确定性。
为何能够实现多实现？
因为继承中父类的措施有措施体？这才是导致不确定性的根本原因，而此处是没有措施体的。
代码体现：
interface A
{
//int show();//这么是不能够的。无法覆盖。
void show();
}
interface B
{

// void method();
void show();//当有重复的措施时。不过此时子类复写它是能够的，为何？
//因为继承中父类的措施有措施体。这才是导致不确定性的根本原因。而
//此处是没有措施体的。
}
class C extends D implements A,B//多实现。此时c必须覆盖两个措施
{
public void show(){}
//public void method(){}

}
//一个类在继承一个的类的时候还可实现多实现
class D
{
public void function();
}
//接口之间是能够继承，并且支持多继承。
interface InterA
{
void showA();
}
interface InterB
{
void showB();
}
interface InterC extends InterA,InterB//为何此处能够实现多继承，因为措施没有主体。
{
void showC();
}

class InterfaceDemo2
{
public static void main(String[] args)
{
C c=new C();
c.show();
System.out.println("Hello World!");
}
}
6、 抽象类和接口之间的区分：
共性：它们都是不停抽取出来的抽象非概念
区分：1、抽象类只能被单继承、接口能够被多实现，防止了单继承的不足。
2、抽象类中能够定义抽象措施，和非抽象措施，它能够用于定义体系的基本共性的内容。接口中只能定义抽象措施，它重要用于对象的功效的扩展。
3、抽象类是继承关系，是is a关系，接口是实现关系是like a关系。
4、抽象类中的组员修饰符都是自定义的，接口中的修饰符都是固定的。
记住：不要把接口狭义的了解为interface,应当了解广义些，就是对外提供的规则，凡是对外暴露的都能够是接口。
实当代码：
1、 abstract class 犬
{
public abstract void 吃饭();
public abstract void 呼啸();
}
interface 搜爆
{
public void 搜爆();
}
class 搜爆犬 extends 犬 implements 搜爆//这是即具备了犬的基本特性，又具备了搜爆功效。
{
public void 搜爆(){}
public void 吃饭(){}
public void 呼啸(){}
}

class 搜爆猫 extends 猫 implements 搜爆
{
public void 搜爆(){}
}
记住： 类里面都是定义的某些基础内容，接口里面都是定义某些特性内容，这么的以便了对其进行扩展。
//抽烟的学生，抽烟是额外功效。
2、abstract class Student
{
abstract void study();
}
interface Smoking
{
void smoke();
}
class SomkeStudent extends Student implements Smoking
{
public void study(){}
public void smoke(){}
}
//烟民。学生烟民 问题领域不一样，对象的属性和行为也不一样。
abstract class Somker
{
abstract void smoke();
}
interface Study
{
void study();
}
class StudentSmoker extends Smoker implements Study
{
public void smoke(){}
public void study(){}
}

7、 多态：重点掌握
定义：某一类事物的多个存在形态。
代码实现：
class 动物
{}
class 猫 extends 动物
{

}
猫 x=new 猫();
动物 y=new 猫();//父类的引用变量指向了其子类的对象。

多态在代码中的体现，父类或者接口的引用指向了自己的子类对象。
实当代码：
class Animal
{
abstract void eat();
}
class Dog extends Animal
{
void eat()
{
sop("啃骨头");
}
void lookHome()
{
sop("看家");
}
}
class Cat extends Animal
{
void eat()
{
sop("吃鱼");
}
void catchMouse()
{
sop("抓老鼠");
}
}
class Pig extends Animal
{
void eat()
{
sop("猪饲料");
}
void gongdi()
{
sop("拱地");
}
}
class DuoTaiDemo
{
public static void main(String[] args)
{
//Cat c=new Cat();
//c.eat();
//Cat c1=new Cat();
//c1.eat();
//method(c);
//method(c1);
重要知识点：----开发都用！
Animal a=new Cat();//此处猫对象类型自动向上提升---向上转型，当指向使用体系基本功效时，能够向上转型操作。
为何体现多态性？
首先猫是一个实体，是一个猫类型，因为有了继承，是动物中的一个，把这个实体称之为动物也能够，因此它具备了两种形态，猫和动物。这便是体现了多态性。
//一旦向上转型，猫就不是猫了，已经是动物类型了。
a.catchMouse();//编译失败。

不过目前想执行猫的抓老鼠的功效怎么办？
向下转型：
Cat c=(Cat)a;//向下转型。当使用子类对象中的特有内容时，才做向下转型。
c.eat();
c.catchMouse();//此时是能够实现猫的抓老鼠的功效的。
总结：在多态转型中，至始至终只有子类对象做着类型的变化。

method(new Cat());

}
public static void method(Animal a)//Animal a=new Cat();
{

重点知识点：instanceof
if(a instanceof Cat)//对象instanceof 类型 判断详细对象是否是指定的类型。
{
Cat c=(Cat)a;//编译通过，不过不能运行，此时类型转换异常classCastException;
//此时为了程序的严谨性，需要对传入的的对象进行判断。
c.catchMouse();
}
else if(a instanceof Dog)
{
Dog d=(Dog)a;
d.lookHome();
}
a.eat();
总结：
instanceof是一个核心字，用于判断对象的类型。什么时候用？
当进行向下转型时，先判断该对象是否符合被转成的子类型。
}
}
8、 重点了解：
1、 多态的好处：提升了代码的扩展性，有了多态，前期设计好的内容能够使用后期出现的子类内容，对于指挥对象做事情这件事情，假如对象诸多，指挥起来很麻烦，抽取对象的共性类型，对该类型的事物进行指挥就会变的很简单。
2、 多态的前提：1、必须要有关系：继承、实现。
2、必须有覆盖的操作。

3、多态的弊端：前期的程序虽然能够使用后期出现的子类内容，不过只能使用子类覆盖父类中的内容，不能使用子类中的特有内容。