7.1面向对象（继承中成员方法关系，final关键字，多态，抽象类，接口）

一、继承中成员方法的关系

（1）子类中的成员方法和父类中的成员方法名称不一致,分别调用!

子类中的成员方法和父类中的成员方法名称一致的情况:  先在子类的成员位置找,有就输出,没有,在父类中的成员位置找;如果父类中没有,报错!

（2）方法重写override:  子类出现了和父类一模一样的方法声明!

子类在有自己特有的功能的时候,还应该具备父类的中的功能,使用方法重写

（3）方法重写(覆盖/方法复写)的注意事项:

a.父类中被private修饰的成员方法,子类不能重写

     b.子类重写父类中的方法,访问权限要足够大，至少要跟父类保持一致

     c.静态方法,子类要重写父类的静态方法,那么子类也必须静态:

        静态只能访问静态:静态不算方法重写(static修饰跟类有关系)

（4）方法重写:有时候不想让子类去修改父类中数据,这时候java提供了一个final关键字final：最终的,无法更改的

举例：父类中有一个绝密文件,任何人不得修改

二、final关键字

（1）用法:

a.  final可以修饰类,该类不能继承

b.  final还可以修饰成员:

       成员变量:final修饰成员变量,此变量变成常量.

       成员方法:final可以修饰成员方法,成员方法不能被重写

c. finally:异常类中:Exception:释放资源

d. finalize():根据GC垃圾回收器有关系

【常量的分类】

字面值常量："hello",'A',100,3.14

自定义常量：final int num = 20 ;

（2）

a.  final修饰基本数据类型：那么该类型的值不能再改变:

final int num = 10 ;

num = 20 ;//错误的写法

final int num;//定义变量 ： 被final修饰:最终,无法更改的变量

在赋值的时候,只能赋值一次

b.  final修饰引用类型:

引用类型的地址值不能再改变了,但是里面的成员变量值可以变化!

（3）final的初始化时机：

a.  被final修饰的成员变量：只能被赋值一次

b.  先定义,然后可以在执行构造方法完毕之前赋值

三、多态

（1）多态：指的是一个事物在不同时刻的体现显示出来的一种状态!

（2） 多态的前提条件:

 a. 必须有继承关系:类与类产生的关系

 b. 有方法重写: 没有重写也可以,没有意义,因为:动物的eat(),猫和狗吃的东西是不一样的,所以需要方法重写

c.父类的引用指向子类对象:

 Fu f = new Zi() ; --->堆内存中指向的是子类:向上转型

（3）多态的成员访问特点:

a.  成员变量:

编译看左(父类中有这个变量,不会报错,编译可以通过),运行看左(输出父类中的成员变量的值)

b.  成员方法:

非静态成员方法:  编译看左边,运行看右边

                  因为:存在方法重写!

静态成员方法:  (直接与类有关系,随着类的加载而加载)

编译看左,运行看左边

c.  构造方法:对数据进行初始化的!

（4）多态的好处:

a.  提高代码的复用性(由继承保证)

b.  提高代码的扩展性(由扩展性):父类引用指向子类对象

（5）多态的弊端:

不能访问子类中的特有功能!

（6）如何解决多态的弊端问题:

a.   使用子类的功能,创建子类对象,使用子类对象调用子类中的功能,可以,但是不够好,又重新new对象,在堆内存中消耗内存,所以不好!

b.  向上转型:父类的引用指向子类对象

可不可以将父类的引用转型子类对象呢?

可以:向下转型:是将父类的引用强制转换成子类对象

（7）向下转型:使用不当,会出现异常：运行的时候会发生一个异常!

java.lang.ClassCastException:类转换异常!

 

四、抽象类

（1）抽象类的简单概述:

定义动物类,动物类是一个大的方法,不应该直接定义为:class Animal,猫和狗才是具体的动物,所以针对这种情况:需要将一种类定义为抽象类:java提供关键字:abstract:抽象

抽象类的格式:

