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