第一题
/**
 * 定义一个交通工具（Vehicle）的类
 * 其中有属性：速度（speed）、体积（size）
 * 方法：移动（move()）、设置速度（setSpeed(int speed)）、
 * 设置体积（setSize(int size)）、加速（speedUp()）、减速（speedDown()）
 * 最后在测试类中的main()中实例化一个交通工具对象
 * 通过方法给它初始化speed、size的值并打印出来
 * 另外调用加速减速的方法对速度进行改变
 */
package oopTest01;
~~~~~~~~~~~~~~~~~Vehicle类~~~~~~~~~~~~~~~~~~~~~~~~~
public class Vehicle {
    // 属性
    private int speed;
    private int size;

    // 方法
    public void setSpeed(int a) {
        speed = a;
        System.out.println("初始速度为：" + speed);
    }

    public void setSize(int a) {
        size = a;
        System.out.println("初始体积为：" + size);
    }

    public void speedUp() {
        speed += 5;
        System.out.println("速度增加了5,当前速度为"+speed);
    }
    
    public void speedDown() {
        speed -= 5;
        System.out.println("速度减少了5，当前速度为"+speed);
    }
    
    public void move() {
        if(speed > 0) {
            System.out.println("体积为"+size+"的汽车正以时速"+speed+"向正方向移动");
        }else if(speed == 0) {
            System.out.println("汽车目前速度为0");
        }else {
            speed = -speed;
            System.out.println("体积为"+size+"的汽车正以时速"+speed+"向反方向移动");
        }
    }

}

~~~~~~~~~~~~~~~~~~~~~Vehicle测试类~~~~~~~~~~~~~~~~~~~~~~~~
import java.util.Scanner;

public class TestVehicle {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入汽车的初始体积");
        int sp = sc.nextInt();
        System.out.println("请输入汽车的初始速度");
        int si = sc.nextInt();
        Vehicle car = new Vehicle();
        car.setSpeed(sp);
        car.setSize(si);
        
        while(true) {
            System.out.println("1.加速");
            System.out.println("2.减速");
            System.out.println("3.移动");
            System.out.println("4.退出");
            System.out.println("请输入操作序号：");
            int number = sc.nextInt();
            
            switch(number) {
            case 1://加速
                car.speedUp();
                break;
            case 2://减速
                car.speedDown();
                break;
            case 3://移动
                car.move();
                break;
            case 4://结束
                sc.close();
                System.exit(0);
                break;
            default:
                System.out.println("请输入正确操作");
                break;
            }
        }
    }
}import java.util.Scanner;

public class TestVehicle {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入汽车的初始体积");
        int sp = sc.nextInt();
        System.out.println("请输入汽车的初始速度");
        int si = sc.nextInt();
        Vehicle car = new Vehicle();
        car.setSpeed(sp);
        car.setSize(si);
        
        while(true) {
            System.out.println("1.加速");
            System.out.println("2.减速");
            System.out.println("3.移动");
            System.out.println("4.退出");
            System.out.println("请输入操作序号：");
            int number = sc.nextInt();
            
            switch(number) {
            case 1://加速
                car.speedUp();
                break;
            case 2://减速
                car.speedDown();
                break;
            case 3://移动
                car.move();
                break;
            case 4://结束
                sc.close();
                System.exit(0);
                break;
            default:
                System.out.println("请输入正确操作");
                break;
            }
        }
    }
}




第二题
/**
 * 在程序中经常要对时间进行操作但是并没有时间类型的数据，
 * 那么我们可以自己实现一个时间类来满足程序中的需要
 * 定义名为MyTime的类
 * 其中应有三个整型成员：时hour、分minute、秒second
 * 为了保证数据的安全性，这三个成员变量应声明为私有
 * 为MyTime类定义构造方法以方便创建对象时初始化成员变量
 * 再定义display( 显示)方法用于将时间信息打印出来
 * 为MyTime类添加方法：addSecond(int second)、addMinute(int minute)、
 * addHour(int hour)、subSecond(int second)、subMinute(int minute)、
 * subHour(int hour)
 * 分别对时、分、秒进行加减运算
 */
package timeTest;

import java.util.Scanner;

