抽象类

一个类中的某些方法，需要声明，但又不确定如何实现时，则可以将其声明为抽象方法（用abstract关键字来修饰该方法），方法被设置为抽象方法时该方法所在的类也必须设置为抽象类（用 abstract 关键字来修饰该类）

抽象类不能修饰属性

abstract class Demo01 {
    private String a;
    public Demo01(String a) {
        this.a = a;
    }

    /*
    * 抽象方法就是该方法我们不知道该怎么写，此时就可以使用抽象类
    * 举个例子：比如我要定义一个动物，但是该动物喜欢吃什么我不知道
    * 此时就可以使用抽象方法来定义该动物吃的东西
    * 抽象方法没有方法体
    * 设置了抽象方法那么该方法所在的类也必须是抽象类
    * 一般来说抽象类将被继承，由子类来实现抽象方法
    * */
    public abstract void cat();
}

在抽象类直接调用父类中的方法

class Demo01 {
    String name = "zhangsan";
    public void index() {

    }
}

abstract class Demo extends Demo01 {
    public void index1() {
//        调用父类中的属性和方法
        super.index();
        System.out.println(super.name);
    }
//    抽象方法没有方法体
    abstract void index3();
}

class Demo02 extends Demo {
    public void index2() {
//        调用父类中的方法
        super.index1();
    }
//    调用抽象类中的抽象方法
//    重写的抽象方法不能是私有类
    public void index3() {

    }
}

抽象类的使用细节

1. 抽象类的本质还是一个类，所以可以和类一样使用类的各种成员方法以及属性
2. 抽象类不可以有主体（main方法）
3. 一个类继承一个抽象类，那么该类就必须实现抽象类的所有抽象方法，或则该类也变为抽象类
4. private 、final 和 static 修饰符不能用来修饰抽象方法，因为这些关键字都是和重写相违背的
5. abstract关键字不可以修饰属性或则其它，只能修饰方法或类，注意：虽然构造器也属于一种方法，但是abstract并不可以修饰构造器

public class Demo03 {
    public static void main(String[] args) {
        /*
        * 抽象类不能被实例化，也就说不能创建抽象类的对象
        * */
//        a a = new a();
    }
}

// 抽象类中不一定有抽象方法
// 但是有抽象方法的类一定是一个抽象类
abstract class a {
    /*
    * 抽象类中可以没有抽象方法
    * 也可以没有别的属性和方法
    * */
}

abstract class b {
    /*
    * abstract关键字不可以修饰属性或则其它
    * 只能修饰方法或类
    * (注意，虽然构造器也属于一种方法，但是abstract并不可以修饰构造器)
    * */
//    abstract int a = 10;

    /*
    * 抽象类中可以有普通方法
    * */
    public void info() {
        System.out.println("hi");
    }
}

继承抽象类细节

abstract class E {
    public abstract void cat();
    public abstract void cat1();
    private String a;
}

//继承一个抽象类，要么实现抽象类的所有抽象方法
//要么把自己定义成一个抽象类
class n extends E {
    // 实现方法就是该方法加上一个大括号 { } 
    // 即使该括号里面什么东西都没有
    // 一个方法没有大括号，那就表示该方法体没有被实现
    @Override
    public void cat() {

    }

    @Override
    public void cat1() {

    }
}

package com.Project.Abstract;

abstract class E {
    public abstract void cat();
    public abstract void cat1();
    private String a;

}

//继承一个抽象类，要么实现抽象类的所有抽象方法
//要么把自己定义成一个抽象类
abstract class n1 extends E {
    
}

abstract class E {
//    不能使用private修饰符是因为该修饰符是一个私有访问修饰符
//    如果有一个类继承了cat方法，而cat方法又正好是一个私有方法
//    此时即使你重写了cat方法你也不能修改cat方法，因为私有的不能被重写

//    不能使用 final是因为被当成员被定义成了final方法之后就不能被修改了
//    所以子类重写了cat方法就不能对cat方法进行重写

//    static其实是和重写无关的关键字
//    在Java中 abstract和static这两个修饰符是不可以写在一起的
//    所以不能写static关键字
    public abstract void cat();
//	  static是关键字也是修饰符
}

抽象类模板设计

有多个项目，记录每个项目所运行的时间

父类

public abstract class Timer {
    // 每个子类相当于是一个项目，每个子类重写这个抽象类
    public abstract void job();

    public void runTime() {
        // 开始计时
        // currentTimeMillis在System这个类里面的，表示的是返回当前的时间（以毫秒为单位）
        long start = System.currentTimeMillis();
        // 然后这里在调用这个抽象类就可以运行子类中的项目
        job();
        // 结束计时
        long end = System.currentTimeMillis();
        // 项目运行时间（结束时间减去开始时间就等于项目运行时间）
        System.out.println("该项目运行的时间为 " + (end - start) + " ms");
    }
}

子类

public class Demo01 extends Timer {
    // 重写父类中的抽象类
    public void job() {
        int a = 1;
        for (int i = 1; i < 50000; i++) {
            a *= i;
        }
    }
}

运行

public class Run {
    public static void main(String[] args) {
        // 分别调用不同项目的计时器
        new Demo01().runTime();
    }
}