4.51 抽象类练习

标签：

1:

/*
猫狗案例
	具体事物：猫，狗
	共性：姓名，年龄，吃饭

分析：从具体到抽象
	猫:
		成员变量：姓名，年龄
		构造方法：无参，带参
		成员方法：吃饭(猫吃鱼)
		
	狗:
		成员变量：姓名，年龄
		构造方法：无参，带参
		成员方法：吃饭(狗吃肉)
		
	因为有共性的内容，所以就提取了一个父类。动物。
	但是又由于吃饭的内容不一样，所以吃饭的方法是抽象的，
	而方法是抽象的类，类就必须定义为抽象类。
	
	抽象动物类：
		成员变量：姓名，年龄
		构造方法：无参，带参
		成员方法：吃饭();

实现：从抽象到具体
	动物类:
		成员变量：姓名，年龄
		构造方法：无参，带参
		成员方法：吃饭();
		
	狗类：
		继承自动物类
		重写吃饭();
		
	猫类：
		继承自动物类
		重写吃饭();
*/
//定义抽象的动物类
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);
	}

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

		// 练习：测试猫类
	}
}

2:

/*
老师案例
	具体事物：基础班老师，就业班老师
	共性：姓名，年龄，讲课。

分析：	
	基础班老师
		姓名，年龄
		讲课。
	就业班老师
		姓名，年龄
		讲课。
实现：
	老师类
		基础班老师
		就业班老师
*/
//定义抽象的老师类
abstract class Teacher {
	// 姓名
	private String name;
	// 年龄
	private int age;

	public Teacher() {
	}

	public Teacher(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 teach();
}

// 基础班老师类
class BasicTeacher extends Teacher {
	public BasicTeacher() {
	}

	public BasicTeacher(String name, int age) {
		super(name, age);
	}

	public void teach() {
		System.out.println("基础班老师讲解JavaSE");
	}
}

// 就业班老师类
class WorkTeacher extends Teacher {
	public WorkTeacher() {
	}

	public WorkTeacher(String name, int age) {
		super(name, age);
	}

	public void teach() {
		System.out.println("就业班老师讲解JavaEE");
	}
}

class AbstractTest2 {
	public static void main(String[] args) {
		// 具体的类测试，自己玩

		// 测试(多态)
		// 基础班老师
		Teacher t = new BasicTeacher();
		t.setName("程又青");
		t.setAge(30);
		System.out.println(t.getName() + "---" + t.getAge());
		t.teach();
		System.out.println("--------------");

		t = new BasicTeacher("程又青", 30);
		System.out.println(t.getName() + "---" + t.getAge());
		t.teach();
		System.out.println("--------------");

		// 就业班老师
		t = new WorkTeacher();
		t.setName("李大仁");
		t.setAge(27);
		System.out.println(t.getName() + "---" + t.getAge());
		t.teach();
		System.out.println("--------------");

		t = new WorkTeacher("李大仁", 27);
		System.out.println(t.getName() + "---" + t.getAge());
		t.teach();
	}
}

３:

/*
学生案例
	具体事务：基础班学员，就业班学员
	共性：姓名，年龄，班级，学习，吃饭

分析：
	基础班学员
		成员变量：姓名，年龄，班级
		成员方法：学习，吃饭
	就业班学员
		成员变量：姓名，年龄，班级
		成员方法：学习，吃饭
		
	得到一个学员类。
		成员变量：姓名，年龄，班级
		成员方法：学习，吃饭
		
实现：
	学员类
	基础班学员
	就业班学员
*/
//定义抽象学员类
abstract class Student {
	// 姓名
	private String name;
	// 年龄
	private int age;
	// 班级
	private String grand;

	public Student() {
	}

	public Student(String name, int age, String grand) {
		this.name = name;
		this.age = age;
		this.grand = grand;
	}

	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 String getGrand() {
		return grand;
	}

	public void setGrand(String grand) {
		this.grand = grand;
	}

	// 学习
	public abstract void study();

	// 吃饭
	public void eat() {
		System.out.println("学习累了,就该吃饭");
	}
}

// 具体基础班学员类
class BasicStudent extends Student {
	public BasicStudent() {
	}

	public BasicStudent(String name, int age, String grand) {
		super(name, age, grand);
	}

	public void study() {
		System.out.println("基础班学员学习的是JavaSE");
	}
}

// 具体就业班学员类
class WorkStudent extends Student {
	public WorkStudent() {
	}

	public WorkStudent(String name, int age, String grand) {
		super(name, age, grand);
	}

	public void study() {
		System.out.println("就业班学员学习的是JavaEE");
	}
}

class AbstractTest3 {
	public static void main(String[] args) {
		// 基础班测试
		// 按照多态的方式测试
		Student s = new BasicStudent();
		s.setName("林青霞");
		s.setAge(27);
		s.setGrand("1111");
		System.out.println(s.getName() + "---" + s.getAge() + "---"
				+ s.getGrand());
		s.study();
		s.eat();
		System.out.println("--------------");

		s = new BasicStudent("武鑫", 48, "1111");
		System.out.println(s.getName() + "---" + s.getAge() + "---"
				+ s.getGrand());
		s.study();
		s.eat();

		// 就业班测试
	}
}

4:

/*
假如我们在开发一个系统时需要对员工类进行设计，员工包含3个属性：姓名、工号以及工资。
经理也是员工，除了含有员工的属性外，另为还有一个奖金属性。
请使用继承的思想设计出员工类和经理类。要求类中提供必要的方法进行属性访问。

分析：
	普通员工类
		成员变量：姓名、工号以及工资。
		成员方法：工作
	经理类：
		成员变量：姓名、工号以及工资，奖金属性
		成员方法：工作
		
实现：
	员工类：
	普通员工类：
	经理类：
*/
//定义员工类
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 money; //bonus 奖金

public Manager(){}

public Manager(String name,String id,int salary,int money) {
	super(name,id,salary);
	this.money = money;
}

public void work() {
	System.out.println("跟客户谈需求");
}

public int getMoney() {
	return money;
}

public void setMoney(int money) {
	this.money = money;
}
}

class AbstractTest4 {
	public static void main(String[] args) {
		// 测试普通员工
		Employee emp = new Programmer();
		emp.setName("程又青");
		emp.setId("czbk001");
		emp.setSalary(18000);
		System.out.println(emp.getName() + "---" + emp.getId() + "---" + emp.getSalary());
		emp.work();
		System.out.println("-------------");
		emp = new Programmer("程又青", "czbk001", 18000);
		System.out.println(emp.getName() + "---" + emp.getId() + "---" + emp.getSalary());
		emp.work();
		System.out.println("-------------");
	
		/*
		emp = new Manager();
		emp.setName("李大仁");
		emp.setId("czbk002");
		emp.setSalary(8000);
		emp.setMoney(2000);
		*/
		//由于子类有特有的内容，所以我们用子类来测试
		Manager m = new Manager();
		m.setName("李大仁");
		m.setId("czbk002");
		m.setSalary(8000);
		m.setMoney(2000);
		System.out.println(m.getName() + "---" + m.getId() + "---"
				+ m.getSalary() + "---" + m.getMoney());
		m.work();
		System.out.println("-------------");

		// 通过构造方法赋值
		m = new Manager("李大仁", "czbk002", 8000, 2000);
		System.out.println(m.getName() + "---" + m.getId() + "---" + m.getSalary() + "---" + m.getMoney());
		m.work();
	}
}

4.51 抽象类练习

标签：

原文地址：http://my.oschina.net/u/2001589/blog/509442