Day14 多态、抽象类、接口

最新推荐文章于 2024-11-18 08:41:09 发布

dejavuuu

最新推荐文章于 2024-11-18 08:41:09 发布

阅读量161

点赞数

文章标签： java

本文链接：https://blog.csdn.net/dejavuuu/article/details/110497842

版权

多态

定义

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

例如：我们可以说猫是猫，可以说猫是动物。

猫 cat = new 猫();

动物 animal = new 猫();

多态的前提和体现

1.有继承/实现关系

2.有方法重写

3.有父类引用指向子类对象

多态中成员访问特点

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

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

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

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

多态的好处和弊端

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

好处的具体体现：在定义方法时，使用父类型作为参数，将来在使用的时候使用子类型参与操作。

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

多态转型

向上转型

从子到父，父类引用指向子类对象

例： Animal a = new Cat();

向下转型（解决了父类不能访问子类特有功能的弊端）

从父到子，子类引用指向父类对象

例：Cat c = (Cat) a;

多态Demo

父类：

package Day14_02多态;

public class Animal {
    private String name;
    private int age;

    public void eat() {
        System.out.println("动物吃东西");
    }

    public Animal() {
    }

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

子类1：

package Day14_02多态;

public class Cat extends Animal{
    public Cat() {
    }

    public Cat(String name, int age) {
        super(name, age);
    }

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

子类2：

package Day14_02多态;

public class Dog extends Animal{
    public Dog() {
    }
    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}

测试类：

package Day14_02多态;

public class AnimalTest {
    public static void main(String[] args) {
        Animal c = new Cat();
        c.setName("dejavuu");
        c.setAge(3);
        System.out.println("Name:"+c.getName()+",Age:"+c.getAge());
        c.eat();

        Animal d = new Dog("REL1nqu1sh",4);
        System.out.println("Name:"+d.getName()+",Age:"+d.getAge());
        d.eat();
    }

}

抽象类

定义

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

抽象类的特点

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

public abstract class 类名{}

public abstract void eat();

2.抽象类中不一定存在抽象方法，但有抽象方法的类一定是抽象类。

3.抽象类不能实例化

但是可以参照多态的方法，通过类的对象实例化。

4.抽象类的子类要么重写抽象类的所有抽象方法，要么它本身就是一个抽象类。

抽象类的成员特点

1.成员变量

可以是变量

也可以说是常量

2.构造方法

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

构造方法的作用是用于类访问父类数据的初始化

3.成员方法

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

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

接口

定义

接口是一种公共的规范标准，只要符合规范标准，大家都可以通用。

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

接口的特点

1.接口使用interface关键字修饰

public interface 接口名{}

2.类实现接口用implements表示

public class 类名 implements 接口名{}

3.接口不能实例化

接口如何实例化呢？参照多态的方式，通过实现类对象实例化，这是接口多态。

多态的形式：具体类多态、抽象类多态、接口口多态。

4.接口的实现类

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

要么是抽象类

接口的成员特点

1.成员变量

只能是常量

默认修饰符：public static final

2.构造方法

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

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

3.成员方法

只能是抽象方法

默认修饰符：public abstract

Demo：用接口实现猫和狗

接口：

package Day14_03Interface;

public interface Jumpping {
    public abstract void Jupping ();
}

父类：

package Day14_03Interface;

public abstract class Animal implements Jumpping{
    private String name;
    private int age;

   public abstract void eat();
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Animal() {
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

子类：

package Day14_03Interface;

public class Cat extends Animal implements Jumpping{
    public Cat(String name, int age) {
        super(name, age);
    }

    public Cat() {
    }

    @Override
    public void eat() {
        System.out.println("吃鱼");
    }
    public void Jupping (){
        System.out.println("猫会跳高咯");
    }
}

子类：

package Day14_03Interface;

public class Dog extends Animal implements Jumpping{
    public Dog(String name, int age) {
        super(name, age);
    }

    public Dog() {
    }

    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
    public void Jupping (){
        System.out.println("狗会跳高咯");
    }
}

测试类：

package Day14_03Interface;

public class AnimalTest {
    public static void main(String[] args) {
        Animal c = new Cat();
        c.setName("Tom");
        c.setAge(5);
        System.out.println("Name:"+c.getName()+",Age:"+c.getAge());
        c.eat();
        c.Jupping();

        Animal d = new Dog("KIKI",4);
        System.out.println("Name:"+d.getName()+",Age:"+d.getAge());
        d.eat();
        d.Jupping();
    }
}