面向对象进阶基础练习

public class Employee {
    //定义员工的属性
    private String id;
    private String name;

    //定义空参构造和带参构造
    public Employee() {
    }

    public Employee(String id, String name) {
        this.id = id;
        this.name = name;
    }

    //定义成员变量的get和set方法
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    //定义方法work，代表行为：工作
    public void work() {
        System.out.println("员工在工作");
    }
}

public class AdminStaff extends Employee {
    //定义空参构造和带参构造
    public AdminStaff() {
    }

    public AdminStaff(String id, String name) {
        super(id, name);
    }

    //重写方法work
    @Override
    public void work() {
        System.out.println("行政部员工在进行行政工作");
    }
}

public class MainTrainer extends AdminStaff {
    //定义空参构造和带参构造
    public MainTrainer() {
    }

    public MainTrainer(String id, String name) {
        super(id, name);
    }

    //重写方法work

    @Override
    public void work() {
        System.out.println("维护专员在进行维护");
    }
}

public class Buyer extends AdminStaff {
    //定义空参构造和带参构造
    public Buyer() {
    }

    public Buyer(String id, String name) {
        super(id, name);
    }

    //重写方法work

    @Override
    public void work() {
        System.out.println("采购专员在采购");
    }
}

public class Teacher extends Employee {
    //定义空参构造和带参构造
    public Teacher() {
    }

    public Teacher(String id, String name) {
        super(id, name);
    }

    //重写方法work
    @Override
    public void work() {
        System.out.println("教研部员工在进行教学任务");
    }
}

public class Lecturer extends Teacher {
    //定义空参构造和带参构造
    public Lecturer() {
    }

    public Lecturer(String id, String name) {
        super(id, name);
    }

    //重写方法work

    @Override
    public void work() {
        System.out.println("讲师在讲课");
    }
}

public class Tutor extends Teacher {
    //定义空参构造和带参构造
    public Tutor() {
    }

    public Tutor(String id, String name) {
        super(id, name);
    }

    //重写方法work

    @Override
    public void work() {
        System.out.println("助教在批改作业");
    }
}

public class EmployeeTest {
    //在黑马程序员中有很多员工(Employee)。
    //按照工作内容不同分教研部员工(Teacher)和行政部员工(AdminStaff)
    //教研部根据教学的方式不同又分为讲师(Lecturer)和助教(Tutor)
    //行政部根据负责事项不同,又分为维护专员(Maintainer),采购专员(Buyer)
    //公司的每一个员工都编号,姓名和其负责的工作
    //每个员工都有工作的功能，但是具体的工作内容又不一样。
    public static void main(String[] args) {
        //创建对象
        Lecturer l = new Lecturer("001", "zhangsan");
        Tutor t = new Tutor("002", "lisi");
        MainTrainer m = new MainTrainer("003", "wangwu");
        Buyer b = new Buyer("004", "zhaoliu");

        //调用方法
        System.out.println(l.getId() + "," + l.getName());
        l.work();
        System.out.println(t.getId() + "," + t.getName());
        t.work();
        System.out.println(m.getId() + "," + m.getName());
        m.work();
        System.out.println(b.getId() + "," + b.getName());
        b.work();
    }
}

二、角色

1.需求

在传智教育的tlias教学资源管理系统中，存在学生、老师角色会进入系统。

2.分析

学生信息和行为（名称，年龄，所在班级，查看课表，填写听课反馈fillForm）

老师信息和行为（名称，年龄，部门名称，查看课表，发布问题publishForm）

定义角色类作为父类包含属性（名称，年龄），行为（查看课表）

定义子类：学生类包含属性（所在班级），行为（填写听课反馈）

定义子类：老师类包含属性（部门名称），行为（发布问题）

3.参考答案

public class Role {
    //定义角色的属性
    private String name;
    private int age;

    //定义空参构造和带参构造
    public Role() {
    }

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

    //定义成员变量的get和set方法
    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;
    }

    //定义方法viewSchedule，代表行为：查看课表
    public void viewSchedule() {
        System.out.println("查看课表");
    }
}

public class Teacher extends Role {
    //定义老师的属性
    private String department;

    //定义空参构造和带参构造
    public Teacher() {
    }

