Java从入门到精通章节练习题——第七章

Exercise 1 创建猫类

package chapter7;

import java.awt.*;

/**
 * 创建猫类
 */

class Cat {
    
    
    private String name;
    private int age;
    private double weight;
    private Color color;


    public Cat(String name, int age, double weight, Color color) {
    
    
        this.name = name;
        this.age = age;
        this.weight = weight;
        this.color = color;
    }


    @Override
    public String toString() {
    
    
        return "名字：" + name + "\n" + "年龄：" + age + "\n" +
                "重量：" + weight + "\n" + "颜色：" + color;
    }
}

public class Exercise1 {
    
    
    public static void main(String[] args) {
    
    
        Cat cat1 = new Cat("Java", 12, 21, new Color(0, 0, 0));
        Cat cat2 = new Cat("C++", 12, 21, new Color(255, 255, 255));
        System.out.print("猫咪1号：");
        System.out.println(cat1);
        System.out.println();
        System.out.print("猫咪2号：");
        System.out.println(cat2);
    }
}

Exercise 2 创建昆虫类

package chapter7;

/**
 * 创建昆虫类
 */

//飞行接口
interface Flyable {
    
    
    public abstract void fly();
}

//抽象昆虫类
abstract class Insect {
    
    
    int legs;
    
    public Insect(int legs) {
    
    
        this.legs = legs;
    }

    abstract public void reproduce();
}

//苍蝇类
class Fly extends Insect implements Flyable{
    
    


    public Fly(int legs) {
    
    
        super(legs);
    }

    @Override
    public void fly() {
    
    
        System.out.println("苍蝇可以在空中飞行。");
    }

    @Override
    public void reproduce() {
    
    
        System.out.println("苍蝇的繁殖方式是产卵。");
    }

    @Override
    public String toString() {
    
    
        return "苍蝇有" + legs + "条腿。";
    }
}

public class Exercise2 {
    
    
    public static void main(String[] args) {
    
    
        Fly fly = new Fly(6);
        System.out.println(fly);
        fly.fly();
        fly.reproduce();
    }
}

Exercise 3 餐馆点菜

package chapter7;

/**
 * 餐馆点菜
 */

class Customer {
    
    

   public void order() {
    
    //点菜方法

    }
}

class Teacher extends Customer {
    
    

    @Override
    public void order() {
    
    
        System.out.println("老师点了'香辣肉丝'");
    }
}

class Student extends Customer {
    
    

    @Override
    public void order() {
    
    
        System.out.println("学生点了'火腿炒面'");
    }
}

class Doctor extends Customer {
    
    

    @Override
    public void order() {
    
    
        System.out.println("医生点了'麻辣香锅'");
    }
}

public class Exercise3 {
    
    
    public static void main(String[] args) {
    
    
        Customer customer1 = new Teacher();//像上转型
        Teacher teacher = (Teacher) customer1;//像下转型，转型前：父类对象要先引用子类对象
        teacher.order();
        Customer customer2 = new Doctor();//像上转型
        Doctor doctor = (Doctor) customer2;//像下转型，转型前：父类对象要先引用子类对象
        doctor.order();
        Customer customer3 = new Student();//像上转型
        Student student = (Student) customer3;//像下转型，转型前：父类对象要先引用子类对象
        student.order();
    }
}

Exercise 4 老虎机

package chapter7;

import java.util.Random;
import java.util.Scanner;

public class Exercise4 {
    
    
    public static void main(String[] args) {
    
    
        //控制老虎机退出
        boolean loop = true;
        //创建老虎机内容
        String[] arr = {
    
    "红", "黄", "蓝"};

        //循环摇动老虎机抽奖
        while (loop) {
    
    
            Scanner scanner = new Scanner(System.in);
            System.out.println("输入任意数字键(0退出)开始。。。。");
            int i = scanner.nextInt();
            if (i == 0) {
    
    
                loop = false;
            }
            Random random = new Random();
            int i1 = random.nextInt(3);//返回[0，2]之间的随机整数
            int i2 = random.nextInt(3);
            int i3 = random.nextInt(3);
            System.out.print(arr[i1] + " " + arr[i2] + " " + arr[i3]);
        }
    }
}

Exercise 5 抽象的图形

package org.hj.chapter7;

public class AbstractGraphics {
    
    

    /**
     * 综合练习5：抽象的图形　创建一个抽象的图形类，图形类中有一个表示“颜色”的属性、
     * 一个有参构造方法和一个抽象的“获得面积”的方法。
     * 让长方形类继承图形类，先在长方形类的构造方法中调用图形类的构造方法，再在长方形类中声明表示“长”和“宽”的两个属性，
     * 接着在长方形类中重写图形类中的抽象方法。控制台输出如下内容：
     * 长为6.0、宽为2.0的黄色长方形的面积是12.0
     */

    public static void main(String[] args) {
    
    

        //创建长方形
        Rectangle blueRectangle = new Rectangle("黄色", 6.0, 2.0);

        //调用获取面积方法
        blueRectangle.getArea();
    }
}

abstract class Graphics {
    
    

    //颜色
    public String colour;

    //有参构造器
    public Graphics(String colour) {
    
    
        this.colour = colour;
    }

    //计算面积的抽象方法
    public abstract void getArea();
}

class Rectangle extends Graphics {
    
    

    //长
    private Double length;

    //宽
    private Double width;

    //长方形类的有参构造器
    public Rectangle(String colour, Double length, Double width) {
    
    
        super(colour);
        this.length = length;
        this.width = width;
    }