public class MyTime {
    private int hour = 0;
    private int minute = 0;
    private int second = 0;

    public void setHour(int a) {
        hour = a;
    }

    public void setMinute(int a) {
        minute = a;
    }

    public void setSecond(int a) {
        second = a;
    }

    public void displayTime() {
        int tempMinute = minute * 60;
        int tempHour = hour * 3600;
        int sum = tempMinute + tempHour + second;
        hour = sum / 3600;
        minute = (sum - (hour * 3600)) / 60;
        second = sum - hour * 3600 - minute * 60;

        System.out.println("现在的时间是：\t" + hour + "时" + minute + "分" + second + "秒");
    }

    public int addHour(int hour) {
        this.hour += hour;
        return this.hour;
    }

    public int addMinute(int minute) {
        this.minute += minute;
        return this.minute;
    }

    public int addSecond(int second) {
        this.second += second;
        return this.second;
    }

    public int subHour(int hour) {
        this.hour -= hour;
        return this.hour;
    }

    public int subMinute(int minute) {
        this.minute -= minute;
        return this.minute;
    }

    public int subSecond(int second) {
        this.second -= second;
        return this.second;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        MyTime time = new MyTime();
        System.out.println("请输入初始的小時");
        int hour = sc.nextInt();
        time.setHour(hour);

        System.out.println("请输入初始的分鐘");
        int minute = sc.nextInt();
        while (minute > 60 || minute < 0) {
            System.out.println("输入分钟的值有误，应在（0~60之间）,请重新输入：");
            minute = sc.nextInt();
        }
        time.setMinute(minute);

        System.out.println("请输入初始的秒鐘");
        int second = sc.nextInt();
        while (second > 60 || second < 0) {
            System.out.println("输入秒钟的值有误，应在（0~60之间）,请重新输入：");
            second = sc.nextInt();
        }
        time.setSecond(second);

        while (true) {
            System.out.println("~~~~~~~~~~~~~~~~~~~~~~~");
            System.out.println("\t1.加小时");
            System.out.println("\t2.加分钟");
            System.out.println("\t3.加秒钟");
            System.out.println("\t4.减小时");
            System.out.println("\t5.减分钟");
            System.out.println("\t6.减秒钟");
            System.out.println("\t7.显示时间");
            System.out.println("\t8.退出");
            System.out.println("~~~~~~~~~~~~~~~~~~~~~~~");
            int number = sc.nextInt();
            switch (number) {
            case 1:
                System.out.println("请输入增加的小时数");
                int addHour = sc.nextInt();
                time.addHour(addHour);
                break;
            case 2:
                System.out.println("请输入增加的分钟数");
                int addMinute = sc.nextInt();
                time.addMinute(addMinute);
                break;
            case 3:
                System.out.println("请输入增加的秒钟数");
                int addSecond = sc.nextInt();
                time.addSecond(addSecond);
                break;
            case 4:
                System.out.println("请输入减少的小时数");
                int subHour = sc.nextInt();
                time.subHour(subHour);
                break;
            case 5:
                System.out.println("请输入减少的分钟数");
                int subMinute = sc.nextInt();
                time.subMinute(subMinute);
                break;
            case 6:
                System.out.println("请输入减少的秒钟数");
                int subSecond = sc.nextInt();
                time.subSecond(subSecond);
                break;
            case 7:
                time.displayTime();
                break;
            case 8:
                sc.close();
                System.exit(0);
                break;
            default:
                System.out.println("输入有误");
            }
        }
    }
}



第三题
/**
 * 编写Java程序模拟简单的计算器
 * 定义名为Number的类，其中有两个整型数据成员n1和n2，应声明为私有
 * 编写构造方法赋予n1和n2初始值
 * 再为该类定义加addition、减subtration、乘multiplication、
 * 除division等公共成员方法
 * 分别对两个成员变量执行加、减、乘、除的运算
 * 在main方法中创建Number类的对象调用各个方法并显示计算结果
 */
package calculator;

import java.util.Scanner;

public class Number {
    private int n1;
    private int n2;
    
    public void setN1(int a) {
        n1 = a;
    }
    
    public void setN2(int a) {
        n2 = a;
    }
    
