多态、抽象类和接口

目录

一、多态

二、抽象类

三、接口

一、多态

1. 多态的概述

 某个事物，在不同的时刻表现出来的不同状态。
 eg： Cat c=new Cat();
      Animal a=new Cat();
      猫可以是猫类型，即 猫 m=new 猫();
      同时猫也是动物的一种，即 动物 d=new 猫();

2. 多态的前提

 1. 要有继承关系；
 2. 要有方法重写，否则就失去了意义。
 3. 要有父类对象引用指向子类对象：eg:父 f=new 子();

3. 多态的案例：猫属于猫类，同时也属于动物

 public class Animal {
     int age;
     String name;
     public void sleep(){
         System.out.println("睡觉");
     }
     public void eat(){
         System.out.println("吃饭");
     }
 }
 public class Cat extends Animal {
     @Override
     public void sleep() {
         System.out.println("白天睡觉");
     }
 }
 public class Test {
     public static void main(String[] args) {
         Animal animal=new Cat();
         animal.eat();
         animal.sleep();
     }
 }

4. 多态中的成员访问特点

 1. 成员变量 ： 
 编译看左边，运行看左边；
 2. 构造方法 ：
 创建子类对象的时候会访问父类的构造方法，对父类的数据进行初始化；
 3. 成员方法 ：
 编译看左边，运行看右边；
 4. 静态方法 ：
 编译看左边，运行看左边。

示例：

 //Animal父类：
 public class Animal {
     String name="父类的成员变量";
     public static void get(){
         System.out.println("父类的静态方法");
     }
 ​
     public Animal() {
         System.out.println("父类的构造方法");
     }
 ​
     public void show(){
         System.out.println("父类的成员方法");
     }
 }
 //Cat子类：
 public class Cat extends Animal {
     String name="子类的成员变量";
     public Cat(){
         System.out.println("子类的构造方法");
     }
     public void show(){
         System.out.println("子类的成员方法");
     }
 }
 //Test测试类：
 public class Test {
     public static void main(String[] args) {
         Animal animal=new Cat();
         System.out.println(animal.name);
         animal.show();
         animal.get();
     }
 }

5. 多态的好处和弊端

好处：

提高了代码的维护性（由继承保证）；

提高了代码的扩展性（由多态保证）。

弊端：

不能使用子类特有的功能。

6. 向下转型和向上转型

 public class Test { //向下转型
     public static void main(String[] args) {
         Animal animal = new Cat();
         Cat cat = (Cat) animal;
     }
 }
public class Test { //向上转型
    public static void main(String[] args) {
        Cat cat = new Cat();
        Animal animal = (Animal) cat;
    }
}

二、抽象类

1. 什么是抽象类

   Java中，一个没有方法体的方法应该定义为抽象方法，如果一个类中有抽象方法，那么这个类必须定义为抽象类。

2.  抽象类的特点

1. 抽象类和抽象方法必须使用abstract关键字修饰，
	抽象类格式： abstract class 类名{}
	抽象方法格式： public abstract void 方法名();
2. 抽象类中不一定有抽象方法，但有抽象方法的一定为抽象类；
3. 抽象类中可以有构造方法，抽象类不能进行实例化；构造方法的作用是用于子类访问父类数据时的初始化；
4. 抽象类具体的子类可以进行实例化。
5. 抽象类的子类： 要么是抽象类，要么重写抽象类中的所有抽象方法。

实例：抽象类不能直接进行实例化，但是其具体的子类可以进行实例化；

//父类
public abstract class Fu {
    public abstract void show();
    public abstract void say();
}
//子类
public class Zi extends Fu{
    public void show(){
        System.out.println("重写的show方法");
    }
    public void say(){
        System.out.println("重写的say方法");
    }
}
//测试类
public class Test {
    public static void main(String[] args) {
        Zi zi=new Zi();

    }
}

        3. 抽象类的成员特点

1. 成员变量： 既可以是变量，也可以是常量；
2. 构造方法： 有，用于子类访问父类数据的初始化；
3. 成员方法： 既可以是抽象的也可以是非抽象的。

抽象类的成员方法特性：
1. 抽象方法： 强制要求子类做的事情；
2. 非抽象方法： 子类继承的事情，提高了代码的复用性。

        4. 抽象类猫狗实例

//父类Animal
public abstract class Animal {
    int age;
    String name;
    public abstract void eat();
    public Animal() {
    }
    public  void sleep(){
        System.out.println("睡觉");
    }
}
//子类Cat
public class Cat extends Animal {
    public Cat(int age,String name) {
        this.age=age;
        this.name=name;
    }
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}
//子类Dog
public class Dog extends Animal {
    public Dog(int age, String name) {
        this.age=age;
        this.name=name;
    }
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}
//测试类Test
public class Test {
    public static void main(String[] args) {
        Animal animal=new Cat(5,"mimi");
        Animal animal2=new Dog(3,"qiqi");
        System.out.println(animal.age);
        System.out.println(animal.name);
        System.out.println(animal2.age);
        System.out.println(animal2.name);
        animal.eat();
        animal.sleep();
        animal2.eat();
        animal2.sleep();
    }
}

三、接口

1. 在Java中，为了体现事物功能的扩展性，提供了接口来定义这些额外功能，并且不给出具体的实现。

2. 接口的特点

1. 接口使用关键字interface来表示，格式为： interface 接口名{}
2. 类实现接口用implements表示，格式为： class 类名 implements 接口名 {}
3. 接口不能实例化，但是可以按照多态的方法实例化
4. 接口的子类可以是抽象类，但是意义不大；
			也可以是具体类，要重写接口中的所有抽象方法。

        3. 接口的成员特点

成员变量： 只能是常量，并且是静态的；
		  默认修饰符：public static final;
		  建议自己手动给出。
构造方法： 接口没有构造方法；
成员方法： 只能是抽象方法，
		  默认修饰符： public abstract;
		  建议自己手动给出。

        4.类与类、类与接口、接口与接口的关系

1.类与类：继承关系，只能单继承，可以多层继承；
2.类与接口：实现关系，可以单实现，也可以多实现，并且还可以在继承一个类的同时实现多个接口；
3.接口与接口：继承关系，可以单继承，也可以多继承。

        5.抽象类与接口的区别

抽象类：

成员变量：可以变量，也可以常量
构造方法：有
成员方法：可以抽象，也可以非抽象。

接口：

成员变量：只可以变量
成员方法：只可以抽象

设计理念的区别：

抽象类：被继承体现的是“is a”的关系，
	   抽象类中定义的是该继承体系的共性功能。
接口： 被实现体现的是：“like a”的关系，
	   接口中定义的是该继承体系的扩展功能。