封装和继承作业（java）（二）

继承的编程题和可选题

五、编程题

1、编写应用程序，创建类的对象，分别设置圆的半径、圆柱体的高，计算并分别显示圆半径、圆面积、圆周长，圆柱体的体积。（7分）
　　提示:（1）编写一个圆类Circle，该类拥有：
　　1)       一个成员变量，radius（私有，浮点型）;//存放圆的半径；
　　2)       两个构造方法
　　Circle（）              //将半径设为0
　　Circle（double  r ）    //创建Circle对象时将半径初始化为r
　　3)       三个成员方法
　　double getArea（）      //获取圆的面积
　　double getPerimeter（）  //获取圆的周长
　　void show（）           //将圆的关径、周长、面积输出到屏幕
                  （2） 编写一个圆柱体类Cylinder，它继承于上面的Circle类。还拥有：
　　1)       一个成员变量，double hight  （私有，浮点型）;  //圆柱体的高；
　　2)       构造方法
　　//创建Cylinder对象时将半径初始化为r,高度初始化为h
　　Cylinder（double r,double h）
　　3)       成员方法
　　double getVolume（）            //获取圆柱体的体积
　　void showVolume（）             //将圆柱体的体积输出到屏幕

class Circle {
    double radius;

    // 无参构造器
    public Circle() {
        this.radius = 0;
    }

    // 有参构造器
    public Circle(double r) {
        this.radius = r;
    }

    //获取圆的面积
    public double getArea() {
        double s = Math.PI * this.radius * this.radius;
        return s;
    }

    //获取圆的周长
    public double getPerimeter() {
        double c = 2 * Math.PI * this.radius;
        return c;
    }

    //将圆的半径、周长、面积输出到屏幕
    public void show() {
        System.out.println("圆的半径是:" + this.radius);
        System.out.print("圆的周长是：");
        System.out.printf("%.2f", getPerimeter());
        System.out.print("\n圆的面积是：");
        System.out.printf("%.2f", getArea());
    }
}

 class Cylinder extends Circle {
    double hight;// 圆柱体的高

    public Cylinder(double r, double h) {
        super(r);
        this.hight = h;
    }

    // 获取圆柱体的体积
    public double getVolume() {
        double s = super.getArea();
        double v = s * this.hight;
        return v;
    }

    //将圆柱体的体积输出到屏幕
    public void showVolume() {
        System.out.print("\n圆柱的体积是：");
        System.out.printf("%.2f", getVolume());
    }
}

public class Test1 {
    public static void main(String[] args) {
        Cylinder c = new Cylinder(3, 6);
        Circle ci = new Circle(5);
        ci.show();
        c.showVolume();
    }
}

2、请使用面向对象的思想，设计自定义类，描述出租车和家用轿车的信息。
设定
1)出租车类:
属性包括：车型，车牌，所属出租公司；方法包括：启动，停止
2)家用轿车类：
属性包括：车型，车牌，车主姓名；方法包括：启动，停止
要求
1)分析出租车和家用轿车的公共成员，提取出父类—汽车类
2)利用继承机制，实现出租车类和家用轿车类
3)编写测试类，分别测试汽车类，出租车类和家用轿车类对象的相关方法
4)定义名为car的包存放汽车类，出租车类，家用轿车类和测试类

class Car { //父类-->汽车类
    //设置属性的私有访问权限
    private String type; //车型
    private String carNum; //车牌

    //通过公有的get,set方法实现对属性的访问
    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public String getCarNum() {
        return carNum;
    }

    public void setCarNum(String carNum) {
        this.carNum = carNum;
    }

    //构造器
    public Car() {
        super();
    }

    public Car(String type, String carNum) {
        super();
        this.type = type;
        this.carNum = carNum;
    }

    //启动的方法
    public void start() {
        System.out.println("我是车,我启动");
    }

    //停止的方法
    public void stop() {
        System.out.println("我是车,我停止");
    }

}


class Taxi extends Car { //子类-->出租车类
    //设置属性的私有访问权限
    private String company; //所属出租公司

    //通过公有的get,set方法实现对属性的访问
    public String getCompany() {
        return company;
    }

    public void setCompany(String company) {
        this.company = company;
    }

    //构造器
    public Taxi() {
        super();
    }

    public Taxi(String type, String carNum, String company) {
        super(type, carNum);
        this.company = company;
    }

    //启动的方法-->方法重写
    public void start() {
        System.out.println("乘客您好\n我是" + company + "的,我的车牌是" + super.getCarNum() + ",您要去哪里?");
    }

    //停止的方法-->方法重写
    public void stop() {
        System.out.println("目的地已经到了,请您付费下车,欢迎再次乘坐");
    }

}


class OwnCar extends Car { // 子类-->家用轿车类
    // 设置属性的私有访问权限
    private String name; // 车主姓名

    // 通过公有的get,set方法实现对属性的访问
    public String getName() {
        return name;
    }

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

    // 构造器
    public OwnCar() {
        super();
    }

    public OwnCar(String type, String carNum, String name) {
        super(type, carNum);
        this.name = name;
    }

    // 启动的方法-->方法重写
    public void start() {
        System.out.println("我是" + name + ",我的汽车我做主");
    }

    // 停止的方法-->方法重写
    public void stop() {
        System.out.println("目的地到了,我们去玩吧");
    }

}

public class Test2 { //测试类
    public static void main(String[] args) {
        Car c = new Car(); //创建父类对象
        c.start(); //调用方法
        c.stop(); //调用方法
        System.out.println("==========================================");

        OwnCar oc = new OwnCar("", "", "武大郎"); //创建子类对象
        oc.start(); //调用方法
        oc.stop(); //调用方法
        System.out.println("==========================================");

        Taxi t = new Taxi("", "京B123", "景顺出租车公司");  //创建子类对象
        t.start(); //调用方法
        t.stop(); //调用方法

    }
}

