JAVA中多态，抽象类，接口

多态：

某一个事物在不同的时刻表现出来不同的状态。
举例：猫可以是猫类型，同时猫也可以是动物的一种。
Cat cat = new Cat();
Animal a =new Cat();
多态的前提：

要有继承的关系
要有方法的重写。
要有父类引用指向子类对象。

多态中的成员访问特点：

成员变量：编译看左边，运行也看左边
成员方法：编译看左边，运行看右边
构造方法：创建子类对象时会访问父类的构造方法，对父类的数据进行初始化
静态方法：编译看左边运行也看左边（静态和类相关，算不上重写）

多态的优点：
提高了代码的维护性（继承保证）
提高了代码的拓展性（多态的保证）
多态的缺点：
不能使用子类的特有功能
解决方法：把父类的引用强制转换为父类的引用（向下转型）
多态的案例演示：

public class Demo3 {
    
    
    public static void main(String[] args) {
    
    
        Animal a = new Cat();
        System.out.println(a.age);//18
        Cat cat = new Cat();
        System.out.println(cat.age);//20
        Cat cat1 = (Cat) a;
        a.eat();//猫吃小鱼干
        a.sleep();//猫睡觉
    }
}
 class Animal {
    
    
    int age = 18;

    public  void eat(){
    
    }

    public  void sleep(){
    
    }
}

class Cat extends Animal {
    
    
    int age = 20;

  
    public void eat() {
    
    
        System.out.println("猫吃小鱼");
    }


    public void sleep() {
    
    
        System.out.println("猫睡觉");
    }
}

抽象类

**概述：**在java中，一个没有方法体的方法应该定义为抽象方法，有抽象方法的类应该定义为抽象类
抽象类的特点：
抽象类的格式： abstract class 类名 {}

抽象类，抽象方法必须用abstract关键字修饰
抽象类的格式： abstract class 类名 {}
抽象方法的格式： public abstract void 方法名（）；
抽象类不一定有抽象方法，有抽象方法的类一定是抽象类
抽象类中可以有构造方法,抽象类不能进行实例化,那么要构造方法有什么作用呢?
用于子类访问父类数据时的初始化
抽象类不能直接实例化那么，抽象类如何实例化呢?
按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。
抽象类的子类
要么是抽象类
要么重写抽象类中的所有抽象方法
抽象类成员特点：
成员变量：既可以是变量，也可以是常量
构造放法：有，用于子类访问父类数据初始化
成员方法：既可以是抽象的，也可以是非抽象的

抽象类的案例演示：
经理与员工类。

public class Demo4 {
    
    
    public static void main(String[] args) {
    
    

        Employee e = new Mannager();
        e.setName("张三");
        e.setSalary(1000);
        System.out.println(e.getName());//张三
        System.out.println(e.getSalary());//1000
        e.work();//经理的具体工作
       Mannager mannager= (Mannager) e;
       mannager.bonus();//经理拥有奖金
    }
}
abstract class  Employee{
    
    

    String name;
    int salary;

    public String getName() {
    
    
        return name;
    }

    public void setName(String name) {
    
    
        this.name = name;
    }

    public int getSalary() {
    
    
        return salary;
    }

    public void setSalary(int salary) {
    
    
        this.salary = salary;
    }

    public  abstract void work();
}
class  Mannager extends Employee{
    
    


    @Override
    public void work() {
    
    
        System.out.println("经理的具体工作");
    }
    public void bonus(){
    
    
        System.out.println("经理拥有奖金");//经理特有的属性
    }
}

接口

概述： 为了体现事物的拓展性，java中就提供了接口来定义这些额外的功能，并不给出具体实现。
接口的特点：

接口用关键字interface表示
格式 interface 接口名{ }
类实现接口用implements表示
格式 class 类名 implements 接口名 { }
接口不能被实例化，按照多态的形式来实例化。
接口的子类，可以是抽象类，也可以是具体子类，但必须要重写接口的所有抽象方法

接口的成员特点

成员变量：只能是常量
默认修饰符为： public static final
成员方法：只能是抽象方法
默认修饰符：public abstract
3.构造方法：没有构造方法

接口案例演示

public class Demo5 {
    
    
    public static void main(String[] args) {
    
    
      MyInterface i = new AA();

        System.out.println(i.age);
        i.show();
        AA  a = (AA) i;
        a.work();

    }}
interface  MyInterface{
    
    
    public  static  final int age =18;
    public abstract  void show();
}
class AA implements  MyInterface{
    
    
    @Override
    public void show() {
    
    
        System.out.println("这是重写后的show方法");
    }
    public void work(){
    
    
        System.out.println("这是work方法");
    }
}

JAVA中多态，抽象类，接口

多态：

抽象类

接口

猜你喜欢