Java 基础之抽象类抽象方法关键字abstract与抽象类的匿名子对象及模板方法

抽象类的定义

随着继承层次中一个个新子类的定义，类变得越来越具体，而父类则更一般，更通用。类的设计应该保证父类和子类能够共享特征。有时将一个父类设计得非常抽象，以至于它没有具体的实例，这样的类叫做抽象类

abstract 关键字的使用
abstract  可以修饰类、修饰方法
abstract 修饰类：抽象类，
         此类不能实例化
         抽象类中一定有构造器，便于子类实例化时调用(涉及子类实例化的全过程)
         开发中，都会提供抽象类的子类

abstract 修饰方法：抽象方法
          >   抽象方法只有方法的声明没有方法体
          >    包含抽象方法的类，一定时个抽象类，反之抽象类中可以没有抽象方法
          >   若子类重写了父类所有抽象方法后，此子类方可实例化
              若子类没有重写所有的抽象方法，此子类还是一个抽象类
示例

ublic class AbstractTest {
    public static void main(String[] args) {
        //person 为抽象类不能直接new对象，不可示例化
 
//        Person p1 = new Person();
//        p1.eat();
//        Person.class
        Stduent s1 = new Stduent("cx",18);
        s1.eat();
    }
}
//abstract 表示声明为抽象类不能，直接new 属性
 
abstract class Person{
    String name;
    int age;
    public  Person(){
 
    }
    public Person(String name,int age){
        this.name = name;
        this.age= age;
 
    }
 
//    public void eat(){
//        System.out.println("人吃饭");
//    }
    //抽象方法的定义
    public abstract  void eat();//此方法就是抽象方法
    public void walk(){
        System.out.println("人走路");
    }
 
}
 
class  Stduent extends Person{
    public  Stduent(String name,int age){
            super(name,age);
    }
 
    @Override
    public void eat() {
        System.out.println("吃有营养的东西");
 
    }
}

　　测试结果

吃有营养的东西

　　抽象类的应用

抽象类是用来模型化那些父类无法确定全部实现，而是由其子类提供具体实现的对象的类。

在航运公司系统中，Vehicle类需要定义两个方法分别计算运输工具的燃料效率和行驶距离。

问题：卡车(Truck)和驳船(RiverBarge)的燃料效率和行驶距离的计算方法完全不同。Vehicle类不能提供计算方法，但子类可以。

实现方案

Java允许类设计者指定：超类声明一个方法但不提供实现，该方法的实现由子类提供。这样的方法称为抽象方法。有一个或更多抽象方法的类称为抽象类。

Vehicle是一个抽象类，有两个抽象方法。

public abstract class Vehicle{

public abstract double calcFuelEfficiency(); //计算燃料效率的抽象方法

public abstract double calcTripDistance(); //计算行驶距离的抽象方法

}

public class Truck extends Vehicle{

public double calcFuelEfficiency( ) { //写出计算卡车的燃料效率的具体方法 }

public double calcTripDistance( ) { //写出计算卡车行驶距离的具体方法 }

}

public class RiverBarge extends Vehicle{

public double calcFuelEfficiency( ) { //写出计算驳船的燃料效率的具体方法 }

public double calcTripDistance( ) { //写出计算驳船行驶距离的具体方法}

}

抽象类应用

注意：抽象类不能实例化 new Vihicle()是非法的

抽象类抽象方法示例

package com.chenxi.exer;
/*
 
 */
    class  Emplotest{
        public static void main(String[] args) {
        Manager manager = new Manager("库克",2,50000,5000);
        manager.work();
        }
    }
 public abstract class Employee {
     String name;
     int  id ;
     double salary;
     public Employee(){
 
     }
     public Employee(String name,int id,double salary){
         this.name= name;
         this.id = id;
         this.salary = salary;
 
 
     }
     public abstract void  work();
}
class Manager extends Employee{
 
    private  double bonus;
    public  Manager(String name, int i, double bonus){
        super();
        this.bonus =bonus;
    }
 
    public Manager(String name, int id, double salary, double bonus) {
        super(name, id, salary);
        this.bonus = bonus;
    }
 
    @Override
    public void work() {
        System.out.println("管理员工提高公司运行效率");
    }
}
class  CommonEmployee extends Employee{
 
    @Override
    public void work() {
        System.out.println("员工在一线车间工作");
    }
}
 
测试结果
管理员工提高公司运行效率

　　抽象类的匿名子类

package com.chenxi.exer;
/*
抽象类的匿名子类
 
 */
public class PersonTest {
    public static void main(String[] args) {
        method(new Student());//匿名对象
        Worker worker = new Worker();
        m1(worker);//非匿名类非匿名对象
        m1(new Worker());//非匿名类匿名对象
        //创建一个匿名子类的对象：p
        Person p = new Person() {
            @Override
            public void eat() {
                System.out.println("nihao");
            }
        };//注意最后有分号
        m1(p);
 
    }
    public static void method(Student s){
 
    }
    public static void m1(Person person){
        person.eat();
        person.walk();
    }
}
class  Worker extends Person{
    @Override
    public void eat() {
        System.out.println("吃鸡肉");
    }
 
 
}
测试结果
 
吃鸡肉
人走路
吃鸡肉
人走路
nihao
人走路

模板方法设计模式

抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展、改造，但子类总体上会保留抽象类的行为方式。
解决的问题：
 当功能内部一部分实现是确定的，一部分实现是不确定的。这时可以把不确定的部分暴露出去，让子类去实现。
 换句话说，在软件开发中实现一个算法时，整体步骤很固定、通用，这些步骤已经在父类中写好了。但是某些部分易变，易变部分可以抽象出来，供不同子类实现。这就是一种模板模式。

package com.chenxi.exer1;
 
/*
抽象类的设计模板
 
 */
public  class TemplateTest {
    public static void main(String[] args) {
       // long start = System.currentTimeMillis();
        Sum t = new Sum();
        t.spendTime();
    }
 
}
abstract  class  Template {
    //计算某段代码具体执行的时间
    public void spendTime() {
 
        long start = System.currentTimeMillis();//获取时间代码数字
        code();//易变的部分
        long end = System.currentTimeMillis();
        System.out.println("******"+(end-start));
    }
    public abstract void code();//测试不确定的代码
 
}
class Sum extends Template{
    @Override
    public void code() {
        for (int i =2 ; i<=1000;i++){
            boolean jsFlag = true;
            for (int j= 2;j<=Math.sqrt(i);i++){
                if (i%j==0){
                    jsFlag = false;
                    break;
                }
            }
 
            if (jsFlag){
                System.out.println(i);
            }
 
        }
    }
}
 
测试结果
2
3
******1