java中的抽象类

package com.aaa.zxf.ajax.test;

/**

  一、java中的 抽象

 Animal这个类 存在的意义是什么？
    （动物园真的有一个动物叫Animal吗？没有 但是你为了某种操作创建了Animal 那么此时程序就有一个bug


 分析：
     1  Animal这个来存来仅仅是用来产生多态，但是为了多态而导致能创建Animal对象这显然是不合理的，
            所以我们希望：Animal这个类得存在，但是不能通过new 创建对象
     2  Animal的eat有用，在编译的时候 如果Animal没有eat函数 编译不会通过，但是我们运行的时候 是调用的真实类型的eat()所以Animal的eat不会被调用。
            Animal的eat方法得有 但是方法体没什么用。
            所以我们希望：Animal中的eat函数 只声明 不写实现（因为没必要写）。
     3  Animal的子类必须要有各自的eat函数，但是我们做的练习 eat可以不写，此时会去调用父类的eat函数。所以我们希望：子类必须实现eat（）函数

    解决方案：将Animal这个类变成抽象类


 二、声明一个抽象类

 三、java中抽象类中构造函数使用
      1.   构造函数是对象的基本，没有构造函数就没有对象。

      2.   父类抽象类中写了有参数的构造函数，子类继承是就必须写一个构造函数来调用父类的构造函数

 四、匿名内部类

 */
public class JavaDuoTai {
    public static void main(String[] args) {
        // 继承多态
        Animal02 h = new Hourse();
        // h 代表了两个对象。
                h.sleep();      // 调用父类抽象类中的普通方法  sleep
                h.eat();        // 调用子类中的方法 eat。

        Hourse hourse = new Hourse("张三", 45);
        System.out.println("  name="+hourse.name +"     age="+ hourse.age);



        /**
         *  抽象类无法通过new 来创建对象。 因为是抽象的。
         *  我是匿名内部类 实现它的抽象方法。
         * 这种写法
         */
        Animal02 animal02 = new Animal02() {
            @Override
            public void eat() {
                System.out.println("我是匿名内部类");
                //多一个T$1.class，这个class就是匿名内部类的原型，
                // 所以new针对的还是普通的class（虽然内部类和普通类有很大不一样），只不过这个class的写法稍有不同，它是编译器帮我们从匿名内部类中提取的。
                System.out.println("获得class的对象"+this.getClass());
            }
        };

        //执行 匿名内部类
        animal02.eat();

    }

}
class Animal01{
    public int id;
    public String name;
    private  int age;

    void run(){
        System.out.println("动物要吃饭");
    }
}

class  Dog01 extends  Animal01{
    public  String food;

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

}

class Cat01 extends Animal01{
    public String color;

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


/**
 * 二、 声明一个抽象类
 *
 *   1.   关键字  abstract  用来修饰类 和 方法。
 *
 *
 *   2.   抽象类的特征？
             * A  抽象方法不需要写方法体
             * B  抽象方法必须在抽象类中
             *      The type Animal must be an abstract class to define abstract methods
             * C  抽象类中不一定要有抽象方法 （抽象类可以有抽象方法 普通方法 成员方法）
             * D  子类继承了一个抽象父类并且父类中有抽象方法 那么子类必须去重写抽象方法----》抽象方法由子类负责实现
             * E  抽象类不能通过new创建对象 但是 有构造函数 （
             *    这个构造函数是用来让子类调用的
 *
 */

// 定义一个抽象类。
abstract class Animal02{


    public  String name;
    public  int age;

    public Animal02() {
    }

    //有参数的构造函数      这个构造函数是用来让子类调用的
    public Animal02(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public  abstract void eat(); //1.抽象方法不需要写方法体    2.抽象方法必须在抽象类中

    //抽象类中不一定要有抽象方法     普通方法
    public  void  sleep(){
        System.out.println("睡觉！");
    }

}


//子类 继承抽象类 需要重写父类的方法
class Hourse extends  Animal02{

    public Hourse() {
    }

    // 让子类调用父类的 构造函数  关键字 super
    public Hourse(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("马飞飞。");
    }
}