目录
第一题
思路分析： 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();
}
5721
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
