1.继承
(1)继承：子类可以自动拥有父类的非私有的成员变量和成员方法
(2)Java中如何表示继承呢?格式是什么呢?
A:用关键字 extends表示
B:格式： class 子类名 extends 父类名 {}
示例：
![]()
![]()
![]()
![]()
(3)继承的好处：
A:提高了代码的复用性 B:提高了代码的维护性 C:让类与类产生了一个关系，是多态的前提
(4)继承的弊端：
A:让类的耦合性增强。这样某个类的改变，就会影响其他和该类相关的 类。 原则：低耦合，高内聚。
耦合：类与类的关系 内聚：自己完成某件事情的能力
B:打破了封装性
(5)Java中继承的特点
A:Java中类只支持单继承（当多继承有重复的方法时，子类调用方法时无法判断是哪个方法）
B:Java中可以多层(重)继承(继承体系)
![]()
(6)继承的注意事项
A:子类不能继承父类的私有成员，只能继承父类所有的非私有成员
B:子类不能继承父类的构造方法，但是可以通过 super 去访问
![]()
C:不要为了部分功能而去继承
(7)什么时候使用继承呢 ?
A:继承体现的是： is a 的关系。 B:采用假设法
(8)Java继承中的成员关系
A:成员变量
a:子类的成员变量名称和父类中的成员变量名称不一样
b:子类的成员变量名称和父类中的成员变量名称一样， 子类的方法访问变量的查找顺序： 在子类方法的局部范围找，有就使用。 在子类的成员范围找，有就使用。 在父类的成员范围找，有就使用。 找不到，就报错。
示例a
![]()
![]()
示例b
![]()
![]()
输出： ls
![]()
输出： ww
在子类方法的局部范围找，有就使用。
在子类的成员范围找，有就使用。 在父类的成员范围找，有就使用。 找不到，就报错。
B:构造方法
a:子类的构造方法默认会去访问父类的无参构造方法 是为了子类访问父类数据的初始化
b:父类中如果没有无参构造方法，怎么办 ? 子类通过 super去明确调用带参构造 子类通过 this 调用本身的其他构造， 但是一定会有一个去访问了 父类的构造 让父类提供无参构造
C:成员方法
a:子类的成员方法和父类中的成员方法名称不一样
b:子类的成员方法和父类中的成员方法名称一样，这个怎么访问呢 ?
通过子类对象访问一个方法的查找顺序： 在子类中找，有就使用 在父类中找，有就使用 找不到，在父类的父类中找，有就使用；都没有就报错
类和类之间的关系：
1.继承
<strong>class Fu{}
class Zi extends Fu{}</strong>
2.组合：一个类是另一个类的成员变量
<strong>class Cat{}
class person{
Cat cat;
String name;
}</strong>
3.关联：一个类是另一个类方法的参数
<strong>class Car{}
class Driver{
public void drive (Car car){
}
}</strong>
耦合：用来形容类和类之间的关系，耦合性越强说明类和类之间的关联越强
耦合性：继承 > 组合 > 关联
面试题：
1.Override 和 Overload 的区别 ?Overload 是否可以改变返回值类型 ?
答：方法重写：在父子类中，子类重写父类的方法，出现和父类中一模一样的方法声明的现象。
特点：1.如果方法名不同，调用对应的方法
2.如果方法名相同，最终使用的是子类自己的
注意：1.父类中私有方法不能被重写
2.子类重写父类方法时，访问权限要更高
3.父类静态方法，子类也必须通过静态方法进行重写
方法重载：同一个类中，出现的方法名相同，参数列表不同的现象。方法重载能改变返回值类型，因为它和返回值类型无关。
2.this 和 super 的区别和各自的作用 ?
答 ：this: 代 表 当 前 类 的 对 象 引 用
super: 代表父类存储空间的标识。 (可以理解为父类的引用， 通过这个东西可以访问父类的成员 )
数据初始化的面试题
A:一个类的初始化过程
1.成员变量的初始化默认初始化
2.显示初始化
3.构造方法初始化
B:子父类的构造执行过程：先进行父类初始化，然后进行子类初始化。
2.final 关键字
(1)是最终的意思，可以修饰类，方法，变量。
(2)特点：
A:它修饰的类，不能被继承。
B:它修饰的方法，不能被重写（可以被继承）。
![]()
![]()
C:它修饰的变量，是一个常量（只能被赋值一次，不能再更改）
![]()
输出：ls
final 修饰后
![]()
![]()
不赋值会报错
![]()
![]()
![]()
![]()
输出：张三 6
final 修饰形参
![600]()
报错
(3)面试相关：
A:局部变量
a:基本类型值不能发生改变 b: 引用类型地址值不能发生改变，但是对象的内容是可以改变的
B:初始化时机
a:只能初始化一次。b: 常见的给值定义的时候。 (推荐 )构造方法中。
3.多态 ( 掌握 )
(1)定义：同一个对象在不同时刻体现出来的不同状态(同一个变量调用同一个方法，执行不同的代码)。
![]()
输出：动物吃
![]()
输出：小猫吃鱼
![]()
![]()
多态示例：
![]()
![]()
输出：小狗吃肉
(2)多态的前提：
A:有继承或者实现关系。
B:有方法重写。
C:有父类或者父接口引用指向子类对象。
![]()
（3）多态的分类：
a:具体类多态
<strong>class Fu {}
class Zi extends Fu {}
Fu f = new Zi(); </strong>
b: 抽象类多态
<strong>abstract class Fu {}
class Zi extends Fu {}
Fu f = new Zi(); </strong>
c:接口多态
<strong>interface Fu {}
class Zi implements Fu {}
Fu f = new Zi();</strong>
(3)多态中的成员访问特点
A:成员变量：编译看左边，运行看左边（无多态）
B:构造方法：子类的构造都会默认访问父类构造
C:成员方法：编译看左边，运行看右边
D:静态方法：编译看左边，运行看左边（无多态）
(4)多态的好处：
A:提高代码的维护性 (继承体现 ) B:提高代码的扩展性 (多态体现 )
(5)多态的弊端：
父不能使用子的特有功能。
现象：
子可以当作父使用，父不能当作子使用。
(6)多态中的转型
A:向上转型 ：从子到父
B:向下转型：从父到子
示例：
![]()
4.抽象类 ( 掌握 )
(1)把多个共性的东西提取到一个类中，这是继承的做法。
但是呢，这多个共性的东西，在有些时候，方法声明一样，但是方法体不一样。
也就是说，方法声明一样，但是每个具体的对象在具体实现的时候内容不一样。
所以，我们在定义这些共性的方法的时候，就不能给出具体的方法体。
而一个没有具体的方法体的方法是抽象的方法。
![]()
在一个类中如果有抽象方法，该类必须定义为抽象类。
![]()
(2)抽象类的特点
A:抽象类和抽象方法必须用关键字 abstract 修饰
B:抽象类中不一定有抽象方法 ,但是有抽象方法的类一定是抽象类
C:抽象类不能实例化，就是用来被继承的（强制继承类中的方法，这个抽象类实际上是定义规范的）
D:抽象类的子类
a:是一个抽象类。 b: 是一个具体类。这个类必须重写抽象类中的所有抽象方法。
(3)抽象类的成员特点：
A:成员变量：有变量，有常量
B:构造方法：有构造方法，不能实例化
C:成员方法：有抽象，有非抽象
(4)抽象类的练习
A:猫狗案例练习B:老师案例练习C:学生案例练习D:员工案例练习
(5)抽象类的几个小问题
A:抽象类有构造方法，不能实例化，那么构造方法有什么用 ?
用于子类访问父类数据的初始化
B:一个类如果没有抽象方法 ,却定义为了抽象类，有什么用 ?
可以，为了限制类的实例化，只想让继承
C:abstract 不能和哪些关键字共存
a:final 冲 突 （final 类不能被继承，abstract抽象类只能被继承）
b:private 冲 突 （私有的不能被继承）
c:static 无意义 （static 本来就不能实例化，不能继承）
参数传递
![]()
![]()
![]()
![]()
![]()
问题：猎人拿着猎枪去打猎物，拿着猎物去酒吧换酒
类：猎人 猎枪 猎物 酒吧 酒
![]()
![]()
![]()
输出：孟凡宝拿着AK47打了一个小兔子
![]()
![]()
![]()
![]()
思路
![]()
输出： ls
