一.多态
1.final关键字
- 方法重写后：父类功能被子类覆盖，有些时候不想让子类覆盖父类，java提供了final关键字
- final：可修饰类、方法、变量。
-
特点：
类：final类无法被继承
方法：该方法不能被重写
变量：该变量不能被二次赋值。因为这个变量就是常量； -
常量：
字面值常量：10，“hello”
自定义常量：final int x = 10； - final关键字修饰局部变量：
基本数据类型：常量，值不能变
引用数据类型：比如创建一个final对象，表示该变量栈地址值不能变，但内部指向堆空间的成员变量可变 - final变量初始化时机：
A：被final修饰的变量只能赋值一次；
B：构造方法完毕前（非静态）
2.多态概述和前提条件
- 多态概述：某一个事物在不同时刻表现出来的不同状态
- 前提和体现：
A：有继承关系
B：有方法重写:其实没有也可以，但如果没有就无意义。比如show方法被重写
C：有父类引用指向子类对象：fu f = new zi()
Animal cat = new Cat();
cat.show();//调用哪个方法
3.多态中的成员访问特点
A：成员变量：编译看左边：如果父类没有该成员变量就报错；运行也看左边，输出为父类该成员变量的值
B：构造方法：创建子类对象时候先调用父类无参构造方法，对付类数据初始化
C：成员方法：编译看左边，运行看右边，也就是说变量还是父类的，但重写的方法用的是子类的
D:静态方法：编译看左，运行看左。故静态和类相关，算不上重写
4.多态的好处
A：提高了代码维护性（继承）
B：提高了代码拓展性（多态）
- 拓展：制作工具类时候，把构造函数修饰为private后，在其它类中不可以创建该类对象。工具类成员方法均为static，这样可以直接类名访问。
- 有了多态以后，不需要工具类中对每个子类新定义。直接用多态即可
4.多态的弊端
- 不能访问子类独有的成员方法
解决方法：向上向下转型
- 把父类引用强制转换为子类引用：向下转型后，在调用
A：向上转型：Fu f = new Zi();
B：向下转型：Zi z = (Zi)f;//要求f必须能够转换为Zi -
内存图解
向上转型.png
向下转型.png
二.抽象类
1.概述
- 比如动物之于猫狗就是一个抽象概念，所以希望在动物类中的方法给出一个声明即可
- java中一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类就必须定义为抽象类
2.特点
A：用abstract修饰
B：抽象类不一定有抽象方法，但有抽象方法必须定义为抽象类
C：虽然有抽象方法，抽象类不能实例化，因为他不是具体的。他的构造方法主要用于子类访问父类数据的初始化（多态）
D：
（1）如果不想重写抽象方法，该子类是一个抽象类
（2）重写了所有的抽象方法，该子类就是一个非抽象类
E：抽象类的实例化其实是靠具体的子类实现的，是多态的方式。Fu f = new Zi();
3.抽象类的成员特点
A：成员变量：既可以是变量也可以是常量
B：成员方法：既可以是抽象（强制要求子类做的事情）的也可以是非抽象的（子类继承的事情，提高复用性）
C：构造方法：有
4.抽象类的问题
- 一个类没有抽象方法也可以定义为抽象类，可以不让创建对象
- abstract和private、final冲突，因为抽象要求子类重写，和static无意义，没有方法体。和这三个关键字冲突
三.接口
1.概述和特点
- 特点：
A：interface关键字修饰：interface 接口名();
B：类实现接口用implements表示：
class 类名 implements 接口名{}
C：接口不能实例化，那么接口如何实例化，用多态方式实例化
故：具体类多态（不用）、抽象类多态（常用）、接口多态（最常用）
D：接口的子类：
a：可以是抽象类，但没意义，还是要多态实例化
b：可以是具体类，重写接口中所有抽象方法
2.接口的成员特点
- 接口名+Impl为接口的实现类命名方式
A：成员变量：只能是常量，并且是静态的，默认修饰符：public static final。建议自己手动给出
B：成员方法：只能是抽象方法，默认public abstract
C：构造方法：没有构造方法，所有类默认继承Object类
3.类与类、类与接口、接口与接口的关系
A：类与类：继承关系，只能单继承，可以多层继承
B：类与接口：实现关系，可以单实现，也可以多实现，并且可以在继承一个类的同时实现多个接口
C：接口与接口：继承关系，可以单继承也可以多继承。
4.抽象类与接口的区别
-
区别：
区别.png -
例子：
猫狗.png
/*
猫狗案例,加入跳高的额外功能
分析：从具体到抽象
猫：
姓名,年龄
吃饭，睡觉
狗：
姓名,年龄
吃饭，睡觉
由于有共性功能，所以，我们抽取出一个父类：
动物：
姓名,年龄
吃饭();
睡觉(){}
猫：继承自动物
狗：继承自动物
跳高的额外功能是一个新的扩展功能，所以我们要定义一个接口
接口：
跳高
部分猫：实现跳高
部分狗：实现跳高
实现；
从抽象到具体
使用：
使用具体类
*/
//定义跳高接口
interface Jumpping {
//跳高功能
public abstract void jump();
}
//定义抽象类
abstract class Animal {
//姓名
private String name;
//年龄
private int age;
public Animal() {}
public Animal(String name,int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
//吃饭();
public abstract void eat();
//睡觉(){}
public void sleep() {
System.out.println("睡觉觉了");
}
}
//具体猫类
class Cat extends Animal {
public Cat(){}
public Cat(String name,int age) {
super(name,age);
}
public void eat() {
System.out.println("猫吃鱼");
}
}
//具体狗类
class Dog extends Animal {
public Dog(){}
public Dog(String name,int age) {
super(name,age);
}
public void eat() {
System.out.println("狗吃肉");
}
}
//有跳高功能的猫
class JumpCat extends Cat implements Jumpping {
public JumpCat() {}
public JumpCat(String name,int age) {
super(name,age);
}
public void jump() {
System.out.println("跳高猫");
}
}
//有跳高功能的狗
class JumpDog extends Dog implements Jumpping {
public JumpDog() {}
public JumpDog(String name,int age) {
super(name,age);
}
public void jump() {
System.out.println("跳高狗");
}
}
class InterfaceTest {
public static void main(String[] args) {
//定义跳高猫并测试
JumpCat jc = new JumpCat();
jc.setName("哆啦A梦");
jc.setAge(3);
System.out.println(jc.getName()+"---"+jc.getAge());
jc.eat();
jc.sleep();
jc.jump();
System.out.println("-----------------");
JumpCat jc2 = new JumpCat("加菲猫",2);
System.out.println(jc2.getName()+"---"+jc2.getAge());
jc2.eat();
jc2.sleep();
jc2.jump();
//定义跳高狗并进行测试的事情自己完成。
}
}
