java 面向对象程序

libin
136 阅读11分钟

持续创作，加速成长！这是我参与「掘金日新计划 · 6 月更文挑战」的第19天，点击查看活动详情

面向对象练习

练习1

需求

定义一个扑克类Card

属性：

  • 花色
  • 点数

构造方法：

  • 满参构造方法

成员方法：

  • showCard方法：打印牌面信息

定义测试类

在main方法中使用满参构造创建Card对象card，并调用showCard方法

代码实现，效果如图所示：

1586008335996.png

案例代码

Card类

public class Card {
    private String ds; // 点数
    private String hs; // 花色
​
    public Card(String ds, String hs) {
        this.ds = ds;
        this.hs = hs;
    }
​
    public void showCard() {
        System.out.println(ds +    hs);
    }
}

测试类

public class Test02 {
    public static void main(String[] args) {
        Card card = new Card("A","黑桃");
        card.showCard();
    }
}

练习2

需求

  • 定义两个类，经理类Manager，程序员类Coder

  • Coder类：

    • 属性：姓名，工号，薪资

    • 构造方法：无参和满参构造方法

    • 成员方法：

      • intro方法：打印姓名，工号信息
      • showSalary方法：打印薪资信息
      • work方法：打印"正在努力写代码...."

  • Manager类：

    • 属性：姓名，工号，薪资，奖金

    • 构造方法：无参和满参构造方法

    • 成员方法：

      • intro方法：打印姓名，工号信息
      • showSalary方法：打印薪资和奖金信息
      • work方法：打印"正在努力的做着管理工作,分配任务,检查员工提交上来的代码....."

  • 定义测试类，创建Manager对象，创建Coder对象，并测试

  • 代码实现，效果如图所示：

1586008712172.png

案例代码

Coder类

public class Coder {
    String name;
    String id;
    int salary; // 基本工资
​
    public Coder() {
    }
    public Coder(String name, String id, double salary) {
        this.name = name;
        this.id = id;
        this.salary = salary;
    }
    public void showSalary() {
        System.out.println("基本工资为" + salary + ",奖金无");
    }
​
    public void intro() {
        System.out.println("程序员姓名:" + name);
        System.out.println("工号:" + id);
    }
​
    public void work() {
        System.out.println("正在努力写代码....");
    }
}

Manager类

public class Manager {
     String name;
     String id;
     int salary; // 基本工资
     int bouns; // 奖金
​
    public Manager() {
    }
    public Manager(String name, String id, double salary, double bonus) {
        this.name = name;
        this.id = id;
        this.salary = salary;
        this.bonus = bonus;
    }
    public void showSalary() {
        System.out.println("基本工资为" + salary + ",奖金为" + bouns);
    }
​
    public void intro() {
        System.out.println("经理姓名:" + name);
        System.out.println("工号:" + id);
    }
​
    public void work() {
        System.out.println("正在努力的做着管理工作,分配任务,检查员工提交上来的代码.....");
    }
}

测试类

public class Test02 {
    public static void main(String[] args) {
        Manager m = new Manager("James","9527",15000,3000);
        m.intro();
        m.showSalary();
        m.work();
​
       System.out.println("============");
       Coder c = new Coder("Kobe","0025",10000);
        c.intro();
        c.showSalary();
        c.work();
    }
}

练习3

需求

请使用继承定义以下类:

程序员(Coder)
  成员变量: 姓名,年龄
  成员方法: 吃饭,睡觉,敲代码
​
老师(Teacher)
  成员变量: 姓名,年龄
  成员方法: 吃饭,睡觉,上课

将程序员和老师中相同的内容(姓名,年龄,吃饭,睡觉)抽取到父类Person中

image-20200505163923615.png 效果如图所示：

1586009011518.png

案例代码

Person类

public class Person {
    String name;
    int age;
    
    public void eat() {
        System.out.println(name + "吃饭");
    }
    
    public void sleep() {
        System.out.println(name + "睡觉");
    }
}

Coder类

public class Coder extends Person {
​
    // 敲代码
    public void coding() {
        System.out.println(name + "敲代码");
    }
}

Teacher类

public class Teacher extends Person {
    
    public void teach() {
        System.out.println(name + "上课");
    }
}

测试类

public class Test03 {
    public static void main(String[] args) {
        // 创建Code对象,并设置成员变量的值
        Coder c = new Coder();
        c.name = "马化腾";
        c.age = 45;
        // 调用Coder对象的eat()方法
        c.eat();
        // 调用Coder对象的sleep()方法
        c.sleep();
        // 调用Coder对象的coding()方法
        c.coding();
​
        System.out.println("-----------");
        // 创建Teacher对象,并设置成员变量的值
        Teacher t = new Teacher();
        t.name = "马云";
        t.age = 50;
        // 调用Teacher对象的eat()方法
        t.eat();
        // 调用Teacher对象的sleep()方法
        t.sleep();
        // 调用Teacher对象的teach()方法
        t.teach();
    }
}