    public void addition() {
        int add;
        add = n1 + n2;
        System.out.println("相加后的值是"+add);
    }
    
    public void subtration() {
        int sub;
        sub = n1 - n2;
        System.out.println("第一个数减第二个数的值是"+sub);
    }
    
    public void multiplication() {
        int mul;
        mul = n1 * n2;
        System.out.println("两数相乘的值是"+mul);
    }
    
    public void division() {
        double div;
        div = (double)n1 / n2;
        System.out.println("n1除以n2后的值是"+div);
    }
    
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入n1的值");
        int n1 = sc.nextInt();
        System.out.println("请输入n2的值");
        int n2 = sc.nextInt();
        
        Number calculator = new Number();
        calculator.setN1(n1);
        calculator.setN2(n2);
        
        calculator.addition();
        calculator.subtration();
        calculator.multiplication();
        calculator.division();
        sc.close();
    }
}


第四题
/**
 * 定义一个人类Person用于显示人的姓名和年龄
 * 该类中应该有两个私有属性姓名name和年龄age
 * 定义构造方法用来初始化数据成员
 * 再定义显示display方法将姓名和年龄打印出来
 * 在main方法中创建人类的实例然后将信息显示。
 */
package peopleInfo;

import java.util.Scanner;

public class Person {
    private String name=null;
    private int age;
    
    public void setName(String a) {
        name = a;
    }
    
    public void setAge(int a) {
        age = a;
    }
    
    public void display() {
        System.out.println("姓名："+name+"\t年龄:"+age);
    }
    
    public static void main(String[] args) {
        Person human = new Person();
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入姓名");
        String name = sc.next();
        human.setName(name);
        System.out.println("请输入年龄");
        int age = sc.nextInt();
        human.setAge(age);
        
        human.display();
        sc.close();
    }
}


第五题
/**
 * 定义一个Computer类
 * 该类有一个私有成员变量品牌type
 * 提供该变量的get和set方法
 * 在main方法中设置type的值并打印出来
 */
package computer;

public class Computer {
    private String type=null;
    public void setType(String a) {
        type = a;
    }
    public String getType() {
        return type;
    }
    public static void main(String[] args) {
        Computer com = new Computer();
        com.setType("机械革命");
        System.out.println(com.getType());
    }
}


第六题

犯的错误：构造方法不需要返回值

[构造方法]必须满足以下语法规则：　　
(1)方法名必须与类名相同；　　
(2)不要声明返回类型；　　
(3)不能被static、final、synchronized、abstract和native修饰；　　
(4)构造方法不能被子类继承，所以用final和abstract修饰没有意义。

/**
 * 为“无名的粉”写一个类WuMingFen
 * 要求：
 * 
 * 1、有三个属性，面码：String theMa、粉的分量：int quantity、
 * 是否带汤：boolean likeSoup
 * 
 * 2、写一个构造方法以便于简化初始化过程，
 * 如WuMingFen f1 = new WuMingFen("牛肉", 3, true);
 * 
 * 3、重载构造方法使得初始化过程可以多样化，
 * 如WuMingFen f2 = new WuMingFen("牛肉", 2);
 * 
 * 4、如何使WuMingFen f3 = new WuMingFen();
 * 语句构造出来的粉的对象是酸辣面码、2两、带汤的
 * 
 * 5、写一个普通方法check()用于查看粉是否符合要求，
 * 即将对象的三个属性打印在控制台上
 */
package foodfans;

public class WuMingFen {
    private String theMa;
    private int quantity;
    private boolean likeSoup;
    
    public WuMingFen(String a,int b,boolean c) {
        theMa = a;
        quantity = b;
        likeSoup = c;
    }
    
    public WuMingFen(String a,int b) {
        theMa = a;
        quantity = b;
        likeSoup = false;
    }
    
    public WuMingFen() {
        theMa = "酸辣";
        quantity = 2;
        likeSoup = true;
    }
    
    public void check() {
        String soup;
        if(likeSoup == true) {
            soup = "带";
        }else {
            soup = "不带";
        }
        System.out.println(theMa+"面\t"+quantity+"两\t"+soup+"汤");
    }
    