    public Teacher(String name, int age, String department) {
        super(name, age);
        this.department = department;
    }

    //定义成员变量的get和set方法
    public String getDepartment() {
        return department;
    }

    public void setDepartment(String department) {
        this.department = department;
    }

    //定义方法publishForm，代表行为：发布问题
    public void publishForm() {
        System.out.println("发布问题");
    }
}

public class Student extends Role {
    //定义学生的属性
    private String atClass;

    //定义空参构造和带参构造
    public Student() {
    }

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

    //定义成员变量的get和set方法
    public String getAtClass() {
        return atClass;
    }

    public void setAtClass(String atClass) {
        this.atClass = atClass;
    }


    //定义方法fillForm，代表行为：填写听课反馈
    public void fillForm() {
        System.out.println("填写听课反馈");
    }
}

public class RoleTest {
    //在传智教育的tlias教学资源管理系统中，存在学生、老师角色会进入系统。
    public static void main(String[] args) {
        //创建老师和学生对象
        Student student1 = new Student("zhangsan", 23, "2203");
        Teacher teacher1 = new Teacher("lisi", 34, "Java");

        //打印信息，并调用方法
        System.out.println(student1.getName() + "," + student1.getAge() + "," + student1.getAtClass());
        student1.viewSchedule();
        student1.fillForm();
        System.out.println("————————————————");
        System.out.println(teacher1.getName() + "," + teacher1.getAge() + "," + teacher1.getDepartment());
        teacher1.viewSchedule();
        teacher1.publishForm();
    }
}

三、手机

1.需求

完成代码(按照标准格式写)，然后在测试类中测试。

（1）手机类Phone

属性:品牌brand,价格price

无参构造,有参构造

行为:打电话call,发短信sendMessage,玩游戏playGame

（2）测试类

创建Phone类对象,调用Phone类中的方法

2.思考

假设所有的手机都有属性屏幕的尺寸(int size),而且假设所有手机的屏幕尺寸为6,应该如何实现?

3.提示

可以把size定义为静态

4.参考答案

public class Phone {
    //定义手机的属性
    private String brand;
    private double price;
    private static int size;

    //定义空参构造和带参构造
    public Phone() {
    }

    public Phone(String brand, double price) {
        this.brand = brand;
        this.price = price;
    }

    //定义成员变量的get和set方法
    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public static int getSize() {
        return size;
    }

    public static void setSize(int size) {
        Phone.size = size;
    }

    //定义方法call，代表行为：打电话
    public void call() {
        System.out.println("打电话");
    }

    //定义方法sendMessage，代表行为：发短信
    public void sendMessage() {
        System.out.println("发短信");
    }

    //定义方法playGame，代表行为：玩游戏
    public void playGame() {
        System.out.println("玩游戏");
    }
}

public class PhoneTest {
    //完成代码(按照标准格式写)，然后在测试类中测试。
    //1.手机类Phone
    //属性:品牌brand,价格price
    //无参构造,有参构造
    //行为:打电话call,发短信sendMessage,玩游戏playGame
    //2.测试类
    //创建Phone类对象,调用Phone类中的方法
    //假设所有的手机都有属性屏幕的尺寸(int size),而且假设所有手机的屏幕尺寸为6,应该如何实现?
    public static void main(String[] args) {
        //对手机屏幕尺寸进行赋值
        Phone.setSize(6);

        //创建手机对象
        Phone phone1 = new Phone("xiaomi", 1999.99);

        //打印信息，并调用方法
        System.out.println(phone1.getBrand() + "," + phone1.getPrice() + "," + Phone.getSize());
        phone1.call();
        phone1.sendMessage();
        phone1.playGame();
    }
}

四、人

1.需求

（1）定义Person类

属性：

姓名name、性别gender、年龄age、国籍nationality；

方法：

吃饭eat、睡觉sleep，工作work。

（2）根据人类，创建一个学生类Student

增加属性：

学校school、学号stuNumber；

重写工作方法（学生的工作是学习）。

（3）根据人类，创建一个工人类Worker

增加属性：

单位unit、工龄workAge；

重写工作方法（工人的工作是盖房子）。

