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 修饰形参

报错

(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打了一个小兔子

思路