1 /*
 2     抽象类的概述：
 3         动物不应该定义为具体的东西，而且动物中的吃，睡等也不应该是具体的。
 4         我们把一个不是具体的功能称为抽象的功能，而一个类中如果有抽象的功能，该类必须是抽象类。
 5
 6     抽象类的特点：
 7         A:抽象类和抽象方法必须用abstract关键字修饰
 8         B:抽象类中不一定有抽象方法,但是有抽象方法的类必须定义为抽象类
 9         C:抽象类不能实例化
10             因为它不是具体的。
11             抽象类有构造方法，但是不能实例化?构造方法的作用是什么呢?
12             用于子类访问父类数据的初始化
13         D:抽象的子类
14             a:如果不想重写抽象方法，该子类是一个抽象类。
15             b:重写所有的抽象方法，这个时候子类是一个具体的类。
16
17         抽象类的实例化其实是靠具体的子类实现的。是多态的方式。
18             Animal a = new Cat();
19 */
20
21 //abstract class Animal //抽象类的声明格式
22 abstract class Animal {
23     //抽象方法
24     //public abstract void eat(){} //空方法体,这个会报错。抽象方法不能有主体
25     public abstract void eat();
26
27     public Animal(){}
28 }
29
30 //子类是抽象类
31 abstract class Dog extends Animal {}
32
33 //子类是具体类，重写抽象方法
34 class Cat extends Animal {
35     public void eat() {
36         System.out.println("猫吃鱼");
37     }
38 }
39
40 class AbstractDemo {
41     public static void main(String[] args) {
42         //创建对象
43         //Animal是抽象的; 无法实例化
44         //Animal a = new Animal();
45         //通过多态的方式
46         Animal a = new Cat();
47         a.eat();
48     }
49 }

 1 /*
 2     抽象类的成员特点：
 3         成员变量：既可以是变量，也可以是常量。
 4         构造方法：有。
 5                     用于子类访问父类数据的初始化。
 6         成员方法：既可以是抽象的，也可以是非抽象的。
 7
 8     抽象类的成员方法特性：
 9         A:抽象方法 强制要求子类做的事情。
10         B:非抽象方法 子类继承的事情，提高代码复用性。
11 */
12 abstract class Animal {
13     public int num = 10;
14     public final int num2 = 20;
15
16     public Animal() {}
17
18     public Animal(String name,int age){}
19
20     public abstract void show();
21
22     public void method() {
23         System.out.println("method");
24     }
25 }
26
27 class Dog extends Animal {
28     public void show() {
29         System.out.println("show Dog");
30     }
31 }
32
33 class AbstractDemo2 {
34     public static void main(String[] args) {
35         //创建对象
36         Animal a = new Dog();
37         a.num = 100;
38         System.out.println(a.num);
39         //a.num2 = 200;
40         System.out.println(a.num2);
41         System.out.println("--------------");
42         a.show();
43         a.method();
44     }
45 }

  1 /*
  2     猫狗案例
  3         具体事物：猫，狗
  4         共性：姓名，年龄，吃饭
  5
  6     分析：从具体到抽象
  7         猫:
  8             成员变量：姓名，年龄
  9             构造方法：无参，带参
 10             成员方法：吃饭(猫吃鱼)
 11
 12         狗:
 13             成员变量：姓名，年龄
 14             构造方法：无参，带参
 15             成员方法：吃饭(狗吃肉)
 16
 17         因为有共性的内容，所以就提取了一个父类。动物。
 18         但是又由于吃饭的内容不一样，所以吃饭的方法是抽象的，
 19         而方法是抽象的类，类就必须定义为抽象类。
 20
 21         抽象动物类：
 22             成员变量：姓名，年龄
 23             构造方法：无参，带参
 24             成员方法：吃饭();
 25
 26     实现：从抽象到具体
 27         动物类:
 28             成员变量：姓名，年龄
 29             构造方法：无参，带参
 30             成员方法：吃饭();
 31
 32         狗类：
 33             继承自动物类
 34             重写吃饭();
 35
 36         猫类：
 37             继承自动物类
 38             重写吃饭();
 39 */
 40 //定义抽象的动物类
 41 abstract class Animal {
 42     //姓名
 43     private String name;
 44     //年龄
 45     private int age;
 46
 47     public Animal() {}
 48
 49     public Animal(String name,int age) {
 50         this.name = name;
 51         this.age = age;
 52     }
 53
 54     public String getName() {
 55         return name;
 56     }
 57
 58     public void setName(String name) {
 59         this.name = name;
 60     }
 61
 62     public int getAge() {
 63         return age;
 64     }
 65
 66     public void setAge(int age) {
 67         this.age = age;
 68     }
 69
 70     //定义一个抽象方法
 71     public abstract void eat();
 72 }
 73
 74 //定义具体的狗类
 75 class Dog extends Animal {
 76     public Dog() {}
 77
 78     public Dog(String name,int age) {
 79         super(name,age);
 80     }
 81
 82     public void eat() {
 83         System.out.println("狗吃肉");
 84     }
 85 }
 86
 87 //定义具体的猫类
 88 class Cat extends Animal {
 89     public Cat() {}
 90
 91     public Cat(String name,int age) {
 92         super(name,age);
 93     }
 94
 95     public void eat() {
 96         System.out.println("猫吃鱼");
 97     }
 98 }
 99
100 //测试类
101 class AbstractTest {
102     public static void main(String[] args) {
103         //测试狗类
104         //具体类用法
105         //方式1：
106         Dog d = new Dog();
107         d.setName("旺财");
108         d.setAge(3);
109         System.out.println(d.getName()+"---"+d.getAge());
110         d.eat();
111         //方式2：
112         Dog d2 = new Dog("旺财",3);
113         System.out.println(d2.getName()+"---"+d2.getAge());
114         d2.eat();
115         System.out.println("---------------------------");
116
117         Animal a = new Dog();
118         a.setName("旺财");
119         a.setAge(3);
120         System.out.println(a.getName()+"---"+a.getAge());
121         a.eat();
122
123         Animal a2 = new Dog("旺财",3);
124         System.out.println(a2.getName()+"---"+a2.getAge());
125         a2.eat();
126
127         //练习：测试猫类
128     }
129 }

 1 /*
 2 一个类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义?
 3     A:可以。
 4     B:不让创建对象。
 5
 6 abstract不能和哪些关键字共存?
 7     private    冲突
 8     final    冲突
 9     static    无意义
10 */
11 abstract class Fu {
12     //public abstract void show();
13     //非法的修饰符组合: abstract和private
14     //private abstract void show();
15
16     //非法的修饰符组合
17     //final abstract void show();
18
19     //非法的修饰符组合
20     static abstract void show();
21
22     public static void method() {
23         System.out.println("method");
24     }
25 }
26
27 class Zi extends Fu {
28     public void show() {}
29 }
30
31 class AbstractDemo3 {
32     public static void main(String[] args) {
33         Fu.method();
34     }
35 }