（4）根据学生类，创建一个学生干部类 StudentLeader

增加属性：

职务job；

增加方法：开会meeting。

（5）编写测试类分别对上述3类具体人物进行测试。

（6）要求运行结果:

学生需要学习!
工人的工作是盖房子!
学生干部喜欢开会!

2.参考答案

public class Person {
    //定义人的属性
    private String name;
    private String gender;
    private int age;
    private String nationality;

    //定义空参构造和带参构造
    public Person() {
    }

    public Person(String name, String gender, int age, String nationality) {
        this.name = name;
        this.gender = gender;
        this.age = age;
        this.nationality = nationality;
    }

    //定义成员变量的get和set方法
    public String getName() {
        return name;
    }

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

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getNationality() {
        return nationality;
    }

    public void setNationality(String nationality) {
        this.nationality = nationality;
    }

    //定义方法eat，代表行为：吃饭
    public void eat() {
        System.out.println("人类要工作");
    }

    //定义方法sleep，代表行为：睡觉
    public void sleep() {
        System.out.println("人类要睡觉");
    }

    //定义方法work，代表行为：工作
    public void work() {
        System.out.println("人类要工作");
    }
}

public class Worker extends Person {
    //定义工人的属性
    private String unit;
    private double workAge;

    //定义空参构造和带参构造
    public Worker() {
    }

    public Worker(String name, String gender, int age, String nationality, String unit, double workAge) {
        super(name, gender, age, nationality);
        this.unit = unit;
        this.workAge = workAge;
    }

    //定义成员变量的get和set方法
    public String getUnit() {
        return unit;
    }

    public void setUnit(String unit) {
        this.unit = unit;
    }

    public double getWorkAge() {
        return workAge;
    }

    public void setWorkAge(double workAge) {
        this.workAge = workAge;
    }

    //重写方法work

    @Override
    public void work() {
        System.out.println("工人的工作是盖房子！");
    }
}

public class Student extends Person {
    //定义学生的属性
    private String school;
    private String stuNumber;

    //定义空参构造和带参构造
    public Student() {
    }

    public Student(String name, String gender, int age, String nationality, String school, String stuNumber) {
        super(name, gender, age, nationality);
        this.school = school;
        this.stuNumber = stuNumber;
    }

    //定义所有成员变量的get和set方法
    public String getSchool() {
        return school;
    }

    public void setSchool(String school) {
        this.school = school;
    }

    public String getStuNumber() {
        return stuNumber;
    }

    public void setStuNumber(String stuNumber) {
        this.stuNumber = stuNumber;
    }

    //重写方法work
    @Override
    public void work() {
        System.out.println("学生需要学习！");
    }
}

public class StudentLeader extends Student {
    //定义学生干部的属性
    private String job;

    //定义空参构造和带参构造
    public StudentLeader() {
    }

    public StudentLeader(String name, String gender, int age, String nationality, String school, String stuNumber, String job) {
        super(name, gender, age, nationality, school, stuNumber);
        this.job = job;
    }

    //定义成员变量的get和set方法
    public String getJob() {
        return job;
    }

    public void setJob(String job) {
        this.job = job;
    }

    //定义方法meeting，代表行为：开会
    public void meeting() {
        System.out.println("学生干部喜欢开会！");
    }
}

public class PersonTest {
    //分析以下需求，并用代码实现
    //1.定义Person类
    //属性：
    //姓名name、性别gender、年龄age、国籍nationality；
    //方法：
    //吃饭eat、睡觉sleep，工作work。
    //2.根据人类，创建一个学生类Student
    //增加属性：
    //学校school、学号stuNumber；
    //重写工作方法（学生的工作是学习）。
    //3.根据人类，创建一个工人类Worker
    //增加属性：
    //单位unit、工龄workAge；
    //重写工作方法（工人的工作是盖房子）。
    //4.根据学生类，创建一个学生干部类 StudentLeader
    //增加属性：
    //职务job；
    //增加方法：开会meeting。
    //5.编写测试类分别对上述3类具体人物进行测试。
    //6.要求运行结果:
    //学生需要学习!
    //工人的工作是盖房子!
    //学生干部喜欢开会!
    public static void main(String[] args) {
        //创建对象
        Student student = new Student("zhangsan", "man", 23, "China", "岳麓书院", "c001");
        Worker worker = new Worker("lisi", "woman", 46, "China", "中建七局", 12.3);
        StudentLeader studentLeader = new StudentLeader("wangwu", "man", 24, "US", "MIT", "u001", "leader");

        //调用方法，打印结果
        student.work();
        worker.work();
        studentLeader.meeting();
    }
}