练习4

需求

请使用继承，抽象方法，抽象类定义以下类：

1.经理
  成员变量:工号,姓名,工资
  成员方法:工作(管理其他人),吃饭(吃鱼)
2.厨师
  成员变量:工号,姓名,工资
  成员方法:工作(炒菜),吃饭(吃肉)

image-20200505164605938.png

说明：虽然经理和厨师都有工作和吃饭的行为，但是工作方式和吃的内容是不一样的，所以需要抽取父类员工类中，并且变为抽象类。

效果如图所示：

1586009200781.png

案例代码

抽象的Employee类

abstract class Employee {
    // 工号属性,姓名属性,工资属性
    private String id;
    private String name;
    private double salary;
​
    public Employee() {
    }
​
    public Employee(String id, String name, double salary) {
        this.id = id;
        this.name = name;
        this.salary = salary;
    }
​
    // 抽象的工作方法
    public abstract void work();
​
    // 抽象的吃饭方法
    public abstract void eat();
​
    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;
    }
​
    public double getSalary() {
        return salary;
    }
​
    public void setSalary(double salary) {
        this.salary = salary;
    }
}

Manager类

// 经理继承员工,重写工作方法,和吃饭方法
class Manager extends Employee {
    public Manager() {
    }
​
    public Manager(String id, String name, double salary) {
        super(id, name, salary);
    }
​
    @Override
    public void work() {
        System.out.println("工号为:" + getId() + ",姓名为:" + getName() + "工资为:" + getSalary() + "的经理在工作,管理其他人");
    }
​
    @Override
    public void eat() {
        System.out.println("工号为:" + getId() + ",姓名为:" + getName() + "工资为:" + getSalary() + "的经理在吃鱼");
    }
}

Cook类

class Cook extends Employee {
    public Cook() {
    }
​
    public Cook(String id, String name, double salary) {
        super(id, name, salary);
    }
​
    @Override
    public void work() {
        System.out.println("工号为:" + getId() + ",姓名为:" + getName() + "工资为:" + getSalary() + "的厨师在工作,炒菜");
    }
​
    @Override
    public void eat() {
        System.out.println("工号为:" + getId() + ",姓名为:" + getName() + "工资为:" + getSalary() + "的厨师在吃肉");
    }
}

测试类

public class Test04 {
    public static void main(String[] args) {
        // 创建Manager对象
        Manager m = new Manager("m110", "老王", 10000);
        // 调用Manager对象的eat方法
        m.eat();
        // 调用Manager对象的work方法
        m.work();
​
        // 创建Cook对象
        Cook c = new Cook("c110", "小王", 6000);
        // 调用Cook对象的eat方法
        c.eat();
        // 调用Cook对象的work方法
        c.work();
    }
}

练习5

需求

请使用继承，抽象方法，抽象类定义以下类：

1.在传智播客有很多员工(Employee),按照工作内容不同分教研部员工(Teacher)和行政部员工(AdminStaff)
2.教研部根据教学的方式不同又分为讲师(Lecturer)和助教(Tutor)
3.行政部根据负责事项不同,又分为维护专员(Maintainer),采购专员(Buyer)
4.公司的每一个员工都有编号,姓名和其负责的工作
5.每个员工都有工作的功能,但是具体的工作内容又不一样,在向上抽取的时候定义为抽象方法

效果如图所示：

1586009473485.png

类之间的关系如下：

1586009506341.png

案例代码

Employee类

/*
 1.定义抽象类员工类(Employee)
    a)成员变量: 工号(id),姓名(name)
    b)抽象方法: void work();
    c)提供无参和带参的构造方法以及setters和getters
 */
public abstract class Employee {
    //  a)成员变量: 工号(id),姓名(name)
    private String id;
    private String name;
​
    //  b)抽象方法: void work();
    public abstract void work();
​
    //  c)提供无参和带参的构造方法以及setters和getters
    public Employee() {
        super();
    }
​
    public Employee(String id, String name) {
        super();
        this.id = id;
        this.name = name;
    }
​
    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;
    }
}

Teacher类

/*
 2.定义抽象类教研部员工（Teacher）类继承员工类(Employee)
 */
public abstract class Teacher extends Employee{
//  a)提供无参和带参的构造方法
    public Teacher() {
        super();
    }
​
    public Teacher(String id, String name) {
        super(id, name);
    }
}

AdminStaff类

