抽象类和方法

前言

父类方法存在不确定性可考虑抽象方法

抽象方法是未实现的方法（即没有方法体）

抽象类由abstract修饰。通常抽象类会被继承由子类实现抽象方法

基本介绍

1. 用abstract关键字来修饰一个类时，这个类就叫抽象类访问【修饰符 abstract 类名】
2. 抽象方法不能有方法体；抽象类不能实例化（new）
3. 抽象类可以没有抽象方法；但是有抽象方法的类必须是抽象类
4. abstract只能修饰方法和类，不能修饰其他的。
5. 抽象类的本质还是类可有任意成员
6. 如果一个类继承了抽象类，他必须实现抽象类的所有抽象方法，除非它也声明为抽象类
7. 抽象方法不能使用private、final和static修饰，因为这些关键字和重写相悖。

查看代码

public class Abstract_ {
    public static void main(String[] args) {
        System.out.println("hello,world");
    }
}
abstract class A{
    public abstract void hi();
}
class B extends A {
    public void hi(){
        //实现继承的抽象类中的所有抽象方法，具有方法体即是实现了（抽象）方法
    }
}

功能实例：

Employee.Java

 abstract public class Employee {
    private String name;
    private int id;
    private double deposit;
    public abstract void work();//抽象方法
    public Employee(String name, int id, double deposit) {
        this.name = name;
        this.id = id;
        this.deposit = deposit;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public double getDeposit() {
        return deposit;
    }

    public void setDeposit(double deposit) {
        this.deposit = deposit;
    }
}

Manager.java

 public class Manager extends Employee {
    private double bonus;
    @Override
    public void work() {
        System.out.println("经理"+getName()+"工作中。。。。");
    }
    public Manager(String name, int id, double deposit) {
        super(name, id, deposit);
    }

    public Manager(String name, int id, double deposit, double bonus) {
        super(name, id, deposit);
        this.bonus = bonus;
    }
}

Common.java

 public class Common extends Employee{

    public Common(String name, int id, double deposit) {
        super(name, id, deposit);
    }
    @Override
    public void work() {
        System.out.println("普通员工工作中。。。");
    }
}

抽象类应用模板设计模式

Abstract_.java

 public class Abstract_ {
    public static void main(String[] args) {
        One one = new One();
        one.calTime();
        Two two = new Two();
        two.calTime();
    }
}

Two.java

 public class Two extends Template{
    // 继承抽象函数后多行注释代码省略
   /* public void calTime() {
        long start = System.currentTimeMillis();
        sum();
        long end = System.currentTimeMillis();
        System.out.println("Two执行时间：" + (end - start));
    }*/

    public void sum() {
        // 得到开始的时间
//        long start=System.currentTimeMillis();
        long num = 0;
        for (long i = 1; i < 9910000; i++) {
            num *= i;
        }
//        long end=System.currentTimeMillis();
//        System.out.println("Two执行时间："+(end-start));
    }
}

One.java

 public class One extends Template{
    // 继承抽象函数后多行注释代码省略
    /*public void calTime(){
        long start=System.currentTimeMillis();
        sum();
        long end=System.currentTimeMillis();
        System.out.println("One执行时间："+(end-start));
    }*/
    public void sum(){
        // 得到开始的时间
//        long start=System.currentTimeMillis();
        long num=0;
        for (long i = 1; i < 8810000; i++) {
            num+=i;
        }
//        long end=System.currentTimeMillis();
//        System.out.println("One执行时间："+(end-start));
    }
}

Template.java

abstract public class Template {
    public abstract void sum();

    public void calTime() {
        long start = System.currentTimeMillis();
        sum();// 动态绑定机制
        long end = System.currentTimeMillis();
        System.out.println("任务执行时间：" + (end - start));
    }
}

根据以上应用例子可以看到抽象类提供一个模板，继承抽象类后重写抽象方法等价于插入自定义的方法内容，以达到模板的效果。