JAVA学习笔记21.11.17（参考黑马程序员B站视频）

JAVA学习笔记21.11.17（参考黑马程序员B站视频） 多态 一、概述

        多态是指同一对象在不同时刻表现出来的不同形态。

        前提：有继承/实现关系；有方法重写；有父类引用指向子类对象。

二、成员访问特点

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

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

        说明：成员方法有重写，成员变量没有

三、优缺点

        优点：提高了程序的扩展性

        表现：定义方法的时候，使用父类型作为参数，在使用的时候使用具体子类型进行 *** 作。

        缺点：不能使用子类特有的功能。

四、多态中的转型

        向上转型：从子到父，父类引用指向子类对象

        范例：Animal a = new Cat();

        向下转型：从父到子，父类引用转为子类对象

        范例：Cat c = (Cat)a;

五、案例

        要求：采用多态的思想实现猫和狗的案例并在测试类中测试。

        思路：

                1.定义动物类：成员变量（姓名，年龄），构造方法（无参，带参），成员方法（get/set方法，吃饭()）

                2.定义猫类：继承动物类，构造方法（无参，带参），成员方法（重写吃饭()）

                3.定义狗类：继承动物类，构造方法（无参，带参），成员方法（重写吃饭()）

                4.定义测试类：写代码测试

                        Animal类的代码：

package DuoTai;

public class Animal {

    private String name;
    private int age;

    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;
    }

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

                        Cat类代码：

package DuoTai;

public class Cat extends Animal{

    public Cat() {
    }

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

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

                        Dog类代码：

package DuoTai;

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

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

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

                        测试类：

package DuoTai;

public class Demo {
    public static void main(String[] args) {
       Animal a = new Cat();
        a.setName("加菲");
        a.setAge(5);
        System.out.println(a.getName() + "," + a.getAge());
        a.eat();
        System.out.println("-----------");

        a = new Cat("波斯",6);
        System.out.println(a.getName() + "," + a.getAge());
        a.eat();
        System.out.println("-----------");

        Animal b = new Dog();
        b.setName("斗牛");
        b.setAge(7);
        System.out.println(b.getName() + "," + b.getAge());
        b.eat();
        System.out.println("-----------");

        b = new Dog("旺财",8);
        System.out.println(b.getName() + "," + b.getAge());
        b.eat();
    }
}

抽象类 一、抽象类概述

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

        范例：public abstract class Animal{

                        public abstract void eat();

                }

二、抽象类的特点

        1.抽象类和抽象方法必须用abstract 修饰

        2.抽象类中不一定有抽象方法但是有抽象方法的一定是抽象类

        3.抽象类不可以实例化，但是可以参照多态的方式，通过子类对象实例化（抽象类多态）

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

三、抽象类的成员特点

        1.成员变量：可以是变量也可以是常量。

        2.构造方法：有构造方法，用来子类访问父类数据的初始化，但不能用来实例化。

        3.成员方法：可以是抽象方法（限定子类必须完成某些动作）。也可以是非抽象方法（提高代码的复用性）。

四、案例

        要求：采用抽象类的思想实现猫和狗的案例并在测试类中测试。

        思路：

                1.定义动物类：成员变量（姓名，年龄），构造方法（无参，带参），成员方法（get/set方法，吃饭()）

                2.定义猫类：继承动物类，构造方法（无参，带参），成员方法（重写吃饭(){……}）

                3.定义狗类：继承动物类，构造方法（无参，带参），成员方法（重写吃饭(){……}）

                4.定义测试类：写代码测试

        代码实现：

                        Animal类的代码：

package MyAbstract;

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

    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;
    }

    public abstract void eat();
}

                        Cat类代码：

package MyAbstract;

public class Cat extends Animal{

    public Cat() {
    }

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

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

                        Dog类代码：

package MyAbstract;

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

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

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

                        测试类：

package MyAbstract;

public class Demo {
    public static void main(String[] args) {
        Animal a = new Cat();
        a.setName("加肥");
        a.setAge(5);
        a.eat();
        System.out.println(a.getName() + "," + a.getAge());
        System.out.println("-----------");

        a = new Cat("波斯",6);
        a.eat();
        System.out.println(a.getName() + "," + a.getAge());
        System.out.println("-----------");

        Animal b = new Dog();
        b.setName("斗牛");
        b.setAge(7);
        b.eat();
        System.out.println(b.getName() + "," + b.getAge());
        System.out.println("-----------");

        b = new Dog("旺财",8);
        b.eat();
        System.out.println(b.getName() + "," + b.getAge());
    }
}