《java入门第一季》之面向对象（抽象类其实不抽象）

上一篇（http://blog.csdn.net/qq_32059827/article/details/51334198）对抽象类做了一些描述，这一篇根据两个案例加深一下印象。会觉得抽象类其实不抽象：

案例一：猫狗案例。

/*
	猫狗案例
		具体事物：猫，狗
		共性：姓名，年龄，吃饭
 
	分析：从具体到抽象
		猫:
			成员变量：姓名，年龄
			构造方法：无参，带参
			成员方法：吃饭(猫吃鱼)
 
		狗:
			成员变量：姓名，年龄
			构造方法：无参，带参
			成员方法：吃饭(狗吃肉)
 
		因为有共性的内容，所以就提取了一个父类。动物。
		但是又由于吃饭的内容不一样，所以吃饭的方法是抽象的，
		而方法是抽象的类，类就必须定义为抽象类。
 
		抽象动物类：
			成员变量：姓名，年龄
			构造方法：无参，带参
			成员方法：吃饭();是抽象的
 
	实现：从抽象到具体
		动物类:
			成员变量：姓名，年龄
			构造方法：无参，带参
			成员方法：吃饭();
 
		狗类：
			继承自动物类
			重写吃饭();
 
		猫类：
			继承自动物类
			重写吃饭();
*/
//定义抽象的动物类
abstract class Animal {
	//姓名
	private String name;
	//年龄
	private int age;
 
	public Animal() {}
 
	public Animal(String name,int age) {
		this.name = name;
		this.age = age;
	}
 
	public String getName() {
		return name;
	}
 
	public void setName(String name) {
		this.name = name;
	}
 
	public int getAge() {
		return age;
	}
 
	public void setAge(int age) {
		this.age = age;
	}
 
	//定义一个抽象方法
	public abstract void eat();
}
 
//定义具体的狗类
class Dog extends Animal {
	public Dog() {}
 
	public Dog(String name,int age) {
		super(name,age);//访问父类中的有参构造方法，用super关键字。
	}
 
	public void eat() {//子类方法重写
		System.out.println("狗吃肉");
	}
}
 
//定义具体的猫类
class Cat extends Animal {
	public Cat() {}
 
	public Cat(String name,int age) {
		super(name,age);
	}
 
	public void eat() {//子类方法重写
		System.out.println("猫吃鱼");
	}
}
 
//测试类
class AbstractTest {
	public static void main(String[] args) {
		//测试狗类
		//具体类用法
		//方式1：
		Dog d = new Dog();
		d.setName("旺财");//继承自父类
		d.setAge(3);//继承自父类
		System.out.println(d.getName()+"---"+d.getAge());
		d.eat();
		//方式2：
		Dog d2 = new Dog("旺财",3);//super那边
		System.out.println(d2.getName()+"---"+d2.getAge());
		d2.eat();
		System.out.println("---------------------------");
 
		//使用多态的方式
		Animal a = new Dog();
		a.setName("旺财");
		a.setAge(3);
		System.out.println(a.getName()+"---"+a.getAge());
		a.eat();
 
		Animal a2 = new Dog("旺财",3);
		System.out.println(a2.getName()+"---"+a2.getAge());
		a2.eat();
		System.out.println("---------------------------");
		a = new Dog("露露",12);
		System.out.println(a.getName()+"---"+a.getAge());
		a.eat();
		System.out.println("---------------------------");
		//练习：测试猫类
		//方式一
		Cat c = new Cat();
		c.setName("小花");
		c.setAge(5);
		System.out.println(c.getName()+"---"+c.getAge());
		c.eat();
		System.out.println("---------------------------");
		//方式二
		Cat c1 = new Cat("xiaohua",4);
		System.out.println(c1.getName()+"---"+c1.getAge());
		c1.eat();
		System.out.println("---------------------------");
		//多态实现
		//方式一
		Animal a3 = new Cat();
		a3.setName("小花");
		a3.setAge(5);
		System.out.println(a3.getName()+"---"+a3.getAge());
		a3.eat();
		System.out.println("---------------------------");
		//方式二
		Animal a4 = new Cat("xiaohua",4);//注意这里书写的方式与老师上面讲解方式的不同，这里相当于给a3（重新分配了地址）（因为new了一下）。但是用了(同一个变量)a3，正确
		System.out.println(a4.getName()+"---"+a4.getAge());
		a4.eat();
		System.out.println("---------------------------");
		a3 = new Cat("tom",9);
		System.out.println(a3.getAge()+"----"+a3.getName());
		a3.eat();
	}
}

案例二：公司职员案例：

/*
 
	实现：
		员工类：
		普通员工类：
		经理类：
*/
//定义员工类
abstract class Employee {
	//姓名、工号以及工资
	private String name;
	private String id;
	private int salary;
 
	public Employee() {}
 
	public Employee(String name,String id,int salary) {
		this.name = name;
		this.id = id;
		this.salary = salary;
	}
 
	public String getName() {
		return name;
	}
 
	public void setName(String name) {
		this.name = name;
	}
 
	public String getId() {
		return id;
	}
 
	public void setId(String id) {
		this.id = id;
	}
 
	public int getSalary() {
		return salary;
	}
 
	public void setSalary(int salary) {
		this.salary = salary;
	}
 
	//工作，工作内容不一样，定义一个抽象方法，在子类中必须要有方法重写
	public abstract void work();
}
 
//普通员工类
class Programmer extends Employee {
	public Programmer(){}
 
	public Programmer(String name,String id,int salary) {
		super(name,id,salary);
	}
 
	public void work() {
		System.out.println("按照需求写代码");
	}
}
 
//经理类
class Manager extends Employee {
	//奖金，经理独有的属性
	private int bonus; //bonus 奖金
 
	public Manager(){}
 
	public Manager(String name,String id,int salary,int bonus) {
		super(name,id,salary);
		this.bonus = bonus;//this代表本类的成员
	}
 
	public void work() {//父类工作的抽象方法子类要有方法重写
		System.out.println("跟客户谈需求");
	}
 
	public int getBonus() {
		return bonus;
	}
 
	public void setBonus(int bonus) {
		this.bonus = bonus;
	}
}
 
class AbstractTest4 {
	public static void main(String[] args) {
		//测试普通员工，利用多态实现
		Employee emp = new Programmer();
		emp.setName("林青霞");
		emp.setId("001");
		emp.setSalary(8000);
		System.out.println(emp.getName()+"---"+emp.getId()+"---"+emp.getSalary());
		emp.work();
		System.out.println("-------------");
		emp = new Programmer("林青霞","001",8000);//重新分配地址，重新分配内存空间
		System.out.println(emp.getName()+"---"+emp.getId()+"---"+emp.getSalary());
		emp.work();
		System.out.println("-------------");
 
		//由于子类有特有的内容，所以不采用多态方式
		Manager m = new Manager();
		m.setName("小吴");
		m.setId("002");
		m.setSalary(8000);
		m.setBonus(2000);
		System.out.println(m.getName()+"---"+m.getId()+"---"+m.getSalary()+"---"+m.getBonus());
		m.work();
		System.out.println("-------------");
 
		//通过构造方法赋值
		m = new Manager("刘意","czbk002",8000,2000);
		System.out.println(m.getName()+"---"+m.getId()+"---"+m.getSalary()+"---"+m.getMoney());
		m.work();
	}
}