《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();
}
}