第五章：抽象类

系列文章目录

---

---

前言

当我们想让子类来实现方法时，我们需要抽象类与抽象方法。

---

一、抽象类

当父类的某些方法，需要声明，但是又不确定如何实现时，可以将其声明为抽象方法，那么这个类就是抽象类。所谓抽象的方法，就是没有实现的方法，所谓没有实现就是指没有方法体。

//语法形式
访问修饰符 abstract 类名
{}

访问修饰符 abstract 返回类型 方法名(参数列表);//没有方法体
1
2
3
4
5

package com.hspedu.abstract_;

public class AbstractDetail01 {
	public static void main(String[] args) {
		//抽象类， 不能被实例化
		//new A();
	}
} 

//抽象类不一定要包含 abstract 方法。 也就是说,抽象类可以没有 abstract 方法
//， 还可以有实现的方法。
abstract class A {
	public void hi() {
		System.out.println("hi");
	}
} 

//一旦类包含了 abstract 方法,则这个类必须声明为 abstract
abstract class B {
	public abstract void hi();
} 

//abstract 只能修饰类和方法， 不能修饰属性和其它的
class C {
	// public abstract int n1 = 1;
}
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

package com.hspedu.abstract_;

public class AbstractDetail02 {
	public static void main(String[] args) {
		System.out.println("hello");
	}
} 

//抽象方法不能使用 private、 final 和 static 来修饰， 因为这些关键字都是和重写相违背的
abstract class H {
	public abstract void hi();//抽象方法
} 

//如果一个类继承了抽象类， 则它必须实现抽象类的所有抽象方法， 除非它自己也声明为 abstract 类
abstract class E {
	public abstract void hi();
} 

abstract class F extends E {
} 

class G extends E {
@Override
	public void hi() { 
	//这里相等于 G 子类实现了父类 E 的抽象方法， 所谓实现方法， 就是有方法体
	}
} 

//抽象类的本质还是类， 所以可以有类的各种成员
abstract class D {
	public int n1 = 10;
	public static String name = "韩顺平教育";
	
	public void hi() {
		System.out.println("hi");
	}
	 
	public abstract void hello();
	
	public static void ok() {
		System.out.println("ok");
	}
}
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

二、模板设计模式

抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展、改造，但子类总体上会保留抽象类的行为方式。

//需求
//有多个类，完成不同的任务job，要求统计得到各自完成任务的时间
package com.hspedu.abstract_;

abstract public class Template { //抽象类-模板设计模式
	public abstract void job();//抽象方法
	public void calculateTime() {//实现方法， 调用 job 方法
		//得到开始的时间
		long start = System.currentTimeMillis();
		job(); //动态绑定机制
		//得的结束的时间
		long end = System.currentTimeMillis();
		System.out.println("任务执行时间 " + (end - start));
	}
}

package com.hspedu.abstract_;

public class AA extends Template {
	//计算任务
	//1+....+ 800000
	@Override
	public void job() { //实现 Template 的抽象方法 job
		long num = 0;
		for (long i = 1; i <= 800000; i++) {
			num += i;
		}
	}
	// public void job2() {
	// //得到开始的时间
	// long start = System.currentTimeMillis();
	// long num = 0;
	// for (long i = 1; i <= 200000; i++) {
	// num += i;
	// }
	// //得的结束的时间
	// long end = System.currentTimeMillis();
	// System.out.println("AA 执行时间 " + (end - start));
	// }
	} 

package com.hspedu.abstract_;

public class BB extends Template{
	public void job() {//这里也去， 重写了 Template 的 job 方法
		long num = 0;
		for (long i = 1; i <= 80000; i++) {
			num *= i;
		}
	}
}



ackage com.hspedu.abstract_;

public class TestTemplate {
	public static void main(String[] args) {
		AA aa = new AA();
		aa.calculateTime(); //这里还是需要有良好的 OOP 基础， 对多态
		BB bb = new BB();
		bb.calculateTime();
	}
}


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
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

---

总结

有抽象方法的类必定是抽象类，抽象类不一定有抽象方法。