Java抽象类，超详细整理，适合新手入门

1.抽象类的引出

这里的eat方法内容其实没有什么意义，即父类方法不确定性问题。
1.可以将该方法设计成abstract方法（所谓抽象的方法就是没有实现的方法，所谓没有实现就是没有方法体）;
2.当一个类中存在抽象方法时，需要将该类设计成abstract类；
3. 一般来说，抽象类会被继承，由其子类实现抽象的方法；

abstract class Animal {
    private String name;

    public Animal(String name) {
        this.name = name;
    }
    //这里的eat方法内容其实没有什么意义
    //父类方法不确定性问题
    public void eat() {
        System.out.println("我是父类Animal，但我不知道吃什么");
    }
}
class Cat extends Animal{
    public Cat(String name) {
        super(name);
    }
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

2.细节

1.Missing method body, or declare abstract(父类方法去掉方法体之后加上abstract修饰)
Abstract method in non-abstract class(类必须也要加上abstract修饰)
Abstract methods cannot have a body(方法加上了abstract修饰就不能再有方法体)

2.抽象类不能实例化-cannot be instantiated

3.抽象类可以没有抽象方法，抽象类可以有实现的方法

5.抽象类可以有任意成员，它本质还是一个类，(比如非抽象方法、构造器、静态属性等)

abstract class DDD {
    //普通属性、静态属性、普通方法、抽象方法、静态方法
    public int n1 = 10;
    public static String name = "赵志伟";
    public void hi() {
        System.out.println("抽象类中实现了的方法");
    }
    public abstract void say();
    public static void cry() {
        System.out.println("cry");
    }
}

6.如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，除非它自己也声明为abstract类；
Class ‘Student’ must either be declared abstract or implement abstract method ‘run()’ in ‘Person’

abstract class Person {
    public abstract void run();
    public abstract void eat();
}
//解决方法1(重写父类所有的抽象方法)
class Student extends Person {
	@Override
	public void run() {}//有大括号就构成重写
	@Override
	public void eat() {}
}
//解决方法2(自己声明为一个抽象类)
abstract class Student extends Person {}

7.抽象方法不能使用private、final 和 static 来修饰，因为这些关键字都是和重写相违背的

• 使用了private修饰符，hi()方法便不能再被子类访问到(无法重写)，和“子类必须实现抽象类的所有抽象方法”相违背；
• Illegal combination of modifiers: ‘abstract’ and ‘private’

abstract class H {
    private abstract void hi(); 
}

• final修饰的方法不能被重写，和“子类必须实现抽象类的所有抽象方法”相违背；
• Illegal combination of modifiers: ‘final’ and ‘abstract’

abstract class H {
    public final abstract void hi(); 
}

• staitc关键字与抽象类无关，非法组合
• static修饰的方法是静态的，静态方法随着类的加载而加载，不需要通过子类去实现，不具备继承的关系
• Illegal combination of modifiers: ‘abstract’ and ‘static’

abstract class H {
    public static abstract void hi(); 
}

8.abstract只能修饰类和方法，不能修饰属性和其它的

abstract class H {
	Modifier 'abstract' not allowed here
    //private abstract int n1 = 100;
}

3.抽象类最佳实践-模版设计模式

1.编写方法calculateTime()，可以计算某段代码的耗时时间；
2.编写抽象方法job();
3.编写子类AA, BB，继承抽象类Template，并实现job方法；
4.编写一个测试类TestTemplate；

public class TestTemplate {
    public static void main(String[] args) {
        AA aa = new AA();
        aa.calculateTime();
        BB bb = new BB();
        bb.calculateTime();
    }
}
abstract class Template {
    public abstract void job();
    public void calculateTime() {////把本类的计算工作时间的功能提取出来
        //得到开始的时间
        long start = System.currentTimeMillis();
        job();//动态绑定机制
        //得到结束的时间
        long end = System.currentTimeMillis();
        System.out.println("执行时间 " + (end - start));
    }
}
class AA extends Template{
    //计算任务: 求和
    //1+2+....+80000000
    @Override
    public void job() {
        long sum = 0;
        for (long i = 0; i < 80000000; i++) {
            sum += i;
        }
    }