JavaSe总结-09--面向对象(4)

09.01
final关键字引入

09.02 final关键字修饰类,方法以及变量的特点

09.03 final关键字修饰局部变量

09.04 final修饰变量的初始化时机

09.05 多态的概述和前提条件

09.06 按照多态前提给出代码体现

09.07 多态中的成员访问特点

09.08 多态的好处

09.09 多态的弊端

09.10 多态中向上转型和向下转型

09.11 孔子装爹案例讲解多态现象

09.12 多态继承中的内存图解

09.13 多态中的对象变化内存图解

09.14 猫狗案例多态版

09.15 南北方人案例

09.16 多态的练习题看程序写结果

09.17 抽象类的引入

09.18 抽象类的特点

09.19 抽象类的成员特点

09.20 抽象类练习猫狗案例

09.21 抽象类练习老师案例

09.22 抽象类练习学员案例

09.23 抽象类练习员工案例

09.24 抽象类中的小问题

09.25 接口的引入

09.26 接口的特点

09.27 接口的成员特点

09.28 类与类,类与接口,接口与接口的关系

09.29 抽象类和接口的区别

09.30 猫狗案例加入跳高功能分析

09.31 猫狗案例加入跳高功能代码实现

09.32 老师学生案例加入抽烟功能分析及代码实现

09.01 final关键字引入

1 class Fu
2 {
3     public final void show()
4     {
5         System.out.println("访问底层资源");
6     }
7 }
8 class Zi extends Fu
9 {
10     public void show()
11     {
12         System.out.println("Zi show run");
13     }
14 }
15 class Demo
16 {
17     public static void main(String[] args)
18     {
19         Zi z = new Zi();
20         z.show();
21     }
22 }

上面的代码中父类中的show()方法如果不想被子类覆盖，可以使用final关键字修饰，当子类覆盖了父类中的show()方法，将会报以下错误:


final关键字是最终的意思，可以修饰类，成员变量，成员方法

09.02 final关键字修饰类,方法以及变量的特点

修饰类，类不能被继承

修饰方法，方法不能被重写

修饰变量，变量就变成了常量，只能被赋值一次







09.03 final关键字修饰局部变量

1 class Student
2 {
3     int age = 10;
4 }
5 class Demo
6 {
7     public static void main(String[] args)
8     {
9         //final修饰基本类型的局部变量
10         final int x = 10;
11         //x = 20; 值不能被改变
12         System.out.println(x);
13
14         //final修饰引用类型的局部变量
15         final Student s = new Student();
16         //s = new Student(); 引用类型的地址值不能变
17         s.age = 20;
18         System.out.println(s.age);
19     }
20 }

final修饰基本类型的局部变量，该变量的值不能被改变

final修饰引用类型的局部变量，引用类型的地址值不能变

09.04 final修饰变量的初始化时机

1 class Test
2 {
3     int num1;
4     final int num2; //在对象构造完毕前即可
5     public Test()
6     {
7         num1 = 100;
8         num2 = 200;
9     }
10 }
11 class Demo
12 {
13     public static void main(String[] args)
14     {
15         Test t = new Test();
16         System.out.println(t.num1);
17         System.out.println(t.num2);
18     }
19 }

09.05 多态的概述和前提条件

多态概述:某一个对象，在不同时刻表现出来的不同状态。

举例:猫可以是猫的类型。Cat c = new Cat();

同时猫也是动物的一种，也可以把猫称为动物。Animal a = new Animal();

多态的前提:

1.有继承关系

2.有方法重写

3.有父类引用指向子类对象

09.06 按照多态前提给出代码体现

1 class Fu
2 {
3     public void show()
4     {
5         System.out.println("Fu show run")
6     }
7 }
8 class Zi extends Fu
9 {
10     public void show()
11     {
12         System.out.println("Zi show run")
13     }
14 }
15 class Demo
16 {
17     public static void main(String[] args)
18     {
19         //父类引用指向子类对象
20         Fu f = new Zi();
21     }
22 }

09.07 多态中的成员访问特点

1.成员变量 编译看左边，运行看左边

1 class Fu
2 {
3     public int num1 = 10;
4 }
5 class Zi extends Fu
6 {
7     public int num1 = 20;
8     public int num2 = 30;
9
10 }
11 class Demo
12 {
13     public static void main(String[] args)
14     {
15         //编译时查看Fu类中是否有num1，有就编译通过
16         Fu f = new Zi();
17         //运行时输出Fu类中的num1
18         System.out.println(f.num1);
19         //Fu类中没有num2，编译失败
20         //System.out.println(f.num2);
21     }
22 }

