abstract关键字以及与public，final，static的关系 day09

    多态程序中，第一大前提要有继承关系。
    但是呢，比如上午写的动物案例，我们将狗，猫，猪这些具体的动物分别编写了一个类进行对应这都是没问题的。
    但是呢，动物本身应该是一个抽象的概念，我们在现实生活中其实是找到不到Animal的实例的。

    具体的事物，我们就可以使用java代码将其定义成一个class类，然后就可以new创建出该对象。
    针对抽象的事物，java也提供了一个关键字，可以将抽象的概念，定义成一个抽象的类，这个类将来不能进行new的。
    这个关键字：abstract

    abstract：抽象的
    可以修饰类，成员方法。

/*
具体实现的方法：指的是方法大括号方法体
抽象方法：指的是方法被abstract关键字修饰，没有具体的实现，连大括号都没有

     abstract：抽象的, 可以修饰类，成员方法。
     使用的注意事项：
        1、抽象类不能进行实例化
        2、抽象类中既可以存在具体的方法，也可以存在抽象方法，如果一个类中有抽象方法，这个类必须是抽象类
        3、抽象类可以被具体的类继承，但是如果是被具体的类继承的话，必须要重写抽象类中的所有抽象方法
        4、抽象类A继承抽象类B的时候，可以选择是否重写抽象方法，也可以都不重写，原因是上面的第2点
        5、抽象类无法进行实例化，但是却可以拥有构造方法，意义是为了将来父类做初始化，子类构造方法第一句话默认是super()
        6、抽象类中，可以存在变量，常量，静态的变量。


 */
//定义一个抽象的动物类
abstract class Animal3{
    int a = 10;
    final int b = 20;
    static int c = 30;

    Animal3(){
        System.out.println("这是抽象类Animal3的构造方法");
    }

    //具体的方法
    public void eat1(){
        System.out.println("吃");
    }
    //抽象方法
    public abstract void eat2();

    public abstract void fun1();
}

abstract class Animal31 extends Animal3{
    @Override
    public void eat2() {

    }
}

class Dog3 extends Animal3{
    @Override
    public void eat2() {
        System.out.println("吃肉");
    }

    @Override
    public void fun1() {
        System.out.println("好好学习，天天向上！");
    }
}

public class AbstractDemo2 {
    public static void main(String[] args) {
//        Animal3 anima3 = new Animal3();

        Dog3 d1 = new Dog3();
//        d1.eat2();
//        d1.fun1();

        Animal3 a1 = new Dog3();
        a1.eat2();
        a1.fun1();
        System.out.println(d1.a);
        System.out.println(d1.b);
        System.out.println(Animal3.c);

    }
}
/*
    abstract不能和哪些关键字共存
        private	冲突
        final	冲突
        static	无意义

    以后我们常见的修饰符组合：
        1、public static
        2、public abstract

 */

abstract class Demo2{
    //private修饰的方法不能被子类继承，但是abstract方法将来是要被重写的，冲突了
//    private abstract void fun1(); //非法的修饰符组合: abstract和private

    // final是不能被子类重写的，而abstract方法将来是要被重写的，也冲突了
//    public abstract final void fun1(); // 非法的修饰符组合: abstract和final

//    public static abstract void fun1(); // 非法的修饰符组合: abstract和static
}

public class AbstractDemo4 {
    public static void main(String[] args) {

    }
}