Java 抽象类

A. 抽象类

1. 概述

抽象方法：没有方法体的方法（不是具体的，不能创建对象）

抽象类：类中有抽象方法

/*
    抽象方法：没有方法体(加上 abstract );必须在抽象类中(抽象类也要加上 abstract )
*/

public abstract class Animal{        //抽象方法必须有抽象类
    public abstract void eat();    //没有方法体，抽象方法
}

2. 抽象类的特点

/*
    （1）抽象方法、抽象类都必须用abstract修饰
    （2）抽象类中可以有抽象方法，也可以有非抽象方法；也可以没有抽象方法存在
    （3）抽象类参照多态的形式创建对象：要有继承（子类继承抽象类，在子类中重写抽象方法）
    （4）抽象类的子类：子类要重写继承抽象类中所有的抽象方法
    （5）抽象类的子类要么重写抽象类中所有抽象方法，要么它本身也是一个抽象方法

*/

//Animal类
public abstract class Animal{        //抽象方法必须有抽象类
    public abstract void eat();    //没有方法体，抽象方法

    //非抽象方法（抽象类中也可以有非抽象方法）
    public void sleep(){
        System.out.println("睡觉");
    }
}

//Cat类
public class Cat{
    //重写eat方法，使得抽象类中的抽象方法可以被创建对象
    @Override
     public void eat(){
        System.out.println("猫吃东西");
    }
    
}


//AnimalDemo类
public class AnimalDemo{
    public static void main(String[] args){
        //通过子类继承抽象类 来创建抽象类中的对象
        Animal a = new Cat();
        a.eat():
        a.sleep();
    }

}


//Dog类
public abstract class Dog extends Animal{
    public abstract void eat();
}

3.抽象类的成员特点

/*

    包含成员变量/不变量、成员方法(非抽象、非抽象方法)

    可以有构造方法(带参、不带参)    【不能实例化、可以通过多态的方式实例化】

    父类的抽象方法的作用：就是限定子类必须要去做某些事情
*/

//Animal类
public static class Animal{
    private int age = 20;
    private final String city = "北京";
    //可以非抽象方法
    public void show(){
        age = 40;
        System.out.println(age);
        //错的(final修饰，是不变量)    city = "广东";
        System.out.println(city);
    }
     //可以抽象方法
    public abstract void eat();
}


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



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

    } 
}

案例：猫和狗

//继承动物类
package CatAndDog3;
public class Cat extends Animal{
    //构造方法（无参、带参）
    public Cat() {
    }
    public Cat(int age, String name) {
        super(age, name);
    }
    //成员方法
    @Override
    public void eat() {
        System.out.println("猫吃饭");
    }

}




//继承Animal 类
package CatAndDog3;
public class Dog extends Animal{
    //构造方法（无参、带参）
    public Dog() {
    }

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

    //成员方法：重写eat方法
    @Override
    public void eat(){
        System.out.println("狗狗吃饭");
    }

}




//Animal类
package CatAndDog3;
public abstract class Animal {
    //成员变量
    private int age;
    private String name;
    //构造方法（无参、带参）
    public Animal() {
    }
    public Animal(int age, String name) {
        this.age = age;
        this.name = name;
    }

    //成员方法：get/set方法、eat()方法（抽象）
    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

}





//AnimalDemo类
package CatAndDog3;
//代码测试
import CatAndDog2.Animal;
import CatAndDog2.Cat;
import CatAndDog2.Dog;

public class AnimalDemo {
    public static void main(String[] args){
        //创建Cat类对象进行测试
        //无参测试
        CatAndDog2.Animal a = new CatAndDog2.Cat();
        a.setName("加菲猫");
        a.setAge(18);
        System.out.println(a.getName() + ", " + a.getAge());
        a.eat();

        //带参测试
        a = new Cat("加菲猫",18);
        System.out.println(a.getName() + ", " + a.getAge());
        a.eat();


        //创建Dog类对象进行测试
        //无参测试
        Animal b = new CatAndDog2.Dog();
        b.setName("掌门狗");
        b.setAge(16);
        System.out.println(b.getName() + ", " + b.getAge());
        b.eat();
        //带参测试
        b = new Dog("掌门狗",16);
        System.out.println(b.getName() + ", " + b.getAge());
        b.eat();

    }

}