3、公司要开发新游戏，请用面向对象的思想，设计游戏中的蛇怪和蜈蚣精
　　设定
　　1)       蛇怪类:
　　属性包括：怪物名字，生命值，攻击力
　　方法包括：攻击，移动（曲线移动），补血（当生命值<10时，可以补加20生命值）
　　2)       蜈蚣精类：
　　属性包括：怪物名字，生命值，攻击力
　　方法包括：攻击，移动（飞行移动）
　　要求
　　1)       分析蛇怪和蜈蚣精的公共成员，提取出父类—怪物类
　　2)       利用继承机制，实现蛇怪类和蜈蚣精类
　　3)       攻击方法，描述攻击状态。内容包括怪物名字，生命值，攻击力
　　4)       编写测试类，分别测试蛇怪和蜈蚣精的对象及相关方法
　　5)       定义名为mon的包存怪物类，蛇怪类，蜈蚣精类和测试类

class Monster {
    String name;
    int healthpoint;// 生命值
    int Attack;// 攻击力

    public String getName() {
        return name;
    }

    public int getHealthpoint() {
        return healthpoint;
    }

    public int getAttack() {
        return Attack;
    }

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

    public void setHealthpoint(int healthpoint) {
        this.healthpoint = healthpoint;
    }

    public void setAttack(int attack) {
        this.Attack = attack;
    }

    //攻击
    public void attack() {
        System.out.println("怪物" + getName() + "展开攻击");
        System.out.println("当前的生命值是：" + getHealthpoint());
        System.out.println("攻击力是：" + getAttack());
    }

    //移动
    public void move() {
    }
    
}

class Snake extends Monster {
    //补血（当生命值<10时，可以补加20生命值）
    public void addHP() {
        if (getHealthpoint() < 10) {//当生命值<10时，可以补加20生命值
            healthpoint = getHealthpoint() + 20;
            System.out.println("施展大蛇补血术。。。。。当前的生命值是：" + healthpoint);
        }

    }

    //方法重写-重写父类move();
    public void move() {
        System.out.println("我是蛇怪，我走S行线路！");
    }
    
}

class Centipede extends Monster {
    // 方法重写-重写父类move();
    public void move() {
        System.out.println("我是蜈蚣精，我御风飞行！");
    }
}

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

        // 创建蛇对象
        Snake s = new Snake();
        s.setName("金蛇怪");
        s.setHealthpoint(1);
        s.addHP();
        s.setAttack(100);
        s.attack();
        s.move();
        // 创建蜈蚣对象
        System.out.println();
        Centipede ce = new Centipede();
        ce.setName("紫衣蜈蚣");
        ce.setHealthpoint(30);
        ce.setAttack(70);
        ce.attack();
        ce.move();
    }
}

六、可选题

1、请用面向对象的思想，设计自定义类描述演员和运动员的信息
　　设定
　　1)       演员类:
　　属性包括：姓名，年龄，性别，毕业院校，代表作
　　方法包括：自我介绍
　　2)       运动员类：
　　属性包括：姓名，年龄，性别，运动项目，历史最好成绩
　　方法包括：自我介始
　　要求
　　3)       分析演员和运动员的公共成员，提取出父类—人类
　　4)       利用继承机制，实现演员类和运动员类
　　5)       编写测试类，分别测试人类，演员类和运动员类对象及相关方法
　　6)       定义名为act的包存人类，演员类，运动员类和测试类

class People {
    private String name;
    private int age;
    private String sex;

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public String getSex() {
        return sex;
    }

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

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

    public void setSex(String sex) {
        this.sex = sex;
    }

    //公共方法-自我介绍
    public void introduce() {
        System.out.println("大家好！我是：" + getName());
        System.out.println("今年" + getAge() + "岁");
        System.out.println("我是一个" + getSex() + "生");
    }
}

class Sportsman extends People {
    private String project;
    private String grade;

    public String getProject() {
        return project;
    }

    public String getGrade() {
        return grade;
    }

    public void setProject(String project) {
        this.project = project;
    }

    public void setGrade(String grade) {
        this.grade = grade;
    }

    public void title() {
        System.out.println("我就是一个普通的小老百姓");
        System.out.println("=====================");
    }

    //运动员介绍-运动项目，历史最好成绩
    public void info() {
        System.out.println("我最擅长的运动项目是：" + getProject() + "短跑");
        System.out.println("历史最好的成绩是：" + getGrade());
    }

}

class Actor extends People {
    private String graduate;
    private String representative;

    public String getGraduate() {
        return graduate;
    }

    public String getRepresentative() {
        return representative;
    }

    public void setGraduate(String graduate) {
        this.graduate = graduate;
    }

    public void setRepresentative(String representative) {
        this.representative = representative;
    }

    //演员介绍-毕业院校，代表作
    public void info() {
        System.out.println("毕业院校：" + getGraduate());
        System.out.println("代表作：" + getRepresentative());
    }

    public void title1() {
        System.out.println("=====================");
    }
}

public class Test4 {
    public static void main(String[] args) {
        //运动员对象
        Sportsman s = new Sportsman();
        s.setName("刘小翔");
        s.setAge(23);
        s.setSex("男");
        s.setProject("200");
        s.setGrade("22秒30");
        s.title();
        s.introduce();
        s.info();

        //演员对象
        Actor a = new Actor();
        a.setName("章依");
        a.setAge(27);
        a.setSex("女");
        a.setGraduate("北京电影学院");
        a.setRepresentative("《寄往天国的家书》");
        a.title1();
        a.introduce();
        a.info();
    }