2.成员方法 编译看左边，运行看右边

1 class Fu
2 {
3     public void show()
4     {
5         System.out.println("Fu show run");
6     }
7
8 }
9 class Zi extends Fu
10 {
11     public void show()
12     {
13         System.out.println("Zi show run");
14     }
15     public void method()
16     {
17         System.out.println("Zi method run");
18     }
19
20 }
21 class Demo
22 {
23     public static void main(String[] args)
24     {
25         Fu f = new Zi();
26         //编译时查看Fu类中是否有show()方法，有就编译通过
27         //运行时输出Zi类中show()方法
28         f.show();
29         //Fu类中没有num2，编译失败
30         //f.method();
31     }
32 }

3.静态方法 编译看左边，运行看左边(静态方法与类相关，不能算方法的重写)

1 class Fu
2 {
3     public static void show()
4     {
5         System.out.println("Fu show run");
6     }
7
8 }
9 class Zi extends Fu
10 {
11     public static void show()
12     {
13         System.out.println("Zi show run");
14     }
15     public void method()
16     {
17         System.out.println("Zi method run");
18     }
19
20 }
21 class Demo
22 {
23     public static void main(String[] args)
24     {
25         Fu f = new Zi();
26         //编译时查看Fu类中是否有show()方法，有就编译通过
27         //运行时输出Fu类中show()方法
28         f.show();
29     }
30 }

09.08 多态的好处

多态的好处

提高了程序的维护性(由继承保证)

提高了程序的扩展性(由多态保证)

例:

1 class Animal
2 {
3     public void eat()
4     {
5         System.out.println("eat");
6     }
7 }
8 class Cat extends Animal
9 {
10     public void eat()
11     {
12         System.out.println("猫吃鱼");
13     }
14 }
15 class Dog extends Animal
16 {
17     public void eat()
18     {
19         System.out.println("狗吃肉");
20     }
21 }
22 class Demo
23 {
24     public static void main(String[] args)
25     {
26         Cat c = new Cat();
27         Dog d = new Dog();
28         method(c);
29         method(d);
30     }
31 　　 //提高了代码的扩展性，前期定义的代码可以使用后期的内容
32     public static void method(Animal a)
33     {
34         a.eat();
35     }
36 }

09.09 多态的弊端

多态的弊端:不能访问子类特有功能

1 class Fu
2 {
3     public void show()
4     {
5         System.out.println("Fu show run");
6     }
7 }
8 class Zi extends Fu
9 {
10     public void show()
11     {
12         System.out.println("Zi show run");
13     }
14     public void method()
15     {
16         System.out.println("Zi method run");
17     }
18 }
19 class Demo
20 {
21     public static void main(String[] args)
22     {
23         Fu f = new Zi();
24         f.show();
25         //错误，不能访问子类特有功能
26         //f.method();
27     }
28 }

09.10 多态中向上转型和向下转型

1 class Fu
2 {
3     public void show()
4     {
5         System.out.println("Fu show run");
6     }
7 }
8 class Zi extends Fu
9 {
10     public void show()
11     {
12         System.out.println("Zi show run");
13     }
14     public void method()
15     {
16         System.out.println("Zi method run");
17     }
18 }
19 class Demo
20 {
21     public static void main(String[] args)
22     {
23         Fu f = new Zi();
24         f.show();
25         //使用向下转型以使用子类特有方法
26         Zi z = (Zi)f;
27         z.method();
28     }
29 }

运行结果:

Zi show run
Zi method run

向上转型:从子到父，父类引用指向子类对象。例:Fu f = new Zi();

向下转型:从父到子，父类引用转为子类对象。例:Zi z = (Zi)f;

09.11 孔子装爹案例讲解多态现象

多态的问题理解:

1 class 孔子爹
2 {
3     public int age = 40;
4
5     public void teach()
6     {
7         System.out.println("讲解JavaSE");
8     }
9 }
10
11 class 孔子 extends 孔子爹
12 {
13     public int age = 20;
14     public void teach()
15     {
16         System.out.println("讲解论语");
17     }
18     public void playGame()
19     {
20         System.out.println("英雄联盟");
21     }
22 }
23
24     //Java培训特别火,很多人来请孔子爹去讲课，这一天孔子爹被请走了
25     //但是还有人来请，就剩孔子在家，价格还挺高。孔子一想，我是不是可以考虑去呢?
26     //然后就穿上爹的衣服，带上爹的眼睛，粘上爹的胡子。就开始装爹
27     //向上转型
28     孔子爹 k爹 = new 孔子();
29     //到人家那里去了
30     System.out.println(k爹.age); //40
31     k爹.teach(); //讲解论语
32     //k爹.playGame(); //这是儿子才能做的
33
34     //讲完了，下班回家了
35     //脱下爹的装备，换上自己的装备
36     //向下转型
37     孔子 k = (孔子) k爹;
38     System.out.println(k.age); //20
39     k.teach(); //讲解论语
40     k.playGame(); //英雄联盟

