Java面向对象 ( 多态 | final关键字 | 接口 )

 前言：本篇文章是Java面向对象系列(四),会介绍到 多态 | final关键字 | 接口。

多态

Animal dog = new Dog();

•  前提：二者存在直接或间接的继承关系.
•  概念：用父类的引用变量指向子类对象，多态也称向上转型，将子类类型转为父类类型.
•  作用：用父类类型表示任意的子类类型对象，利于程序扩展.

两个时间段：

•  编译期 --- 类型是父类类型.

•  运行期 --- 类型是具体的子类类型.

成员方法：编译看左边，运行看右边.

静态方法：不存在重写，编译看运行都看左边（父类）.

//父类

public class Animal {
//成员方法
    public void eat(){
        System.out.println("吃东西");
    }
//静态方法
    public static void show(){
        System.out.println("动物");
    }
}

//子类  以狗为例
public class Dog extends Animal {   //继承父类

    public void eat(){
        System.out.println("狗吃骨头");//方法重写
    }
    public static void show(){
        System.out.println("狗");
    }

}
public class Test {
    public static void main(String[] args) {
        Animal dog = new Dog();
        dog.eat();   //找左边
        Animal cat=new Cat();
        cat.eat();
        System.out.println("---------");
        dog.show();   //静态看父类
       
    }

运行结果：

• 缺点：一旦转为父类类型，就不能调用子类中拓展的特有方法。
• 解决方法：向下转型----将父类类型转为子类类型.

Animal dog = new Dog();   
Dog d = (Dog) dog

• 转换时需要使用 instanceof 判断：

 public void putAnimal(Animal animal){

        System.out.println("放入动物");
//如果放入的动物不是狗类,例如放入猫类则错误

        if(animal instanceof Dog){
            Dog dog = (Dog) animal;
            dog.eat();
        }
        System.out.println("动物错误！");
    }

 分别传入cat，dog：                                        运行结果：

---

final关键字 

•  final 可以修饰类，方法，参数，成员变量(常量).
•  final 修饰的类不能被继承，所以不能修饰抽象类，例如Java中String类就是final修饰.
•  final 修饰的方法不能被重写.
•  final 修饰方法的参数，参数值在方法中不能被改变.
•  final 修饰的成员变量值不能改变，因此称为常量.

//1.在类定义时,值就确定,直接赋值,赋值后不能改变,建议用static修饰
    final static int A = 10;
//2.在类定义时,值不明确,必须在创建对象后在构造方法中赋值,每个对象中都有一个常量
    final int COUNT ;
​
    public demo1(){
        COUNT = 10;
    }
    public demo1(int COUNT){
        this.COUNT=COUNT;
    }

                                                     （常量一般建议全部使用大写字母 多个单词间用下划线连接）

---

接口

概念及特点：

• 接口可以看做是一种特殊的抽象类，里面可以包含抽象方法，但不能被创建对象；
• 接口可以被类实现，实现类必须实现接口中定义的所有方法；
• 接口和抽象类十分的类似，接口内部的方法也是默认抽象的，不可在内部实例化的，只能由接口的调用者去实现。
• 接口通过关键字 interface定义；类通过implements关键字来实现接口。

代码演示：

 //interface关键字修饰接口
public interface MyInterface {
​
    int num = 10; // public static final int num = 10;
    void eat();  //public abstract void eat();
​
    //静态方法，可以直接通过接口名调用
    public static void test(){
​
    }
    //默认方法,被子类继承后调用
    default void test1(){
​
    }
}

注意：类实现接口后，要么重写接口中所有抽象方法，要么声明为抽象类。

•   一个类可以实现多个接口：

public class MyClass implements A,B{
    //Myclass类实现A,B接口
}

•   一个接口可以继承多个接口：

public interface A extends B,C{  
    //A继承B,C接口
}