java基础学习_面向对象(下)01_day08总结

=============================================================================
=============================================================================
涉及到的知识点有：
1：继承(掌握)
　　(0)Java继承概述
　　(1)继承定义
　　(2)Java中如何表示继承呢？格式是什么呢？
　　(3)继承的好处
　　(4)继承的弊端
　　　　A:让类的耦合性增强。这样某个类的改变，就会影响其他和该类相关的类。
　　　　B:打破了封装性。
　　(5)Java中继承的特点
　　(6)继承的注意事项
　　　　A:Java中类只支持单继承，不支持多继承。
　　　　B:Java中可以多层(重)继承(继承体系)
　　(7)那么什么时候使用继承呢？
　　　　A:继承体现的是：is a的关系。
　　　　B:采用假设法。
　　(8)Java继承中的成员关系
　　　　A:成员变量
　　　　B:构造方法
　　　　C:成员方法
　　(9)方法重写：(方法=成员方法)
　　(10)方法重写的两个面试题
　　　　A:Override和Overload的区别？Overload是否可以改变返回值类型？
　　　　B:this和super的区别和各自的作用？
　　(11)数据初始化的面试题
　　　　A:一个类的初始化过程
　　　　B:子父类的构造执行过程
　　　　C:子父类的初始化(分层初始化)
　　(12)继承案例
　　　　A:学生和老师案例
　　　　B:猫狗案例的分析和实现
=============================================================================
=============================================================================
1：继承(掌握)
　　(0)Java继承概述
　　(1)继承定义：把多个类中相同的成员给提取出来定义到一个独立的类中。然后让这多个类和该独立的类产生一个关系，这多个类就具备了这些内容。这个关系叫继承。
　　(2)Java中如何表示继承呢？格式是什么呢？
　　　　A:用关键字extends表示。
　　　　B:格式：
　　　　　　class 子类名 extends 父类名 {}
---------------------------------------
　　(3)继承的好处：
　　　　A:提高了代码的复用性。
　　　　B:提高了代码的维护性。
　　　　C:让类与类之间产生了一个关系，是多态的前提。
　　　　　　类与类产生了关系，其实也是继承的一个弊端：
　　　　　　　　类的耦合性增强了。
---------------------------------------
　　(4)继承的弊端：
　　　　A:让类的耦合性增强。这样某个类的改变，就会影响其他和该类相关的类。
　　　　　　开发设计的原则：低耦合，高内聚。
　　　　　　　　耦合：类与类之间的关系。
　　　　　　　　内聚：自己完成某件事情的能力。
　　　　B:打破了封装性。
　　　　　　因为我们曾经说过：一个类中的成员尽量不要让外界直接访问，子类继承父类后，那么父类的封装就被打破了。
---------------------------------------
　　(5)Java中继承的特点：
　　　　A:Java中类只支持单继承，不支持多继承。
　　　　　　即：一个类只能有一个父类，不可以有多个父类。
　　　　　　class Father {}
　　　　　　class Mother {}
　　　　　　class Son exnteds Father {} 　　//正确的
　　　　　　class Son extends Father,Mother {} 　　//错误的
　　　　　　有些语言是支持多继承的额，比如c++。其格式是：extends 类1,类2,...
　　　　B:Java中可以多层(重)继承(继承体系)
　　　　　　class A {}
　　　　　　class B extends A {}
　　　　　　class C extends B {}
---------------------------------------
　　(6)继承的注意事项：
　　　　A:子类不能继承父类的私有成员(成员变量和成员方法)。
　　　　　　其实这也体现了继承的另一个弊端：打破了封装性。
　　　　　　因为我们曾经说过：一个类中的成员尽量不要让外界直接访问，子类继承父类后，那么父类的封装就被打破了。
　　　　B:子类不能继承父类的构造方法，但是可以通过super关键字去访问父类构造方法。
　　　　　　因为构造方法比较特殊，谈不上继承，构造方法是对对象进行数据初始化的。
　　　　C:不要为了部分功能而去继承。
　　　　　　例如：
　　　　　　class A {
　　　　　　　　public void show1(){}
　　　　　　　　public void show2(){}
　　　　　　}

　　　　　　class B {
　　　　　　　　public void show2(){}
　　　　　　　　public void show3(){}
　　　　　　}

