Pragma mark — NO.1 基础代码

public class ChouxiangLei {

    public  static  void main(String[] args){
        // Animal1 a = new Animal1(); Animal1是无法被实例化的，因为这个eat方法
        //是一个抽象方法，没有实现，如果我们可以实例化类，那么就可以调用这个eat方法，这是不允许的
        Animal1 a = new Cat1();//父类引用指向子类对象--多态啊
        a.eat();
    }

}
//创建一个抽象类--abstract是抽象的关键字

//抽象类:不知道类内部是怎样的，有什么成员变量，有什么方法
//抽象方法:不知道方法内部该怎么实现

/*
* 抽象类不一定有抽象方法，有抽象方法的类，一定是抽象类或者接口
*B:抽象类不能实例化，那么如何实例化呢?
* 按照多态的方式，由具体的子类实例化，其实这也是多态的一种:抽象类多态
* C:抽象类的子类:
* 要么是抽象类
* 要么重写抽象类中的所有抽象方法
* */
abstract  class Animal1{

   //抽象方法--注意抽象方法后面不接这个方法实现的中括号了
    public abstract void eat();
}

//创建一个子类继承自Animal1 -- 对于这个子类来说，继承自抽象类，那么必须重写父类所有的抽象方法
class  Cat1 extends Animal1{
     public  void eat(){
         System.out.println("猫要吃鱼”);
    }
}

Pragma mark — NO.2 抽象类特点

public class ChouXianglei2 {

    public static void  main(String[] args){

     SubDemo s = new SubDemo();
     s.method();

    }

}
/*
* A:抽象类的成员特点
* a:成员变量:既可以是变量，也可以是常量。 abstract 不能修饰成员变量
* b:构造方法:有
* 用于子类访问父类数据的初始化
* c:成员方法:既可以是抽象的，也可以不是
* */
//创建一个抽象类--抽象类中可以有哪些东西
abstract  class  Demo {
    int num1 = 10;//变量
    final  int num2 = 20;//常量
    //构造方法
    public  Demo(){
        //我们在super的构造中写点东西\
        System.out.println("我是构造方法");
    }

    //普通方法
    public void print(){

        System.out.println("我是普通方法");
    }
    //抽象方法
    public abstract  void method();
}

//搞个子类
class  SubDemo extends Demo{
    public SubDemo(){
        //在子类的构造方法中隐藏了super
        super();
    }
    //子类必须要重写抽象父类的抽象方法
    public void method(){
        System.out.println("我是子类，重写了父类的抽象方法");
    }
}

Pragma mark — NO.3 葵花宝典的例子说明父类强制子类执行

public class ChouXianglei3 {
    public static void main (String[] args){
        //分别创建这三个人类
        DongFbb dongfang = new DongFbb();
        Yuebq yue = new Yuebq();
        Lingpz ling = new Lingpz();

        dongfang.Zigong();
        yue.Zigong();
        ling.Zigong();
    //这个例子告诉我们，父类要求子类强制执行的，你要练我神功，就必须实现自宫这一步.
    }
}

/*
* 以葵花宝典举例说明这个抽象类
* */
//创建一个葵花宝典的抽象类
abstract class Kuihuabaodian{
    //创建一个抽象方法--自宫
    //创建这个方法的意思是:你只要练我这个武功，你就得自宫
    public abstract void Zigong();
}
//接下来有人要练这个葵花宝典了，那么就得继承自这个抽象类
//假如东方不败练这个东西
class DongFbb extends Kuihuabaodian{
    public  void Zigong(){
        System.out.println("欲练此功，必先自宫--用刀");
    }
}
//我们再来一个人岳不群练这个
class Yuebq extends Kuihuabaodian{
    public void Zigong(){
        System.out.println("欲练此功，必先自宫--用牙签");
    }
}
//我们再来一个人林平之练这个
class Lingpz extends Kuihuabaodian {
    public void Zigong() {
        System.out.println("欲练此功，必先自宫--用指甲刀");
    }
}

Pragma mark — NO.4 简单猫狗案例

public class ChouXianglei4 {

    public static void main (String[] args){

     //创建对象
        Cat12 c = new Cat12("lingling",18);
        Dog2 d = new Dog2("dulan",22);

        //调用方法
        c.eat();
        c.catchMouse();

        d.eat();
        d.lookHome();
    }
}

/*
* 案例演示:
* 具体事物:猫，狗
* 共性:姓名，年龄，吃饭
* 猫的特性:抓老鼠
* 狗的特性:看家
**/

//抽取一个父类--动物类
abstract class  Animal2 {

    private  String name;
    private  int age;

    public Animal2(){}

    public Animal2(String name, int age){

        this.name = name;
        this.age = age;
    }

    //set/get方法
    public void setName(String name){

        this.name = name;
    }

    public String getName(){

        return name;
    }

    public void setAge(int age){

        this.age = age;
    }

    public int getAge(){
        return age;
    }

    //这里有个吃饭方法，我们无法确定，定义为抽象方法

    public abstract void eat();


}
//定义猫类
class  Cat12 extends Animal2{

    //写上有参和无参构造
    public Cat12(){}

    public Cat12(String name, int age){

//        this.name = name;
//        this.age = age;//这里不能直接this，因为本类中并没有name和age的成员
        //可以直接调用父类的,让父类去给我们构建
        super(name,age);
    }
//重写抽象类的抽象方法
    public void eat(){

        System.out.println("猫要吃鱼");
    }
    //自身特有方法
    public  void catchMouse(){
        System.out.println("我要抓老鼠");
    }

}
//定义狗类
class Dog2 extends Animal2{

    //写上有参和无参构造
    public Dog2(){}

    public Dog2(String name, int age){
        super(name,age);
    }
    public void eat(){
        System.out.println("狗要吃骨头");
    }
    public void lookHome(){
        System.out.println("我会看家");
    }

}

Pragma mark — NO.5 面试题

1.一个抽象类如果没有抽象方法，可不可以定义为抽象类，有什么意义?
答:可以,作用是:目的只有一个，就是不让其它类创建本类对象，交给子类去调用。
2.abstract关键字不能和哪些关键字共存
答:
(1).不能和static共存:
 被abstract修饰的方法没有方法体，被static修饰的可以用类名.调用，但是类名.调用抽象方法是没有意义的
(2).不能和final共存:
 被abstract修饰的方法强制子类重写
 被final修饰的不让子类重写，所以这两个是矛盾的 
(3).private和abstract:
被abstract修饰的是为了让子类看到并强制重写
被private修饰不让子类访问，所以这两个是矛盾的