五、员工

1.需求

（1）定义项目经理类属性：姓名工号工资奖金行为：工作work

（2）定义程序员类属性：姓名工号工资行为：工作work

（3）向上抽取一个父类,让这两个类都继承这个父类,共有的属性写在父类中，子类重写父类中的方法

（4）编写测试类:完成这两个类的测试

2.参考答案

public class Employee {
    //定义员工的属性
    private String name;
    private String id;
    private double salary;

    //定义空参构造和带参构造
    public Employee() {
    }

    public Employee(String name, String id, double salary) {
        this.name = name;
        this.id = id;
        this.salary = salary;
    }

    //定义成员变量的get和set方法
    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 double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    //定义方法work，代表行为：工作
    public void work() {
        System.out.println("员工在工作");
    }
}

public class Manager extends Employee {
    //定义项目经理的属性
    private double bonus;

    //定义空参构造和带参构造
    public Manager() {
    }

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

    //定义成员变量的get和set方法
    public double getBonus() {
        return bonus;
    }

    public void setBonus(double bonus) {
        this.bonus = bonus;
    }

    //重写方法work
    public void work() {
        System.out.println("项目经理正在增加需求");
    }
}

public class Programmer extends Employee {
    //定义空参构造和带参构造
    public Programmer() {
    }

    public Programmer(String name, String id, double salary) {
        super(name, id, salary);
    }

    //重写方法work
    public void work() {
        System.out.println("程序员正在更改需求");
    }
}

public class EmployeeTest {
    //1.定义项目经理类 属性： 姓名 工号 工资 奖金 行为： 工作work
    //2.定义程序员类 属性： 姓名 工号 工资 行为： 工作work
    //3.向上抽取一个父类,让这两个类都继承这个父类,共有的属性写在父类中，子类重写父类中的方法
    //4.编写测试类:完成这两个类的测试
    public static void main(String[] args) {
        //创建对象
        Manager manager = new Manager("zhangsan", "001", 19999.9, 39999.9);
        Programmer programmer = new Programmer("lisi", "002", 29999.9);

        //打印信息，并调用方法
        System.out.println(manager.getName() + "," + manager.getId() + "," + manager.getSalary() + "," + manager.getBonus());
        manager.work();
        System.out.println("——————————————");
        System.out.println(programmer.getName() + "," + programmer.getId() + "," + programmer.getSalary());
        programmer.work();
    }
}

六、人与动物

1.需求

（1）定义动物类

属性：年龄，颜色

行为: eat(String something)方法(无具体行为,不同动物吃的方式和东西不一样,something表示吃的东西)

生成空参有参构造，set和get方法

（2）定义狗类继承动物类

行为: eat(String something)方法,看家lookHome方法(无参数)

（3）定义猫类继承动物类

行为:eat(String something)方法,逮老鼠catchMouse方法(无参数)

（4）定义Person类

属性：姓名，年龄

行为1： keepPet(Dog dog,String something)方法

功能1：喂养宠物狗，something表示喂养的东西

该方法调用后打印结果为：颜色为黑色的2岁的狗，在吃骨头

行为2： keepPet(Cat cat,String something)方法

功能2：喂养宠物猫，something表示喂养的东西

该方法调用后打印结果为：颜色为白色的2岁的猫，在吃小鱼干

（5）生成空参有参构造，set和get方法

（6）测试以上方法

2.参考答案

public class Animal {
    //定义动物的属性
    private int age;
    private String color;

    //定义空参构造和带参构造
    public Animal() {
    }

    public Animal(int age, String color) {
        this.age = age;
        this.color = color;
    }

    //定义成员变量的get和set方法
    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    //定义方法eat，代表行为：吃
    public String eat(String sth) {
        return "在吃" + sth;
    }
}

