第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中的nameSystem.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{@Overridepublic 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类分别实现Vehicles3.创建交通工具工厂类，有两个方法分别获得交通工具Horse和Boat4.有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{@Overridepublic 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,07.定义接口，里面有方法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;}@Overridepublic void show() {}@Overridepublic String toString() {return "Color{" +"redValue=" + redValue +", greenValue=" + greenValue +", blueValue=" + blueValue +'}';}
}interface IA {public void show();
}
