第11章练习题（2）

目录

第一题

第二题

第三题

第四题

---

第一题

思路分析：
1.首先成员内部类是定义在方法或者代码块中
2.因为默认遵守的是就近原则，如果直接输出name，那么会访问的都是B类中的属性，我们访问外部类中的属性，就需要使用类名.this.属性名去访问

要求：

        内部类
        1.编一个类A，在类中定义局部内部类B，B中有一个私有常量name，有一个方法show)打
        印常量name。进行测试
        2.A中也定义一个私有的变量name，在show方法中打印测试

package idea.chapter11.homework;

public class Homework05 {
    public static void main(String[] args) {
        /*
        内部类
        1.编一个类A，在类中定义局部内部类B，B中有一个私有常量name，有一个方法show)打
        印常量name。进行测试
        2.A中也定义一个私有的变量name，在show方法中打印测试
         */

        A a = new A();
        a.hi();
    }
}
/*
思路分析：
1.首先成员内部类是定义在方法或者代码块中
2.因为默认遵守的是就近原则，如果直接输出name，那么会访问的都是B类中的属性，我们访问外部类中的属性，就需要使用类名.this.属性名去访问
 */

class A {

    //外部类的私有属性
    private String name = "tom";

    public void hi() {
        //局部内部类，定义在方法或者代码块中
        class B {
            private String name = "jack";

            public void show() {
                //因为默认遵守就近原则，所以这里访问到的就是内部类B中的name
                System.out.println(name);

                //此时在外部类中也有一个name属性，那么我们要去访问外部类中的并且名字和内部类中相同的属性是，我们需要这样访问
                System.out.println(A.this.name);//这里访问到的就是外部类中的属性
            }
        }

        B b = new B();
        b.show();
    }
    
}

第二题

思路分析：

1.vehicles是一个接口类型可以指向实现了Vehicles接口类的对象实例 因为Boat类和House类都实现了Vehicles接口，因此接口可以指向实现了该类的对象

2.懒汉式实现步骤

//步驟
//1.任然构造器私有化
//2.定义一个static静态属性对象
//3.提供一个public的static方法，可以返回一个Cat对象
//4.懒汉式，只有当用户使用getInstance时，才返回cat对象, 后面再次调用时，会返回上次创建的cat对象，从而保证单例

3.本题中还用到了单例设计模式中的懒汉式

Boat类

package idea.chapter11.homework.homework06;

public class Boat implements Vehicles{
    @Override
    public void work() {
        System.out.println("遇到河流使用船");
    }
}

Homework06类

package idea.chapter11.homework.homework06;

public class Homework06 {
    public static void main(String[] args) {
        /*
        1.有一个交通工具接口类Vehicles，有work方法
        2.有Horse类和Boat类分别实现Vehicles
        3.创建交通工具工厂类，有两个方法分别获得交通工具Horse和Boat
        4.有Person类，有name和Vehicles属性，在构造器中为两个属性赋值
        5.实例化Person对象“唐僧”，要求一般情况下用Horse作为交通工具，遇到大河时用Boat作为交通工具
         */

        Person tang = new Person("唐僧", new Horse());
        tang.common();
        tang.passRiver();
        tang.passRiver();
        tang.passRiver();
        tang.common();
    }
}

Horse类

package idea.chapter11.homework.homework06;

public class Horse implements Vehicles{
    @Override
    public void work() {
        System.out.println("一般情况下用马");
    }
}

Person类

package idea.chapter11.homework.homework06;

public class Person {
    private String name;
    private Vehicles vehicles;

    public Person(String name, Vehicles vehicles) {
        this.name = name;
        this.vehicles = vehicles;
    }

    public void passRiver() {
        if (!(vehicles instanceof Boat)) {// vehicles是一个接口类型可以指向实现了Vehicles接口类的对象实例 因为Boat类和House类都实现了Vehicles接口，因此接口可以指向实现了该类的对象
            vehicles = VehiclesFactory.getBoat();
        }
        vehicles.work();
    }