public class Cat extends Animal {
    //定义空参构造和带参构造
    public Cat() {
    }

    public Cat(int age, String color) {
        super(age, color);
    }

    //重写方法eat
    @Override
    public String eat(String sth) {
        return "喵喵喵地舔着吃" + sth;
    }

    //定义方法catchMouse，代表行为：逮老鼠
    public void catchMouse() {
        System.out.println("猫在逮老鼠");
    }
}

public class Dog extends Animal {
    //定义空参构造和带参构造
    public Dog() {
    }

    public Dog(int age, String color) {
        super(age, color);
    }

    //重写方法eat
    @Override
    public String eat(String sth) {
        return "汪汪汪地咬着吃" + sth;
    }

    //定义方法lookHome，代表行为：看家
    public void lookHome() {
        System.out.println("狗在看家");
    }
}

public class Person {
    //定义人的属性
    private String name;
    private int age;

    //定义空参构造和带参构造
    public Person() {
    }

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

    //定义成员变量的get和set方法
    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;
    }

    //定义方法keepPet，代表行为：喂养宠物狗
    public void keepPet(Dog dog, String sth) {
        System.out.println("颜色为" + dog.getColor() + "的" + dog.getAge() + "岁的狗，" + dog.eat(sth));
    }

    //定义方法keepPet，代表行为：喂养宠物猫
    public void keepPet(Cat cat, String sth) {
        System.out.println("颜色为" + cat.getColor() + "的" + cat.getAge() + "岁的猫，" + cat.eat(sth));
    }
}

public class AnimalTest {
    //根据需求完成代码:
    //1.定义动物类
    //属性： 年龄，颜色 行为: eat(String something)方法(无具体行为,不同动物吃的方式和东西不一样,something表示吃的东西)
    //生成空参有参构造，set和get方法
    //2.定义狗类继承动物类
    //行为: eat(String something)方法,看家lookHome方法(无参数)
    //3.定义猫类继承动物类
    //行为:
    //eat(String something)方法,逮老鼠catchMouse方法(无参数)
    //4.定义Person类
    //属性： 姓名，年龄
    //行为： keepPet(Dog dog,String something)方法
    //功能：喂养宠物狗，something表示喂养的东西
    //该方法调用后打印结果为：颜色为黑色的2岁的狗，在吃骨头
    //行为： keepPet(Cat cat,String something)方法 功能：喂养宠物猫，something表示喂养的东西
    //该方法调用后打印结果为：颜色为白色的2岁的猫，在吃小鱼干
    //5.生成空参有参构造，set和get方法
    //6.测试以上方法
    public static void main(String[] args) {
        //创建对象
        Dog dog = new Dog(2, "黑色");
        Cat cat = new Cat(3, "白色");
        Person person = new Person("zhangsan", 23);

        //打印信息，并调用方法
        System.out.println(person.getName() + "," + person.getAge());
        System.out.println(dog.getAge() + "," + dog.getColor());
        person.keepPet(dog, "骨头");
        System.out.println(cat.getAge() + "," + cat.getColor());
        person.keepPet(cat, "小鱼干");
    }
}

七、面积与周长

1.需求

（1）定义形状类:

功能：求面积，求周长

（2）定义圆形类Round:

属性：半径，圆周率

功能：求面积，求周长

（3）定义长方形类Rectangle:

 属性：长和宽

功能：求面积，求周长

（4）定义测试类:

 分别创建圆形和长方形对象，为相应的属性赋值

分别调用求面积和求周长的方法

2.参考答案

public abstract class Shape {
    //定义空参构造
    public Shape() {
    }

    //定义抽象方法getArea，表示行为求面积
    public abstract double getArea();

    //定义抽象方法getPerimeter，表示行为求周长
    public abstract double getPerimeter();
}

public class Rectangle extends Shape {
    //定义长方形的属性
    private double length;
    private double width;

    //定义空参构造和带参构造
    public Rectangle() {
    }

    public Rectangle(double length, double width) {
        this.length = length;
        this.width = width;
    }

    //定义所有成员变量的get和set方法
    public double getLength() {
        return length;
    }

    public void setLength(double length) {
        this.length = length;
    }