    public static void main(String[] args) {
        WuMingFen f1 = new WuMingFen("牛肉", 3, true);
        f1.check();
        WuMingFen f2 = new WuMingFen("牛肉", 2);
        f2.check();
        WuMingFen f3 = new WuMingFen();
        f3.check();
        
    }
}


第七题

/**
 * 定义一个网络用户类
 * 要处理的信息有用户ID、用户密码、email地址
 * 在建立类的实例时把以上三个信息都作为构造函数的参数输入
 * 其中用户ID和用户密码是必须的，缺省的email地址是用户ID加上字符串"@gameschool.com"
*/
package netUser;
public class Test {
    public static void main(String[] args) {
        User user1 = new User("Jacky","123456","1120259485@qq.com");
        User user2 = new User("xiaoli","11112");
        user1.showInfo();
        user2.showInfo();
    }
}

class User{
    private String userId;
    private String userPassWord;
    private String email;
    
    public User(String id,String pass,String email) {
        userId = id;
        userPassWord = pass;
        this.email = email;
    }
    
    public User(String id,String pass) {
        userId = id;
        userPassWord = pass;
        email = id+"@gameschool.com";
    }
    public void showInfo() {
        System.out.println(userId+"\t"+userPassWord+"\t"+email);
    }
}


第八题

/**
 *  编写Addition类
 * 该类中应包含一组实现两数相加运算的重载方法
 * 实现加法运算的方法应接受两个参数，即加数和被加数
 * 方法将两个参数进行加法运算后返回相加结果
 * 考虑可能针对不同的数据类型进行计算，重载方法
 * 包括整型、长整型、浮点型、双精度浮点型、还有字符串
 * 在main创建方法中Addition类的实例，分别调用重载方法测试其效果
 */
package addition;

public class Test {
    public static void main(String[] args) {
        Addition oper = new Addition();
        System.out.println(oper.add(1.1, 2));
        System.out.println(oper.add(555, 666));
        System.out.println(oper.add(123.3f, 13.3));
        System.out.println(oper.add(1,3));
        System.out.println(oper.add("asd", "qwe"));
    }
}

class Addition{
    public int add(int a,int b) {
        return a+b;
    }
    public long add(long a,long b) {
        return a+b;
    }
    public float add(float a,float b) {
        return a+b;
    }
    public double add(double a,double b) {
        return a+b;
    }
    public String add(String a,String b) {
        return a+b;
    }
}

第九题

/**
 * 建立一个汽车类
 * 包括轮胎个数、汽车颜色、车身重量等属性
 * 并通过不同的构造方法创建事例
 * 至少要求汽车能够加速、减速、停车
 * 再定义一个小汽车类继承汽车类
 * 并添加空调、CD等属性
 * 覆盖加速、减速、停车的方法
 */
package car;

public class Test {
    public static void main(String[] args) {
        Auto car1 = new Auto();
        car1.speedDown();
        car1.speedUp();
        car1.stop();
        
        Car car = new Car();
        car.speedDown();
        car.speedUp();
        car.stop();
    } 
}

class Auto {
    private int tyre;
    private String color;
    private double weight;
    
    public int getTyre() {
        return tyre;
    }

    public void setTyre(int tyre) {
        this.tyre = tyre;
    }

    public void setWeight(double weight) {
        this.weight = weight;
    }
    
    public String getColor() {
        return color;
    }

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

    public double getWeight() {
        return weight;
    }
    public Auto (int tyre,String color,double weight) {
        this.tyre = tyre;
        this.color = color;
        this.weight = weight;
    }
    
    public Auto (int tyre,String color) {
        this.tyre = tyre;
        this.color = color;
        this.weight = 100;
    }
    
    public Auto (int tyre) {
        this.tyre = tyre;
        this.color = "black";
        this.weight = 100;
    }
    
    public Auto () {
        this.tyre = 4;
        this.color = "black";
        this.weight = 100;
    }
    
    public void speedUp() {
        System.out.println("汽车加速了");
    }
    
    public void speedDown() {
        System.out.println("汽车减速了");
    }
    
    public void stop() {
        System.out.println("汽车停止了");
    }
}

class Car extends Auto{
    String airCondition;
    String cd;
    
