1-3-2-抽象类

 

 父类的抽象方法就像图形计算面积的方法，是没有办法计算的，需要子类来计算抽象方法，就像正方形是可以计算面积的一样

子类既是父类也是子类，就像汪星人就是汪星人，汪星人就是汪星人的父类，汪星人也是动物的子类一样

 

抽象方法：就是加上abstract关键字，然后去掉大括号，直接分号结束

抽象类：抽象方法所在的类必须是抽象类，在class前直接写上abstract即可，抽象类里可以有非抽象方法

//抽象类
public abstract class Animal {
    //抽象方法
    public abstract void eat();
    public abstract void drink();

    //普通的成员方法
    public void normalMethod(){

    }
}

 

如何使用抽象类和抽象方法：
1.不能直接创建new抽象类对象

public class DemoMain {
    public static void main(String[] args) {
        Animal animal = new Animal();//错误写法
    }
}

2.必须用一个子类来继承抽象父类
3.子类必须覆盖重写父类当中所有抽象方法

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

    @Override
    public void drink() {
        System.out.println("猫喝水");
    }
}

4.虽然方法是父类创建的抽象方法，但是是子类对象进行使用

public class DemoMain {
    public static void main(String[] args) {
//        Animal animal = new Animal();//错误写法
        Cat cat = new Cat();//子类创建对象进行使用而不是父类创建
        cat.eat();
        cat.drink();
    }
}

 

 

 

 

1.第一个注意事项就是上面第4条的用法

2.

父类

public abstract class Fu {
    //构造器
    public Fu(){
        System.out.println("父类构造器启动");
    }
    //抽象方法
    public abstract void eat();
}

子类

public class Zi extends Fu {
    //子类构造器

    public Zi(){
        //构造器启动前会有一个隐藏的super()去调用父类的构造器
        //super();
        System.out.println("子类构造器启动");
    }

    //父类抽象方法
    @Override
    public void eat() {
        System.out.println("吃东西");
    }
}

 

启动类

public class DemoMain {
    public static void main(String[] args) {
        Zi zi = new Zi();
        zi.eat();
    }
}

运行结果

3.抽象方法所在的类必须是抽象类，在class前直接写上abstract即可，抽象类里可以有非抽象方法，也可以没有抽象方法

//这样没有抽象方法的抽象类，也不能直接创建对象，在一些特殊场景下有用（适配器模式）
public abstract class MyAbstract {

}

4.子类必须覆盖重写父类当中所有抽象方法，除非你的子类也是抽象类，否则就会编译不通过报错

抽象父类Animal

//父类
public abstract class Animal {
    public abstract void sleep();
    public abstract void eat();
}

抽象子类Dog

//子类
public abstract class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗吃饭");
    }
    //这里隐藏了Animal中的public abstract void sleep();方法，Dog方法的子类可以重写该方法
}

Dog子类Dog2Ha

public class Dog2Ha extends Dog {
    @Override
    public void sleep() {
        System.out.println("二哈睡觉");
    }
}

Dog子类DogGold

//Dog类的子类
public class DogGold extends Dog{
    //这里只有重写sleep方法，因为eat方法在Dog被重写过了
    @Override
    public void sleep() {
        System.out.println("金毛睡觉");
    }
}

启动类

public class DemoMain2 {
    public static void main(String[] args) {
//        Animal animal = new Animal();//这是抽象类，错误的
//        Dog dog = new Dog();//这也是错误的，这也是抽象类
        Dog2Ha dog2Ha = new Dog2Ha();
        dog2Ha.eat();
        dog2Ha.sleep();
        System.out.println("================");
        DogGold dogGold = new DogGold();
        dogGold.eat();
        dogGold.sleep();
    }
}

结果