　　　　　　//我们发现B类中出现了和A类一样的show2()方法，所以，我们就用继承来体现。
　　　　　　class B extends A {
　　　　　　　　public void show3(){}
　　　　　　}
　　　　　　这样其实不好，因为这样你不但有了show2()，而且还多了show1()。
　　　　　　有可能show1()不是你想要的。
---------------------------------------
　　(7)那么什么时候使用继承呢？
　　　　A:继承体现的是：is a的关系。
　　　　　　例如：
　　　　　　　　Person
　　　　　　　　　　Student
　　　　　　　　　　Teacher
　　　　　　　　水果
　　　　　　　　　　苹果
　　　　　　　　　　香蕉
　　　　　　　　　　橘子
　　　　B:采用假设法。
　　　　　　假设有两个类A，B。只有他们符合A是B的一种，或者B是A的一种的时候，就可以考虑使用继承。
---------------------------------------
　　(8)Java继承中的成员关系：
　　　　A:成员变量
　　　　　　a:子类的成员变量名称和父类中的成员变量名称不一样时，这个太简单。
　　　　　　b:子类的成员变量名称和父类中的成员变量名称一样时，这个怎么访问呢？
　　　　　　　　在子类的方法中访问一个成员变量的查找顺序：
　　　　　　　　　　1.在子类方法的局部范围找，有就使用。
　　　　　　　　　　2.在子类的成员范围找，有就使用。
　　　　　　　　　　3.在父类的成员范围找，有就使用。
　　　　　　　　　　4.都找不到，就报错。
　　　　B:构造方法
　　　　　　a:子类的所有的构造方法默认都会去访问父类的无参构造方法。
　　　　　　　　因为子类会继承父类中的数据，可能还会使用父类的数据。
　　　　　　　　所以，子类初始化之前，一定要先完成父类数据的初始化。
　　　　　　　　特别注意：其实子类的每一个构造方法的第一条语句默认都是：super();
　　　　　　b:父类中如果没有无参构造方法(也即父类中只给了带参构造方法)，子类的构造方法怎么办？
　　　　　　　　法1:子类的构造方法通过 super(...); 去显示调用父类的带参构造方法。
　　　　　　　　法2:子类的构造方法通过 this();/this(...); 调用本类的其他的构造方法，但是子类的其他的构造方法中一定会有一个去访问了父类的带参构造方法。
　　　　　　　　法3:让父类提供无参构造。

　　　　　　　　注意事项： this();/this(...);/super(...); 这三个语句访问子类或父类的构造方法的时候，必须放在第一句语句上。
　　　　　　　　　　否则，就可能会对父类数据进行多次初始化。
　　　　C:成员方法
　　　　　　a:子类的成员方法名称和父类中的成员方法名称不一样时，这个太简单。
　　　　　　b:子类的成员方法名称和父类中的成员方法名称一样时，这个怎么访问呢？
　　　　　　　　通过子类对象访问一个成员方法的查找顺序：
　　　　　　　　　　1.在子类的成员方法中找，有就使用。
　　　　　　　　　　2.在父类的成员方法中找，有就使用。
　　　　　　　　　　3.都找不到，就报错。
---------------------------------------
　　(9)方法重写：(方法=成员方法)
　　　　方法重写：子类中出现了和父类中方法声明一模一样的方法(方法名、参数列表和返回值类型都一样)，也被称为方法覆盖、方法复写。
　　　　方法重载：本类中出现的方法名一样，参数列表不同，与返回值类型无关的方法。

　　　　方法重写的使用特点：
　　　　　　如果子类和父类的方法名不同，就调用各自对应的方法。
　　　　　　如果子类和父类的方法名相同，最终使用的是子类自己的方法。
　　　　方法重写的应用：
　　　　　　当子类需要父类的功能，而功能的主体子类还有自己特有的内容时，可以重写父类中的方法，这样，即沿袭了父类的功能，又定义了子类自己特有的内容。
　　　　方法重写的注意事项：
　　　　　　1.父类中的私有方法不能被重写。
　　　　　　　　因为父类私有方法子类根本无法继承。
　　　　　　2.子类重写父类方法时，访问权限不能更低。(最好权限要一致。)
　　　　　　　　默认的权限要小于public的权限。
　　　　　　3.父类的静态方法，子类也必须通过静态方法进行重写。
　　　　　　　　(其实这个算不上方法重写，但是现象确实如此，至于为什么算不上方法重写，多态中我会讲解。)

　　　　　　　　因为方法是跟对象相关的，而静态是跟类相关的。
　　　　　　小结：子类重写父类方法的时候，最好声明一模一样。
---------------------------------------
　　(10)方法重写的两个面试题：
　　　　A:Override和Overload的区别？Overload是否可以改变返回值类型？
　　　　　　方法重写：
　　　　　　　　在子类中，出现和父类中一模一样的方法声明的现象。(包含方法名、参数列表和返回值类型都一样)
　　　　　　方法重载：
　　　　　　　　同一个类中，出现的方法名相同，参数列表不同，与返回值类型无关的现象。
　　　　　　方法重载能改变返回值类型，因为它和返回值类型无关。
　　　　　　Override：方法重写
　　　　　　Overload：方法重载
　　　　B:this和super的区别和各自的作用？
　　　　　　this: 代表当前类的对象引用。
　　　　　　super:代表父类存储空间的标识。(可以理解为父类的引用，通过这个东西可以访问父类的成员。)
　　　　　　应用场景：
　　　　　　　　成员变量：
　　　　　　　　　　this.成员变量
　　　　　　　　　　super.成员变量
　　　　　　　　构造方法：
　　　　　　　　　　this(...)
　　　　　　　　　　super(...)
　　　　　　　　成员方法：
　　　　　　　　　　this.成员方法
　　　　　　　　　　super.成员方法
---------------------------------------
　　(11)数据初始化的面试题
　　　　A:一个类的初始化过程
　　　　　　先进行成员变量的初始化：
　　　　　　　　默认初始化
　　　　　　　　显示初始化
　　　　　　　　构造方法初始化
　　　　B:子父类的构造方法发的执行过程
　　　　　　子类的所有的构造方法默认都会去访问父类的无参构造方法。
　　　　C:子父类的初始化(分层初始化)
　　　　　　先进行父类初始化，然后进行子类初始化。
---------------------------------------
　　(12)继承案例：
　　　　A:学生和老师案例
　　　　　　继承前案例
　　　　　　继承后案例
　　　　B:猫狗案例的分析和实现
　　　　　　做设计的时候，先找到具体的事物，然后发现具体的事物的共性，再提取出一个父类。
=============================================================================