09.12 多态继承中的内存图解



09.13 多态中的对象变化内存图解



09.14 猫狗案例多态版

1 class Animal
2 {
3     public void eat()
4     {
5         System.out.println("吃饭");
6     }
7 }
8 class Cat extends Animal
9 {
10     public void eat()
11     {
12         System.out.println("猫吃鱼");
13     }
14     public void playGame()
15     {
16         System.out.println("猫玩游戏");
17     }
18 }
19 class Dog extends Animal
20 {
21     public void eat()
22     {
23         System.out.println("狗吃肉");
24     }
25     public void lookDoor()
26     {
27         System.out.println("狗看门");
28     }
29 }
30 class Demo
31 {
32     public static void main(String[] args)
33     {
34         Animal a = new Dog();
35         a.eat();
36         Dog d = (Dog)a;
37         d.lookDoor();
38         System.out.println("------");
39         a = new Cat();
40         a.eat();
41         Cat c = (Cat)a;
42         c.playGame();
43     }
44 }

运行结果:

狗吃肉
狗看门
------
猫吃鱼
猫玩游戏

09.15 南北方人案例

1 class Person
2 {
3     String name;
4     Person(String name)
5     {
6         this.name = name;
7         System.out.println(name);
8     }
9     public void eat()
10     {
11         System.out.println("吃饭");
12     }
13 }
14
15 class SouthPerson extends Person
16 {
17     SouthPerson(String name)
18     {
19         super(name);
20     }
21     public void eat()
22     {
23         System.out.println("炒菜,吃米饭");
24     }
25
26     public void jingShang()
27     {
28         System.out.println("经商");
29     }
30 }
31
32 class NorthPerson extends Person
33 {
34     NorthPerson(String name)
35     {
36         super(name);
37     }
38     public void eat()
39     {
40         System.out.println("炖菜,吃馒头");
41     }
42
43     public void yanJiu()
44     {
45         System.out.println("研究");
46     }
47 }
48 class Demo
49 {
50     public static void main(String[] args)
51     {
52         //测试
53         //南方人
54         Person p = new SouthPerson("南方人");
55         p.eat();
56         SouthPerson sp = (SouthPerson)p;
57         sp.jingShang();
58         System.out.println("--------");
59
60         //北方人
61         p = new NorthPerson("北方人");
62         p.eat();
63         NorthPerson np = (NorthPerson)p;
64         np.yanJiu();
65     }
66 }

运行结果:

南方人
炒菜,吃米饭
经商
--------
北方人
炖菜,吃馒头
研究

09.16 多态的练习题看程序写结果

1.看程序写结果:先判断有没有问题，如果没有，写出结果

1 class Fu
2 {
3     public void show()
4     {
5         System.out.println("fu show run");
6     }
7 }
8
9 class Zi extends Fu
10 {
11     public void show()
12     {
13         System.out.println("zi show run");
14     }
15
16     public void method()
17     {
18         System.out.println("zi method run");
19     }
20 }
21 class Demo
22 {
23     public static void main(String[] args)
24     {
25         Fu f = new Zi();
26         //找不到符号
27         //f.method();
28         f.show();
29     }
30 }

运行结果:

zi show run

2.看程序写结果:先判断有没有问题，如果没有，写出结果

1 class A
2 {
3     public void show()
4     {
5         show2();
6     }
7     public void show2()
8     {
9         System.out.println("hello ");
10     }
11 }
12 class B extends A
13 {
14     /*
15     //从父类继承
16     public void show()
17     {
18         show2();
19     }
20     */
21
22     public void show2()
23     {
24         System.out.println("world ");
25     }
26 }
27 class C extends B
28 {
29     public void show()
30     {
31         super.show();
32     }
33     public void show2()
34     {
35         System.out.println("java ");
36     }
37 }
38 class Demo
39 {
40     public static void main(String[] args)
41     {
42         A a = new B();
43         a.show();
44
45         B b = new C();
46         b.show();
47     }
48 }

运行结果:

world
java

09.17 抽象类的引入

