=============================================================================
=============================================================================
涉及的知识点有:
1:final关键字(掌握)
2:多态(掌握)
3:抽象类(掌握)
4:接口(掌握)
=============================================================================
=============================================================================
1:final关键字(掌握)
(0)由于继承中方法有一个现象:方法重写。
所以,父类的功能,就会被子类给覆盖掉。
有些时候,我们不想让子类去覆盖掉父类的功能,只能调用但不能去覆盖修改。
这个时候,针对这种情况,Java就提供了一个关键字:final。
---------------------------------------
(1)final是最终的意思,常见的final可以修饰类、方法、变量。
(2)fianl的特点:
A:final修饰的类,不能被继承。
编译报错:无法从最终Fu进行继承
应用:最底层的那个类可以用final修饰,这样该类就不能有儿子了。(即绝育)
B:final修饰的方法,不能被重写(覆盖/复写)。
编译报错:Zi中的show()无法覆盖Fu中的show()
C:final修饰的变量,是一个常量,只能被赋值一次。
编译报错:无法为最终变量num2分配值
注意:被final修饰的成员变量没有默认值,必须在构造器(constructor )结束之前被赋予一个明确的值。即在定义被final修饰的成员变量时就给值。
小补充:
常量分为两种:
1.字面值常量
例如:"hello"、10、true
2.自定义常量
例如:final int x = 10;
---------------------------------------
(3)final关键字面试题相关:
public、private等权限修饰符会用来修饰成员变量、构造方法和成员方法。
不会用来修饰局部变量(在方法内部的变量),因为权限修饰符修饰局部变量是没有意义的,在方法内部的局部变量是被封装好的,外界的方法看不到。
final既可以修饰局部变量也可以修饰成员变量和成员方法。
A:final修饰局部变量
a:当局部变量为基本数据类型 值不能发生改变
final x = 100;
b:当局部变量为引用数据类型 地址值不能发生改变,但是该对象的堆内存的内容是可以改变的。
final Student s = new Student();
s = new Student(); //对象s重新指向了新的地址值,但是对象s被final修饰了,所以这句会报错!
---------------------------------------
B:final修的饰变量的初始化时机
a:被final修饰的变量只能被初始化一次(默认初始化不算哦)。
b:被final修饰的变量的初始化时机:在对象构造方法执行完毕前进行赋值就行。
注意:这个时机仅仅针对的是非静态的常量。因为静态的早早就加载了。
c:变量常见的给值时机
1.在定义的时候就给值。(推荐方式)
2.在构造代码块中给值。
3.在构造方法中给值。
-----------------------------------------------------------------------------
2:多态(掌握)
(1)某一个事物,在不同时刻表现出来的不同状态。
猫可以是猫的类型。
猫 m = new 猫();
同时猫也是动物的一种,也可以把猫称为动物。
动物 d = new 猫();
再举一个例子:水在不同时刻的状态。
---------------------------------------
(2)多态的前提和体现:
A:多态有继承或者实现关系。
B:多态有方法重写。(因为多态是靠方法重写来体现不同状态的)
其实没有方法重写也是可以的,但是如果没有方法重写就没有意义了。
C:多态有父类或者父接口引用指向子类对象。
即:父 f = new 子();
多态的分类:
a:具体类的多态
class Fu {}
class Zi extends Fu {}
Fu f = new Zi();
b:抽象类的多态
abstract class Fu {}
class Zi extends Fu {}
Fu f = new Zi();
c:接口的多态
interface Fu {}
class Zi implements Fu {}
Fu f = new Zi();
---------------------------------------
(3)多态中的成员访问特点:
A:对于多态中的成员变量的访问
编译看左边,运行看左边。
因为子可以访问父的成员变量,父不可以访问子的成员变量。(即:对于成员变量,可以向上访问,不可以向下访问。)
B:对于多态中的构造方法的访问
创建子类对象的时候,子类的构造都会默认访问父类构造,为了对父类的数据进行初始化。
C:对于多态中的成员方法的访问
编译看左边,运行看右边。
因为成员方法有重写,父类的成员方法会被子类覆盖掉。因为成员方法是跟对象相关的。
D:对于多态中的静态方法的访问
编译看左边,运行看左边。
因为静态方法只能被静态方法重写,但是静态方法根本算不上重写。因为静态是跟类相关的。所以访问静态方法的时候是左边。
为什么?
因为成员方法有方法重写,父类的动作被子类重写掉了,所以该动作走的是儿子的。
也即对于多态中的成员方法的访问看右边(子类)。
---------------------------------------
(4)多态的好处:
A:提高了代码的维护性(继承体现)
因为多态有继承或者实现关系。
B:提高了代码的扩展性(多态体现)
原因如下:
猫狗案例:
注意几点:
测试类里面不能放其他东西,只能放创建的对象和通过对象调用的方法。
把构造方法私有,别人就不能创建对象了,只能通过类名来调用静态方法了。
针对动物操作的工具类中,调用动物的功能时,形参用动物类进行接收(即多态)。
即 Animal a = new Cat();
a = new Dog();
a = new Pig();
......
---------------------------------------
(5)多态的弊端:
Fu f = new Zi();
父类不能使用子类的特有功能(即成员方法)。
因为我们拿父类去访问子类,但是对于成员方法,父类只能访问在父类中定义的方法,在父类中没有定义的方法不能访问。
简言之:子可以当做父使用,父不能当做子使用。因为子比父的东西要多。
我父类就想使用子类的特有功能?行不行?
答:行。
那怎么行呢?
法一:创建子类对象调用方法即可。(可以,但是很多时候不合理。而且,重新创建对象,太占内存了。)
Zi z = new Zi();
法二:把父类的引用强制赋值给子类的引用。(向下转型)(这样做内存中只有一个对象,省内存!)
因为引用类型赋值要求类型要兼容!
Zi z = (Zi)f;
---------------------------------------
(6)多态中的转型问题:
A:向上转型
从子到父
Fu f = new Zi();
B:向下转型
从父到子
Zi z = (Zi)f; //前提:要求该f必须是能够转换为Zi的。
---------------------------------------
(7)孔子装爹的案例帮助大家理解多态
//然后就穿上爹的衣服,带上爹的眼睛,粘上爹的胡子。就开始装爹。
//其实就是向上转型。
孔子爹 k爹 = new 孔子();
//脱下爹的装备,换上自己的装备。
//其实就是向下转型。
孔子 k = (孔子)k爹;
---------------------------------------
(8)多态的练习
A:猫狗案例
B:老师和学生案例
-----------------------------------------------------------------------------
3:抽象类(掌握)
(1)抽象类的概述:
把多个共性的东西提取到一个类中,这是继承的做法。
但是呢,这多个共性的东西,在有些时候,方法声明是一样的,但是方法体不一样。
也就是说,方法声明是一样,但是每个具体的对象在具体实现的时候内容不一样。
所以,我们在定义这些共性的方法的时候,就不能给出具体的方法体。
在Java中,一个没有具体的方法体的方法应该定义为抽象方法。
而在一个类中如果有抽象方法,该类必须定义为抽象类。
---------------------------------------
(2)抽象类的特点:
A:抽象类和抽象方法必须用关键字abstract修饰。
格式:
abstract class 类名 {}
public abstract void eat(); //没有方法体。
//public abstract void eat() {} //有方法体,但方法体为空。会报错。
B:抽象类中不一定有抽象方法,但是有抽象方法的类一定是抽象类。
C:抽象类不能实例化。
例如:
abstract class Animal {}
Animal a = new Animal(); //会报错,因为动物类是抽象的,不能new。
抽象类有构造方法,但是不能实例化。
那么抽象类的构造方法的作用是什么呢?
答:用于子类访问父类数据初始化。
D:抽象类的子类可能是:
a:抽象类的子类可以是一个抽象类。这个子类不用重写抽象类中的抽象方法。
b:抽象类的子类可以是一个具体类(可以new对象,使用多态实例化抽象类)。但这个子类必须重写抽象类中的所有抽象方法。
E:抽象类的实例化
通过具体的子类实现的(即:多态的方式。也即:向上转型的方式),其实这也是多态的一种,叫做抽象类多态。
多态最主要的应用是在抽象类中使用,而不是在具体类中。这样抽象类对外界提供的是抽象的方法,而靠真正具体的子类来重写实现的。
---------------------------------------
(3)抽象类的成员特点:
A:抽象类的成员变量的特点
可以有变量
也可以有常量
B:抽象类的构造方法的特点
有构造方法,但是不能实例化。用于子类访问父类数据的初始化。
C:抽象类的成员方法的特点
可以有抽象方法 强制具体的子类必须完成某些动作。
也可以有非抽象方法 使子类继承非抽象方法,提高代码复用性。
---------------------------------------
(4)抽象类的练习:
A:猫狗案例练习
示例代码如下:
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 */
42
43 //定义抽象的动物类
44 abstract class Animal {
45 //姓名
46 private String name;
47 //年龄
48 private int age;
49
50 public Animal() {}
51
52 public Animal(String name, int age) {
53 this.name = name;
54 this.age = age;
55 }
56
57 public String getName() {
58 return name;
59 }
60
61 public void setName(String name) {
62 this.name = name;
63 }
64
65 public int getAge() {
66 return age;
67 }
68
69 public void setAge(int age) {
70 this.age = age;
71 }
72
73 //定义一个抽象的方法
74 public abstract void eat();
75 }
76
77 //定义具体的狗类
78 class Dog extends Animal {
79 public Dog() {}
80
81 public Dog(String name, int age) {
82 super(name, age);
83 }
84
85 public void eat() {
86 System.out.println("狗吃肉");
87 }
88 }
89
90 //定义具体的猫类
91 class Cat extends Animal {
92 public Cat() {}
93
94 public Cat(String name, int age) {
95 super(name, age);
96 }
97
98 public void eat() {
99 System.out.println("猫吃鱼");
100 }
101 }
102
103 //测试类
104 class AbstractTest {
105 public static void main(String[] args) {
106 //测试狗类
107 //具体类测试
108 //方式1:
109 Dog d = new Dog();
110 d.setName("旺财");
111 d.setAge(3);
112 System.out.println(d.getName()+"---"+d.getAge());
113 d.eat();
114 //方式2:
115 Dog d2 = new Dog("旺财", 3);
116 System.out.println(d2.getName()+"---"+d2.getAge());
117 d2.eat();
118 System.out.println("---------------------------");
119
120 //多态测试:因为子类中没有定义特有功能,所以可以多态实现。
121 Animal a = new Dog();
122 a.setName("旺财");
123 a.setAge(3);
124 System.out.println(a.getName()+"---"+a.getAge());
125 a.eat();
126
127 Animal a2 = new Dog("旺财", 3);
128 System.out.println(a2.getName()+"---"+a2.getAge());
129 a2.eat();
130 System.out.println("---------------------------");
131
132 //练习:测试猫类
133 //具体类测试
134 //方式一:
135 Cat c = new Cat();
136 c.setName("多啦A梦");
137 c.setAge(5);
138 System.out.println(c.getName()+"---"+c.getAge());
139 c.eat();
140 //方式二:
141 Cat c2 = new Cat("哆啦A梦", 5);
142 System.out.println(c2.getName()+"---"+c2.getAge());
143 c2.eat();
144 System.out.println("---------------------------");
145
146 //多态测试:因为子类中没有定义特有功能,所以可以多态实现。
147 Animal a3 = new Cat();
148 a3.setName("哆啦A梦");
149 a3.setAge(5);
150 System.out.println(a3.getName()+"---"+a3.getAge());
151 a3.eat();
152
153 Animal a4 = new Cat("哆啦A梦", 5);
154 System.out.println(a4.getName()+"---"+a4.getAge());
155 a4.eat();
156
157 }
158 }
B:老师案例练习
示例代码如下:
1 /*
2 老师案例练习:
3 具体事物:基础班老师,就业班老师
4 共性:姓名,年龄,讲课
5 ---------------------------------------
6 分析:
7 基础班老师类
8 姓名,年龄
9 无参,带参
10 讲课(讲解JavaSE)
11 就业班老师类
12 姓名,年龄
13 无参,带参
14 讲课(讲解JavaEE)
15 抽象老师类
16 姓名,年龄
17 无参,带参
18 讲课();
19 ---------------------------------------
20 实现:
21 抽象老师类
22 具体的基础班老师类
23 具体的就业班老师类
24 测试类
25 */
26
27 //定义抽象的老师类
28 abstract class Teacher {
29 //姓名
30 private String name;
31 //年龄
32 private int age;
33
34 public Teacher() {}
35
36 public Teacher(String name, int age) {
37 this.name = name;
38 this.age = age;
39 }
40
41 public String getName() {
42 return name;
43 }
44
45 public void setName(String name) {
46 this.name = name;
47 }
48
49 public int getAge() {
50 return age;
51 }
52
53 public void setAge(int age) {
54 this.age = age;
55 }
56
57 //抽象方法
58 public abstract void teach();
59 }
60
61 //具体的基础班老师类
62 class BasicTeacher extends Teacher {
63 public BasicTeacher(){}
64
65 public BasicTeacher(String name, int age) {
66 super(name, age);
67 }
68
69 public void teach() {
70 System.out.println("基础班老师讲解JavaSE");
71 }
72 }
73
74 //具体的就业班老师类
75 class WorkTeacher extends Teacher {
76 public WorkTeacher(){}
77
78 public WorkTeacher(String name, int age) {
79 super(name, age);
80 }
81
82 public void teach() {
83 System.out.println("就业班老师讲解JavaEE");
84 }
85 }
86
87 class AbstractTest2 {
88 public static void main(String[] args) {
89 //具体的类测试,自己玩
90 //基础班老师
91 //方式一:
92 BasicTeacher bt = new BasicTeacher();
93 bt.setName("刘意");
94 bt.setAge(30);
95 System.out.println(bt.getName()+"---"+bt.getAge());
96 bt.teach();
97 //方式二:
98 bt = new BasicTeacher("刘意", 30);
99 System.out.println(bt.getName()+"---"+bt.getAge());
100 bt.teach();
101 System.out.println("--------------");
102
103 //就业班老师
104 //方式一:
105 WorkTeacher wt = new WorkTeacher();
106 wt.setName("林青霞");
107 wt.setAge(27);
108 System.out.println(wt.getName()+"---"+wt.getAge());
109 wt.teach();
110 //方式二:
111 wt = new WorkTeacher("林青霞", 27);
112 System.out.println(wt.getName()+"---"+wt.getAge());
113 wt.teach();
114 System.out.println("---------------");
115
116 //多态测试:因为子类中没有定义特有功能,所以可以多态实现。
117 //基础班老师
118 Teacher t = new BasicTeacher();
119 System.out.println(t);//BasicTeacher@6d06d69c
120 t.setName("刘意");
121 t.setAge(30);
122 System.out.println(t.getName()+"---"+t.getAge());
123 t.teach();
124 System.out.println("--------------");
125
126 //对象名没有改哦,因为这是同一个对象此时指向了别的地址。
127 t = new BasicTeacher("刘意", 30);
128 System.out.println(t);//BasicTeacher@7852e922
129 System.out.println(t.getName()+"---"+t.getAge());
130 t.teach();
131 System.out.println("--------------");
132
133 //就业班老师
134 //对象名依旧没有改哦,因为这是同一个对象此时指向了别的地址。
135 t = new WorkTeacher();
136 System.out.println(t);//WorkTeacher@4e25154f
137 t.setName("林青霞");
138 t.setAge(27);
139 System.out.println(t.getName()+"---"+t.getAge());
140 t.teach();
141 System.out.println("--------------");
142
143 //对象名依旧依旧没有改哦,因为这是同一个对象此时指向了别的地址。
144 t = new WorkTeacher("林青霞", 27);
145 System.out.println(t);//WorkTeacher@70dea4e
146 System.out.println(t.getName()+"---"+t.getAge());
147 t.teach();
148 }
149 }
C:学生案例练习
示例代码如下:类同B,不在赘述。
D:员工案例练习
示例代码如下:
1 /*
2 假如我们在开发一个系统时需要对员工类进行设计,员工包含3个属性:姓名、工号以及工资。
3 经理也是员工,除了含有员工的属性外,另为还有一个奖金属性。
4 请使用继承的思想设计出员工类和经理类。要求类中提供必要的方法进行属性访问。
5 ---------------------------------------
6 分析:
7 普通员工类
8 成员变量:姓名、工号以及工资。
9 成员方法:工作
10 经理类:
11 成员变量:姓名、工号以及工资,奖金属性。
12 成员方法:工作
13 ---------------------------------------
14 实现:
15 抽象员工类
16 具体的普通员工类
17 具体的经理类
18 测试类
19 */
20
21 //定义抽象员工类
22 abstract class Employee {
23 //姓名、工号以及工资
24 private String name;
25 private String id;
26 private int salary;
27
28 public Employee() {}
29
30 public Employee(String name, String id, int salary) {
31 this.name = name;
32 this.id = id;
33 this.salary = salary;
34 }
35
36 public String getName() {
37 return name;
38 }
39
40 public void setName(String name) {
41 this.name = name;
42 }
43
44 public String getId() {
45 return id;
46 }
47
48 public void setId(String id) {
49 this.id = id;
50 }
51
52 public int getSalary() {
53 return salary;
54 }
55
56 public void setSalary(int salary) {
57 this.salary = salary;
58 }
59
60 //工作
61 public abstract void work();
62 }
63
64 //具体的普通员工类
65 class Programmer extends Employee {
66 public Programmer() {}
67
68 public Programmer(String name, String id, int salary) {
69 super(name, id, salary);
70 }
71
72 public void work() {
73 System.out.println("按照需求写代码");
74 }
75 }
76
77 //具体的经理类
78 class Manager extends Employee {
79 //奖金
80 private int money; //bonus 奖金
81
82 public Manager() {}
83
84 public Manager(String name, String id, int salary, int money) {
85 super(name, id, salary);
86 this.money = money;
87 }
88
89 public void work() {
90 System.out.println("跟客户谈需求");
91 }
92
93 public int getMoney() {
94 return money;
95 }
96
97 public void setMoney(int money) {
98 this.money = money;
99 }
100 }
101
102 //测试类
103 class AbstractTest4 {
104 public static void main(String[] args) {
105 //测试具体的普通员工类
106 Employee emp = new Programmer();
107 emp.setName("林青霞");
108 emp.setId("czbk001");
109 emp.setSalary(18000);
110 System.out.println(emp.getName()+"---"+emp.getId()+"---"+emp.getSalary());
111 emp.work();
112 System.out.println("-------------");
113 emp = new Programmer("林青霞", "czbk001", 18000);
114 System.out.println(emp.getName()+"---"+emp.getId()+"---"+emp.getSalary());
115 emp.work();
116 System.out.println("-------------");
117
118 //测试具体的经理类
119 /*
120 emp = new Manager();
121 emp.setName("刘意");
122 emp.setId("czbk002");
123 emp.setSalary(8000);
124 emp.setMoney(2000);
125 */
126 //由于子类经理类有特有的内容-成员变量-奖金,用多态(父类)测试不合适,所以我们用具体的子类来测试。
127 Manager m = new Manager();
128 m.setName("刘意");
129 m.setId("czbk002");
130 m.setSalary(8000);
131 m.setMoney(2000);
132 System.out.println(m.getName()+"---"+m.getId()+"---"+m.getSalary()+"---"+m.getMoney());
133 m.work();
134 System.out.println("-------------");
135
136 //通过含参构造方法赋值
137 m = new Manager("刘意", "czbk002", 8000, 2000);
138 System.out.println(m.getName()+"---"+m.getId()+"---"+m.getSalary()+"---"+m.getMoney());
139 m.work();
140 }
141 }
---------------------------------------
(5)抽象类的几个小问题
A:抽象类有构造方法,但是抽象类不能实例化,那么构造方法有什么用?
答:用于子类访问父类数据的初始化。
B:一个类如果没有抽象方法,却定义为抽象类,有什么用?
答:为了不让外界创建该抽象类的对象,要想访问它只能通过该抽象类的子类。
C:abstract不能和哪些关键字共存?
a:final 冲突 因为最终方法不能被重写,而抽象的方法需要被具体的子类重写。
final abstract void show(); //错误: 非法的修饰符组合: abstract和private
b:private 冲突 因为私有方法不能被继承,所以就不能被重写,而抽象的方法需要被具体的子类重写。
private abstract void show(); //错误: 非法的修饰符组合: abstract和final
c:static 无意义 因为抽象方法是没有方法体的,而静态是可以直接通过类名访问的。访问一个没有方法体的方法,意义何在呢?
static abstract void show(); //错误: 非法的修饰符组合: abstract和static
-----------------------------------------------------------------------------
4:接口(掌握)
(1)回顾猫狗案例,它们仅仅提供一些基本功能。
部分的猫会钻火圈,狗会跳高等功能,不是动物本身就具备的,
是在后面的培养中训练出来的,所以,为了体现事物功能的扩展性,
Java中就提供了接口来定义这些额外功能,并不给出具体实现(说明是抽象方法),将来哪些猫狗需要被培训,只需要这部分猫狗把这些额外功能实现即可。
其实接口是最最抽象的抽象类。
---------------------------------------
(2)接口的特点:
A:接口用关键字interface修饰
interface 接口名 {}
B:类实现接口用implements修饰
class 类名 implements 接口名 {}
C:接口不能实例化
那么,接口如何实例化呢?
按照多态的方式来实例化。(即就要去做一个具体的子类,通过具体的子类去实例化)
由此可见,多态有几种方式:
1.具体类多态(几乎没有,但是讲解是通过具体类讲解的)
2.抽象类多态(常用)
3.接口多态(最常用)
D:接口的实现类(子类)
接口的实现类格式:接口名+Impl
a:接口的实现类是一个抽象类。但是意义不大,因为你是抽象类,最终还得需要具体子类。
//定义动物培训接口
interface AnimalTrain {
public abstract void jump();
}
//抽象类实现接口
abstract class Dog implements AnimalTrain {
}
b:接口的实现类是一个具体类,这个类必须重写接口中的所有抽象方法。(推荐方案)
//定义动物培训接口
interface AnimalTrain {
public abstract void jump();
}
//具体类实现接口
class Cat implements AnimalTrain {
public void jump() {
System.out.println("猫可以跳高了");
}
}
---------------------------------------
(3)接口的成员特点:
A:接口的成员变量特点:
只能是常量,并且是静态的。
因为接口的所有成员变量的默认修饰符都是:public static final
建议自己手动给出。
B:接口的构造方法特点:
接口没有构造方法 。
那么接口的实现类的无参构造方法默认访问的是谁的无参构造呢?
答:所有的类都默认继承一个类:Object类。
因为:类 Object 是类层次结构的根类。每个类都使用 Object 作为超类。
又因为:类 Object 只有无参构造方法,所以后来要求所有子类都默认调用的是父类的无参构造方法。
//接口名+Impl这种格式是接口的实现类格式
/*
class InterImpl implements Inter {
public InterImpl() {
super();
}
}
*/
//上面的写法等价于下面的写法
class InterImpl extends Object implements Inter {
public InterImpl() {
super();
}
}
C:接口的成员方法特点:
接口的成员方法只能是抽象的。
因为接口的所有成员方法的默认修饰符都是:public abstract
建议自己手动给出。
---------------------------------------
(4)类与类、类与接口、接口与接口的关系
A:类与类的关系
继承关系,只能单继承,不能多继承(只有一个父类),可以多层继承(可以有爷爷)。
class Son extends Father {} //正确
class Son extends Father, Mother {} //错误
B:类与接口的关系
1.实现关系,可以单实现,也可以多实现。(可以多扩展嘛)
2.还可以在继承一个类的同时,实现多个接口。(继承类 Object 嘛)
class Son implements Father, Mother {} //正确
class Son extends Object implements Father, Mother {} //正确
C:接口与接口的关系
继承关系,可以单继承,也可以多继承。
小结:Java中的类是单继承的,Java中的接口可以多继承。
---------------------------------------
(5)抽象类和接口的区别(自己补齐)?
A:成员区别
抽象类:
成员变量:可以有变量,也可以有常量
构造方法:有(用于子类访问父类数据的初始化)
成员方法:可以有抽象方法,也可以有非抽象方法
接口:
成员变量:只可以是常量
构造方法:无
成员方法:只可以是抽象方法
B:关系区别:
类与类:
继承关系,只能单继承和多层继承。
类与接口:
实现关系,可以单实现,也可以多实现。
接口与接口:
继承关系,可以单继承,也可以多继承。
C:设计理念不同
抽象类 被继承体现的是:“is a”的关系,抽象类中定义的是共性功能。
接口 被实现体现的是:“like a”的关系,接口中定义的是扩展功能。
---------------------------------------
(6)接口练习:
A:猫狗案例,加入跳高功能
共有六个类:(这里将接口理解为最最抽象的类)
跳高接口
动物类
猫类
狗类
有跳高功能的猫类
有跳高功能的狗类
测试类
示例代码如下:
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 interface Jumpping {
42 //跳高功能
43 public abstract void jump();
44 }
45
46 //定义抽象动物类
47 abstract class Animal {
48 //姓名
49 private String name;
50 //年龄
51 private int age;
52
53 public Animal() {}
54
55 public Animal(String name, int age) {
56 this.name = name;
57 this.age = age;
58 }
59
60 public String getName() {
61 return name;
62 }
63
64 public void setName(String name) {
65 this.name = name;
66 }
67
68 public int getAge() {
69 return age;
70 }
71
72 public void setAge(int age) {
73 this.age = age;
74 }
75
76 //吃饭();
77 public abstract void eat();
78
79 //睡觉(){}
80 public void sleep() {
81 System.out.println("睡觉觉了");
82 }
83 }
84
85 //具体的猫类
86 class Cat extends Animal {
87 public Cat() {}
88
89 public Cat(String name,int age) {
90 super(name, age);
91 }
92
93 public void eat() {
94 System.out.println("猫吃鱼");
95 }
96 }
97
98 //具体的狗类
99 class Dog extends Animal {
100 public Dog() {}
101
102 public Dog(String name, int age) {
103 super(name, age);
104 }
105
106 public void eat() {
107 System.out.println("狗吃肉");
108 }
109 }
110
111 //有跳高功能的具体的猫类
112 class JumpCat extends Cat implements Jumpping {
113 public JumpCat() {}
114
115 public JumpCat(String name, int age) {
116 super(name,age);
117 }
118
119 public void jump() {
120 System.out.println("跳高猫");
121 }
122 }
123
124 //有跳高功能的具体的狗类
125 class JumpDog extends Dog implements Jumpping {
126 public JumpDog() {}
127
128 public JumpDog(String name, int age) {
129 super(name,age);
130 }
131
132 public void jump() {
133 System.out.println("跳高狗");
134 }
135 }
136
137 //测试类
138 class InterfaceTest {
139 public static void main(String[] args) {
140 //定义有跳高功能的具体的猫类并测试
141 //法一:
142 JumpCat jc = new JumpCat();
143 jc.setName("哆啦A梦");
144 jc.setAge(3);
145 System.out.println(jc.getName()+"---"+jc.getAge());
146 jc.eat();
147 jc.sleep();
148 jc.jump();
149
150 //法二:
151 JumpCat jc2 = new JumpCat("加菲猫", 2);
152 System.out.println(jc2.getName()+"---"+jc2.getAge());
153 jc2.eat();
154 jc2.sleep();
155 jc2.jump();
156 System.out.println("-----------------");
157
158 //定义有跳高功能的具体的狗类并测试
159 //法一:
160 JumpDog jd = new JumpDog();
161 jd.setName("旺财");
162 jd.setAge(8);
163 System.out.println(jd.getName()+"---"+jd.getAge());
164 jd.eat();
165 jd.sleep();
166 jd.jump();
167
168 //法二:
169 jd = new JumpDog("旺财", 8);
170 System.out.println(jd.getName()+"---"+jd.getAge());
171 jd.eat();
172 jd.sleep();
173 jd.jump();
174 }
175 }
B:老师和学生案例,加入抽烟功能
共有六个类:(这里将接口理解为最最抽象的类)
抽烟接口
人类
学生类
老师类
有抽功能的学生类
有抽功能的老师类
测试类
示例代码同上,不在赘述!
=============================================================================
我的GitHub地址: https://github.com/heizemingjun我的博客园地址: http://www.cnblogs.com/chenmingjun
我的蚂蚁笔记博客地址: http://blog.leanote.com/chenmingjun
Copyright ©2018 黑泽明军
【转载文章务必保留出处和署名,谢谢!】