Java学习之抽象类

2021-06-11

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

1.抽象特点

1.1代码演示

package Java_Abstract;

public abstract class Animal {
    public abstract void eat();
    public void sleep(){
        System.out.println("动物爱睡觉");
    }
}

public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫猫爱吃鱼");
    }
}

public class Demo_1 {
    public static void main(String[] args) {
        //Animal a = new Animal();
        Animal c = new Cat();
        c.eat();
        c.sleep();
    }
}
//输出结果
/*
	猫猫爱吃鱼
	动物爱睡觉
*/

1.2特点

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

public abstract class 类名 {}

public abstract void 方法名();
抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
抽象类不能实例化

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

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

要么就是抽象类

2.抽象类的成员特点

2.1代码演示

package Java_Abstract2;

public abstract class Car {
    private String name = "劳斯莱斯";
    private final int price = 1;

    public Car() {
    }

    public Car(String name){
        this.name = name;
    }

    public abstract void drive();
//    public abstract void drive(){}; //Abstract methods cannot have a body:抽象方法不能有主体(不能加大括号)

    public void show() {
        name = "大众";
//        price = 2;
        System.out.println(name + price);
    }
}

public class Taxi extends Car {
    @Override
    public void drive() {
        System.out.println("开出租车");
    }
}

public class Demo_1 {
    public static void main(String[] args) {
        Car t = new Taxi();
        t.drive();
        t.show();
    }
}
//输出结果
/*
	开出租车
	大众1
*/

2.2成员特点

成员变量

可以是变量

也可以是常量
构造方法

有构造方法但不能实例化

那么，构造方法的作用是什么呢?用于子类访问父类数据的初始化
成员方法

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

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

3.利用抽象类的猫和狗案例

3.1代码演示

package Java_Abstract3;

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

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

    public abstract void eat();

    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 class Cat extends Animal {
    public Cat() {
    }

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

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

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

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

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

public class Demo_1 {
    public static void main(String[] args) {
        Animal c = new Cat();
        c.setName("Tom");
        c.setAge(4);
        System.out.println(c.getName() + "今年" + c.getAge() + "岁了");
        c.eeat();
        Animal c_2 = new Cat("tom",5);
        System.out.println(c_2.getName() + "今年" + c_2.getAge() + "岁了");
        c_2.eeat();
    }
}
//输出结果
/*
	Tom今年4岁了
	小动物爱吃东西
	tom今年5岁了
	小动物爱吃东西
*/

4.抽象类名当形参和返回值

4.1代码演示

package Java_Abstract4;

public abstract class Animal {
    public abstract void eat();
}

public class AnimalOperator {
    public void useAnimal(Animal a){  //Animal c = new Cat();
        a.eat();
    }

    public Animal getAnimal(){
        Animal a = new Cat();
        return a;
    }
}

public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫猫爱吃鱼");
    }
}

public class Demo_1 {
    public static void main(String[] args) {
        AnimalOperator a = new AnimalOperator();
        Animal c = new Cat();
        a.useAnimal(c);

        Animal c_2 = a.getAnimal(); //new Cat();
        c_2.eat();
    }
}
//输出结果
/*
	猫猫爱吃鱼
	猫猫爱吃鱼
*/

4.2总结

方法的形参是抽象类名，其实需要的是该抽象类的子类对象
方法的返回值是抽象类名，其实返回的是该抽象类的子类对象