Java的抽象类与举例
1.抽象类
我们知道类是产生对象的模板；那么我们可以将抽象类理解为是产生 实体类的模板。
在 Java 中可以专门创建一种父类，它的子类必须遵循父类设定的规则，但父类又不能 直接创建对象，如果要创建对象，则必须使用实现它的子类来创建，这样的父类称为抽象类。
抽象类的使用场景一般为：抽象类（父类）知道其子类应该包含哪些方法，但又不知道 这些子类的方法是如何实现的情况。
抽象类与抽象方法
1.抽象类必须用abstract关键字修饰，语法如下：
==abstract== class 抽象类名称{
声明成员变量；
返回值类型 方法名(参数列表){… …} //实体方法，有方法体
abstract 返回值类型 方法名(参数列表)； //抽象方法，没有方法体
}注意以下几点：
1） 抽象类的最终目的是用来定义实现它的子类，因此抽象类不能被定义为final；
2） 抽象方法不能被 private、static、final等关键字修饰，否则不能被继承、覆盖；
3） 成员变量没有抽象概念；
4） 抽象类可以没有抽象方法；但一个类里如果包含抽象方法，那么这个类一定是抽象 类。
抽象类的应用
不能用抽象类创建对象，但可以用它声明对象；创建对象的任务交给实现抽象类的子类 去完成。
示例1：
package ch08;
abstract class Shape{ //定义一个抽象类：Shape
protected String name;
public Shape(String xm){
name=xm;
System.out.print("名称："+name);
}
abstract public double getArea(); //抽象方法
abstract public double getLength(); //抽象方法
}
class Circle extends Shape{ //实现抽象类Shape的子类
private final double PI=3.14;
private double radius;
public Circle(String shapeName,double r){
super(shapeName);
radius=r;
}
public double getArea(){ //重写 getArea方法
return PI*radius*radius;
}
public double getLength(){ //重写 getLength 方法
return 2*PI*radius;
}
}
class Rectangle extends Shape{ //实现抽象类Shape的另一个子类
private double width;
private double height;
public Rectangle(String shapeName,double width,double height){
super(shapeName);
this.width=width;
this.height=height;
}
public double getArea(){
return width*height;
}
public double getLength(){
return 2*(width+height);
}
}
public class Demo{
public static void main(String[] args){
//可以用Shape声明对象，但不能用它创建对象
Shape rect =new Rectangle("长方形",6.5,10.3);
//Shape rect =new Shape("长方形"); //错误！
//Rectangle rect=new Rectangle("长方形",6.5,10.3);
System.out.print("；面积="+rect.getArea());
System.out.println("；周长="+rect.getLength());
Shape circle=new Circle("圆",10.2);
System.out.print("；面积="+circle.getArea());
System.out.println("；周长="+circle.getLength());
}
}示例2：
假设学校员工分为教师与职工两大类，使用抽象类与抽象方法实现如下所示要求：
1.声明一个名为Employee 的抽象类，其中包含有name (姓名）和sex (性别）两个 String类型的私有属性；包含一个能为name和sex字段赋值的构造方法；重写从Object 类继承来的toString0方法，使之能返回姓名和性别组成的字符串；包含一个名为subSidy() 用于计算员工津贴值的抽象方法（返回值为 double) 和一个用于判断是否为骨干员工的 important()抽象方法（返回值为boolean) 。
2.声明两个继承于Employee 抽象类的子类Teacher和Worker。在Teacher类中新 增一个用于表示教师职称的title 私有字段（String类型），在 Worker 类中新增一个用于 表示工龄的workingAge私有字段（int 类型）。在这两个子类中分别重写继承于Employee 抽象类的subSidy()和important()方法。
教师津贴按职称计算： 教授 1200， 副教授 800，讲师500，其他 300。
职工津贴按工龄计算：津贴－工龄＊50。
骨干员工指职称为教授或副教授的教师，或者工龄为10年及以上的职工。
3.在主方法中编写测试程序，当程序运行时显示“输入姓名、性别、职称／工龄（用 空格分隔）：“，用户输入数据后能根据第3段数据是否为数字分别使用Teacher或Worker 类中的构造方法创建对象，并调用 subSidy()和important()方法显示姓名、性别、津贴值 和是否为骨干员工。
相关代码如下：
package ch08;
import java.util.Scanner;
abstract class Employee{
private String name,sex;
public Employee(String name,String sex) {
this.name=name;
this.sex=sex;
}
public String toString() {
return name+","+sex+",";
}
abstract public double subSidy();
abstract public boolean important();
}
class Teacher extends Employee{
private String title;
public Teacher(String name,String sex,String title) {
super(name,sex);
this.title=title;
}
public double subSidy() {
switch(title) {
case "教授": return 1000;
case "副教授": return 800;
case "讲师": return 500;
default: return 300;
}
}
public boolean important() {
if("副教授".equals(title)||"教授".equals(title))
return true;
else
return false;
}
}
class Worker extends Employee{
private int workAge;
public Worker(String name,String sex,int workAge) {
super(name,sex);
this.workAge=workAge;
}
public double subSidy() {
return workAge*50;
}
public boolean important() {
return workAge>=10;
}
}
public class DemoTest {
public static void main(String args[]) {
Scanner sc=new Scanner(System.in);
System.out.println("请输入姓名、性别、职称/工龄（用空格分隔）：");
String n=sc.next();
String s=sc.next();
Teacher t;
Worker w;
if(sc.hasNextInt()) {
w=new Worker(n,s,sc.nextInt());
System.out.println(w.toString()+w.subSidy()+","+w.important());
}else {
t=new Teacher(n,s,sc.next());
System.out.println(t.toString()+t.subSidy()+","+t.important());
}
sc.close();
}
}