abstract class Animal{} //动物类是一个抽象类

（2）抽象类的特点:

a.   抽象类中可以有抽象方法,也可以有非抽象方法

抽象类和抽象方法必须用abstract关键字修饰

抽象类的格式：abstract class类名 {}

抽象的方法的格式：是没有方法体的,并有public abstract

public void show(){}  //有方法体的方法不是抽象方法

public abstract void show() ;

b.  如果一个类中有抽象方法,那么这个类就必须定义为抽象类

c.  抽象类中有没有构造方法呢?

有:作用:对数据进行初始化

d.  抽象类的子类:

非抽象类:有意义的,因为使用的就是子类的功能,通过子类对象给父类(抽象类)间接的实例化

抽象类:子类的抽象类,没有意义,因为使用的就是子类的具体功能

 e.  抽象类不能直接实例化-->该类不能直接创建对象,就需要用到子类像,可以通过子类对象间接的实例化

Fu f = new Zi();属于多态的形式:抽象类多态

（3）抽象类的成员的特点:

成员变量:可以出现变量,也可以自定义常量

成员方法:可以是抽象的,也可以是非抽象的

构造方法:去给数据进行初始话:有参/无参都可以有

（4） 抽象类的特性:

a.  强制要求子类重写抽象类中的抽象方法:由抽象类保证

b.  子类继承父类,代码的复用性,由继承保证

（5）如果一类中没有抽象方法,那么这个类可不可以定义为抽象类?如果可以,为什么定义抽象类?

可以.为了不创建对象

（6）abstract不能和哪些关键字冲突

private :冲突

 final:冲突

static:冲突,静态的抽象方法,没有意义

五、接口

（1）接口：接口体现的是该事物的一种扩展功能,比如:猫跳高,狗计算等等这写动作不是一开始就具备的,属于额外动作,额外功能!

（2）接口的特点：

a.  接口:interface +接口(命名规范:和类名的命名规范一样)

inteface Jump{}

接口中的方法:只能是抽象方法

b.  接口不能直接实例化--->不能创建对象

c.  接口的子类称为子实现类：

子实现类是抽象类:没意义,不能创建对象

子实现类是非抽象类:接口不能直接实例化,所以通过子实现类进行实例化:接口多态

AnimalTrain at = new Cat() ; //接口多态的形式

【在实际的开发中,给接口的实现类起名字:接口名+Impl】

d.  子实现类和接口的关系:---->implements:实现的意思

格式：class类名implements 接口名{}

子实现类要实现接口中所有的抽象方法

（3）接口中的成员特点:

a.  成员变量:只能是常量,默认的修饰符:public static final

b.  成员方法:  只能是抽象方法:默认修饰符:public abstract

c.  构造方法:接口中没有构造方法! 因为接口主要是扩展功能的，而没有具体存在

（4）类与类,类与接口,类与接口的关系:

a.  类与类:  继承关系:单继承,不能多继承,但是可以多层继承

b.  类与接口的关系:实现关系:implements:可以单实现,也可以多实现

并且还可以在继承一个类的同事实现多个接口

c.  接口和接口的关系:继承关系:可以单继承,可以多继承

（5）接口和抽象类的区别?（面试题）

a.   成员的区别:

成员变量:

  抽象类:可以是变量,也可以是常量

 接口:只能是常量

成员方法:

抽象类:可以抽象方法,也可以是非抽象方法

接口:只能是抽象方法

构造方法:

抽象类:可以是有参构造,也可是无参构造

接口:没有构造方法

b.    设计原则的区别:

抽象类：需要实例化,需要抽象类多态进行,体现的是一种"is a"的关系,由继承保证

接口：是事物一种扩展功能,只需子实现类进行实现即可,体现是一种"like a" 的关系:跳高猫(部分猫具有这样的功能)

c.  应用场景:实际的开发中会到

具体类对象(很少使用)

抽象类多态(一般会使用)

接口多态(经常常用)