从零开始学JAVA——abstract关键字的使用

abstract关键字使用

1.abstract:抽象的
2.abstract可以用来修饰的结构：类、方法
3.abstract修饰类：抽象类
此类不能实例化
抽象类中一定有构造器，便于子类对象实例化(涉及：子类对象实例化的全过程)
开发者，都会提供抽象类的子类，让子类对象实例化，完成相关操作

4.abstract修饰方法：抽象方法
抽象方法只有方法声明，没有方法体
包含抽象方法的类，一定是抽象类。反之，抽象类可以没有抽象方法
若子类重写了父类中的所有的抽象方法后，此子类方可实例化
若子类没有重写了父类中的所有的抽象方法后，则子类是一个抽象类，需要使用abstract修饰
abstract使用上的注意点
1.abstract不能用来修饰：属性、构造器结构
2.abstract不能用来修饰私有方法、静态方法、final的方法、final的类

public class AbstractTest {
	public static void main(String[] args) {
//		Person p1 = new Person();
//		p1.eat();
	}
}
abstract class Creature {
	public abstract void breath();
}
abstract class Person extends Creature{
	String name;
	int age;
	public Person() {
		
	}
	public Person(String name,int age) {
		this.name = name;
		this.age = age;
	}
	public void eat() {
		System.out.println("人吃饭");
	}
	//抽象方法
	public abstract void e1();
	public void walk() {
		System.out.println("人走路");
	}
}

class Student extends Person{
	public Student() {

	}
	public Student(String name,int age) {
		super(name,age);
	}
	@Override
	public void e1() {
		System.out.println("重写");
	}
	@Override
	public void breath() {
		System.out.println("breath重写");
	}

课后练习一

定义PayrollSystem类，创建Employee变量数组并初始化，该数组存放各类雇员对象的引用利用循环结构遍历数组，输出各个对象的类型，name，number，birthday，以及对象生当键盘输入本月份值时，如果本月某个Employee对象生日，还要输出增加工资信息

测试类

public class PayrollSystem {
	public static void main(String[] args) {
//		Scanner scanner = new Scanner(System.in);
//		System.out.println("请输入当前的月份");
//		int month = scanner.nextInt();
		//方式二
		Calendar calendar = Calendar.getInstance();
		int month = calendar.get(Calendar.MONTH);
		
		Employee[] emps= new Employee[2];
		
		emps[0] = new SalariedEmployee("马森", 1002, new MyDate(1992, 9, 28),10000);
		emps[1] = new HourlyEmployee("潘月", 2001, new MyDate(1991, 5, 6),60,240);
		
		for(int i = 0;i<emps.length;i++) {
			System.out.println(emps[i].toString());
			double salary = emps[i].earnings();
			System.out.println("月工资为："+salary);
			
			if(month+1==emps[i].getBirthday().getMonth()) {
				System.out.println("生日快乐，奖励100元");
			}
		}
	}
}

定义一个Employee类，该类包含：
private的成员变量name,number,birthday,其中birthday为MyDate类的对象
abstract方法earnings()
toString()方法输出name,number和birthday

public abstract class Employee {
	private String name;
	private int number;
	private MyDate birthday;


	public Employee(String name, int number, MyDate birthday) {
		super();
		this.name = name;
		this.number = number;
		this.birthday = birthday;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getNumber() {
		return number;
	}

	public void setNumber(int number) {
		this.number = number;
	}

	public MyDate getBirthday() {
		return birthday;
	}

	public void setBirthday(MyDate birthday) {
		this.birthday = birthday;
	}
	
	public abstract double earnings();
	
	@Override
	public String toString() {
		return "Employee [name=" + name + ", number=" + number + ", birthday=" + birthday.toDateString() + "]";
	}
	
}

参照SalariedEmployee 类定义HourlyEmployee类，实现按小时计算工资的员工处理。
该类包括private成员变量wage和hour
实现父类抽象方法earnings()，该方法返回wage*hour值
toString()方法输出员工类型信息及员工name，number，birthday

public class HourlyEmployee extends Employee{
	private int wage;
	private int hour;
	
	
	public HourlyEmployee(String name, int number, MyDate birthday) {
		super(name, number, birthday);
	}
	public HourlyEmployee(String name, int number, MyDate birthday,int wage,int hour) {
		super(name, number, birthday);
		this.wage= wage;
		this.hour= hour;
	}

	public int getWage() {
		return wage;
	}
	public void setWage(int wage) {
		this.wage = wage;
	}
	public int getHour() {
		return hour;
	}
	public void setHour(int hour) {
		this.hour = hour;
	}
	@Override
	public double earnings() {
		return wage*hour;
	}
	public String toString() {
		return "HourlyEmployee[" + super.toString()+"]";
	}
}

MyDate类包含
private 成员变量year，month，day
toString()方法返回日期对应的字符串，XXXX年XX月XX日

public class MyDate {
	private int year;
	private int month;
	private int day;

	public MyDate(int year, int month, int day) {
		super();
		this.year = year;
		this.month = month;
		this.day = day;
	}
	public int getYear() {
		return year;
	}
	public void setYear(int year) {
		this.year = year;
	}
	public int getMonth() {
		return month;
	}
	public void setMonth(int month) {
		this.month = month;
	}
	public int getDay() {
		return day;
	}
	public void setDay(int day) {
		this.day = day;
	}
	public String toDateString() {
		return year+"年"+month+"月"+day+"日";
	}
}

SalariedEmployee继承Employee类
实现按月计算工资的员工处理。该类包括private成员变量mothlySalary
实现父类的抽象方法earnings()，该方法返回monthly Salary值
toString()方法输出员工类型信息及员工name，number，birthday

public class SalariedEmployee extends Employee{
	private double mothlySalary;
	public SalariedEmployee(String name, int number, MyDate birthday) {
		super(name, number, birthday);
	}
	public SalariedEmployee(String name, int number, MyDate birthday,double mothlySalary) {
		super(name, number, birthday);
		this.mothlySalary = mothlySalary;
	}

	public double getMothlySalary() {
		return mothlySalary;
	}

	public void setMothlySalary(double mothlySalary) {
		this.mothlySalary = mothlySalary;
	}

	@Override
	public double earnings() {
		return mothlySalary;
		
	}
	public String toString() {
		return "SalariedEmployee[" + super.toString()+"]";
	}
}