    public double getWidth() {
        return width;
    }

    public void setWidth(double width) {
        this.width = width;
    }

    @Override
    public double getArea() {
        return length * width;
    }

    @Override
    public double getPerimeter() {
        return 2 * (length + width);
    }
}

public class Round extends Shape {
    //定义圆形的属性
    private double radius;
    private final double pi = 3.14;

    //定义空参构造和带参构造
    public Round() {
    }

    public Round(double radius) {
        this.radius = radius;
    }

    //定义成员变量的get和set方法
    public double getRadius() {
        return radius;
    }

    public void setRadius(double radius) {
        this.radius = radius;
    }

    public double getPi() {
        return pi;
    }

    @Override
    public double getArea() {
        return pi * (radius * radius);
    }

    @Override
    public double getPerimeter() {
        return 2 * pi * radius;
    }
}

//需求
/*定义形状类:

功能：求面积，求周长

定义圆形类Round:

属性：半径，圆周率

功能：求面积，求周长

定义长方形类Rectangle:

 属性：长和宽
功能：求面积，求周长

定义测试类:

 分别创建圆形和长方形对象，为相应的属性赋值
分别调用求面积和求周长的方法*/
public class Test {
    public static void main(String[] args) {
        //创建圆形对象
        Round r1 = new Round(2);
        //调用方法，求面积与周长
        System.out.println("圆形的面积为：" + r1.getArea());
        System.out.println("圆形的周长为：" + r1.getPerimeter());

        //创建长方形对象
        Rectangle r2 = new Rectangle(4, 2);
        //调用方法，求面积与周长
        System.out.println("长方形的面积为：" + r2.getArea());
        System.out.println("长方形的周长为：" + r2.getPerimeter());
    }
}

八、新旧手机

1.需求

（1）定义手机类

行为：打电话,发短信

（2）定义接口IPlay

行为：玩游戏

（3）定义旧手机类继承手机类

行为：继承父类的行为

（4）定义新手机继承手机类实现IPlay接口

行为：继承父类的行为,重写玩游戏方法

（5）定义测试类

在测试类中定义一个用手机的方法,要求该方法既能接收老手机对象,也能接收新手机对象

在该方法内部调用打电话,发短信以及新手机特有的玩游戏方法

2.参考答案

public class Phone {
    //定义空参构造
    public Phone() {
    }

    //定义方法call，代表行为：打电话
    public void call() {
        System.out.println("用手机打电话");
    }

    //定义方法message，代表行为：发短信
    public void message() {
        System.out.println("用手机发短信");
    }
}

public class OldPhone extends Phone {
}

public class NewPhone extends Phone implements IPlay {
    @Override
    public void playGame() {
        System.out.println("用新手机玩游戏");
    }
}

public interface IPlay {
    //定义抽象方法playGame，代表行为：玩游戏
    public abstract void playGame();
}

//需求
/*定义手机类
    行为：打电话,发短信

定义接口IPlay
    行为：玩游戏

定义旧手机类继承手机类
    行为：继承父类的行为

定义新手机继承手机类实现IPlay接口
    行为：继承父类的行为,重写玩游戏方法

定义测试类
    在测试类中定义一个用手机的方法,要求该方法既能接收老手机对象,也能接收新手机对象
    在该方法内部调用打电话,发短信以及新手机特有的玩游戏方法*/
public class Test {
    public static void main(String[] args) {
        //使用多态，创建新手机对象和老手机对象
        Phone p1 = new OldPhone();
        Phone p2 = new NewPhone();

        usePhone(p1);
        usePhone(p2);
    }

    //定义方法usePhone，代表行为：用手机
    public static void usePhone(Phone p) {
        p.call();
        p.message();
        if (p instanceof NewPhone) {
            ((NewPhone) p).playGame();
        }
    }
}

九、匿名内部类调用方法

1.需求

（1）接口IPlay中有一个方法playGame()，在测试类中如何调用该方法？

要求1.创建子类实现接口的方式实现要求2:用匿名内部类实现

（2）一个抽象类Fun中有一个抽象方法 fun() , 在测试类中如何调用该方法?

要求1.创建子类继承抽象类的方式实现要求2:用匿名内部类实现

