Java abstract 关键字

Java abstract 关键字

abstract—抽象的，在java中可以用来修饰类和方法。在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。

在 Java 中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口。

1.abstract修饰类：抽象类

1.1不能实例化

1.2抽象类中一定有构造器，便于子类实例化使用

1.3开发中，会提供抽象类的子类，让子类实例化，完成相关操作

2.abstract修饰方法

2.1抽象方法只有方法的声明，没有方法体

2.2包含抽象方法的类，一定是抽象类

2.3若子类重写了父类中抽象方法，则子类可实例化

2.4若子类没有重写父类中所有抽象方法，则子类也是一个抽象类，需要使用abstract修饰

3.抽象类的匿名子类

4.抽象类的体现就是一种模板模式的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展，改造，但子类总体上会保留抽象类的行为方式。

使用的两种场景：

4.1当功能内部一部分是确定的实现，另一部分是不确定的实现，这时可以把不确定的部分暴露出去，让子类实现。

4.2通用的写法在父类中写好，存在变化的部分，可以抽象出来让子类实现。

代码示例：

/*
abstract 关键字的使用
1.abstract 抽象的
2.abstract 可以用来修饰的结构：类、方法
3.abstract修饰类：抽象类
    1.不能实例化
    2.抽象类中一定有构造器，便于子类实例化时使用
    3.开发中，会提供抽象类的子类，让子类实例化，完成相关操作
4.abstract修饰方法
    1.抽象方法只有方法的声明，没有方法体
    2.包含抽象方法的类，一定时抽象类
    3.若子类重写了父类中的抽象方法，则子类可实例化
    4.若子类没有重写父类中的所有抽象方法，则子类也是一个抽象类，需要使用abstract修饰

5.抽象类的匿名子类
6.抽象类的体现就是一种模板模式的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展，改造，但子类总体上会保留抽象类的行为方式。
    1.当功能内部一部分实现时确定的，另一部分实现是不确定的，这时可以吧不确定的部分暴露出去，让子类去实现。
    2.通用的写法在父类中写好，存在变化的部分，可以抽象出来让子类实现。

 */
public class AbstractTest {
    public static void main(String[] args) {
        //一旦Person类抽象了，就不可以实例化
//        aPerson p1 = new aPerson();
//        p1.eat();

        //非匿名的类，非匿名的对象
        Student stu1 = new Student("Zane",55);
        stu1.eat();//Students need to eat more meat.
        stu1.drink();//Students need to drink milk.
        stu1.show();//name = Zane, age = 55

        //非匿名的类，匿名的对象
        method(new Student());//name = null, age = 0

        //创建了一个匿名子类的对象p1,一般只用一次该对象
        aPerson p1 = new aPerson(){

            @Override
            public void eat() {
                System.out.println("Eating");

            }

            @Override
            public void drink() {
                System.out.println("Drinking");

            }
        };
        p1.eat();//Eating
        p1.drink();//Drinking

        //创建匿名子类的匿名对象
        method(new aPerson() {
            @Override
            public void eat() {
                System.out.println("I like eating");
            }

            @Override
            public void drink() {
                System.out.println("I like drinking");

            }
        });


    }


    public static void method(aPerson p){
        p.show();

    }

}

abstract class Creature{
    public abstract void drink();
}

abstract class aPerson extends Creature{
    String name;
    int age;

    public aPerson(){

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

//    public void eat(){
//        System.out.println("Person need eating.");
    public abstract void eat();

    public void show(){
        System.out.println("name = " + name + ", age = " + age);
    }



}

class Student extends aPerson{
    public Student(String name, int age){
        super(name, age);
    }

    public Student(){

    }
    //需要重写父类aPerson中的eat方法
    @Override
    public void eat() {
        System.out.println("Students need to eat more meat.");

    }

    @Override
    public void drink() {
        System.out.println("Students need to drink milk.");
    }
}

class Worker extends aPerson{

    @Override
    public void drink() {

    }

    @Override
    public void eat() {

    }
}