java面向对象(下)-抽象类

　　抽象类和抽象方法

　　抽象类和抽象方法必须使用abstract修饰符来定义,有抽象方法的类只能被定义成抽象类,抽象类里可以没有抽象方法

抽象类和抽象方法的规则如下

　　1.抽象类和抽象方法必须要用abstract来修饰,抽象方法里可以没有方法体.

　　2.抽象类不能实例化,无法使用new关键字来调用构造器创建抽象类的实例.

　　3.抽象类可以包含成员变量,方法(普通方法和抽象方法都可以),构造器,初始化块,内部类(接口,枚举)5种成分,抽象类的构造器不能用与创建实例,主要用于被其子类调用.

　　4.含有抽象方法的类(包括直接定义了一个抽象方法;或者是继承了一个抽象父类,但是没有完全实现父类包含的抽象方法;或者是实现了一个接口,但是没有完全实现接口包含的抽象方法三种情况)只能被定义成抽象类.

定义抽象类只需要在类上面加关键字abstract,定义抽象方法只需要在普通方法上增加abstract修饰符,并把普通方法的方法体(也就是方法后面的花括号括起来的部分)全部去掉,并在方法后面增加分号即可.

　　抽象方法:public abstract void test();

　　普通方法:public void test(){}

示例代码:

package com.j1803.abstractTest;

public abstract class Shape {
    
    {
        System.out.println("执行Shape的初始化块");
    }
    
   private String color;
   
   //定义计算周长的抽象方法
   public abstract double calPerimeter();
   //定义一个返回形状的抽象方法
   public abstract String getType();
   
   //构造函数,用于被子类调用.
   public Shape() {}
   public Shape(String color) {
       System.out.println("执行Shape的构造器");
       this.color=color;
   }
}
package com.j1803.abstractTest;

public class Triangle extends Shape{
    //定义三角形的三边
    private double a;
    private double b;
    private double c;
    
    //构造方法
    public Triangle(String color, double a, double b, double c) {
        super(color);
        System.out.println("执行Triangle构造器");
        this.a = a;
        this.b = b;
        this.c = c;
    }

    public static void main(String[] args) {
        Shape s1=new Triangle("黑色",3,4,5);
        System.out.println(s1.getType());
        System.out.println(s1.calPerimeter());
    }
    
    //重写Shape类的计算周长公式
    @Override
    public double calPerimeter(){
        return a+b+c;
    }
    //重写Shape类的返回形状的抽象方法
    @Override
    public String getType() {
        return "三角形";
    }

}
　　当使用abstract修饰时表明这个类只能被继承;当使用abstract修饰方法时,表明这个类必须由子类提供实现(即重写).final修饰的类和方法不能被继承和重写,因此final和abstract永远不能同时使用　　

　　abstract不能用于修饰成员变量,不能用于修饰局部变量,即没有抽象变量,没有抽象成员变量说法.

　　abstract不能用于修饰构造器,没有抽象构造器,抽象类里定义构造器只能是普通构造器

　　,static修饰一个方法时,表明这个方法属于这个类,通过类就可以调用这个方法,但如果该方法被定义成抽象方法,则将导致通过该类来调用该方法时出现错误(调用了一个没有方法体的方法肯定会引起错误),因此,static和abstract不能同时修饰某个方法,即没有所谓的类抽象方法..注:static和abstract并不是绝对互斥的,static和abstract虽然不能同时修饰某个方法,但它们可以同时修饰内部类

　　abstract关键字修饰的方法必须被其子类重写才有意义,否则这个方法将永远不会有方法体,因此abstract方法不能定义为private访问权限,即private和abstract不能同时修饰方法

======================================================

抽象类的作用:

　　抽象类作为子类的模板,避免了子类设计的随意性,抽象类体现的就是一种模板模式的设计.

模板模式范例2:抽象父类中,父类的普通方法依赖于一个抽象方法,而抽象方法则推迟到子类中提供实现

package com.j1803.abstractTest;

public abstract class SpeedMeter {
    //转速
    private double turnRate;
    //无参构造方法
    public SpeedMeter() {}
    //把计算车轮周长的方法定义成抽象方法
    public abstract double calGirth();
    
    public double getTurnRate() {
        return turnRate;
    }
    public void setTurnRate(double turnRate) {
        this.turnRate = turnRate;
    }
    //定义计算速度的通用算法
    public double getSpeed() {
        //速度等于 周长*转速=============calGirth()为抽象方法
        return calGirth()*turnRate;
    }
}
package com.j1803.abstractTest;

public class CarSpeedMeter extends SpeedMeter{
    private double radius;
    

    public CarSpeedMeter(double radius) {
        super();
        this.radius = radius;
    }

    public static void main(String[] args) {
        CarSpeedMeter csm=new CarSpeedMeter(0.34);
        csm.setTurnRate(15);
        System.out.println(csm.getSpeed());

    }

    @Override
    public double calGirth() {
        return radius*2*Math.PI;
    }

}
　　SpeedMeter类提供了速度表的通用算法,但一些具体的实现细节则推迟到其子类CarSpeedMeter类中实现.这也是一种典型的模板模式

　　模板模式在面向对象的软件中很常见,其原理简单,实现也很简单,下面是两条简单规则.

　　1.抽象父类可以只定义需要使用的某些方法,吧不能实现的部分抽象成抽象方法,留给其子类去实现

2.父类中可能包含需要调用其他系列的方法,这些被调用方法既可以有父类实现,也可以由其子类实现,父类里提供的方法只是定义了一个通用算法,其实现也许并不完全由自身实现,而必须依赖于其子类的辅助