final关键字：
final表示：最终的
1.final可以修饰类、成员变量、成员方法；
1).被final修饰的类，表示：最终类，不能被继承
2).被final修饰的成员变量，表示：拥有最终值，只能被赋值1次，不能被修改，
final的非static的变量，可以先声明后赋值，但只能在构造方法中赋值，而且只能被赋值一次；
final的static的变量，必须要在声明时赋值；此值在运行时不允许修改；
3).被final修饰的成员方法，表示：最终的方法，不能被重写；
继承：
1.为了增加代码复用，我们可以将现有的类中的属性和方法进行进一步抽取，形成一个"父类";
2.其它类可以"继承"自这个类，使用关键字：extends.
3.继承之后，子类将拥有可以被继承的成员变量和成员方法；
继承的特点：
1.java中只支持单继承，不支持多继承
2.但是Java中允许"多级继承"
注意：
1.不要仅为了获取其他类中某个功能而去继承
2.类与类之间要有所属( " is a " )关系，xx1是xx2的一种。
类和类之间的关系：(UML)
1.is a(是一个的关系)：继承
2.has a(有一个的关系):
class 学生{
}
class 教师{
}
class 班级{
int 楼层；//自己的属性
String 门牌号；//自己的属性
学生[] stuArray = new 学生[80];//有学员
教师 tea = new 教师();//有教师
}
3.组合关系：
class 硬盘{
}
class 主板{
}
....
class 电脑{//全部都是由其它类对象组成
硬盘 yp = new 硬盘();
主板 zb = new 主板();
...
}
4.依赖关系：
class 学生{
}
class 教师{
}
class 校长{//校长依赖于学生类和教师类，紧"耦合"
void 谈话(学生 stu){
}
void 谈话(教师 tea){
}
}
子类的构造过程
1.在构造一个子类对象之前，先构造一个父类对象
2.子类不能继承父类的private的成员属性和成员方法，在子类中可以定义和父类相同的private的成员变量
或成员方法，但是子类自己的；
3.父类的构造方法是不能被继承的；
4.当继承时，一定要仔细观察父类的构造器，我们的子类构造器一定要保证能够正确的调用父类的构造器；
当父类没有默认构造器时，子类的构造器中可以调用父类构造器，使用super()关键字；
this 和 super
1.this 是存储本类当前对象的引用；
super是存储父类对象的引用；
2.当本类内部多个构造器之间，需要互相调用时，使用this()，放在第一句话
当显示调用父类构造器时，使用super()，放在第一句话；
3.this关键字：当"局部变量"覆盖"成员变量"时(局部变量同成员变量同名)，显示调用成员变量，使用this.XXX=
super关键字：当"子类的成员(变量、方法)"覆盖"父类的成员"时，在子类中可以访问父类的同名成员，使用super.XXX
4.当父类没有默认构造器时，子类的构造器中可以调用父类构造器，使用super()关键字；
方法的重写(Override)
1.当子类需要父类的功能，而功能主体子类有自己特有内容时，可以复写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容。
2.重写的规则：
子类方法的：返回值类型、方法名、参数列表：必须完全相同；
如果只有返回值类型、方法名：编译可以通过，此方法认为是子类自己的方法
如果只有方法名、参数列表相同，返回值不同：编译错误.不能重写，要求返回值类型必须相同；
构造方法的特点及注意事项：
1.方法名同类名相同；
2.没有返回值类型，甚至是void;
3.不能返回任何值；
4.构造方法可以重载；
5.构造方法可以接收参数；
6.构造方法是自动执行，当实例化一个此类对象的时候；
7.实例化一个对象的时候，只能执行一个构造方法；
8.构造方法可以调用构造方法，使用this([参数]);
9.构造方法可以被修饰为private(私有的)；
注意：
1.如果我们不指定构造方法的话，系统会自动为我们的类添加一个默认构造方法：无参、不做任何事情；
如果我们指定了构造方法，那么系统将不再自动添加默认构造方法；
抽象类：
当一个方法不需要定义方法体，可以只有方法声明，此时，这个方法就是一个抽象方法，
抽象方法，使用关键字：使用abstract关键字修饰；
一个类中如果有一个抽象方法，那么这个类必须也被声明为abstract(抽象类)
一个类成为抽象类后，意味着：此类不能被实例化；就是用来被继承的；
如果一个子类继承一个抽象类后，必须要重写父类的抽象方法。否则，子类也必须是抽象的；
子类继承抽象类使用extends关键字，同样只能单继承；一个抽象类可以继承另一个抽象类
抽象类：
1.抽象类中可以有抽象方法，可以有普通方法；也可以有普通的成员变量
2.抽象类中可以不包含抽象方法；也可以什么都不包含；
3.抽象类中有构造方法么？
可以的。虽然抽象类不能被实例化，但抽象类可以包含构造方法，用来子类给
成员变量赋值；
4.抽象关键字abstract不可以和哪些关键字共存？
1).private :因为一个abstract方法需要被重写，所以不能修饰为private;
2).final:因为一个abstract方法需要被重写。被final修饰的方法是不能被重写的，所以不能同final共存；
3).static:因为一个abstract方法没有方法体。静态方法需要对方法体执行内容分配空间，所以不能同static共存；
5.抽象类中可不可以没有抽象方法？
抽象类中可以什么都没有！！！
模板模式：
1.抽象类作为一个模板类；
2.抽象类中要包含模板方法和基本方法；
3.模板方法要调用基本方法；
4.基本方法是抽象的，需要子类去实现；
单例模式：
在整个引用程序运行周期，对于某个类的对象，只需要一个对象存在，
此时可以将此类设为"单例模式"；
制作单例模式：
1.将默认构造器私有化，外界不能实例化此类对象；
2.声明一个私有的，静态的此类对象的引用，作为成员变量；
3.声明一个公有的，静态的获取此类对象的方法；
注意：单例，在此方法内控制；
多态：某一类事物的多种存在形态；
1.一个父类的引用指向子类对象
多态的特点：
1.当父类的引用指向子类对象时，访问被覆盖成员时，访问的是父类的；
在调用被覆盖的方法时，调用的是"子类的"。方法是运行时动态绑定的；
2.当父类的引用指向子类对象时，不能访问子类自有的成员；只能访问被覆盖的；
//类型自动向上转型：子类类型——>父类类型(自动转)
如果明确接收的子类类型，可以将父类变量强制转换为子类类型：向下转型：父类——>子类(强制转)
Student stu = (Student)obj;//传入的是Student类型OK的。如果传入的是Teacher类型： java.lang.ClassCastException（运行时）
//可以使用instanceof关键字进行判断
//双目运算符：判断左边的变量是否是右边的"类"类型。返回一个boolean值
Personnel p = new Teacher();//向上转型(自动)
Teacher t = (Teacher)p;//向下转型(强制)
多态的应用：
1.增加一个父类，让所有的人员继承自这个父类
2.修改Master类，保留一个talk方法，接收参数改为：父类类型；
3.一旦增加新人员时，只需继承自Personnel类，重写方法，Master类不需要修改；
接口：
当我们抽取出抽象方法后，如果全部都是抽象方法，可以将此类定义为"接口"
1.定义接口：使用关键字interface。没有class关键字
2.接口同抽象类，都不能被实例化，使用来被继承的；
3.一个类如果需要继承一个接口使用关键字：implements(实现)
4.一个类如果实现一个接口，必须重写接口中定义的抽象方法,访问修饰符一定要等于或大于父类的访问修饰符；如果不全部实现，这个类就是一个抽象类；
5.接口中可以定义成员变量、抽象方法：
1).接口中定义的成员变量必须被声明为：public static final
上述关键字可以不写，系统会自动添加；
2).接口中定义的成员方法，必须被声明为:public abstract
上述关键字可以不写，系统会自动添加；
作为功能扩展：
1.在Java中不允许多继承，但允许同时实现多个接口。相同的方法都只是定义，没有方法体
所以不会产生冲突；
2.一个接口可以"继承"另一个接口，使用关键字：extends，而且可以多继承
i
接口和抽象类：
相同点：
1.都不能被实例化，都是用来被继承的；
不同点：
1.抽象类：抽象类中可以有实现的方法和抽象的方法；
接口： 接口中只能包含抽象方法；
2.抽象类：抽象类使用关键字abstract class定义
接口： 接口使用关键字interface 定义
3.抽象类：子类继承抽象类使用关键字：extends，只能单继承
接口： 实现类实现接口使用关键字：implements，可以多实现；
4.抽象类：成员变量可以是普通的成员变量；
接口： 成员变量必须被修饰为：public static final
5.抽象类：抽象类中可以有构造方法；
接口： 没有构造器；
|
收藏
淘帖
踩
