Java的抽象类

1、定义

  • 抽象方法:只有方法名字,没有具体方法实现的方法
  • 抽象类:有抽象方法的类即为抽象类

2、规则

(1)抽象方法和抽象类必须使用abstract修饰符来修饰

(2)有抽象方法的类必须为抽象类、但抽象类里可以没有抽象方法

(3)抽象类不可被实例化,无法使用new关键字调用抽象类的构造器来创建抽象类的实例。只能当做父类被其他子类继承,并且子类要实现里面的抽象方法

(4)抽象类里可以有成员变量、方法(抽象方法和普通方法)、构造器、初始化块、内部类(接口、枚举)5种成分,其中构造器不能用于创建实例,只是用来被子类调用

(5)如果一个类:直接定义了抽象方法、或继承一个抽象父类,但并没有完全实现该父类的所有抽象方法、或实现一个接口,但并没有完全实现接口内包含的所有抽象方法,这种类只能被定义成抽象类

抽象方法的定义方式:将普通方法的方法体去掉,在后面加上分号即可
public abstract class Test{
	public abstract void info();  //抽象方法
}
注意:public void info(){}  这是一个普通的方法,不是抽象方法,只是该方法的方法体为空,即什么也不做
抽象类的定义方式:只要在类前加上abstract修饰符即可
//定义一个形状抽象类
abstract class Shape{
	private String color;
	//color的setter和getter方法
	public void setColor(String color) {
		this.color=color;
	}
	public String getColor() {
		return this.color;
	}
	//定义一个计算周长的抽象方法
	public abstract double callPerimeter();
	//定义一个形状的抽象方法
	public abstract String getType();
	//定义构造器,为了给子类调用
	public Shape() {}
	public Shape(String color) {
		this.setColor(color);
	}
}
//定义一个普通的三角形类
class Triangle extends Shape{
	//定义三角形的三边
	private double a;
	private double b;
	private double c;
	//三角形必须满足:两边之和大于第三边
	public 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;
	}
	public Triangle(String color,double a,double b,double c) {
		super(color);  //调用父类抽象类的构造器
		this.setSides(a,b,c); 
	}
	//重写计算周长的方法,实现父类的抽象方法
	public double callPerimeter() {
		return a+b+c;
	}
	//重写形状的方法,实现父类的抽象方法
	public String getType() {
		return getColor()+"三角形";
	}
}
//定义一个普通的圆形类
class Circle extends Shape{
	//定义圆的半径
	private double radius;
	//radius的setter和getter方法
	public void setRadius(double radius) {
		this.radius=radius;
	}
	public double getRadius() {
		return this.radius=radius;
	}
	//Circle的构造器
	public Circle(String color,double radius) {
		super(color);
		this.setRadius(radius);
	}
	//重写计算周长的方法,实现父类的抽象方法
	public double callPerimeter() {
		return 2*Math.PI*radius;
	}
	//重写形状方法,实现父类的抽象方法
	public String getType() {
		return getColor()+"圆";
	}
}
public abstract class Test{
	public static void main(String[] args) {
		Shape s1=new Triangle("黑色",3,4,5);
		Shape s2=new Circle("红色",2);
		System.out.println(s1.callPerimeter());
		System.out.println(s1.getType());
		System.out.println(s2.callPerimeter());
		System.out.println(s2.getType());
	}
}
输出结果:
12.0
黑色三角形
12.566370614359172
红色圆

上面的程序中,使用了Shape类型的引用变量来指向实际的子类对象,从这里也可以看出明显的多态现象:同一个类(Shape类)的多个实例(s1、s2),在调用相同的方法(callPerimeter()和getType())时,呈现出不同的结果。

3、注意点

(1)final修饰一个类和方法时,表明该类不能被继承、该方法不可被重写;而abstract修饰一个类、方法时,表明该类是抽象类,必须被子类继承、该方法是抽象方法,必须由子类重写;故final和abstract不可同时出现

(2)abstract不能修饰构造器、成员变量、局部变量

(3)static和abstract不能同时修饰一个方法,即没有所谓的抽象类方法(但是可以同时修饰内部类)

(4)abstract修饰的抽象方法必须被子类重写,因此不能使用private修饰,即private和abstract不可同时修饰一个方法

4、设计方法:模板模式

抽象类体现了一种模板模式的设计,父类提供多个子类的通用方法,具体的实现留给每一个子类。

展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 大白 设计师: CSDN官方博客
应支付0元
点击重新获取
扫码支付

支付成功即可阅读