Java篇--继承与多态

继承与多态 

继承与多态

 继承

  继承的好处

继承概述：

把多个类中相同的内容给提取出来定义到一个类中。

如何实现继承呢?

Java提供了关键字：extends

格式：

class 子类名 extends 父类名 {}

好处：

A:提高了代码的复用性

B:提高了代码的维护性

C:让类与类之间产生了关系，是多态的前提

  Java中继承的特点

A:Java只支持单继承，不支持多继承。

有些语言是支持多继承，格式：extends 类1,类2,...

B:Java支持多层继承(继承体系)

  继承的注意事项

A:子类只能继承父类所有非私有的成员(成员方法和成员变量)

B:子类不能继承父类的构造方法，但是可以通过super(马上讲)关键字去访问父类构造方法。

C:不要为了部分功能而去继承

  继承中成员变量的关系

继承中成员变量的关系:

A:子类中的成员变量和父类中的成员变量名称不一样，这个太简单。

B:子类中的成员变量和父类中的成员变量名称一样，这个怎么玩呢?

在子类方法中访问一个变量的查找顺序：

a:在子类方法的局部范围找，有就使用

b:在子类的成员范围找，有就使用

c:在父类的成员范围找，有就使用

d:如果还找不到，就报错。

  super关键字

this和super的区别?

分别是什么呢?

this代表本类对应的引用。

super代表父类存储空间的标识(可以理解为父类引用,可以操作父类的成员)

怎么用呢?

A:调用成员变量

this.成员变量 调用本类的成员变量

super.成员变量 调用父类的成员变量

B:调用构造方法

this(...) 调用本类的构造方法

super(...) 调用父类的构造方法

C:调用成员方法

this.成员方法 调用本类的成员方法

super.成员方法 调用父类的成员方法

  继承中构造方法的关系

继承中构造方法的关系

A:子类中所有的构造方法默认都会访问父类中空参数的构造方法

B:为什么呢?

因为子类会继承父类中的数据，可能还会使用父类的数据。

所以，子类初始化之前，一定要先完成父类数据的初始化。

注意：子类每一个构造方法的第一条语句默认都是：super();

如何父类中没有构造方法，该怎么办呢?

如果父类没有无参构造方法，那么子类的构造方法会出现什么现象呢?

报错。

如何解决呢?

A:在父类中加一个无参构造方法

B:通过使用super关键字去显示的调用父类的带参构造方法

C:子类通过this去调用本类的其他构造方法

子类中一定要有一个去访问了父类的构造方法，否则父类数据就没有初始化。

注意事项：

this(...)或者super(...)必须出现在第一条语句上。

如果不是放在第一条语句上，就可能对父类的数据进行了多次初始化，所以必须放在第一条语句上。

  方法重写概述

方法重写：子类中出现了和父类中方法声明一模一样的方法。

方法重载：reaload

本类中出现的方法名一样，参数列表不同的方法。与返回值无关。

子类对象调用方法的时候：

先找子类本身，再找父类。

方法重写的应用：

当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法。

这样，即沿袭了父类的功能，又定义了子类特有的内容。

方法重写的注意事项

A:父类中私有方法不能被重写

因为父类私有方法子类根本就无法继承

B:子类重写父类方法时，访问权限不能更低

最好就一致

C:父类静态方法，子类也必须通过静态方法进行重写

其实这个算不上方法重写，但是现象确实如此，至于为什么算不上方法重写，多态中我会讲解

子类重写父类方法的时候，最好声明一模一样。

  final关键字

final关键字是最终的意思，可以修饰类，成员变量，成员方法。

修饰类，类不能被继承

修饰变量，变量就变成了常量，只能被赋值一次

修饰方法，方法不能被重写

/*

继承的代码体现

由于继承中方法有一个现象：方法重写。

所以，父类的功能，就会被子类给覆盖调。

有些时候，我们不想让子类去覆盖掉父类的功能，只能让他使用。

这个时候，针对这种情况，Java就提供了一个关键字：final

final:最终的意思。常见的是它可以修饰类，方法，变量。

*/

Final特性

/*

final可以修饰类，方法，变量

特点：

final可以修饰类，该类不能被继承。

final可以修饰方法，该方法不能被重写。(覆盖，复写)

final可以修饰变量，该变量不能被重新赋值。因为这个变量其实常量。

常量：

A:字面值常量

"hello",10,true

B:自定义常量

final int x = 10;

*/

final关键字面试题

final修饰局部变量

在方法内部，该变量不可以被改变

在方法声明上，分别演示基本类型和引用类型作为参数的情况

基本类型，是值不能被改变

引用类型，是地址值不能被改变

/*面试题：final修饰局部变量的问题基本类型：基本类型的值不能发生改变。引用类型：引用类型的地址值不能发生改变，但是，该对象的堆内存的值是可以改变的。*/class Student {int age = 10;}class FinalTest {public static void main(String[] args) {//局部变量是基本数据类型int x = 10;x = 100;System.out.println(x);final int y = 10;//无法为最终变量y分配值//y = 100;System.out.println(y);System.out.println("--------------");//局部变量是引用数据类型Student s = new Student();System.out.println(s.age);s.age = 100;System.out.println(s.age);System.out.println("--------------");final Student ss = new Student();System.out.println(ss.age);ss.age = 100;System.out.println(ss.age);ss = new Student();}}

final修饰变量的初始化时机

在对象构造完毕前即可

/*

final修饰变量的初始化时机

A:被final修饰的变量只能赋值一次。

B:在构造方法完毕前。(非静态的常量)

/*final修饰变量的初始化时机A:被final修饰的变量只能赋值一次。B:在构造方法完毕前。(非静态的常量)*/class Demo {//int num = 10;//final int num2 = 20;int num;final int num2;{//num2 = 10;}public Demo() {num = 100;//无法为最终变量num2分配值num2 = 200;}}class FinalTest2 {public static void main(String[] args) {Demo d = new Demo();System.out.println(d.num);System.out.println(d.num2);}}

 多态

  多态的前提

多态的前提：

A:要有继承关系。

B:要有方法重写。

其实没有也是可以的，但是如果没有这个就没有意义。

动物 d = new 猫();

d.show();

动物 d = new 狗();

d.show();

C:要有父类引用指向子类对象。

父 f = new 子();

  多态中的成员访问特点

多态中的成员访问特点：

A:成员变量

编译看左边，运行看左边。

B:构造方法

创建子类对象的时候，访问父类的构造方法，对父类的数据进行初始化。

C:成员方法

编译看左边，运行看右边。

D:静态方法

编译看左边，运行看左边。

(静态和类相关，算不上重写，所以，访问还是左边的)

由于成员方法存在方法重写，所以它运行看右边。

  多态的好处

多态的好处：

A:提高了代码的维护性(继承保证)

B:提高了代码的扩展性(由多态保证)

  多态的弊端

多态的弊端：

不能使用子类的特有功能。

  多态中的转型问题

向上转型

从子到父

父类引用指向子类对象

向下转型

从父到子

父类引用转为子类对象

多态中对象变化的内存图解