当父类的一些方法不能确定时,可以用abstract关键字来修饰该方法，这个方法就是抽象方法，用abstract来修饰该类就是抽象类。
//我们看看如何把Animal做成抽象类，并让子类Cat类实现。
abstract class Animal{
String name;
int age;
abstract public void cry();}1)用abstract 关键字来修饰一个类时,这个类就叫抽象类访问修饰符 abstract 类名{12)用abstract关键字来修饰一个方法时，这个方法就是抽象方法访问修饰符 abstract 返回类型方法名(参数列表）；/∥没有方法体3）抽象类的价值更多作用是在于设计，是设计者设计好后，让子类继承并实现抽象类（）4）抽象类，是考官比较爱问的知识点，在框架和设计模式使用较多
注意事项及讨论：
1）抽象类不能被实例化[举例]2)抽象类不一定要包含abstract方法。也就是说，抽象类可以没有abstract方法[举例]3)一旦类包含了abstract方法，则这个类必须声明为abstract[说明]4)abstract 只能修饰类和方法，不能修饰属性和其它的。[说明]
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;
}5）抽象类可以有任意成员【抽象类本质还是类】，比如：非抽象方法、构造器、静态属性等等[举例]6）抽象方法不能有主体，即不能实现.如图所示tXIabstract void aaa()7）如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，除非它自己也声明为abstract类。[举例A类，B类，C类]
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
模板设计模式能解决的问题：
1）当功能内部一部分实现是确定，一部分实现是不确定的。这时可以把不确定的部分暴露出去，让子类去实现。2)编写一个抽象父类，父类提供了多个子类的通用方法，并把一个或多个方法留给其子类实现，就是一种模板模式.
3.
最佳实践:
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;
}
}
}
package 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();
}
}