    /**
     * 重写抽象类中计算面积方法
     */
    @Override
    public void getArea() {
    
    

        /**
         * 面积
         */
        Double area;

        //计算面积公式
        area = length * width;

        //控制台输出
        System.out.println("长为" + length + "、" + "宽为" + width + "的" + colour + "长方形的面积是" + area);
    }
}

Exercise 6 判断3条给定长度的边能否构成三角形

package org.hj.chapter7;

public class DetermineTriangle {
    
    

    /**
     * 综合练习6：判断3条给定长度的边能否构成三角形　创建一个抽象的图形类，图形类中有一个抽象的“计算周长”的方法。
     * 让三角形类继承图形类，先在三角形类中声明三角形的3条边，
     * 再判断这3条边能否构成三角形，接着重写图形类中的抽象方法。
     * 现有长为3、4、5的3条边和长为1、4、5的3条边，
     * 控制台分别输出这两组边能否构成三角形。如果能，计算三角形的周长。
     * 控制台输出如下内容：
     * 长为3.0、4.0、5.0的3条边能构成三角形，这个三角形的周长为12.0
     * 长为1.0、4.0、5.0的3条边不能构成三角形，因为三角形两边之和必须大于第三边
     */

    public static void main(String[] args) {
    
    
        Triangle triangle1 = new Triangle(3.0, 4.0, 5.0);
        triangle1.calculatePerimeter();
        Triangle triangle2 = new Triangle(1.0, 4.0, 5.0);
        triangle2.calculatePerimeter();
    }

}

abstract class Graph {
    
    

    /**
     * 计算周长的抽象方法
     */
    public abstract void calculatePerimeter();

}

class Triangle extends Graph {
    
    

    private Double edge1;

    private Double edge2;

    private Double edge3;

    public Triangle(Double edge1, Double edge2, Double edge3) {
    
    
        this.edge1 = edge1;
        this.edge2 = edge2;
        this.edge3 = edge3;
    }

    @Override
    public void calculatePerimeter() {
    
    

        //先判断边长能否构成三角形
        if (!(edge1 + edge2 > edge3 && edge1 + edge3 > edge2 && edge2 + edge3 > edge1)) {
    
    
            System.out.println("长为" + edge1 + "、" + edge2 + "、" + edge3 + "的3条边不能构成三角形，因为三角形两边之和必须大于第三边");
            return;
        }

        //能构成三角形则计算周长
        double perimeter;
        perimeter = edge1 + edge2 + edge3;

        System.out.println("长为" + edge1 + "、" + edge2 + "、" + edge3 + "的3条边能构成三角形，这个三角形的周长为" + perimeter);

    }
}

Exercise 7 USB/TypeC充电接口

package org.hj.chapter7;

public class USBTypeC {
    
    

    /**
     * 综合练习7：USB/TypeC充电接口　首先，创建一个表示USB充电的接口USBRechargeable，
     * 接口中有一个表示充电的抽象方法charge()。然后，
     * 创建一个表示TypeC充电的接口TypeCRechargeable，
     * 接口中也有一个表示充电的抽象方法charge()。接着，创建一个汽车类Car，
     * 使之同时实现接口USBRechargeable和接口TypeCechargeable。最
     * 后，创建测试类Test，并在控制台上输出“汽车上的USB和TypeC接口都能用于给手机充电”。
     */

    public static void main(String[] args) {
    
    
        Car car = new Car();
        car.charge();
    }
}

interface USBRechargeable {
    
    

    void charge();
}

interface TypeCRechargeable {
    
    

    void charge();
}

class Car implements USBRechargeable,TypeCRechargeable {
    
    

    @Override
    public void charge() {
    
    
        System.out.println("汽车上的USB和TypeC接口都能用于给手机充电");
    }
}

Exercise 8 景区游客人数

package org.hj.chapter7;

public class ScenicSpotPeopleNum {
    
    

    /**
     * 综合练习8：景区游客人数　创建3个接口，分别表示可增加的接口Addable，
     * 可减少的接口Reducible和可变化的接口Changeable，
     * 其中接口Changeable同时继承接口Addable和接口Reducible。
     * 接口Addable中有一个表示增加的抽象方法add()，
     * 接口Reducible中有一个表示减少的抽象方法reduce()，
     * 接口Changeable中有一个表示均匀变化30个单位的常量UNITS。
     * 创建一个人数类Number，使之实现接口Changeable。
     * 编写一个程序模拟如下场景：某景区只允许满载30人的大巴车进出，
     * 当天自景区开放起，已驶入景区的大巴车有7辆，驶出景区的大巴车有4辆，计算景区里还有多少人？
     */

    public static void main(String[] args) {
    
    

        int addCarNum = 7;
        int redCarNum = 4;

        Number number = new Number(addCarNum, redCarNum);
        for (int i = 0; i < addCarNum; i++) {
    
    
            number.add();
        }
        for (int i = 0; i < redCarNum; i++) {
    
    
            number.reduce();
        }
        System.out.println("景区里还有 " + Number.PeopleNum + " 人");
    }

}

interface Addable {
    
    

    abstract void add();
}

interface Reducible {
    
    

    abstract void reduce();
}

interface Changeable extends Addable, Reducible {
    
    

    public static final int UNITS = 30;
}

class Number implements Changeable {
    
    

    //增加车数
    int addCarNum;
    //减少车数
    int redCarNum;
    //剩余人数
    static int PeopleNum;

    public Number(int addCarNum, int redCarNum) {
    
    
        this.addCarNum = addCarNum;
        this.redCarNum = redCarNum;
    }

    @Override
    public void add() {
    
    
        //调用一次方法增加一辆车人，即 30 人
        PeopleNum += UNITS;
    }

    @Override
    public void reduce() {
    
    
        //调用一次方法减少一辆车人，即 30 人
        PeopleNum -= UNITS;
    }
}