抽象类的基本概念

本章目标
掌握抽象类的定义格式
掌握抽象类的使用规则

 

抽象类的定义及使用规则
包含一个抽象方法的类必须是抽象类；
抽象类和抽象方法都要使用abstract关键字声明；
抽象方法只需声明而不需要实现；
抽象类必须被子继承，子类（如果不是抽象类）必须覆写抽象类中的全部抽象方法。

 

抽象类的定义格式
abstract class 抽象类名称{
  属性 ;
  访问权限 返回值类型 方法名称(参数){  // 普通方法
  [return 返回值] ;
  }
  访问权限 abstract 返回值类型 方法名称(参数) ;   // 抽象方法
  // 在抽象方法中是没有方法体的
}

 

定义一个抽象类

abstract class A {
	public static final String FLAG = "CHINA";
	private String name = "chaoyi";
	public String getName() {//设置姓名
		return name;
	}
	public void setName(String name) {//取得姓名
		this.name = name;
	}
	public abstract void print();//定义抽象方法
}

 

继承抽象类

abstract class A {
	public static final String FLAG = "CHINA";
	private String name = "chaoyi";
	public String getName() {//设置姓名
		return name;
	}
	public void setName(String name) {//取得姓名
		this.name = name;
	}
	public abstract void print();//定义抽象方法
}
class B extends A{//继承抽象类，覆写全部抽象方法
	public void print(){
		System.out.println("FLAG = "+FLAG);
		System.out.println("姓名 = "+super.getName());
	}
}
public class AbstractDemo02 {
	public static void main(String[] args) {
		B b = new B();//实例化子类对象
		b.print();//调用被子类覆写过的方法
	}
/* 结果：
 * FLAG = CHINA
 * 姓名 = chaoyi
 * */
}

 
抽象类的图形表示

 

抽象类的思考
问题1：一个抽象类可以使用final关键字声明吗？
问题2：一个抽象类中可以定义构造方法吗？

 

回答
问题一：
——一个类如果使用了final关键字声明，则此类不能被子类继承，而抽象类又必须被子类覆写，所以很明显，第一个问题的答案是：“一个抽象类不能使用final关键字声明”。
问题二：
——实际上在一个抽象类中是允许存在构造方法的，因为抽象类依然使用的是类的继承关系，而且抽象类中也存在各个属性，所以子类在实例化之前肯定是先要对父类进行实例化的。

 

在抽象类中定义构造方法

abstract class A {
	public A(){//在抽象类中定义构造方法
		System.out.println("A、抽象类中的构造方法。");
	}
}
class B extends A{//定义子类
	public B(){
		//super();//隐含了此语句
		System.out.println("B、子类中的构造方法。");
	}
}
public class AbstractDemo03 {
	public static void main(String[] args) {
		B b = new B();//实例化子类对象
	}
/* 结果：
 * A、抽象类中的构造方法。
 * B、子类中的构造方法。
 * */
}

 

调用抽象类中指定参数的构造方法

abstract class Person{//定义抽象类 Person
	private String name;//定义 name 属性
	private int age;//定义 age 属性
	public Person(String name, int age) {//在抽象类定义构造方法
		this.setName(name);//为 name 赋值
		this.setAge(age);//为 age 赋值
	}
	public String getName() {//取得 name 属性
		return name;
	}
	public void setName(String name) {//设置 name属性
		this.name = name;
	}
	public int getAge() {//取得 age 属性
		return age;
	}
	public void setAge(int age) {//设置 age 属性
		this.age = age;
	}
	public abstract String getInfo();//取得信息，抽象方法
}
class Student extends Person{//定义子类 
	private String school;//定义 school 属性
	public Student(String name, int age, String school) {
		super(name, age);//调用父类中有两个参数的构造方法
		this.setSchool(school);//为 school 赋值
	}
	public String getSchool() {//取得 school 属性
		return school;
	}
	public void setSchool(String school) {//设置 school 属性
		this.school = school;
	}
	public String getInfo(){//覆写抽象类中的抽象方法
		return "姓名："+super.getName()+"；年龄："+super.getAge()+"；学校："+this.getSchool();
	}
}
public class AbstractDemo04 {
	public static void main(String[] args) {
		Student stu = new Student("张三", 30, "MyShool");
		System.out.println(stu.getInfo());
	}
/* 结果：
 * 姓名：张三；年龄：30；学校：MyShool
 * */
}