JAVA中的多态，抽象类及接口

一、final关键字

     final可以修饰类，方法，变量
1、特点
      final可以修饰类，被修饰的类不能被继承
      final可以修饰方法，使用final修饰父类中的方法，子类就无法重写这个方法
      final可以修饰变量，被修饰的变量不能被重新赋值（其实这个变量就变成了常量），只能赋值一次
2、注意
final修饰基本类型：基本类型的值是不能改变的
final修饰引用类型：引用类型的地址值不能发生改变，但是该对象堆内存的值是可以改变的

二、多态：   同一个对象，在不同时刻呈现出的不同的状态

1、多态的种类：

     （1）具体类多态  （几乎没有）

class Fu {}
class Zi extends Fu {}
Fu f = new Zi();

     （2）抽象类多态  （常用）

abstract class Fu {}
class Zi extends Fu {}
Fu f = new Zi();

     （3）接口多态     （最常用）

interface Fu {}
class Zi implements Fu {}
Fu f = new Zi();

2、前提：
     要有继承或实现关系
     要有方法重写
     要有父类引用或者父接口指向子类对象（父 f = new 子（））

3、多态中成员访问的特点：
 （1)成员变量：
     编译看左边，运行看左边

   (2)成员方法：
    编译看左边，运行看右边

   (3)静态方法：

       编译看左边，运行看左边

   (4)构造方法：

     子类的构造都会默认访问父类的构造方法
 

class Fu{
    public int n = 10;
    public void show() {
        System.out.println("这是父类");
    }
}
class Zi extends Fu{
    public int n = 100;
    public void show() {
        System.out.println("这是子类");
    }
}
public class DuoTai {
    public static void main(String[] args) {
        Fu f = new Zi();
        //成员变量还是父类中的值
        System.out.println(f.n);
        System.out.println("-------");
        //成员方法被子类重写
        f.show();
    }
}

4、好处：
     提高了代码的维护性
     提高了代码的扩展性
 扩展性：

class Animal{
    public void eat() {
        System.out.println("eat");
    }
    
    public void sleep() {
        System.out.println("sleep");
    }
}
class Cat extends Animal{
    public void eat() {
        System.out.println("猫吃鱼");
    }
    public void sleep() {
        System.out.println("猫卧着睡");
    }
}
class Dog extends Animal{
    public void eat() {
        System.out.println("狗吃骨头");
    }
    public void sleep() {
        System.out.println("狗站着睡");
    }
}
class AnimalTool{
    private AnimalTool() {}
    public static void useAnimal(Animal a) {
        a.eat();
        a.sleep();
    }
}
public class AnimalsDemo {
    public static void main(String[] args) {
            Cat c = new Cat();
            AnimalTool.useAnimal(c);
            Dog d = new Dog();
            AnimalTool.useAnimal(d);
    }
}

5、弊端：
     不能使用子类的特有功能