    public Car() {
        airCondition = "奥克斯";
        cd = "甜蜜蜜";
    }
    public void speedUp() {
        System.out.println("空调是"+airCondition+"播放着"+cd+"的"+super.getTyre()+"轮的"+super.getColor()+"小汽车加速了");
    }
    
    public void speedDown() {
        System.out.println("空调是"+airCondition+"播放着"+cd+"的"+super.getTyre()+"轮的"+super.getColor()+"小汽车减速了");
    }
    
    public void stop() {
        System.out.println("空调是"+airCondition+"播放着"+cd+"的"+super.getTyre()+"轮的"+super.getColor()+"小汽车停止了");
    }
}

第十题
/**
 * 创建一个名称为StaticDemo的类
 * 并声明一个静态变量和一个普通变量
 * 对变量分别赋予10和5的初始值
 * 在main()方法中输出变量值。
 */

package OOP;

public class StaticDemo {
    static int a=10;
    int b=5;
    public static void main(String[] args) {
        System.out.println(a);
        System.out.println(new StaticDemo().b);
    }
}


第十一题
/**
 * 创建一个父类和子类
 * 父类有一个数据成员
 * 子类继承父类
 * 通过子类构造函数初始化并显示该数据成员的值。
 */
package OOP;

public class Father {
    int a;
    public Father(int a){
        this.a = a;
    }
}

class Sun extends Father {
    public Sun (int i) {
        super(i);
    }
    public void show(){
        System.out.println(super.a);
    }
}

public class TestFather {
    public static void main(String[] args) {
        Sun i = new Sun(156);
        i.show();
    }
}

第十二题
/**
 * 
 * 创建一个Vehicle2类并将它声明为抽象类
 * 在Vehicle2类中声明一个numberOfWheels方法，使它返回一个字符串值
 * 创建两个类Car2和Motorbike2继承于Vehicle2类并在这两个类中实现numberOfWheels方法
 * 在Car2类中应当显示“四轮车”
 * 而在Motorbike类中应当显示“双轮车”
 * 创建Car2和Motorbike2的实例并在控制台中显示信息
 */
package OOP;

public abstract class Vehicle2 {
    public abstract String numberOfWheels();
    
    public static void main(String[] args) {
        Vehicle2 car = new Car2();
        Vehicle2 bike = new Motorbike2();
        System.out.println(car.numberOfWheels());
        System.out.println(bike.numberOfWheels());
    }
}

class Car2 extends Vehicle2{
    public String numberOfWheels() {
        return "四轮车";
    }
}

class Motorbike2 extends Vehicle2{
    public String numberOfWheels() {
        return "双轮车";
    }
}



第十三题

/**
 * 创建一个名称为Vehicle的接口
 * 在接口中分别添加带有一个参数的方法start()和stop()
 * 在两个名称分别为Bike和Bus的类中实现Vehicle接口
 * 创建Bike和Bus对象并访问start()和stop()方法
 */
package OOP;

public class TestInterface {
    public static void main(String[] args) {
        Bike bike = new Bike();
        Bus bus = new Bus();
        bike.start(10);
        bike.stop(2);
        bus.start(50);
        bus.stop(3);
    }
}

interface Vehicle {
    void start(int a);
    void stop(int a);
}

class Bike implements Vehicle {
    
    public void start(int a) {
        System.out.println("我是自行车，我正在以"+a+"m/s的速度行驶");
    }
    
    public void stop(int a) {
        System.out.println("我是自行车，我停了"+a);
    }
}

class Bus implements Vehicle{
    public void start(int a) {
        System.out.println("我是大巴车，我正在以"+a+"m/s的速度行驶");
    }
    
    public void stop(int a) {
        System.out.println("我是大巴车，我停了"+a);
    }
}

第十四题
/**
 *
     * 设计一张抽象的门Door
     * 那么对于这张门来说就应该拥有所有门的共性：开门openDoor()和关门closeDoor()
     * 然后对门进行另外的功能设计：防盗theftProof()、防水waterProof()、防弹bulletProof()
     * 实例化一个拥有所有功能的门
    */

package OOP;

public class TestDoor {
    public static void main(String[] args) {
        DoorDemo nbDoor = new DoorDemo();
        nbDoor.openDoor();
        nbDoor.closeDoor();
        nbDoor.bulletProof();
        nbDoor.waterProof();
        nbDoor.theftProof();
    }
}

