本节目标：
1.掌握继承及用法
2.了解继承的组合
3.掌握多态的用法
目录
前言
我们知道，面向对象语言的三大特性是封装，继承和多态。在上一节，我们了解了什么是封装及封装的用法。在这一节，我们要了解oop的另外两个特性——继承和多态。
一、继承
1.1为什么要用到继承？
通俗地讲，java中的继承有些类似现实生活中的继承关系，子女会继承父母的财产，因为java是面向对象的思想，我们可以将子和父都看成一个对象，所以java中的类也有这种继承关系，例如，狗和猫狗都是动物，所以我们可以把动物看成父类，把猫和狗看成子类。
我们先分别定义一个猫和狗的类，代码如下：
class Dog { public String name; public int age; public void bark() { System.out.println(name+"正在汪汪叫"); } public void eat() { System.out.println(name+" 正在吃饭"); } } class Cat { public String name; public int age; public void miaomiao() { System.out.println(name+" 正在喵喵叫"); } public void eat() { System.out.println(name+" 正在吃饭"); } }
此时我们发现， 上述代码中有很多重复代码
有什么办法可以将这些重复的代码提取出来，大家都可以调用呢。这时就要用用到继承的思想了。我们可以将代码共性进行抽取，创建一个新的类Animal，用来放置重复代码。
class Animal {
public String name;
public int age;
public void eat() {
System.out.println(name+" 正在吃饭");
}
}
然后将Dog类和Cat类与Animal建立连接，使用关键字 extends ，此时Animal为父类，Dog和Cat类为子类。继承之后，子类可以复用父类中成员，子类在实现时只需关心自己新增加的成员即可。
class Dog extends Animal{
public void bark() {
System.out.println(name+"正在汪汪叫");
}
}
class Cat extends Animal{
public void miaomiao() {
System.out.println(name+" 正在喵喵叫");
}
}
1.2 继承的概念
继承
：是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特 性
的基础上进行
扩展，增加新功能
，这样产生新的类，称
派生类
。父类也被称为基类或超类。继承呈现了面向对象程序设计的层次结构， 体现了 由简单到复杂的认知过程。继承主要解决的问题是：共性的抽取，实现代码复用
。
注意：
1.
子类会将父类中的成员变量或者成员方法继承到子类中
2.
子类继承父类之后，要新添加自己特有的成员，体现出与基类的不同，否则继承就没有意义了。
1.3 父类成员的访问
1.子类和父类不存在同名成员变量
public class Animal {int a ;int b ;}public class Dog extends Animal {int c ;public void method (){a = 10 ; // 访问从父类中继承下来的 ab = 20 ; // 访问从父类中继承下来的 bc = 30 ; // 访问子类自己的 c}}
2. 子类和父类成员变量同名
public class Test { int a = 5; int b = 4; int c = 3; } class Dog extends Test{ int a; int b; public void method(){ a = 100; b = 101; c = 102; System.out.println(a); System.out.println(b); System.out.println(c); } public static void main(String[] args) { Dog dog = new Dog(); dog.method(); } }
最终打印结果：
我们得到结论，成员变量的访问遵循就近原则，子类有优先访问子类自己的，子类没有再去调用父类的。调用成员方法时同理。
1.4 super 关键字
super
关键字，该关键字主要作用：指定子类调用父
类中的成员变量或成员方法
。
语法是： super . 成员变量
super . 成员方法
super （ ） 调用父类构造方法
代码如下：
class Test { int a = 5; int b = 4; int c = 3; } class Dog extends Test{ int a = 100; int b = 500; public void func() { System.out.println(super.a); } public static void main(String[] args) { Dog dog = new Dog(); dog.func(); } }
最终打印结果，a = 5，调用了父类的成员变量。
要注意一点的是：super不能用在静态方法中，所以无法在main方法中调用，我们重新写了一个非静态的 func 方法，然后在main方法中调用func方法，就能够得到想要的结果。
super关键字总结：
1.
只能在非静态方法中使用
2.
在子类方法中，访问父类的成员变量和方法
。
1.5 子类构造方法
父子父子，先有父再有子，即：子类对象构造时，需要先调用基类构造方法，然后执行子类的构造方法。所以，子类在构造完成之前，一定要先帮父类进行构造。
class Animal {
public String name;
public int age;
public Animal(String name, int age) { // 父类的构造方法
this.name = name;
this.age = age;
System.out.println("Animal (String name,int age)");
}
public void eat() {
System.out.println(name+" 正在吃饭");
}
}
class Dog extends Animal{
public Dog (String name,int age) {
super(name,age); //调用父类的构造方法，帮助初始化子类从父类继承过来的成员，并不会生成父类对象
System.out.println("Dog (String name,int age)");
}
public void bark() {
System.out.println(name+"正在汪汪叫");
}
}
class Cat extends Animal{
public Cat (String name,int age) {
super(name,age);
System.out.println("Cat (String name,int age)");
}
public void miaomiao() {
System.out.println(name+" 正在喵喵叫");
}
}
注意：
1.
若父类显式定义无参或者默认的构造方法，在子类构造方法第一行默认有隐含的
super()
调用，即调用基类构 造方法
2.
如果父类构造方法是带有参数的，此时需要用户为子类显式定义构造方法，并在子类构造方法中选择合适的 父类构造方法调用，否则编译失败。
3.
在子类构造方法中，super(...)调用父类构造时，必须是子类构造函数中第一条语句。
4.
super(...)只能在子类构造方法中出现一次，并且不能和this同时出现
1.6 super 和 this
相同点：
1. 只能在类的非静态方法中使用，用来访问非静态成员方法和字段
2.
在构造方法中调用时，必须是构造方法中的第一条语句，并且不能同时存在
不同点：
1. this
是当前对象的引用，当前对象即调用实例方法的对象，super相当于是子类对象中从父类继承下来部分成员的引用
2.
在非静态成员方法中，
this
用来访问本类的方法和属性，
super
用来访问父类继承下来的方法和属性
3.
在构造方法中：
this(...)
用于调用本类构造方法，
super(...)
用于调用父类构造方法，两种调用不能同时在构造方法中出现
4.
构造方法中一定会存在
super(...)
的调用，用户没有写编译器也会增加，但是
this(...)
用户不写则没有
1.7 再谈初始化
还记得之前讲过的代码块吗？我们简单回顾一下几个重要的代码块：实例代码块和静态代码块。在没有继承关系时的执行顺序。
class Animal { public String name; public int age; public Animal(String name, int age) { this.name = name; this.age = age; System.out.println("Animal (String name,int age)"); } static { System.out.println("Animal::{静态代码块}"); } { System.out.println("Animal::{实例代码块}"); } public void eat() { System.out.println(name+" 正在吃饭"); } } class Dog extends Animal{ public Dog (String name,int age) { super(name,age); //调用父类的构造方法，帮助初始化子类从父类继承过来的成员，并不会生成父类对象 System.out.println("Dog (String name,int age)"); } static { System.out.println("Dog::{静态代码块}"); } { System.out.println("Dog::{实例代码块}"); } public void bark() { System.out.println(name+"正在汪汪叫"); } } class Cat extends Animal{ public Cat (String name,int age) { super(name,age); System.out.println("Cat (String name,int age)"); } public void miaomiao() { System.out.println(name+" 正在喵喵叫"); } } public class Test { public static void main(String[] args) { Dog dog = new Dog("black",5); } public static void main1(String[] args) { Dog dog = new Dog("xiaohei",2); dog.bark(); dog.eat(); System.out.println("--------------------"); Cat cat = new Cat("huahua",1); cat.miaomiao(); cat.eat(); } }
最终打印结果：
通过分析执行结果，得出以下结论：
1、父类静态代码块优先于子类静态代码块执行，且是最早执行
2、父类实例代码块和父类构造方法紧接着执行
3、子类的实例代码块和子类构造方法紧接着再执行
4、第二次实例化子类对象时，父类和子类的静态代码块都将不会再执行
1.8 protected 关键字
还记得上节讲过的四个访问修饰限定符吗，其中有一个关键字 protected 上节没有介绍到，他主要用于继承。
| 范围 | public | protected | default | private |
| 同一包中同一类 | √ | √ | √ | √ |
| 同一包中不同类 | √ | √ | √ | |
| 不同包中的子类 | √ | √ | ||
| 不同包中的非子类 | √ |
为什么protected 主要用于继承呢，通俗讲因为继承有时需要在不同包中继承，能够在不同包中使用的关键字只有 public 和 protected ， 但 public 是公共的，相对太不安全，所以继承中一般使用protected。
我们希望类要尽量做到
"
封装
",
即隐藏内部实现细节
,
只暴露出
必要
的信息给类的调用者
.
因此我们在使用的时候应该尽可能的使用
比较严格
的访问权限
.
例如如果一个方法能用
private,
就尽量不要用 public. 另外,
还有一种
简单粗暴
的做法
:
将所有的字段设为
private,
将所有的方法设为
public.
不过这种方式属于是对访问权限的滥用,
还是更希望同学们能写代码的时候认真思考
,
该类提供的字段方法到底给
"
谁
"
使用
(
是类内部自己用,
还是类的调用者使用
,
还是子类使用。
1.9 继承方式
但在Java中只支持以下几种继承方式：
1.单继承
2.多层继承
3.不同类继承同一个类
注意：Java中不支持多继承。
时刻牢记
,
我们写的类是现实事物的抽象
.
而我们真正在公司中所遇到的项目往往业务比较复杂
,
可能会涉及到一系列复杂的概念,
都需要我们使用代码来表示
,
所以我们真实项目中所写的类也会有很多
.
类之间的关系也会更加复杂.
但是即使如此
,
我们并不希望类之间的继承层次太复杂
.
一般我们不希望出现超过三层的继承关系
.
如果继承层次太多,
就需要考虑对代码进行重构了
.
如果想从语法上进行限制继承
,
就可以使用
fifinal
关键字
1.10 final关键字
fifinal关键可以用来修饰变量、成员方法以及类。
1.
修饰变量或字段，表示常量
(
即不能修改
)
2.
修饰类：表示此类不能被继承，被final修饰的类叫做密封类
3.
修饰方法：表示该方法不能被重写
1.11 继承与组合
和继承类似
,
组合也是一种表达类之间关系的方式
,
也是能够达到代码重用的效果。组合并没有涉及到特殊的语法 (诸如
extends
这样的关键字
),
仅仅是将一个类的实例作为另外一个类的字段。
继承表示对象之间是
is-a
的关系
，比如：狗是动物，猫是动物
组合表示对象之间是
has-a
的关系
，比如：汽车
二、多态
2.1.多态的概念
多态的概念：通俗来说，就是多种形态，
具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。总的来说：同一件事情，发生在不同对象身上，就会产生不同的结果。
2.2 多态实现条件
在
java
中要实现多态，必须要满足如下几个条件，缺一不可：
1.
必须在继承体系下
2.
子类必须要对父类中方法进行重写
3.
通过父类的引用调用重写的方法
多态体现：在代码运行时，当传递不同类对象时，会调用对应类中的方法。
class Animal { public String name; public int age; public Animal(String name, int age) { this.name = name; this.age = age; } public void eat() { System.out.println(name+" 正在吃东西"); } } class Dog extends Animal{ public Dog(String name, int age) { super(name, age); } public void bark() { System.out.println(name+" 正在汪汪叫"); } @Override //注解 //对 eat 方法进行了重写 public void eat() { System.out.println(this.name+" 正在吃狗粮！"); } } class Cat extends Animal { public Cat(String name, int age) { super(name, age); } public void miaomiao() { System.out.println(name+" 正在喵喵叫"); } @Override public void eat() { System.out.println(this.name+"正在吃猫粮"); } public static void main(String[] args) { Dog dog = new Dog("xiaobai",18); dog.eat(); dog.bark(); }
当类的调用者在编写
eat
这个方法的时候
,
参数类型为
Animal (
父类
),
此时在该方法内部并
不知道
,
也不关注
当前的 dog 引用指向的是哪个类型
(
哪个子类
)
的实例
.
此时
dog
这个引用调用
eat
方法可能会有多种不同的表现
(
和
dog
引用的实例相关),
这种行为就称为
多态
.
2.3 方法的重写
1.最基本的返回值，参数列表，方法名必须是一样的。
2.被重写的方法的访问修饰限定符在子类中要大于等于父类的。（从小到大：private，default(默认的)，protected，public），比如，当父类被public修饰时，子类必须是public。
3.被 private 修饰的方法是不可以被重写的。
4.被 static 修饰的方法是不可以被重写的。
5.被 final 修饰的方法是不可以被重写的。
6.构造方法也是不可以被重写的。
7.重写的方法, 可以使用 @Override 注解来显式指定. 有了这个注解能帮我们进行一些合法性校验. 例如不小心将方法名字拼写错了 (比如写成 aet), 那么此时编译器就会发现父类中没有 aet 方法, 就会编译报错, 提示无法构成重写
重写和重载的区别
| 区别点 | 重写(override) |
重载
(overloade)
|
| 参数列表 | 一定不能修改 | 必须修改 |
|
返回类型
| 一定不能修改【除非可以构成父子类关系】 | 可以修改 |
| 访问限定符 | 一定不能做更严格的限制（可以降低限制） | 可以修改 |
即：方法重载是一个类的多态性表现
,
而方法重写是子类与父类的一种多态性表现。
【
重写的设计原则
】
对于已经投入使用的类，尽量不要进行修改。最好的方式是：重新定义一个新的类，来重复利用其中共性的内容，并且添加或者改动新的内容。
静态绑定
：也称为前期绑定
(
早绑定
)
，即在编译时，根据用户所传递实参类型就确定了具体调用那个方法。典型代表函数重载。
动态绑定
：也称为后期绑定
(
晚绑定
)
，即在编译时，不能确定方法的行为，需要等到程序运行时，才能够确定具体调用那个类的方法。
2.4 向上转移和向下转型
2.4.1 向上转型
向上转型：实际就是创建一个子类对象，将其当成父类对象来使用。
语法格式：父类类型 对象名
= new
子类类型
()
Animal animal1 = new Cat("七月三",6);
animal是父类类型，但可以引用一个子类对象，因为是从小范围向大范围的转换。
常见的可以发生向上转型的三个时机或场景：
1. 直接赋值
Animal animal1 = new Cat("七月三",6);
2. 方法的参数，传参的时候进行向上转型
public static void eatfunc(Animal animal) { animal.eat(); } public static void main3(String[] args) { Dog dog = new Dog("小白",4); eatfunc(dog);}
3.返回值向上转型
public static Animal eatfun() { Dog dog = new Dog("小白",4); return dog;}
向上转型的优点：让代码实现更简单灵活。
向上转型的缺陷：不能调用到子类特有的方法。
2.4.2 向下转型
将一个子类对象经过向上转型之后当成父类方法使用，再无法调用子类的方法，但有时候可能需要调用子类特有的方法，此时：将父类引用再还原为子类对象即可，即向下转换。
public class Test{
public static void main(String[] args) {
Animal animal = new Dog("xiaohuang",7);
//向下转型
Dog dog = (Dog) animal;
dog.bark();
}
向下转型用的比较少，而且不安全，万一转换失败，运行时就会抛异常。
Java
中为了提高向下转型的安全性，引入了 instanceof
，如果该表达式为
true
，则可以安全转换。
2.5 多态的优缺点
class Shape {
public void draw() {
System.out.println("画一个图形！");
}
}
class Rect extends Shape{
@Override
public void draw() {
System.out.println("□！");
}
}
class Flower extends Shape {
@Override
public void draw() {
System.out.println("❀！");
}
}
class Cycle extends Shape {
@Override
public void draw() {
System.out.println("○！");
}
}
【
使用多态的好处
】
1.
能够降低代码的
"
圈复杂度
",
避免使用大量的
if - else
什么叫
"
圈复杂度
" ?
圈复杂度是一种描述一段代码复杂程度的方式
.
一段代码如果平铺直叙
,
那么就比较简单容易理解
.
而如果有很多的条件分支或者循环语句, 就认为理解起来更复杂
.
因此我们可以简单粗暴的计算一段代码中条件语句和循环语句出现的个数
,
这个个数就称为
"
圈复杂度
". 如果一个方法的圈复杂度太高,
就需要考虑重构
.
不同公司对于代码的圈复杂度的规范不一样
.
一般不会超过
10
假如我们现在需要打印的不是一个形状了, 而是多个形状. 如果不基于多态, 实现代码如下:
class Shape { public void draw() { System.out.println("画一个图形！"); } } class Rect extends Shape{ @Override public void draw() { System.out.println("□！"); } } class Flower extends Shape { @Override public void draw() { System.out.println("❀！"); } } class Cycle extends Shape { @Override public void draw() { System.out.println("○！"); } } public class Test { //不用多态 public static void main(String[] args) { Rect rect = new Rect(); Flower flower = new Flower(); Cycle cycle = new Cycle(); String[] strings = {"cycle","rect","cycle","rect","flower"}; for (String x:strings) { if(x.equals("cycle")) { cycle.draw(); } else if (x.equals("rect")) { rect.draw(); } else if (x.equals("flower")) { flower.draw(); } } } }
如果使用使用多态, 则不必写这么多的 if - else 分支语句, 代码更简单：
public static void main(String[] args) {
Shape[] shapes = {new Cycle(),new Rect(),new Cycle(),new Rect(),new Flower()};
for (Shape shape:shapes) {
shape.draw();
}
2.
可扩展能力更强
如果要新增一种新的形状
,
使用多态的方式代码改动成本也比较低
class Triangle extends Shape {@Overridepublic void draw () {System . out . println ( " △ " );}}
多态缺陷：代码的运行效率降低
。
1.
属性没有多态性
当父类和子类都有同名属性的时候，通过父类引用，只能引用父类自己的成员属性
2.
构造方法没有多态性
总结
这一节涵盖的部分比较多，相对来说更难理解，但只要理解了继承和多态，我们的代码能力肯定会有一个质的飞跃！
421
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