动物本身并不是一个具体的事物，而是一个抽象的事物。只有真正的猫，狗才是具体的动物。同理，不同的动物吃的东西应该是不一样的，所以，我们不应该在动物类中给出具体体现，而是应该给出一个声明即可。

在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类。

09.18 抽象类的特点

抽象类特点:

1.抽象类和抽象方法必须用abstract关键字修饰

格式: abstract class 类名 {}

public abstract void method();

2.抽象类不一定有抽象方法，有抽象方法的类一定是抽象类

3.抽象类不能实例化，因为抽象类不是具体的，抽象类有构造方法，按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。

4.抽象类的子类如果不重写父类中的抽象方法，那么该子类还是抽象类，否则必须重写抽象类中的所有抽象方法

1 abstract class Animal
2 {
3     public abstract void eat();
4 }
5 class Cat extends Animal
6 {
7     public void eat()
8     {
9         System.out.println("猫吃鱼");
10     }
11 }
12 class Demo
13 {
14     public static void main(String[] args)
15     {
16         //多态
17         Animal a = new Cat();
18         a.eat();
19     }
20 }

运行结果:

猫吃鱼

09.19 抽象类的成员特点

成员变量:可以是变量，也可以是常量

构造方法:有构造方法，但是不能实例化，构造方法的作用是用于子类访问父类数据的初始化

成员方法:可以有抽象方法限定子类必须完成某些动作，也可以有非抽象方法提高代码复用性

1
abstract
class
Animal

2 {
3     public int num1 = 10;//变量
4     public final int num2 = 20;//常量
5     public Animal(){}//构造函数
6     public abstract void show();//抽象方法
7     public void method()//非抽象方法
8     {
9         System.out.println("Animal method run");
10     }
11 }
12 class Cat extends Animal
13 {
14     public void show()
15     {
16         System.out.println("Cat show run");
17     }
18 }
19 class Demo
20 {
21     public static void main(String[] args)
22     {
23         //创建对象
24         Animal a = new Cat();
25         System.out.println(a.num1);//访问变量
26         System.out.println(a.num2);//访问常量
27         a.show();//访问抽象方法
28         a.method();//访问非抽象方法
29     }
30 }

运行结果:

10
20
Cat show run
Animal method run

09.20 抽象类练习猫狗案例

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 abstract class Animal
41 {
42     //姓名
43     private String name;
44     //年龄
45     private int age;
46
47     public Animal() {}
48
49     public Animal(String name,int age)
50     {
51         this.name = name;
52         this.age = age;
53     }
54
55     public String getName()
56     {
57         return name;
58     }
59
60     public void setName(String name)
61     {
62         this.name = name;
63     }
64
65     public int getAge()
66     {
67         return age;
68     }
69
70     public void setAge(int age)
71     {
72         this.age = age;
73     }
74
75     //定义一个抽象方法
76     public abstract void eat();
77 }
78 //定义具体的狗类
79 class Dog extends Animal
80 {
81     public Dog() {}
82
83     public Dog(String name,int age)
84     {
85         super(name,age);
86     }
87
88     public void eat()
89     {
90         System.out.println("狗吃肉");
91     }
92 }
93
94 //定义具体的猫类
95 class Cat extends Animal
96 {
97     public Cat() {}
98
99     public Cat(String name,int age)
100     {
101         super(name,age);
102     }
103
104     public void eat()
105     {
106         System.out.println("猫吃鱼");
107     }
108 }
109 class Demo
110 {
111     public static void main(String[] args)
112     {
113         //测试狗类，具体类用法 方式1
114         Dog d = new Dog();
115         d.setName("旺财");
116         d.setAge(3);
117         System.out.println(d.getName()+"---"+d.getAge());
118         d.eat();
119         //测试狗类，具体类用法 方式2:
120         Dog d2 = new Dog("旺财",3);
121         System.out.println(d2.getName()+"---"+d2.getAge());
122         d2.eat();
123         System.out.println("-------------");
124         //测试狗类，多态用法 方式1:
125         Animal a = new Dog();
126         a.setName("旺财");
127         a.setAge(3);
128         System.out.println(a.getName()+"---"+a.getAge());
129         a.eat();
130         //测试狗类，多态用法 方式2:
131         Animal a2 = new Dog("旺财",3);
132         System.out.println(a2.getName()+"---"+a2.getAge());
133         a2.eat();
134     }
135 }

运行结果:

旺财---3
狗吃肉
旺财---3
狗吃肉
-------------
旺财---3
狗吃肉
旺财---3
狗吃肉

09.21 抽象类练习老师案例