    public void common() {
        if (!(vehicles instanceof Horse)) {
            vehicles = VehiclesFactory.getHorse();
        }
        vehicles.work();
    }
}

VehiclesFactory类

package idea.chapter11.homework.homework06;

public class VehiclesFactory {
    //运用到单例设计模式——懒汉式，每次返回的会是同一个对象
    private static Horse horse=new Horse();

    //将构造器私有化，防止一个新的对象
    private VehiclesFactory() {
    }

    public static Horse getHorse(){
        return new Horse();
    }

    public static Boat getBoat(){
        return new Boat();
    }
}

Vehicles接口

package idea.chapter11.homework.homework06;

public interface Vehicles {
    public void work();
}

第三题

思路分析：
1.使用了局部内部类，把内部类定义在方法中，
2.在外部类中有一个属性是温度，并且是私有的属性，但是因为内部类最大的特点就是可以直接访问外部类中的私有属性，所以在内部类中写一个方法判断即可
3.因为外部其他类不可以直接访问内部类中的方法，因此我们要现在f1方法中创建好Air的对象，最后外部其他类创建外部类的对象，再去调用方法即可

第二种方法思路分析

1.第二种方法使用了成员内部类了的方法，我们知道内部类最大的特点就是可以直接访问外部类中的私有属性，所以我们只需要在内部中编写一个方法，判断即可
2.我们可以在外部类中定义一个方法，用于返回一个内部类中对象，这样在外部其他类去调用该方法的时候，就可以等到内部类的对象，在调用对应的方法即可

要求：

        内部类
        有一个Car1类，有属性temperature（温度），车内有Air（空调）类，有吹风的功能flowAir会监视车内的温度
        ，如果温度超过40度则吹冷气。如果温度低于0度则吹暖气，如果在这之间则关掉空调。
        实例化具有不同温度的Car对象，调用空调的flow方法，测试空调吹的风是否正确.

package idea.chapter11.homework;

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


        Car1 car1 = new Car1(41);
        car1.f1();
        Car1 car2 = new Car1(4);
        car2.f1();
        Car1 car3 = new Car1(-1);
        car3.f1();

    }
}

/*
思路分析：
1.使用了局部内部类，把内部类定义在方法中，
2.在外部类中有一个属性是温度，并且是私有的属性，但是因为内部类最大的特点就是可以直接访问外部类中的私有属性，所以在内部类中写一个方法判断即可
3.因为外部其他类不可以直接访问内部类中的方法，因此我们要现在f1方法中创建好Air的对象，最后外部其他类创建外部类的对象，再去调用方法即可
 */
class Car1 {
    private double temperature;

    public Car1(double temperature) {
        this.temperature = temperature;
    }

    public void f1() {
        class Air {
            public void flowAir() {
                if (temperature > 40) {
                    System.out.println("空调吹冷风");
                } else if (temperature < 0) {
                    System.out.println("空调吹暖风");
                } else {
                    System.out.println("关闭空调");
                }
            }
        }
        Air air = new Air();
        air.flowAir();
    }
}


//第二种方法  类里面包含一个类，通过写一个公共的方法返回Air对象
/*
思路分析：
1.第二种方法使用了成员内部类了的方法，我们知道内部类最大的特点就是可以直接访问外部类中的私有属性，所以我们只需要在内部中编写一个方法，判断即可
2.我们可以在外部类中定义一个方法，用于返回一个内部类中对象，这样在外部其他类去调用该方法的时候，就可以等到内部类的对象，在调用对应的方法即可
 */
