Java-抽象类

抽象类的引出

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

package com.pero.abstract_;

/**
 * 抽象类的引出
 *
 * @version 1.0
 * @author Pero
 */

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_;

/**
 * 如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，除非它也声明为抽象(abstract)类
 *
 * @version 1.3
 * @author Pero
 */

public class Abstract04 {
    public static void main(String[] args) {

    }
}
abstract class A{
    //抽象方法
    public abstract void hi();

    //非抽象方法
    public void study(){
        System.out.println("正在学习");
    }
}

//抽象类的子类要不定义为抽象类，要不就实现抽象类的所有抽象方法
/*abstract*/class B extends A{
    //所谓实现方法，就是方法有方法体，方法体具体有什么不管（可为空）
    public void hi(){
        System.out.println("你好");
    }

    //非抽象方法不一定要实现
}

8）抽象方法不能使用private、final和static 来修饰，因为这些关键字与重写相违背。

package com.pero.abstract_;

/**
 * 抽象方法不能用private、final和static来修饰，这些关键字与重写相违背
 */

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;
        }
    }
}