一.多态

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();
        
        //定义跳高狗并进行测试的事情自己完成。
    }
}