前言
父类方法存在不确定性可考虑抽象方法
抽象方法是未实现的方法（即没有方法体）
抽象类由abstract修饰。通常抽象类会被继承由子类实现抽象方法
基本介绍
- 用abstract关键字来修饰一个类时，这个类就叫抽象类访问【修饰符 abstract 类名】
- 抽象方法不能有方法体；抽象类不能实例化（new）
- 抽象类可以没有抽象方法；但是有抽象方法的类必须是抽象类
- abstract只能修饰方法和类，不能修饰其他的。
- 抽象类的本质还是类可有任意成员
- 如果一个类继承了抽象类，他必须实现抽象类的所有抽象方法，除非它也声明为抽象类
- 抽象方法不能使用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));
}
}根据以上应用例子可以看到抽象类提供一个模板，继承抽象类后重写抽象方法等价于插入自定义的方法内容，以达到模板的效果。
标签：name,void,System,long,抽象类,方法,public From： https://www.cnblogs.com/vayenge/p/18079553