当父类的某些方法需要声明，但是又不确定如何实现时，可以将其声明为抽象方法，那么这个类就是抽象类。
package com.pero.abstract_;
public class Abstract01 {
public static void main(String[] args) {
}
}
abstract class Animal{
private String name;
public Animal(String name){
this.name = name ;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
//在这里实现eat()方法并没有什么意义
//将该方法设计为抽象(abstract)方法
//抽象方法就是没有实现的方法，也就是没有方法体
//当一个类中存在抽象方法时，那么这个类是抽象类，需要用abstract来修饰
//抽象类会被继承，由子类实现抽象方法
// public void eat(){
// System.out.println("某某动物，喜欢吃什么");
// }
public abstract void eat();
}
抽象类的介绍
1）用abstract关键字来修饰一个类时，这个类就是抽象类；
访问修饰符 abstract 类名 {
}
2）用abstract关键字修饰一个方法时，这个方法就是抽象方法；
访问修饰符 abstract 返回类型 方法名 （参数列表）；//没有方法体
3）抽象类的价值更多作用在于设计，设计好后让子类继承并实现抽象类；
4）抽象类，在框架和设计模式中使用较多。
抽象类使用注意事项和细节1）抽象类不能被实例化；
public class Abstract02 {
public static void main(String[] args) {
//new Person(); 错误，抽象类不能被实例化
}
}
abstract class Person{ }
2）抽象类不一定包含抽象（abstract）方法，可以有实现的方法；
//抽象类
abstract class Person{
//普通方法
public void study(){
System.out.println("正在学习！");
}
//没有定义抽象方法
}
3）一旦类包含了抽象（abstract）方法，则一定要声明为抽象（abstract）类；
abstract class Animal{
//当一个类中存在抽象方法时，那么这个类是抽象类，必须要用abstract来修饰
public abstract void eat();
}
4）abstract只能修饰类和方法，不能修饰属性和其他；
5）抽象方法可以有任意成员（抽象类本质还是类），比如：非抽象方法、静态和非静态属性、构造器等等；
package com.pero.abstract_;
public class Abstract03 {
public static void main(String[] args) {
}
}
abstract class Student {
//私有属性
private String name;
private final static int AGE;
//静态方法体
static {
AGE = 18;
}
//构造器
public Student(String name){
this.name = name;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public static int getAGE() {
return AGE;
}
//抽象方法
public abstract void say();
}
6）抽象方法不能有主体，因为不能实现；
7）如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，除非它也声明为抽象(abstract)类。
package com.pero.abstract_;
public class Abstract04 {
public static void main(String[] args) {
}
}
abstract class A{
//抽象方法
public abstract void hi();
//非抽象方法
public void study(){
System.out.println("正在学习");
}
}
//抽象类的子类要不定义为抽象类，要不就实现抽象类的所有抽象方法
class B extends A{
//所谓实现方法，就是方法有方法体，方法体具体有什么不管（可为空）
public void hi(){
System.out.println("你好");
}
//非抽象方法不一定要实现
}
8）抽象方法不能使用private、final和static 来修饰，因为这些关键字与重写相违背。
package com.pero.abstract_;
public class Abstract05 {
public static void main(String[] args) {
}
}
abstract class Father{
public abstract void hi();
//private abstract void hi(); 错误，私有的方法，子类继承后无法重写
//final abstract void hi(); 错误，final修饰的方法子类无法重写
//static abstract void hi(); 错误，static方法可以直接采用类形式调用，static和abstract是非法组合
}
抽象模板模式
1）设计一个抽象类
2）将子类中重复动作的方法在抽象类中写成一个非抽象方法，用于继承执行
3）将子类中独特动作的相同方法写成一个抽象方法，用于子类重写，由于动态绑定机制，子类会执行重写方法的特有动作
抽象类模板的父类：package com.pero.abstract_;
public abstract class Template {
public abstract void job();
public void calculateTime(){
//得到开始时间
long start = System.currentTimeMillis();
job(); //动态绑定机制，执行子类中的job()方法
//得到结束的时间
long end = System.currentTimeMillis();
System.out.println("执行时间"+(end-start));
}
}
抽象类模板中的子类：
package com.pero.abstract_;
public class AbstractExercise01 {
public static void main(String[] args) {
AA aa = new AA();
aa.calculateTime();//执行从父类中继承的calculateTime()方法
}
}
class AA extends Template{
//计算任务
//1+.....+10000
public void job(){ //重写父类中的job()方法
long number = 0;
for (long i = 0; i <= 100000; i++) {
number += i;
}
}
}
