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

痛定思痛。 2023-09-27 12:07 82阅读 0赞

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

*  Exercise 1 创建猫类
 *  Exercise 2 创建昆虫类
 *  Exercise 3 餐馆点菜
 *  Exercise 4 老虎机
 *  Exercise 5 抽象的图形
 *  Exercise 6 判断3条给定长度的边能否构成三角形
 *  Exercise 7 USB/TypeC充电接口
 *  Exercise 8 景区游客人数

## 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;
        }
    }