2.参考答案

public interface IPlay {
    public abstract void playGame();
}

public abstract class Fun {
    public abstract void fun();
}

public class Zi extends Fun implements IPlay {
    @Override
    public void playGame() {
        System.out.println("玩游戏");
    }

    @Override
    public void fun() {
        System.out.println("子类继承抽象类的方式实现fun方法");
    }
}

//需求
/*接口IPlay中有一个方法playGame()，在测试类中如何调用该方法？
要求1.创建子类实现接口的方式实现 要求2:用匿名内部类实现

一个抽象类Fun中有一个抽象方法 fun() , 在测试类中如何调用该方法?
要求1.创建子类继承抽象类的方式实现 要求2:用匿名内部类实现*/
public class Test {
    public static void main(String[] args) {
        //使用创建子类实现接口的方式，在测试类中调用方法playGame()
        Zi z1 = new Zi();
        z1.playGame();
        //用匿名内部类实现
        new IPlay() {
            @Override
            public void playGame() {
                System.out.println("用匿名内部类实现playGame方法");
            }
        }.playGame();

        //使用创建子类继承抽象类的方式，在测试类中调用方法fun()
        Zi z2 = new Zi();
        z2.fun();
        //用匿名内部类实现
        new Fun() {
            @Override
            public void fun() {
                System.out.println("用匿名内部类实现fun方法");
            }
        }.fun();
    }
}

十、输出”HelloWorld”

1.需求

在控制台输出”HelloWorld”

自己书写，不要用idea自动生成。

interface Inter {
    void show(); 
}
class Outer { 
    //补齐代码 
}
public class OuterDemo {
    public static void main(String[] args) {
        Outer.method().show();
    }
}

2.参考答案

//需求
//在控制台输出”HelloWorld”
interface Inter {
    void show();
}

class Outer {
    //补齐代码
    public static Inter method() {
        return new Inter() {
            @Override
            public void show() {
                System.out.println("HelloWorld");
            }
        };
    }
}

public class OuterDemo {
    public static void main(String[] args) {
        Outer.method().show();
    }
}

十一、创建对象并调用成员方法1

1.需求

在测试类Test中创建A的对象a并调用成员方法methodA(),要求用两种方式实现

自己书写，不要用idea自动生成。

public class Test {
    public static void main(String[] args) {	
        
    }
}

//定义接口
interface InterA {
    void showA();	
}

class A {
    public void methodA(InterA a) {
        a.showA();		
    }	
}

2.参考答案

//需求
//在测试类Test中创建A的对象a并调用成员方法methodA(),要求用两种方式实现
public class Test {
    public static void main(String[] args) {
        //创建A的对象a并调用成员方法methodA()
        A a = new A();
        InterA a1 = new InterA() {
            @Override
            public void showA() {
                System.out.println("第一种方式，重写showA方法");
            }
        };
        //第一种方式传入对象a1，第二种方式传入对象a
        a.methodA(a1);
    }
}

//定义接口
interface InterA {
    void showA();
}

class A implements InterA {
    public void methodA(InterA a) {
        a.showA();
    }

    @Override
    public void showA() {
        System.out.println("第二种方式，重写showA方法");
    }
}

十二、创建对象并调用成员方法2

1.需求

在测试类Test中创建B的对象b，并调用成员方法methodB

自己书写，不要用idea自动生成。

public class Test {
    public static void main(String[] args) {

    }
}

//定义一个接口
interface InterB {
    void showB();	
}

//目标：调用成员方法methodB
class B {
    InterB b;
    public B(InterB b){
        this.b = b;
    }
    public void methodB(){
        b.showB();		
    }
}

2.参考答案

//需求
//在测试类Test中创建B的对象b，并调用成员方法methodB
public class Test {
    public static void main(String[] args) {
        B b = new B(new InterB() {
            @Override
            public void showB() {
                System.out.println("传入形参为InterB类型");
            }
        });
        b.methodB();
    }
}

//定义一个接口
interface InterB {
    void showB();
}

//目标：调用成员方法methodB
class B {
    InterB b;

    public B(InterB b) {
        this.b = b;
    }

    public void methodB() {
        b.showB();
    }
}