1 /*
2 老师案例
3         具体事物:基础班老师，就业班老师
4         共性:姓名，年龄，讲课。
5
6 分析:
7     基础班老师
8         姓名，年龄
9         讲课。
10     就业班老师
11         姓名，年龄
12         讲课。
13 实现:
14     老师类
15         基础班老师
16         就业班老师
17 */
18 //定义抽象的老师类
19 abstract class Teacher
20 {
21     //姓名
22     private String name;
23     //年龄
24     private int age;
25
26     public Teacher() {}
27
28     public Teacher(String name,int age)
29     {
30         this.name = name;
31         this.age = age;
32     }
33
34     public String getName()
35     {
36         return name;
37     }
38
39     public void setName(String name)
40     {
41         this.name = name;
42     }
43
44     public int getAge()
45     {
46         return age;
47     }
48
49     public void setAge(int age)
50     {
51         this.age = age;
52     }
53
54     //抽象方法
55     public abstract void teach();
56 }
57
58 //基础班老师类
59 class BasicTeacher extends Teacher
60 {
61     public BasicTeacher(){}
62
63     public BasicTeacher(String name,int age)
64     {
65         super(name,age);
66     }
67
68     public void teach()
69     {
70         System.out.println("基础班老师讲解JavaSE");
71     }
72 }
73
74 //就业班老师类
75 class WorkTeacher extends Teacher
76 {
77     public WorkTeacher(){}
78
79     public WorkTeacher(String name,int age)
80     {
81         super(name,age);
82     }
83
84     public void teach()
85     {
86         System.out.println("就业班老师讲解JavaEE");
87     }
88 }
89 class Demo
90 {
91     public static void main(String[] args)
92     {
93         //多态测试
94         //基础班老师
95         Teacher t = new BasicTeacher();
96         t.setName("小明");
97         t.setAge(30);
98         System.out.println(t.getName()+"---"+t.getAge());
99         t.teach();
100         System.out.println("--------------------");
101
102         t = new BasicTeacher("小明",30);
103         System.out.println(t.getName()+"---"+t.getAge());
104         t.teach();
105         System.out.println("--------------------");
106
107         //就业班老师
108         t = new WorkTeacher();
109         t.setName("小红");
110         t.setAge(35);
111         System.out.println(t.getName()+"---"+t.getAge());
112         t.teach();
113         System.out.println("--------------------");
114
115         t = new WorkTeacher("小红",35);
116         System.out.println(t.getName()+"---"+t.getAge());
117         t.teach();
118     }
119 }

运行结果:

小明---30
基础班老师讲解JavaSE
--------------------
小明---30
基础班老师讲解JavaSE
--------------------
小红---35
就业班老师讲解JavaEE
--------------------
小红---35
就业班老师讲解JavaEE

09.22 抽象类练习学员案例

1 /*
2 学生案例
3         具体事务:基础班学员，就业班学员
4         共性:姓名，年龄，班级，学习，吃饭
5
6 分析:
7     基础班学员
8         成员变量:姓名，年龄，班级
9         成员方法:学习，吃饭
10     就业班学员
11         成员变量:姓名，年龄，班级
12         成员方法:学习，吃饭
13
14 得到一个学员类。
15     成员变量:姓名，年龄，班级
16     成员方法:学习，吃饭
17
18 实现:
19     学员类
20     基础班学员
21     就业班学员
22 */
23 //定义抽象学员类
24 abstract class Student
25 {
26     //姓名
27     private String name;
28     //年龄
29     private int age;
30     //班级
31     private String grand;
32
33     public Student() {}
34
35     public Student(String name,int age,String grand)
36     {
37         this.name = name;
38         this.age = age;
39         this.grand = grand;
40     }
41
42     public String getName()
43     {
44         return name;
45     }
46
47     public void setName(String name)
48     {
49         this.name = name;
50     }
51
52     public int getAge()
53     {
54         return age;
55     }
56
57     public void setAge(int age)
58     {
59         this.age = age;
60     }
61
62     public String getGrand()
63     {
64         return grand;
65     }
66
67     public void setGrand(String grand)
68     {
69         this.grand = grand;
70     }
71
72     //学习
73     public abstract void study();
74
75     //吃饭
76     public void eat()
77     {
78         System.out.println("吃饭");
79     }
80 }
81
82 //具体基础班学员类
83 class BasicStudent extends Student
84 {
85     public BasicStudent() {}
86
87     public BasicStudent(String name,int age,String grand)
88     {
89         super(name,age,grand);
90     }
91     //重写父类抽象方法
92     public void study()
93     {
94         System.out.println("基础班学员学习JavaSE");
95     }
96 }
97
98 //具体就业班学员类
99 class WorkStudent extends Student
100 {
101     public WorkStudent() {}
102
103     public WorkStudent(String name,int age,String grand)
104     {
105         super(name,age,grand);
106     }
107     //重写父类抽象方法
108     public void study()
109     {
110         System.out.println("就业班学员学习JavaEE");
111     }
112 }
113 class Demo
114 {
115     public static void main(String[] args)
116     {
117         //按照多态的方式测试基础班学员
118         Student s = new BasicStudent();
119         s.setName("小明");
120         s.setAge(27);
121         s.setGrand("1111");
122         System.out.println(s.getName()+"---"+s.getAge()+"---"+s.getGrand());
123         s.study();
124         s.eat();
125         System.out.println("--------------");
126
127         s = new BasicStudent("小红",28,"1111");
128         System.out.println(s.getName()+"---"+s.getAge()+"---"+s.getGrand());
129         s.study();
130         s.eat();
131     }
132 }