abstract class Door{
    public abstract void openDoor();
    public abstract void closeDoor();
}


interface Proof {
    void theftProof();
    void waterProof();
    void bulletProof();
}

class DoorDemo extends Door implements Proof{

    @Override
    public void theftProof() {
        System.out.println("防盗");
    }

    @Override
    public void waterProof() {
        System.out.println("防水");
    }

    @Override
    public void bulletProof() {
        System.out.println("防弹");
    }

    @Override
    public void openDoor() {
        System.out.println("关门");
    }

    @Override
    public void closeDoor() {
        System.out.println("开门");
    }
    
}

第十五题
/**
 * 设计一个纯净水生产线
 * 目前流程是从某个地方把水取出来，然后经过缓冲、过滤、加热、放糖等步骤
 */
package OOP;

public class WaterTest {
    public static void main(String[] args) {
        Factory nongfu = new PlaceWater();
        nongfu.getBuffer();
        nongfu.getFilter();
        nongfu.getHeating();
        nongfu.getSuger();
    }
}

class PlaceWater extends Factory{
    PlaceWater (){
        System.out.println(super.a);
    }
}

abstract class Factory implements Buffer,Filter,Heating,Suger{
    String a="来到工厂";

    @Override
    public void getSuger() {
        System.out.println("放糖");
    }

    @Override
    public void getHeating() {
        System.out.println("加热");
    }

    @Override
    public void getFilter() {
        System.out.println("过滤");
    }

    @Override
    public void getBuffer() {
        System.out.println("缓冲");
    }
}

interface Buffer{
    void getBuffer();
}

interface Filter{
    void getFilter();
}

interface Heating{
    void getHeating();
}

interface Suger{
    void getSuger();
}

第十六题
/**
 * 
     * 定义一个抽象的Role类
     * 有姓名、年龄、性别等成员变量
     * 要求尽可能隐藏所有变量(能够私有就私有,能够保护就不要公有)
     * 再通过GetXXX()和SetXXX()方法对各变量进行读写
     * 具有一个抽象的play()方法
     * 该方法不返回任何值
     * 同时至少定义两个构造方法
     * Role类中要体现出this的几种用法。
     * 从Role类派生出一个Employee类
     * 该类具有Role类的所有成员，构造方法除外
     * 并扩展salary成员变量
     * 同时增加一个静态成员变量“职工编号 ID ”
     * 同样要有至少两个构造方法
     * 要体现出this和super的几种用法
     * 还要求覆盖play()方法
     * 并提供一个final sing()方法
     * Manager类 继承Employee类
     * 有一个final成员变量vehicle
     * 创造Manager和Employee对象，并测试这些对象的方法
 */

package OOP;

public class TestRole {
    public static void main(String[] args) {
        Role em = new Employee("狗琛", "女", 18, 8000.1);
        Role ma = new Manager("宽宽", "男", 19, 123);
        em.play();
        ma.play();
                
    }
}

abstract class Role{
    private String name;
    private String gender;
    private int age;
    
    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;
    }
    
    abstract public void play();
    
    public Role() {
        this.name = "镔狗";
        this.gender = "男";
        this.age = 10;
    }
    public Role(String name) {
        this.name = name;
        this.gender = "女";
        this.age = 18;
    }
    public Role(String name,String gender,int age) {
        this.name = name;
        this.gender = gender;
        this.age = age;
    }
}

class Employee extends Role{
    double salary;
    static int id;
    @Override
     public void play() {
        System.out.println("我扮演员工的角色");
    }
    public Employee(String name,String gender,int age,double salary) {
        super.setName(name);
        super.setGender(gender);
        super.setAge(age);
        this.salary = salary;
    }
    
    public static int getId() {
        return id;
    }
    
    final public void sing() {
        System.out.println("sing方法被调用");
    }
}

class Manager extends Employee{
    
    public Manager(String name, String gender, int age, double salary) {
        super(name, gender, age, salary);
    }
    
    public void play() {
        System.out.println("我扮演管理者的角色");
    }
    final String vehicle = "商务管理车";
    
}

第十七题