目录
1.抽象类/方法
1.1 基本介绍
① 当父类的某些方法，需要声明，但是又不确定如何实现时，可以将其声明为抽象方法
② 类中只要存在一个抽象方法，则该类必须为抽象类
③ 抽象类的价值更多作用在于设计，具体来说：设计者设计好后，让子类继承并实现父类的抽象方法
public class Test {
public static void main(String[] args) {
Dog dog = new Dog();
dog.eat();
}
}
//抽象类
abstract class Animal{
//抽象方法,只知道吃的动作，但不知道具体的动物吃什么东西
public abstract void eat();
}
class Dog extends Animal{
public void eat(){
System.out.println("狗吃骨头");
}
}1.2 语法格式
抽象类：被 abstract 修饰的类，一般会被继承，由其子类来实现抽象的方法
[修饰符] abstract class 类名{
}抽象方法：被 abstract 修饰而且没有方法体的方法，也叫做没有实现的方法
[修饰符] abstract 返回值类型 方法名([形参列表]);//不需要方法体{}1.3 使用细节
① abstract 只能修饰类和方法，不能用来修饰属性和其他的
② 使用 abstract 修饰类，只是表示该类为抽象类，类内部的属性和方法不会自动具有 abstract 修饰符
③ 抽象类不能创建对象实例
④ 抽象类的本质还是类，可以有类的各种成员。比如：非抽象方法、构造器、非静态方法/属性、静态方法/属性等等，都可以继承给子类
public class Test {
public static void main(String[] args) {
Dog dog = new Dog();
System.out.println(Dog.num);
System.out.println(dog.name);
dog.eat();
}
}
//抽象类
abstract class Animal{
public static int num = 1;
public String name = "小马";
public abstract void eat();//抽象方法
}
class Dog extends Animal{
//实现父类的抽象方法
public void eat(){
System.out.println("狗吃骨头");
}
}
/*输出结果
1
小马
狗吃骨头
*/⑤ 如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，除非它自己也声明为 abstract类，否则编译不通过
⑥ 抽象方法不能使用 private、final、static 来修饰，因为这些关键字都是和重写相违背的
private：如果父类的抽象方法用 private 修饰，那其子类没有访问权限，无法实现抽象方法
final：如果父类的抽象方法用 final 修饰，则该方法不能重写，其子类无法实现抽象方法
static：static 修饰的方法可以 "直接类.方法名" 调用，而 abstract 修饰的方法没有方法体，因此两者是相悖的【这样理解不知道对不对】
2. 模板设计模式（抽象类使用场景）
2.1 基本介绍
抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展、改造，但子类总体上会保留抽象类的行为方式
解决的问题：
① 当功能内部一部分实现是确定的，另一部分实现是不确定的，这时可以把不确定的部分暴露出去，让子类去实现
② 换句话说，在软件开发中实现一个算法时，整体步骤很固定、通用，这些步骤已经在父类中写好了。但是某些部分易变，则易变部分可以抽象出来，供不同子类实现。这就是一种模板模式
看上面的文字可能会觉得很抽象，可以结合具体的例子理解一下
2.2 具体例子
需求：计算不同类各自任务的执行时间
未使用模板设计模式之前
public class demo {
public static void main(String[] args) {
new JobA().job();
new JobB().job();
}
}
class JobA{
public void job(){
int result = 0;
long startTime = System.currentTimeMillis();//开始时间
for(int i=0;i<100000;i++){
result += i;
}
long endTime = System.currentTimeMillis();//结束时间
long duration = endTime - startTime;
System.out.println("任务执行时间: " + duration + "毫秒");
}
}
class JobB{
public void job(){
int result = 1;
long startTime = System.currentTimeMillis();//开始时间
for(int i=0;i<8000;i++){
result *= i;
}
long endTime = System.currentTimeMillis();//结束时间
long duration = endTime - startTime;
System.out.println("任务执行时间: " + duration + "毫秒");
}
}缺点：代码冗余，复用性差，可以看到代码整体的步骤是很固定的，如下：
① 记录任务开始时间
② 执行任务
③ 记录任务结束时间
④ 打印任务执行时间
其中，① ③ ④ 是固定不变的，变的只有 ② ，这就有了改进的空间
引入模板设计模式
优点：利用抽象类+动态绑定机制使得模板类中的 job() 可以动态调用执行方法，代码复用性高
public class demo {
public static void main(String[] args) {
new JobA().calculateJobTime();
new JobB().calculateJobTime();
}
}
//模板类
abstract class Template{
public abstract void job();//抽象方法
//计算任务执行时间
public void calculateJobTime(){
long startTime = System.currentTimeMillis();//开始时间
job();//动态绑定机制
long endTime = System.currentTimeMillis();//结束时间
long duration = endTime - startTime;
System.out.println("任务执行时间: " + duration + "毫秒");
}
}
class JobA extends Template{
//重写抽象方法
public void job(){
int result = 0;
for(int i=0;i<100000;i++){
result += i;
}
}
}
class JobB extends Template{
//重写抽象方法
public void job(){
int result = 1;
for(int i=0;i<8000;i++){
result *= i;
}
}
}