运行结果:

小明---27---1111
基础班学员学习JavaSE
吃饭
--------------
小红---28---1111
基础班学员学习JavaSE
吃饭

09.23 抽象类练习员工案例

假如我们在开发一个系统时需要对员工类进行设计，员工包含3个属性:姓名、工号以及工资。

经理也是员工，除了含有员工的属性外，另为还有一个奖金属性。

请使用继承的思想设计出员工类和经理类。要求类中提供必要的方法进行属性访问。

1 /*
2
3 分析:
4     普通员工类
5             成员变量:姓名、工号以及工资。
6             成员方法:工作
7     经理类:
8             成员变量:姓名、工号以及工资，奖金属性
9             成员方法:工作
10
11 实现:
12     员工类:
13     普通员工类:
14     经理类:
15 */
16 //定义员工类
17 abstract class Employee
18 {
19     //姓名、工号以及工资
20     private String name;
21     private String id;
22     private int salary;
23
24     public Employee() {}
25
26     public Employee(String name,String id,int salary)
27     {
28         this.name = name;
29         this.id = id;
30         this.salary = salary;
31     }
32
33     public String getName()
34     {
35         return name;
36     }
37
38     public void setName(String name)
39     {
40         this.name = name;
41     }
42
43     public String getId()
44     {
45         return id;
46     }
47
48     public void setId(String id)
49     {
50         this.id = id;
51     }
52
53     public int getSalary()
54     {
55         return salary;
56     }
57
58     public void setSalary(int salary)
59     {
60         this.salary = salary;
61     }
62
63     //工作
64     public abstract void work();
65 }
66
67 //普通员工类
68 class Programmer extends Employee
69 {
70     public Programmer(){}
71
72     public Programmer(String name,String id,int salary)
73     {
74         super(name,id,salary);
75     }
76
77     public void work()
78     {
79         System.out.println("按照需求写代码");
80     }
81 }
82
83 //经理类
84 class Manager extends Employee
85 {
86     //奖金
87     private int money;
88
89     public Manager(){}
90
91     public Manager(String name,String id,int salary,int money)
92     {
93         super(name,id,salary);
94         this.money = money;
95     }
96
97     public void work()
98     {
99         System.out.println("跟客户谈需求");
100     }
101
102     public int getMoney()
103     {
104         return money;
105     }
106
107     public void setMoney(int money)
108     {
109         this.money = money;
110     }
111 }
112 class Demo
113 {
114     public static void main(String[] args)
115     {
116         //测试普通员工
117         Employee emp = new Programmer();
118         emp.setName("小明");
119         emp.setId("czbk001");
120         emp.setSalary(18000);
121         System.out.println(emp.getName()+"---"+emp.getId()+"---"+emp.getSalary());
122         emp.work();
123         System.out.println("-------------");
124         emp = new Programmer("小明","czbk001",18000);
125         System.out.println(emp.getName()+"---"+emp.getId()+"---"+emp.getSalary());
126         emp.work();
127         System.out.println("-------------");
128
129         //由于子类有特有的内容，所以我们用子类来测试
130         Manager m = new Manager();
131         m.setName("小红");
132         m.setId("czbk002");
133         m.setSalary(8000);
134         m.setMoney(2000);
135         System.out.println(m.getName()+"---"+m.getId()+"---"+m.getSalary()+"---"+m.getMoney());
136         m.work();
137         System.out.println("-------------");
138
139         //通过构造方法赋值
140         m = new Manager("小红","czbk002",8000,2000);
141         System.out.println(m.getName()+"---"+m.getId()+"---"+m.getSalary()+"---"+m.getMoney());
142         m.work();
143     }
144 }