//public class Homework07 {
//    public static void main(String[] args) {
//        Car_ car_ = new Car_(2);
//        car_.getAir().flowAir();
//    }
//}
//
//class Car_ {
//    private double temperature;
//
//    public Car_(double temperature) {
//        this.temperature = temperature;
//    }
//
//
//    class Air {
//        public void flowAir() {
//            if (temperature > 40) {
//                System.out.println("空调吹冷风");
//            } else if (temperature < 0) {
//                System.out.println("空调吹暖风");
//            } else {
//                System.out.println("关闭空调");
//            }
//        }
//    }
//
//    //提供一个公共的方法返回一个Air对象
//    public Air getAir() {
//        return new Air();
//    }
//}

第四题

思路分析：
1.因为Color是enum修饰的，所以他隐式的继承了Enum类，因为Java是单继承机制，所以不能在继承其他类，但是可以实现接口
2.使用enum关键字去定义属性，常量值要写在第一行，否则会报错
3.RED(255, 0, 0) 后面括号中的三个参数，对应的就是构造器中的值

要求：

        枚举类
        1.创建一个Color枚举类
        2.有RED,BLUE,BLACK,YELLOW GREEN这个五个枚举值/对象；
        3.Color有三个属性redValue,greenValue,blueValue,
        4.创建构造方法，参数包括这三个属性，
        5. 每个枚举值都要给这三个属性赋值，三个属性对应的值分别是
        6.red:255.0.0 blue:0.0.255  black:0.0.0   yellow:255,255.0 green:0,255,0
        7.定义接口，里面有方法show，要求Color实现该接口
        8.show方法中显示三属性的值
        9.将枚举对象在switch语句中匹配使用

小细节：enum修饰的类，会隐式的继承Enum类

package idea.chapter11.homework;

public class Homework08 {
    public static void main(String[] args) {
       /*
        枚举类
        1.创建一个Color枚举类
        2.有RED,BLUE,BLACK,YELLOW GREEN这个五个枚举值/对象；
        3.Color有三个属性redValue,greenValue,blueValue,
        4.创建构造方法，参数包括这三个属性，
        5. 每个枚举值都要给这三个属性赋值，三个属性对应的值分别是
        6.red:255.0.0 blue:0.0.255  black:0.0.0   yellow:255,255.0 green:0,255,0
        7.定义接口，里面有方法show，要求Color实现该接口
        8.show方法中显示三属性的值
        9.将枚举对象在switch语句中匹配使用
         */

        Color a = Color.BLACK;
        Color b = Color.RED;
        Color c = Color.YELLOW;
        Color d = Color.GREEN;
        switch (c) {
            case RED:
                System.out.println("匹配到红色");
                System.out.println(Color.RED);
                break;
            case BLUE:
                System.out.println("匹配到蓝色");
                System.out.println(Color.BLUE);
                break;
            case BLACK:
                System.out.println("匹配到黑色");
                System.out.println(Color.BLACK);
                break;
            case YELLOW:
                System.out.println("匹配到黄色");
                System.out.println(Color.YELLOW);
                break;
            case GREEN:
                System.out.println("匹配到绿色");
                System.out.println(Color.GREEN);
                break;
        }

    }
}

/*
思路分析：
1.因为Color是enum修饰的，所以他隐式的继承了Enum类，因为Java是单继承机制，所以不能在继承其他类，但是可以实现接口
2.使用enum关键字去定义属性，常量值要写在第一行，否则会报错
3.RED(255, 0, 0) 后面括号中的三个参数，对应的就是构造器中的值
 */
enum Color implements IA {
    RED(255, 0, 0), BLUE(0, 0, 255),
    BLACK(0, 0, 0), YELLOW(255, 255, 0), GREEN(0, 255, 0);

    private int redValue;
    private int greenValue;
    private int blueValue;

    Color(int redValue, int greenValue, int blueValue) {
        this.redValue = redValue;
        this.greenValue = greenValue;
        this.blueValue = blueValue;
    }

    @Override
    public void show() {

    }

    @Override
    public String toString() {
        return "Color{" +
                "redValue=" + redValue +
                ", greenValue=" + greenValue +
                ", blueValue=" + blueValue +
                '}';
    }
}

interface IA {
    public void show();
}