面向对象(13-2)：抽象类练习
1、猫狗案例
/*
具体事物：猫，狗
共性：姓名，年龄，吃饭
①先分析：
Cat 猫：成员变量：name,age
构造方法：无参，有参
成员方法：吃饭(猫吃鱼)
Dog 狗：成员变量：name,age
构造方法：无参，有参
成员方法：吃饭(狗吃骨头)
②通过分析，两个类存在相同的内容，所以提前出来一个抽象类：Animal
Animal 动物：成员变量：name,age
构造方法：无参，有参(this)
成员方法：公共的get()Xxx和set()Xxx方法
show()方法
吃饭的抽象方法
再写具体的类：
Cat 猫：构造方法：无参，有参(super)
重写方法
Dog 狗：构造方法：无参，有参(super)
重写方法
*/
//定义一个动物抽象类
abstract class Animal{
//定义成员变量
private String name;
private int age;
//定义构造方法
Animal(){
}
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;
}
//show方法
public void show(){
System.out.println("姓名"+name+"年龄"+age);
}
//定义吃的抽象方法
public abstract void eat();
}
//定义具体的猫类来继承抽象类
class Cat extends Animal{
//构造方法
Cat(){
}
Cat(String name,int age){
super(name, age);//当前类没有name/age,需要传入抽象类的name/age
}
//重写抽象类的抽象方法
@Override
public void eat() {
System.out.println("猫吃鱼");
}
}
//创建具体的狗类来继承抽象类
class Dog extends Animal{
//构造方法
Dog(){
}
Dog(String name,int age){
super(name,age);
}
//重写方法
@Override
public void eat() {
System.out.println("狗啃骨头");
}
}
//测试类
public class AbstractTest {
public static void main(String[] args) {
//使用多态创建对象,使用构造方法赋值（在括号里赋值）
Animal a = new Cat("小花",2);
a.show();//抽象类中的show方法
a.eat();//具体的猫类的吃的方法
Animal a1 = new Dog("大黄",3);
a.show();//抽象类中的show方法
a1.eat();//具体的狗类的吃的方法
System.out.println("===使用公共的setXxx()和getXxx()赋值===");
//使用多态创建对象
Animal a3 = new Cat();
a3.setName("小花");
a3.setAge(2);
a3.show();
a3.eat();
Animal a4 = new Dog();
a4.setName("大黄");
a4.setAge(3);
a4.show();
a4.eat();
}
}
成员变量的赋值和接收的方式：
①构造方法赋值，show()方法接收
①构造方法赋值，getXxx()接收
③setXxx赋值，show()方法接收
④setXxx赋值，getXxx()接收
2、员工案例
/*
假如我们在开发一个系统时需要对员工类进行设计，
员工包含3个属性：姓名、工号以及工资。
经理也是员工，除了含有员工的属性外，另为还有一个奖金属性。
请使用继承的思想设计出员工类和经理类,要求类中提供必要的方法进行属性访问。
①分析：
普通员工 staff：成员变量：姓名，工号，工资
成员方法：工作（敲代码）
经理 manage：成员变量：姓名，工号，工资，奖金
成员方法：工作（管理）
②存在相同的内容，提取一个抽象类：职员 worker
worker 抽象类：成员变量：姓名，工号，工资
构造方法：无参，有参
成员方法：公共的setXxx()和getXxx()方法
show()方法
抽象方法
具体的类来继承抽象类：
普通员工 staff：构造方法：无参，有参
重写的方法
经理 manage：特有的成员变量：奖金
构造方法：无参，有参
重写方法
*/
//创建一个职员抽象类
abstract class Worker{
//定义成员变量
private String name;
private int jobNumber;
private int wages;
//构造方法
Worker(){
}
Worker(String name,int jobNumber,int wages){
this.name = name;
this.jobNumber = jobNumber;
this.wages = wages;
}
//公共的方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getJobNumber() {
return jobNumber;
}
public void setJobNumber(int jobNumber) {
this.jobNumber = jobNumber;
}
public int getWages() {
return wages;
}
public void setWages(int wages) {
this.wages = wages;
}
//show方法
public void show(){
System.out.println("姓名"+name+"---工号"+jobNumber+"---工资"+wages);
}
//抽象方法
public abstract void work();
}
//定义一个具体的普工类
class Staff extends Worker{
//构造方法
Staff(){
}
Staff(String name,int jobNumber,int wages){
super(name,jobNumber,wages);
}
//重写方法
@Override
public void work() {
System.out.println("敲代码");
}
}
//定义一个具体的经理类
class Manage extends Worker{
//特有的成员变量：奖金
private int bonus;
//构造方法
Manage() {
}
Manage(String name, int jobNumber, int wages, int bonus) {
super(name, jobNumber, wages);
this.bonus = bonus;
}
//添加特有的成员变量时，子类要添加公共的setXxx()和getXxx()方法单独赋值
public void setBonus(int bonus) {
this.bonus = bonus;
}
public int getBonus() {
return bonus;
}
//重写方法
@Override
public void work() {
System.out.println("管理");
}
}
//测试类
class AbstractTest2 {
public static void main(String[] args) {
//使用多态创建普工对象,并使用构造方法赋值
Worker w1 = new Staff("李玉伟",888,50000);
w1.show();
w1.work();
//使用多态创建经理对象,并使用setXxx()赋值
Worker w2 = new Manage();
w2.setName("伟爷");
w2.setJobNumber(666);
w2.setWages(100000);
((Manage) w2).setBonus(500000);//编译看左。左边没有，需要向下转型
//使用getXxx()接收
System.out.println("姓名"+w2.getName()+"---工号"+w2.getJobNumber()+
"---工资"+w2.getWages()+"---奖金"+((Manage) w2).getBonus());
w2.work();
}
}
执行结果如下：
姓名李玉伟---工号888---工资50000
敲代码
姓名伟爷---工号666---工资100000---奖金500000
管理
Process finished with exit code 0