运行结果:

小明---czbk001---18000
按照需求写代码
-------------
小明---czbk001---18000
按照需求写代码
-------------
小红---czbk002---8000---2000
跟客户谈需求
-------------
小红---czbk002---8000---2000
跟客户谈需求

09.24 抽象类中的小问题

1.一个类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义?

可以。不让创建对象。

2.abstract不能和哪些关键字共存

private 冲突

final 冲突

static 无意义

09.25 接口的引入

为了体现事物功能的扩展性，Java中就提供了接口来定义这些额外功能，并不给出具体实现，将来哪些猫狗需要被培训，只需要这部分猫狗把这些额外功能实现即可。

09.26 接口的特点

接口特点:接口用关键字interface表示，格式:interface 接口名 {}

类实现接口用implements表示，格式:class 类名 implements 接口名 {}

接口不能实例化，按照多态的方式，由具体的子类实例化。其实这也是多态的一种，接口多态。

接口的子类要么是抽象类，要么重写接口中的所有抽象方法

09.27 接口的成员特点

成员变量:只能是常量，默认修饰符 public static final

构造方法:没有，因为接口主要是扩展功能的，而没有具体存在

成员方法:只能是抽象方法，默认修饰符 public abstract

09.28 类与类,类与接口,接口与接口的关系

类与类的关系:继承关系，只能单继承，但是可以多层继承

类与接口的关系:实现关系，可以单实现，也可以多实现。还可以在继承一个类的同时实现多个接口

接口与接口的关系:继承关系，可以单继承，也可以多继承

09.29 抽象类和接口的区别

成员区别:

抽象类:成员变量，可以是变量也可以是常量。构造方法，有。成员方法，可以是抽象方法也可以是非抽象方法

接口:成员变量，只可以是常量。构造方法，没有。成员方法，只可以是抽象方法

关系区别:

类与类继承，单继承

类与接口实现，单实现，多实现

接口与接口继承，单继承，多继承

设计理念区别:

抽象类被继承体现的是:”is a”的关系。继承体系的共性功能

接口被实现体现的是:”like a”的关系。继承体系的扩展功能

09.30 猫狗案例加入跳高功能分析

猫狗案例,加入跳高的额外功能

分析:从具体到抽象

猫:姓名,年龄 吃饭，睡觉

狗:姓名,年龄 吃饭，睡觉

由于有共性功能，所以，我们抽取出一个父类:

动物:姓名,年龄 吃饭();睡觉(){}

猫:继承自动物

狗:继承自动物

跳高的额外功能是一个新的扩展功能，所以我们要定义一个接口:跳高

部分猫:实现跳高

部分狗:实现跳高

实现:从抽象到具体

使用:使用具体类

09.31 猫狗案例加入跳高功能代码实现

1 //定义跳高接口
2 interface Jumpping
3 {
4     //跳高功能
5     public abstract void jump();
6 }
7
8 //定义抽象类
9 abstract class Animal
10 {
11     //姓名
12     private String name;
13     //年龄
14     private int age;
15
16     public Animal() {}
17
18     public Animal(String name,int age)
19     {
20         this.name = name;
21         this.age = age;
22     }
23
24     public String getName()
25     {
26         return name;
27     }
28
29     public void setName(String name)
30     {
31         this.name = name;
32     }
33
34     public int getAge()
35     {
36         return age;
37     }
38
39     public void setAge(int age)
40     {
41         this.age = age;
42     }
43
44     //吃饭();
45     public abstract void eat();
46
47     //睡觉(){}
48     public void sleep()
49     {
50         System.out.println("睡觉");
51     }
52 }
53
54 //具体猫类
55 class Cat extends Animal
56 {
57     public Cat(){}
58
59     public Cat(String name,int age)
60     {
61         super(name,age);
62     }
63
64     public void eat()
65     {
66         System.out.println("猫吃鱼");
67     }
68 }
69
70 //具体狗类
71 class Dog extends Animal
72 {
73     public Dog(){}
74
75     public Dog(String name,int age)
76     {
77         super(name,age);
78     }
79
80     public void eat()
81     {
82         System.out.println("狗吃肉");
83     }
84 }
85
86 //有跳高功能的猫
87 class JumpCat extends Cat implements Jumpping
88 {
89     public JumpCat() {}
90
91     public JumpCat(String name,int age)
92     {
93         super(name,age);
94     }
95
96     public void jump()
97     {
98         System.out.println("跳高猫");
99     }
100 }
101
102 //有跳高功能的狗
103 class JumpDog extends Dog implements Jumpping
104 {
105     public JumpDog() {}
106
107     public JumpDog(String name,int age)
108     {
109         super(name,age);
110     }
111
112     public void jump()
113     {
114         System.out.println("跳高狗");
115     }
116 }
117 class Demo
118 {
119     public static void main(String[] args)
120     {
121         //定义猫并测试
122         JumpCat jc = new JumpCat();
123         jc.setName("哆啦A梦");
124         jc.setAge(3);
125         System.out.println(jc.getName()+"---"+jc.getAge());
126         jc.eat();
127         jc.sleep();
128         jc.jump();
129         System.out.println("-----------------");
130
131         JumpCat jc2 = new JumpCat("加菲猫",2);
132         System.out.println(jc2.getName()+"---"+jc2.getAge());
133         jc2.eat();
134         jc2.sleep();
135         jc2.jump();
136     }
137 }

