Java - 多态 抽象 接口

一 多态

1 多态：同一个事物在不同时刻呈现的多种形态

eg: 狗

我们可以说狗是狗 ：  狗 dog = new 狗();

我们也可以说狗是动物：动物 animal = new 狗();

2 多态的前提和体现：

1. 有继承/实现关系
2. 有方法重写
3. 有父类引用指向子类对象

第三个条件是 父类的引用指向子类对象 

动物 animal = new 狗();

父类引用 指的是左边的内容 而子类对象 指的是右边的内容

使用代码怎么去表现呢？

public class Animal{
    public void eat(){

        System.out.println("动物吃东西")
    }

}

// Cat类 继承 Animal类  所以Animal 为父类 Cat 为子类
public class Cat extends Animal{
    // 重写方法

    @Override
    public void eat(){

        System.out.println("猫吃鱼")

    }

}


/*
    多态的前提和体现
        有继承/实现关系
        有方法的重写
        有父类引用指向子类
    


*/
public class AnimalDemo{

    pub static void main(String[] args){
        Animal a = new Cat();
        // Animal 父类的引用指向了 Cat 子类new的对象
        
}

2 多态中成员的访问特点

然后就是 多态中成员的访问特点 我们先看代码

public class Animal {
    public int age = 40;
    public void eat(){

    System.out.println("动物吃东西")


    }

}

public class Cat extends Animal{

       public int age = 20 ;
       public int weight = 10;

       @Override
       public void eat(){
            System.out.println("猫吃鱼")

    }
    
    //子类特有方法
    public void playGame(){
        System.out.println("毛捉迷藏")
    }
}

//测试类

public class AniamlDemo{

    public static void main(String[] args){
        Animal a = new Cat();

        System.out.println(a.age); //age=40;
        
        a.eat(); // 调用子类重写的eat 方法


    }
}

多态中成员方法特点：

成员变量：编译看左边 ，执行看左边

成员方法：编译看左边 执行看右边、

为什么成员变量和成员方法的访问不一样呢？

因为成员方法有重写，而成员变量没有

3 多态的优劣

优：提高了程序的拓展性

劣： 不能使用子类的特有功能

3多态中的转型

有两种转型的情况

向上转型

        从子到父

        父类引用指向子类对象

向下转型

        从父到子

        父类引用转为子类对象

二 抽象类

1 什么是抽象类

当时我们提取出了一个动物类，这个时候我们是可以通过Animal a = new Animal()来创建动物对象，

其实这是不对的。为什么呢？因为，我说动物，你知道我说的是什么动物吗？只有看到了具体的动物，你才知道，

这是什么动物。 所以说，动物本身并不是一个具体的事物，而是一个抽象的事物。只有真正的猫，狗才是具体的动物。

在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类

看看代码：

public abstract class Animal{

    public abstract void eat();
}

//测试类

public class AnimalDemo{

    public static void main(String[] args){
            
    }
}

2 抽象类的特点

1. 抽象类和抽象方法 必须使用abstract 关键字修饰 public abstract class 类名{} public abstract void eat();
2. 抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
3. 抽象类不能实例化 通过子类对象实例化，这叫抽象类多态

4. 抽象类的子类 要么重写抽象类中的所有抽象方法  要么是抽象类

3 抽象类的成员特点

public abstract class Animal {

    private int age = 20;
    private final String name = "动物";

    public Animal() {
    }

    public Animal(int age) {
        this.age = age;
    }


    public void show() {
        age = 40;
        System.out.println(age);
//        name = "老虎";
        System.out.println(name);
    }

    public abstract void eat();

}


public class Cat extends Animal {

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

/*
    测试类
 */
public class AnimalDemo {
    public static void main(String[] args) {
        Animal a = new Cat();
        a.eat();
        a.show();
    }
}

抽象类的成员特点：

• 成员变量  可以是变量 也可以是常量
• 有构造方法 但是不能实例化  构造方法 是用于子类访问父类数据的初始化
• 成员方法 可以有抽象方法： 限定子类必须完成某些动作
• 也可以有非抽象方法 ：提高代码的复用性

三 接口

1 什么是接口

java中就是一种公共的规范标准 只要符合规范标准 大家就都可以通用

java中的接口更多体现在对行为的抽象

2 接口的特点

我们先看看代码：

// 定于一个接口
public interface Inter{
    public abstract void show();
}

// 实现上面接口
public class InterIml implement Inter{
    // 重写实现的接口的抽象方法
    @Override 
    public void show(){
        System.out.println("show ...")
    }
}

public abstract class InterImpl2 implements Inter{

}


/*
    测试类
 */
public class InterDemo {
    public static void main(String[] args) {
//        Inter i = new Inter();
        Inter i = new InterImpl();
        i.show();
    }
}

接口的特点：

• 接口 用关键字 interface 修饰
• public interface 接口名{};
• 类实现接口使用 implements 接口名{}

• 接口不能实例化 接口如何实例化呢？参照多态的方式，通过实现类对象实例化，这叫接口多态  多态的形式：具体类多态，抽象类多态，接口多态    多态的前提：有继承或者实现关系；有方法重写；有父(类/接口)引用指向(子/实现)类对象

• 接口的实现类  要么重写接口中的所有抽象方法  要么是抽象类

3 接口的成员特点

成员变量 ：只能是常量

默认修饰符： public static final

构造方法 ：没有 

成员方法 ： 只能是抽象方法 默认修饰符 public abstract 

4 类和接口的关系

类和类的关系

继承关系 只能单继承 但是可以多层继承

类和接口的关系：

实现关系 可以单实现 也可以多实现 还可以在继承一个类的同时实现多个接口

接口与接口的关系 继承关系 可以单继承 也可以多继承

抽象类和接口的区别

成员区别

• 抽象类 变量,常量；有构造方法；有抽象方法,也有非抽象方法

• 接口 常量；抽象方法

关系区别

• 类与类 继承，单继承

• 类与接口 实现，可以单实现，也可以多实现

• 接口与接口 继承，单继承，多继承

设计理念区别

• 抽象类 对类抽象，包括属性、行为

• 接口 对行为抽象，主要是行为