JAVA面向对象之多态与接口

多态概述:

        同一个对象，在不同时刻表现出的不同形态

举例：猫

我们可以说猫是猫：猫 cat =new 猫（）；

我们也可以说猫是动物：动物 animal = new 猫（）；

这是猫在不同时刻表现出的不同形态，这就是多态；
 

多态的前提和体现：

• 有继承/实现的关系
• 有方法重写
• 有父类引用指向子类对象

 多态中成员访问特点

• 成员变量：编译看左边，执行看右边
• 成员方法：编译看左边，执行看右边

 代码示例如下：

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

/*3.口诀1：父类引用指向子类对象
        * 解释：创建出来的子类对象的地址值，交给父类类型的引用类型变量来保存*/
        Animal a =new Cat();

        System.out.println(a.age);//打印的是父类中的成员变量

//        System.out.println(a.weight);

         /*4.口诀2：编译看左边，运行看右边
        * 解释：必须要在父类定义这个方法，才能通过编译，把多态对象看作是父类类型
        *      必须要在子类重写这个方法，才能满足多态，实际干活的是子类*/

        a.eat();//猫吃鱼

//        a.playGame();

       
    }
}



public class Cat extends Animal {
    public int age=20;
    public int weight =10;
    public void eat()
    {
        System.out.println("猫吃鱼");
    }
    public void playGame()
    {
        System.out.println("猫捉老鼠");
    }
}

public class Animal {
    public int age=40;
    public void eat()
    {
        System.out.println("动物吃东西");
    }
}

 

 多态的好处和弊端：

• 多态的好处：提高了程序的扩展性

                具体体现:定义方法的时候 ，使用父类型座位参数，将来在使用的时候，使用具体的子类型参与操作

• 多态的弊端：不能使用子类的特有功能

 多态中的转型：

为了消除多态中的弊端，多态中的转型能够帮助我们实现子类中的特有功能

• 向上转型：

                从子到父

                父类引用指向子类对象

• 向下转型

                从父到子

                父类引用转为子类对象

废话不多说，上代码

public class AnimalDemo {
    public static void main(String[] args)
    {
    //向上转型
        Animal a =new Cat();
        a.eat();                //猫吃鱼
    //a.playGame();

    
    //向下转型
        Cat c=(Cat)a;
        c.eat();                //猫吃鱼
        c.playGame();           //猫捉老鼠



       
    }
}



public class Cat extends Animal {
    public int age=20;
    public int weight =10;
    public void eat()
    {
        System.out.println("猫吃鱼");
    }
    public void playGame()
    {
        System.out.println("猫捉老鼠");
    }
}

public class Animal {
    public int age=40;
    public void eat()
    {
        System.out.println("动物吃东西");
    }
}

---

接下来了解一下抽象类

抽象类的概念

在JAVA中，一个没有方法体的方法应该定义为抽象方法，而类中有抽象方法，该类应该定义为抽象类，接下来我们看看抽象类在java中的写法

public abstract class Animal{

    
    public abstract void eat();//带有abstract关键字的为抽象方法，类中方法有抽象方法，该类必须是抽象类，即类的定义前要加abstract关键字，表示该类为抽象类


}

抽象类的特点：

• 抽象类和抽象方法必须使用abstract关键字修饰

                public abstract void eat();

• 抽象类中不一定有抽象方法，有抽象方法的一定是抽象类
• 抽象类不能实例化

                抽象类如何实例化？参照多态的方式，通过子类对象实例化，这叫抽象多态类

• 抽象类的子类

                要么是重写抽象类中所有抽象方法

                要么子类本身就是抽象类

抽象类的成员特点：

• 成员变量

                可以是变量

                也可以是常量

• 构造方法      

                有构造方法，但是不能实例化

                构造方法用于子类访问父类数的初始化

• 成员方法

                可以有抽象方法：限定于子类必须完成某些动作

                也可以有非抽象方法：提高代码的复用性

---

Java中的接口：

接口就像一个类一样，一个接口也能够拥有方法和属性，但是在接口中声明的方法默认是抽象的。（即只有方法标识符，而没有方法体）。Java中的接口更多的体现在对行为的抽象上面

接口的特点：

接口的创建：创建Java类时，kind一行选中Interface

接口的特点：

• 接口使用关键字interface修饰
• 类实现接口用implements表示

例：

 

• 接口不能实例化

                接口如何实现实例化？通过实现类多态实例化，这叫接口多态

                多态的形式：具体类多态，抽象类多态，接口多态。（具体类多态使用很少）

                多态的前提：有继承或者实现关系；有方法重写；有父（类/接口）引用指向（子/实现）类对象

• 接口的实现类

                要么重写接口中的所有抽象方法

                要么是抽象类

 接口的成员特点：

• 成员变量：

                只能是常量

                默认修饰符：public static final

• 构造方法：

                接口没有构造方法，因为接口主要是对行为进行抽象的，是没有具体存在

                一个类如果没有父类，默认继承Object类

•  成员方法

                只能是抽象方法

                默认修饰符：public abstract

---

接口和类的关系：

• 类和类的关系

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

• 类和接口的关系

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

• 接口和接口的关系

                继承关系，可以单继承，也可以多继承

类与接口关系

 接口与接口的关系

 抽象类和接口的区别

• 成员区别

                抽象类：变量；常量，有构造方法；有抽象方法，也有非抽象方法发

                接口：常量，抽象方法

• 关系区别：

                类与类：继承，单继承

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

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

• 设计理念区别：

                抽象类：对类抽象，包括属性，行为

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