解决方法：
       方法一：创建子类对象，调用子类特有方法
       方法二：把父类的引用强制转换为子类的引用（占用内存少）
                     格式：子类  z = (子类） f
       对象间的转型问题：为了调用子类中自己特有的方法
       (1) 向上转型： 从子到父
       (2)父类 f = new 子类（）；
       向下转型：从父到子
       子类 z = （子类）f   //必须是能够转换为子的，否则会类型转换异常

class Animal1{
    public void eat() {
        System.out.println("eat");
    }
    
    public void use() {
        System.out.println("sleep");
    }
}
class Cat1 extends Animal1{
    public void eat() {
        System.out.println("猫吃鱼");
    }
    public void use() {
        System.out.println("猫捉老鼠");
    }
}
class Dog1 extends Animal1{
    public void eat() {
        System.out.println("狗吃肉");
    }
    public void use() {
        System.out.println("狗看门");
    }
}
public class Animals {
    public static void main(String[] args) {
        //向上转换
        Animal1 a  = new Dog1();  
        a.eat();
        a.use();
        System.out.println("----------");
        //向下转换
        Dog1 d = (Dog1)a;
        d.eat();
        d.use();
        System.out.println("----------");
        //变成猫
        a = new Cat1();
        a.eat();
        a.use();
        System.out.println("----------");
        //还原成猫
        Cat1 c = (Cat1)a;
        c.eat();
        c.use();
    }
}

三、抽象类：这个类不是具体的事物

1、抽象类的特点：

（1）抽象类和抽象方法必须用abstract关键字修饰
（2）抽象类中不一定有抽象方法（就是不让创建对象），但有抽象方法的的类必须定义为抽象类
（3）抽象类不能实例化（不能创建对象）
    抽象类有构造方法，用于子类访问父类数据的初始化
（4）抽象类的子类：
         重写所有的抽象方法，子类是一个具体的类
         如果不想重写抽象方法，该子类是一个抽象类
（5）抽象类的实例化是靠具体的子类实现的，是多态的方式
         抽象类 a = new 子类();

抽象类的实例化：

abstract class Animal{
    public abstract void eat();
}
//子类为抽象类
abstract class Cat extends Animal{}

//子类重写抽象类的所有抽象方法，是一个具体的类
class Dog extends Animal{
    public void eat() {
        System.out.println("狗吃肉");
    }
}

public class AbstractDemo {
    public static void main(String[] args) {
        //抽象类的实例化
        Animal a = new Dog();
        a.eat();
    }
}

2、格式：
abstract class 类名 { }
public abstract void 方法名（）；
抽象方法不能有主体

3、抽象类的成员方法特性：
1、抽象方法是强制要求子类要做的事情
2、非抽象方法是子类继承的事情，可以提高代码的复用性

四、接口：功能的扩展

定义额外功能，不给出具体实现（抽象类）
1、特点：

（1）接口用关键字interface实现
     格式：interface 接口名 {};
（2)类实现接口用“implements”表示
     class 类名 implements 接口名 {}
  (3)接口不能实例化
   解决方法：
          按照多态的方式来实例化
  (4)接口的子类
     可以是抽象类，意义不大
     可以是具体类，要重写接口中所有抽象方法
接口的实现类格式：接口名+Impl

2、接口中的成员特点：
（1)成员变量：
     只能是常量，并且是静态的
默认修饰符： public static final
  (2)构造方法：接口没有构造方法
  (3)成员方法：
     只能是抽象方法
默认修饰符：public abstract

3、抽象类和接口的区别：
（1）成员区别：
  抽象类：
       成员变量：可以是变量，也可以是常量
       构造方法：有
       成员方法：可以抽象，也可以非抽象
 接口：
       成员变量：只可以是常量
       构造方法：无
       成员方法：只可以抽象
（2）关系区别：
  类与类：
         继承关系，只能单继承，可以多层继承
  类与接口：
         实现关系，可以单实现，也可以多实现
         并且还可以在继承一个类的同时实现多个接口
  类与类：
         继承关系，可以单继承也可以多继承

interface Father{
    public abstract void show1();
}

interface Mother{
    public abstract void show2();
}

//接口与接口：继承关系
interface Sister extends Father,Mother{
    public abstract void show3();
}

//接口与类：实现关系
class Son implements Father,Mother,Sister{
    public void show1() {
        System.out.println("继承父亲的");
    }
    public void show2() {
        System.out.println("继承母亲的");
    }
    public void show3() {
        System.out.println("继承姐姐的");
    }
}

public class InterfaceDemo {
    public static void main(String[] args) {
        Father f = new Son();
        f.show1();
        Mother m = new Son();
        m.show2();
        Sister s = new Son();
        s.show3();
    }
}

（3）设计理念：
  抽象类：
         抽象类中定义的是该继承体系的共性功能
  接口：
         接口中定义的是该继承体系中的扩展功能