/*
 3.定义抽象类行政部员工(AdminStaff)类继承员工类(Employee)
 */
public abstract class AdminStaff extends Employee {
//  a)提供无参和带参的构造方法
    public AdminStaff() {
        super();
    }
​
    public AdminStaff(String id, String name) {
        super(id, name);
    }
}  

Lecturer类

/*
 4.定义讲师(Lecturer)类继承研部员工（Teacher）类
 */
public class Lecturer extends Teacher {
//  a)提供无参和带参的构造方法
    public Lecturer() {
        super();
    }
    public Lecturer(String id, String name) {
        super(id, name);
    }
    
//  b)实现抽象方法: void work();
//      输出格式: 工号为 666 的讲师 傅红雪 在讲课
    public void work() {
        System.out.println("工号为 "+getId()+" 的讲师 "+getName()+" 在讲课");
    }
}

Tutor类

/*
 5.定义助教(Tutor)类继承研部员工（Teacher）类
 */
public class Tutor extends Teacher{
//  a)提供无参和带参的构造方法
    public Tutor() {
        super();
    }
​
    public Tutor(String id, String name) {
        super(id, name);
    }
//  b)实现抽象方法: void work();
//      i.输出格式: 工号为 668的助教 顾棋 在帮助学生解决问题
    public void work() {
        System.out.println("工号为 "+getId()+"的助教 "+getName()+" 在帮助学生解决问题");
    }
}

Maintainer类

/*
 6.定义维护专员(Maintainer)类继承行政部员工(AdminStaff)类
 */
public class Maintainer extends AdminStaff {
//  a)提供无参和带参的构造方法
    public Maintainer() {
        super();
    }
​
    public Maintainer(String id, String name) {
        super(id, name);
    }
//  b)实现抽象方法: void work();
//  i.输出格式: 工号为 686 的维护专员 庖丁 在解决不能共享屏幕问题
    public void work() {
        System.out.println("工号为 "+getId()+" 的维护专员 "+getName()+" 在解决不能共享屏幕问题");
    }
}

Buyer类

/*
 7.定义采购专员(Buyer) 类继承行政部员工(AdminStaff)类
 */
public class Buyer extends AdminStaff {
//  a)提供无参和带参的构造方法
    public Buyer() {
        super();
    }
​
    public Buyer(String id, String name) {
        super(id, name);
    }
//  b)实现抽象方法: void work();
//  输出格式:  工号为 888 的采购专员 景甜 在采购音响设备
    public void work() {
        System.out.println("工号为 "+getId()+" 的采购专员 "+getName()+" 在采购音响设备");
    }
}

测试类

/*
8.定义测试类Test
 */
public class Test5 {
    public static void main(String[] args) {
//      a)创建讲师对象l, 把工号赋值为666,姓名赋值为”傅红雪”
        Lecturer l = new Lecturer("666", "傅红雪");
//      b)调用讲师对象l的工作方法
        l.work();
​
//      c)创建助教对象 t, 把工号赋值为668,姓名赋值为”顾棋”
        Tutor t = new Tutor("668", "顾棋");
//      d)调用助教对象t的工作方法
        t.work();
​
//      e)创建维护专员对象 m, 把工号赋值为686,姓名赋值为”庖丁”
        Maintainer m = new Maintainer("686", "庖丁");
//      f)调用维护专员对象m的工作方法
        m.work();
​
//      g)创建采购专员对象 b, 把工号赋值为888,姓名赋值为”景甜”
        Buyer b = new Buyer("888", "景甜");
//      h)调用采购专员对象b的工作方法
        b.work();
    }
}

练习6

需求

请使用继承，接口，定义以下类：

两个手机类OldPhone和NewPhone都有call()和sendMessage()方法.定义接口Play,Play中有一个抽象的玩游戏的方法playGame(),NewPhone继承旧手机类OldPhone并实现Play接口有玩游戏的功能;

要求:

分别测试OldPhone和NewPhone的call()和sendMessage()方法,再测试新手机palyGame()的方法

效果如图所示：

1586009853091.png

案例代码

Play接口

// 1.定义接口Play
interface Play {
    // 2.在Play中定义一个抽象的玩游戏的方法playGame()
    public abstract void playGame();
}

OldPhone类

// 3.定义OldPhone类
class OldPhone {
    // 4.在OldPhone类中定义call()和sendMessage()方法
    public void call() {
        System.out.println("旧手机打电话");
    }
​
    public void sendMessage() {
        System.out.println("旧手机发短信");
    }
}

NewPhone类

