文章目录
- 1.抽象方法和抽象类
- 2.抽象类的作用
- 3.接口
- 4.接口和抽象类的异同
- 5.面向接口编程
1.抽象方法和抽象类
抽象方法和抽象类必须使用abstract修饰符来定义，有抽象方法的类只能被定义成抽象类，抽象类里可以没有抽象方法。
抽象类必须使用abstract修饰符来修饰，抽象方法也必须使用abstract修饰符来修饰，抽象方法不能有方法体。
抽象类不能被实例化，无法使用new关键字来调用抽象类的构造器创建抽象类的实例。
抽象类可以包含成员变量，方法（普通方法和抽象方法都可），构造器，初始化块，内部类（接口，枚举）5种成分。
抽象类的构造器不能用于创建实例，主要用于其子类调用。
package abstractDemon;
public abstract class shape {
{
System.out.println("执行Shape的初始化块");
}
private String color;
//定义一个计算周长的抽象方法
public abstract double calPerimeter();
//定义一个返回形状的抽象方法
public abstract String getType();
//定义Shape的构造器，该构造器并不是用于创建Shape对象
//而是用于被子类调用
public shape() {
}
public shape(String color) {
this.color = color;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
}
当使用super调用父类构造方法时，如果有初始化代码块会先执行初始化代码块。
package abstractDemon;
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);
this.setSides(a,b,c);
}
private void setSides(double a, double b, double c) {
if(a>=b+c||b>=a+c||c>=a+b){
System.out.println("三角形两边之和必须大于第三边");
return;
}
this.a=a;
this.b=b;
this.c=c;
}
//重写Shape类的计算周长的抽象方法
@Override
public double calPerimeter() {
return a+b+c;
}
//重写shape类的返回形状抽象方法
@Override
public String getType() {
return "三角形";
}
}
package abstractDemon;
public class Circle extends shape{
private double radius;
public Circle(String color,double radius){
super(color);
this.radius=radius;
}
public void setRadius(double radius) {
this.radius = radius;
}
//重写Shape类的计算周长的抽象方法
@Override
public double calPerimeter() {
return 2*Math.PI*radius;
}
//重写shape类的返回形状抽象方法
@Override
public String getType() {
return getColor()+"圆形";
}
public static void main(String[] args) {
shape s1=new Triangle("黑色",3,4,5);
shape s2=new Circle("黄色",3);
System.out.println(s1.getType());
System.out.println(s1.calPerimeter());
System.out.println(s2.getType());
System.out.println(s2.calPerimeter());
}
}
上面程序的两个shape类型的引用变量，他们分别指向Triangle对象和Circle对象。由于shape类中定义了callPerimeter()方法和getType()方法，所以程序可以直接调用s1变量和s2变量的callPerimeter()方法和getType()方法，无需强制类型转换为其子类类型。
利用抽象类和抽象方法的优势，可以更好的发挥多态的优势，使程序更灵活，比如s1.getColor()和s2.getColor()如果子类没重写，实际上就是父类的方法。
当使用abstract修饰类时，表明这个类只能被继承；当使用abstract修饰方法时，表明这个方法必须由子类提供实现(即重写)。
2.抽象类的作用
模版模式：
抽象父类可以只定义需要使用的某些方法，把不能实现的部分抽象成抽象方法，留给其子类去实现。
父类中可能包含需要调用其他系列方法的方法，这些方法既可以由父类实现，也可以由其子类实现。父类中提供的方法只是定义了一个通用算法，其实现也许并不是由自身实现，而必须依赖于其子类的辅助。
package abstractDemon;
public abstract class SpeedMeter {
//转速
private double turnRate;
public SpeedMeter(){
}
//把计算车轮周长的方法定义成抽象方法
public abstract double calGirth();
public void setTurnRate(double turnRate){
this.turnRate=turnRate;
}
//定义计算速度的通用算法
public double getSpeed(){
//速度等于 周长*转速
return calGirth()*turnRate;
}
}
package abstractDemon;
public class CarSpeedMeter extends SpeedMeter{
private double radius;
public CarSpeedMeter(double radius){
this.radius=radius;
}
@Override
public double calGirth() {
return radius*2*Math.PI;
}
public static void main(String[] args) {
CarSpeedMeter csm = new CarSpeedMeter(0.34);
csm.setTurnRate(15);
System.out.println(csm.getSpeed());
}
}
SpeedMeter类里提供了速度表的通用算法，但一些具体实现的细节则推迟到其子类CarSpeedMeter类中实现，这也是一种典型的模版模式。
3.接口
package abstractDemon;
public interface Output {
//接口里定义的成员变量只能是常量
int MAX_CACHE_LINE=50;
//接口里定义的普通方法只能时public的抽象方法
void out();
void getData(String msgs);
//在接口中定义默认方法，需要使用default修饰
default void print(String... msgs){
for(String msg:msgs){
System.out.println(msg);
}
}
//在接口中定义类方法，需要使用static修饰
default void test(){
System.out.println("默认的test()方法");
}
//在接口中定义类方法，需要使用static修饰
static String staticTest(){
return "接口里的类方法";
}
}
上面程序接口中的成员变量MAX_CACHE_LINE系统将会默认修饰为public static final。而定义的两个普通方法：表示取得数据的getData()方法和表示输出的out()方法。
4.接口和抽象类的异同
接口和抽象类都不能被实例化
接口和抽象类都可以包含抽象方法，实现接口或继承抽象类的普通子类都必须实现这些抽象方法。
子类是抽象类可以不实现接口中的所有方法，而非抽象类就要实现接口中的所有方法。
接口里只能包含抽象方法，静态方法，默认方法，不能为普通方法提供方法实现；抽象类则完全可以包含普通方法。
接口里只能定义静态常量，不能定义普通成员变量；抽象类里则可以定义普通成员变量，也可以定义静态常量。
接口里不包含构造器；抽象类里可以包含构造器，抽象类的构造器并不是用来创建对象，而是让其子类调用这些构造器来完成属于抽象类的初始化操作。
接口里不能包含初始化块，而抽象类则完全可以包含初始化块
一个类最多只能有一个直接父类，包括抽象类；但一个类可以直接实现多个接口，通过实现多个接口可以补足java单继承的不足。
5.面向接口编程
工厂模式
package abstractDemon;
public class Computer {
private Output out;
public Computer(Output out){
this.out=out;
}
//定义一个模拟获取字符串输入的方法
public void KeyIn(String msg){
out.getData(msg);
}
//定义一个模拟打印的方法
public void print(){
out.out();
}
}
package abstractDemon;
public class BetterPrinter implements Output{
private String[] printData=new String[MAX_CACHE_LINE*2];
//用以记录当前需打印的作业数
private int dataNum=0;
@Override
public void out() {
//只要还有作业，就继续打印
while (dataNum>0){
System.out.println("高速打印机正在打印："+printData[0]);
//把作用队列整体前移一位，并将剩下的作业数减1
System.arraycopy(printData,1,printData,0,--dataNum);
/*
Object src：the source array. 源数组
int srcPos：starting position in the source array. 在源数组中，开始复制的位置
Object dest：the destination array. 目标数组
int destPos：starting position in the destination data. 在目标数组中，开始赋值的位置
int length：the number of array elements to be copied. 被复制的数组元素的数量
*/
}
}
@Override
public void getData(String msg) {
if(dataNum>=MAX_CACHE_LINE*2){
System.out.println("输出队列已满，添加失败");
}else {
//把打印数据添加到队列里，已保存数据的数量加1
printData[dataNum++]=msg;
}
}
}
package abstractDemon;
public class OutFactory {
public Output getOutput(){
return new BetterPrinter();
}
public static void main(String[] args) {
OutFactory of = new OutFactory();
Computer c = new Computer(of.getOutput());
c.KeyIn("轻量级java EE企业应用实战");
c.KeyIn("疯狂java讲义");
c.print();
}
}
通过这种方式，即可把所有生成Output对象的逻辑集中在OutputFactory工厂类中管理，而所有需要使用Output对象的类只需要与Output接口耦合，而不是与具体的实现类耦合。即时系统中有很多类使用了printer对象，只要OutputFactory类的getOutput()方法生成的Output对象是BetterPrinter对象，则他们全部都会改为使用BetterPrinter对象，而所有程序无需修改，只需要修改OutputFactory工厂类的getOutput()方法实现即可。
