------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------
一：继承(掌握)
(1)把多个类中相同的成员给提取出来定义到一个独立的类中。然后让这多个类和该独立的类产生一个关系，
这多个类就具备了这些内容。这个关系叫继承。
(2)Java中如何表示继承呢?格式是什么呢?
A:用关键字extends表示
B:格式：
class 子类名 extends 父类名 {}
(3)继承的好处：
A:提高了代码的复用性
B:提高了代码的维护性
C:让类与类产生了一个关系，是多态的前提
(4)继承的弊端：
A:让类的耦合性增强。这样某个类的改变，就会影响其他和该类相关的类。
开发的原则：低耦合，高内聚。
耦合：类与类的关系
内聚：自己完成某件事情的能力
B:打破了封装性
(5)Java中继承的特点
A:Java中类只支持单继承（一个类只能有一个父类，不可以有多个父类）
B:Java中可以多层(重)继承(继承体系) 如：class A{} class B extends A{} class C extends B{}
(6)继承的注意事项：
A:子类不能继承父类的私有成员
B:子类不能继承父类的构造方法，但是可以通过super去访问
C:不要为了部分功能而去继承
(7)什么时候使用继承呢?
A:继承体现的是：is a的关系。
B:采用假设法,如果有两个类，只要他们符合A是B的一种，或者B是A的一种，就可以考虑使用继承。
(8)Java继承中的成员关系
A:成员变量
a:子类的成员变量名称和父类中的成员变量名称不一样，这个太简单
b:子类的成员变量名称和父类中的成员变量名称一样，这个怎么访问呢?(就近原则)
子类的方法访问变量的查找顺序：
在子类方法的局部范围找，有就使用。
在子类的成员范围找，有就使用。
在父类的成员范围找，有就使用。
找不到，就报错。
c.我们不仅仅要输出局部范围的num，还要输出本类成员范围的num，这是用this.num.这里的this就相当于子类类名。
要输出父类成员范围的num，就用super关键字。super.num
d.this和super的区别。
1）this代表本类对应的引用。 super代表父类存储空间的标识（可以理解为父类的引用，可以操作父类的成员）
2）用法：this.成员变量 调用本类的成员变量。 this（参数） 调用本类的构造方法 this.成员方法() 调用本类的成员方法
super.成员变量 调用父类的成员变量。 super（参数） 调用父类的构造方法 super.成员方法() 调用父类的成员方法。
B:构造方法
a:子类的所有构造方法默认会去访问父类的无参构造方法
为什么呢？ 因为子类继承父类中的数据，可能还会使用父类的数据，所以，子类初始化之前，一定要先完成父类数据的初始化。
注意：子类每一个构造方法中第一条语句都会被系统默认为：super(),不论你写与不写，我都会占据子类构造方法第一句。
b:父类中如果没有无参构造方法，怎么办?
子类通过super去明确调用带参构造
子类通过this调用本身的其他构造，但是一定会有一个去访问了父类的构造，否则父类数据没法初始化。
让父类提供无参构造
注意：this(参数)或者super(参数)必须出现在子类构造方法的第一条语句上，如果不是放在第一条语句上，就可能对父类的数据进行了多次初始化，所以必须
放在第一条语句。
C:成员方法
a:子类的成员方法和父类中的成员方法名称不一样，这个太简单
b:子类的成员方法和父类中的成员方法名称一样，这个怎么访问呢(就近原则)?
通过子类对象访问一个方法的查找顺序：
在子类中找，有就使用
在父类中找，有就使用
找不到，就报错
(9)两个面试题：
A:Override和Overload的区别?
方法重写：子类中出现了和父类中一模一样的方法声明。又称方法覆盖，方法复写
方法重载：本类中出现了方法名一样，参数列表不同的方法，与返回值无关。
B:this和super的区别和各自的作用?
this：代表当前类的对象引用，
super：代表父类存储空间的标识，（可以理解为父类的引用，通过这个东西可以访问父类的成员）
(10)数据初始化的面试题
A:一个类的初始化过程：成员变量的初始化：默认初始化，显示初始化，构造方法初始化。
B:子父类的构造执行过程：
父类静态代码块 1
子类静态代码块 2
父类构造代码块 3
父类无参构造方法 4
子类构造代码块 5
子类无参构造方法 6
C:分层初始化（子父类的初始化）：先进行父类初始化，然后进行子类初始化。
D：虽然子类中构造方法默认有一个super(),但是初始化的时候不是按照这个默认的super()来执行的，而是按照分层初始化进行的。所以要
先初始化父类的所有数据，再初始化子类的数据。
例：
class X{
Y b=new Y();//Y
X(){
System.out.println("X");//X
}
}
class Y{
Y(){
System.out.println("Y");
}
}
public class Z extends X{
Y y=new Y();//Y
Z(){
System.out.println("Z");//Z
}
public static void main(String[]args){
new Z();
}
}
输出结果：先初始化父类：Y X,再初始化子类：Y Z. 结果是YXYZ
补充：
1：方法重写和方法重载的区别。
方法重写：子类中出现了和父类中一模一样的方法声明。又称方法覆盖，方法复写
方法重载：本类中出现了方法名一样，参数列表不同的方法，与返回值无关。
2：方法重写的注意事项。
1，父类中私有方法 不能被重写。因为父类私有方法没法继承。
2，子类重写父类方法时，访问权限不能更低。
3，子类重写父类方法时，最好声明一模一样，父类静态子类也静态。
3：案例：
A:学生案例
继承前
继承后
class Person{
private String name;
private int age;
public Person(){}
public Person(String name,int age){
this.name=name;
this.age=age;
}
public String getName(){
return name;
}
public void setName(String name){
this.name=name;
}
public int getAge(){
return age;
}
public void setAge(int age){
this.age=age;
}
}
class Student extends Person{
public Student(){}
public Student(String name,int age){
super(name,age);
}
}
class Test3{
public static void main(String[]args){
Student s=new Student();
s.setName("小石头1");
s.setAge(22);
System.out.println(s.getName()+"-----"+s.getAge());
Student s2=new Student("小石头2",22);
System.out.println(s2.getName()+"-----"+s2.getAge());
}
}
二：:多态(掌握)
(1)同一个对象在不同时刻体现出来的不同状态。如：猫 m=new 猫（）； 动物 d=new 猫（）；（猫可以是猫，也可以是动物） 水（液体 固体 气态）
(2)多态的前提：
A:有继承或者实现关系。
B:有方法重写。（通过方法重写来体现不同状态，没有重写也可以，但是如果没有重写，多态就没有意义了）
C:有父类或者父接口引用指向子类对象。Fu f=new Zi();
多态的成员访问特点：
A：成员变量
编译看左边，运行看左边。（因为变量不能被重写）
B:静态方法
编译看左边，运行看左边。（因为静态方法只和类相关，算不上重写，所以访问的还是左边）
C:构造方法
创建子类对象的时候，访问父类的构造方法，对父类的数据进行初始化。
D:成员方法
编译看左边，运行看右边。
代码体现：
class Test1{
public static void main(String[]args){
Fu f=new Zi();//访问父类构造方法,访问子类构造方法
System.out.println(f.num);//10访问父类的变量
f.show();//访问父类静态方法
f.method();//访问子类成员方法
}
}
多态的分类：
a:具体类多态
class Fu {}
class Zi extends Fu {}
Fu f = new Zi();
b:抽象类多态
abstract class Fu {}
class Zi extends Fu {}
Fu f = new Zi();
c:接口多态
interface Fu {}
class Zi implements Fu {}
Fu f = new Zi();
(3)多态中的成员访问特点
A:成员变量
编译看左边，运行看左边
B:构造方法
子类的构造都会默认访问父类构造
C:成员方法
编译看左边，运行看右边
D:静态方法
编译看左边，运行看左边
为什么?
因为成员方法有重写。
(4)多态的好处：
A:提高代码的维护性(继承体现)
B:提高代码的扩展性(多态体现)
(5)多态的弊端：
父不能使用子的特有功能。
现象：
子可以当作父使用，父不能当作子使用。
解决办法：
A:创建子类对象的调用方法即可，（这种方式可以，但是很多时候不合理，而且创建对象过多太占内存）
B:把父类的引用强制转换为子类的引用（向下转型）
(6)多态中的转型
A:向上转型
从子到父 Fu f=new Zi(); 父类引用指向子类对象。
B:向下转型
从父到子 父类引用转为子类对象。 Zi z=(Zi)f //要求该f必须是能够转换为Zi的。
(7)孔子装爹的案例帮助大家理解多态
(8)多态的练习
A:猫狗案例
B:老师和学生案例