＜Java＞抽象类

定义一个抽象类Person,其中含有一个抽象方法getDescription().

public abstract class Person {
	public abstract String getDescription();   //抽象方法，继承的子类需要实现
	private String name;
	
	public Person(String aName)
	{
		this.name=aName;
	}
	
	public String getName()
	{
		return name;
	}
	
}

只要包含了抽象方法，那么这个类就是抽象类，因此在声明类的时候就必须加上关键字abstract。

然后通过继承实现类Employee和类Student，需要实现抽象超类中定义的抽象方法

Employee:

import java.time.LocalDate;

public class Employee extends Person{
	private double salary;
	private LocalDate hireDay;
	
	public Employee(String aName,double aSalary,int year,int month,int day)
	{
		super(aName);
		this.salary=aSalary;
		this.hireDay=LocalDate.of(year, month, day);
	}
	
	public double getSalary()
	{
		return this.salary;
	}
	public String getDescription()  //实现抽象方法
	{
		return String.format("salary is%.2f", salary);
	}
	public void raiseSalary(double byPercent)
	{
		double raise=salary*byPercent/100;
		salary+=raise;
	}
}

Student：

public class Student extends Person{
	private String major;
	
	public Student(String aName,String aMajor)
	{
		super(aName);
		major=aMajor;
	}
	public String getDescription()
	{
		return "My major is"+major;
	}
}

• 抽象方法相当于是在占位，抽象方法的具体实现是在子类中实现的。
• 抽象类可以不含抽象方法，但是含有抽象方法就是抽象类。
• 抽象类不能被实例化，如上面的定义，那么就不能使用
  Person p=new Person(“Beta”);
  这么写是错误的，但是可以创建一个具体子类的对象，如
  Person p=new Student(“LiMing”,“Math”);
  这里p是抽象类Person的变量，Person引用了子类Student的实例。

Person people[]=new Person[2];
people[0]=new Student(...);
people[1]=new Employee(...);

for(Person p:people)
{
	System.out.print(p.getDescription());
}

在这里，p.getDescription()并不是调用了一个未定义的方法，由于不能构造抽象类Person的对象，因此变量p永远不可能引用Person对象，也就不会调用Person中未定义的getDescription()方法，而是引用诸如Employee和Student的具体实例的getDescription()方法。