// 5.定义NewPhone类,继承OldPhone,实现Play接口
class NewPhone extends OldPhone implements Play {
    @Override
    public void playGame() {
        System.out.println("新手机玩游戏");
    }
​
    @Override
    public void call() {
        System.out.println("新手机打电话");
    }
​
    @Override
    public void sendMessage() {
        System.out.println("新手机发短信");
    }
}

测试类

public class Test06 {
    public static void main(String[] args) {
        // 6.创建旧手机对象
        OldPhone oldPhone = new OldPhone();
        // 7.使用旧手机打电话
        oldPhone.call();
        // 8.使用旧手机发信息
        oldPhone.sendMessage();
​
        // 9.创建新手机对象
        NewPhone newPhone = new NewPhone();
        // 10.使用新手机打电话
        newPhone.call();
        // 11.使用新手机发信息
        newPhone.sendMessage();
        // 12.使用新手机玩游戏
        newPhone.playGame();
    }
}

练习7

需求

请使用继承，接口，定义以下类：

学生都有年龄和姓名属性,有吃饭(学生餐)和学习方法,但是有部分学生会打篮球
老师都有年龄和姓名属性,有吃饭(工作餐)和讲课方法,但是有部分老师会打篮球
定义一个方法模拟去打篮球,只要会打篮球的人都可以传入. (提示通过在测试类中定义一个方法参数为接口)

效果如图所示：

1586010200891.png

类和接口之间的关系如下：

1586011401638.png

案例代码

抽象的Person类

// 1.定义Person类
abstract class Person {
    //  2.Person类包含name,age属性和抽象的eat方法
    private String name;
    private int age;
​
    public abstract void eat();
​
    public Person() {
        super();
    }
​
    public Person(String name, int age) {
        super();
        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;
    }
}

Sport接口

// 3.定义Sport接口,包含playBasketball方法
interface Sport {
    public abstract void playBasketball();
}

Teacher类

// 4.定义Teacher类继承Person类,重写抽象方法eat()
class Teacher extends Person {
    public void eat() {
        System.out.println();
    }
    
    public void teach() {
        System.out.println(getName() + "老师在讲课");
    }
​
    public Teacher() {
        super();
    }
​
    public Teacher(String name, int age) {
        super(name, age);
    }
}

SportTeacher类

// 5.定义SportTeacher类继承Teacher类,实现Sport接口,重写Sport接口中的playBasketball方法
class SportTeacher extends Teacher implements Sport {
    public void playBasketball() {
        System.out.println("年龄为" + getAge() + "岁 " + getName() + " 的老师在打篮球");
    }
​
    public SportTeacher() {
        super();
    }
​
    public SportTeacher(String name, int age) {
        super(name, age);
    }
}

Student类

// 6.定义Student类继承Person类,重写抽象方法eat()
class Student extends Person {
    public void eat() {
        System.out.println("年龄" + getAge() + "岁的 " + getName() + " 在吃学生餐");
    }
    
    public void study() {
        System.out.println(getName() + "学生在学习");
    }
​
    public Student() {
        super();
    }
​
    public Student(String name, int age) {
        super(name, age);
    }
}

SportStudent类

// 7.定义SportStudent类继承Student类,实现Sport接口,重写Sport接口中的playBasketball方法
class SportStudent extends Student implements Sport {
    public SportStudent() {
    }
​
    public SportStudent(String name, int age) {
        super(name, age);
    }
​
    public void playBasketball() {
        System.out.println("年龄为" + getAge() + "岁 " + getName() + " 的学生在打篮球");
    }
}

测试类

public class Test07 {
    public static void main(String[] args) {
        // 9.在main方法中创建普通的老师t1,姓名为马云,年龄为45岁
        Teacher t1 = new Teacher("马云", 45);
        // 10.在main方法中创建会打篮球的老师t2,姓名为大姚,年龄为35岁
        SportTeacher t2 = new SportTeacher("大姚", 35);
​
        // 11.在main方法中创建普通的学生s1,姓名为小王,年龄为20
        Student s1 = new Student("小王", 20);
        // 12.在main方法中创建会打篮球的学生s2,姓名为王中王,年龄为21
        SportStudent s2 = new SportStudent("王中王", 21);
​
        // 13.在main方法中调用goToSport方法.传入t1,t2,s1,s2四个对象.我们会发现只有实现Sport接口的对象才能传入
        // goToSport(t1); // 没有实现Sport接口不能传入
        goToSport(t2);
        // goToSport(s1); // 没有实现Sport接口不能传入
        goToSport(s2);
    }
​
    // 8.在测试类中定义静态的goToSport方法,参数为Sport接口类型
    public static void goToSport(Sport s){
        // 在goToSport方法中调用传入参数的playBasketball方法
        s.playBasketball();
    }
}
avatar
文章
阅读
粉丝