运行结果:

哆啦A梦---3
猫吃鱼
睡觉
跳高猫
------------
加菲猫---2
猫吃鱼
睡觉
跳高猫

09.32 老师学生案例加入抽烟功能分析及代码实现

1 /*
2 老师和学生案例,加入抽烟的额外功能
3 分析:从具体到抽象
4 老师:姓名，年龄，吃饭，睡觉
5 学生:姓名，年龄，吃饭，睡觉
6 由于有共性功能，我们提取出一个父类，人类。
7 人类:
8     姓名，年龄
9     吃饭();
10     睡觉(){}
11 抽烟的额外功能不是人或者老师，或者学生一开始就应该具备的，所以，我们把它定义为接口
12 部分老师抽烟:实现抽烟接口
13 部分学生抽烟:实现抽烟接口
14 实现:从抽象到具体
15 */
16 //定义抽烟接口
17 interface Smoking
18 {
19     //抽烟的抽象方法
20     public abstract void smoke();
21 }
22
23 //定义抽象人类
24 abstract class Person
25 {
26     //姓名
27     private String name;
28     //年龄
29     private int age;
30
31     public Person() {}
32
33     public Person(String name,int age)
34     {
35         this.name = name;
36         this.age = age;
37     }
38
39     public String getName()
40     {
41         return name;
42     }
43
44     public void setName(String name)
45     {
46         this.name = name;
47     }
48
49     public int getAge()
50     {
51         return age;
52     }
53
54     public void setAge(int age)
55     {
56         this.age = age;
57     }
58
59     //吃饭();
60     public abstract void eat();
61
62     //睡觉(){}
63     public void sleep()
64     {
65         System.out.println("睡觉");
66     }
67 }
68
69 //具体老师类
70 class Teacher extends Person
71 {
72     public Teacher() {}
73
74     public Teacher(String name,int age)
75     {
76         super(name,age);
77     }
78
79     public void eat()
80     {
81         System.out.println("吃大白菜");
82     }
83 }
84
85 //具体学生类
86 class Student extends Person
87 {
88     public Student() {}
89
90     public Student(String name,int age)
91     {
92         super(name,age);
93     }
94
95     public void eat()
96     {
97         System.out.println("吃红烧肉");
98     }
99 }
100
101 //抽烟的老师
102 class SmokingTeacher extends Teacher implements Smoking
103 {
104     public SmokingTeacher() {}
105
106     public SmokingTeacher(String name,int age)
107     {
108         super(name,age);
109     }
110
111     public void smoke()
112     {
113         System.out.println("抽烟的老师");
114     }
115 }
116
117 //抽烟的学生
118 class SmokingStudent extends Student implements Smoking
119 {
120     public SmokingStudent() {}
121
122     public SmokingStudent(String name,int age)
123     {
124         super(name,age);
125     }
126
127     public void smoke()
128     {
129         System.out.println("抽烟的学生");
130     }
131 }
132 class Demo
133 {
134     public static void main(String[] args)
135     {
136         //测试学生
137         SmokingStudent ss = new SmokingStudent();
138         ss.setName("小明");
139         ss.setAge(27);
140         System.out.println(ss.getName()+"---"+ss.getAge());
141         ss.eat();
142         ss.sleep();
143         ss.smoke();
144         System.out.println("------------");
145
146         SmokingStudent ss2 = new SmokingStudent("小强",30);
147         System.out.println(ss2.getName()+"---"+ss2.getAge());
148         ss2.eat();
149         ss2.sleep();
150         ss2.smoke();
151     }
152 }