1.写出下列代码的运行结果

public static void main(String []args){
Car c = new Car();
Car c1 = new Car(100);
System.out.println(c);
System.out.println(c1);
}
class Car{
double price = 10;
static String color = "white";
public String toString(){return price+"\t"+color;
}
public Car(){
this.price = 9;
this.color = "red";
}
public Car(double price){
this.price = price;
}
}

步骤分析：
创建对象调用无参构造器，将此对象的price 改成9，将静态变量color 改成red 。将此对象地址给到 c
创建另一个对象调用有参构造器，将此对象的price 改成100，将此对象地址给到 c1
输出这两个对象，自动调用Car类中重写的toString方法输出：
9 red
100 red

2.编程题

1. 在Forck类中声明私有的静态属性currentNum[int类型]，初始值为100000，作为衣服出厂的序列号初始值
2. 声明公有的静态方法getNexttNum，作为生成衣服序列号的方法，每调用一次将currentNum增加100，并返回
3. 在TestFork类的main方法，分两次调用getNexttNum方法，获取序列号并打印输出
4. 在Frock类中声明seriaNumber(序列号)属性，并提供对应的get方法
5. 在Frock类的构造器中，调用getNextNum方法为Frock对象获取序列号，赋给seralNum属性
6. 在TestFrock类的main方法中，分别创建三个Frock对象，并打印三个对象的序列号，验证是否按100递增

public class TestFrock {public static void main(String[] args) {Frock f1 = new Frock();Frock f2 = new Frock();Frock f3 = new Frock();System.out.println("f1的序列号为："+f1.getSeriaNumber()+"f2的序列号为："+f2.getSeriaNumber()+"f3的序列号为："+f3.getSeriaNumber());}
}
class Frock{private static int currentNum = 100000;private int seriaNumber;public Frock() {this.seriaNumber = getNextNumber();}public static int getNextNumber() {return currentNum+=100;}public int getSeriaNumber() {return seriaNumber;}
}

运行结果：
f1的序列号为：100100 f2的序列号为：100200 f3的序列号为：100300

3.编程题

1. 动物类Animal包含了抽象方法 shout()
2. Cat类继承了Animal，并实现方法shout，打印“猫会喵喵叫”
3. Dog类继承了Animal，并实现方法shout，打印"狗会汪汪叫"
4. 则测试类的main方法中实例化Cat和Dog类，且调用它们的shout方法

public class TestAnimal {public static void main(String[] args) {new Cat().shou();new Dog().shou();}
}
abstract class Animal{public abstract void shou();
}
class Cat extends Animal{@Overridepublic void shou() {System.out.println("小猫喵喵叫");}
}
class Dog extends Animal{@Overridepublic void shou() {System.out.println("小狗汪汪叫");}
}

4.编程题

1. 计算器接口又work方法，功能是运算，
2. 有一个手机类Cellphone，有一个方法testWork用于测试计算功能，调用计算机接口的work方法
3. 要求调用Cellphone对象的testWork方法，使用匿名内部类

public class testInterface {public static void main(String[] args) {new Cellphone().testWork(new Calculator() {//匿名内部类@Overridepublic double work(double a, double b) {return a+b;}},89,102);}
}
interface Calculator{public abstract double work(double a,double b);
}
class Cellphone  {public double testWork(Calculator calculator,double n1,double n2){double sum = calculator.work(n1,n2);System.out.println(sum);return sum;}
}

5.编程题

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

public class Test3 {public static void main(String[] args) {new A().newB();}
}
class A{private String name = "A的名字";public void newB(){class B{private String name = "B的名字";public void show(){System.out.println(name+A.this.name);}}new B().show();}
}

6.编程题

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

public class test3 {//测试运行类public static void main(String[] args) {Person tang = new Person("唐僧",Factory.getHorse());tang.normal();tang.river();tang.normal();tang.normal();}
}
interface Vehicles{//交通工具接口void work();
}
class Horse implements Vehicles{//马类@Overridepublic void work() {System.out.println("正常情况，骑马前进");}
}
class Boat implements Vehicles{//船类@Overridepublic  void work() {System.out.println("遇到大河了，使用船过河");}
}
class Factory{//交通工具工厂类public static Horse getHorse(){//获取马的方法return new Horse();}public static Boat getBoat(){//获取船的方法return new Boat();}
}
class Person{private String name;private Vehicles vehicles;public Person(String name, Vehicles vehicles) {this.name = name;this.vehicles = vehicles;}public void normal(){//正常情况if (vehicles instanceof Horse){vehicles.work();}else{vehicles = Factory.getHorse();vehicles.work();}}public void river(){//遇到河了if (vehicles instanceof Boat){vehicles.work();}else{vehicles = Factory.getBoat();vehicles.work();}}
}

这里直接已实现效果为目的了，如果要进行优化，符合实际逻辑。可以将马设计成枚举类对象或者使用单例设计模式，毕竟唐僧不是一遇到河就把马龙马丢掉的。

7.编程题

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

public class test4 {public static void main(String[] args) {//外部其他类调用成员内部类的方式1，外部类对象.成员内部类对象.方法名System.out.println(new Car(-12.3).new Air().flow());System.out.println(new Car(38).new Air().flow());System.out.println(new Car(45).new Air().flow());}
}
class Car{double temperature;public Car(double temperature) {this.temperature = temperature;}class Air{public String flow(){if (temperature < 0){return "怕你被冻死，给你吹暖气";}else if(temperature >=0 && temperature <=40){return "温度正常，空调已关闭";}else{return "怕你被热死,给你吹冷气";}}}
}

8.编程题

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

public class test5 {public static void main(String[] args) {Color color = Color.YELLOW;switch (color){case RED:color.show();break;case BLUE:color.show();break;case GREEN:color.show();break;case BALCK:color.show();break;case YELLOW:color.show();break;default:System.out.println("为查找到");}}
}
enum Color implements inMy{RED(255,0,0),BLUE(0,0,255),BALCK(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() {System.out.println("属性值为："+redValue+","+greenValue+","+blueValue);}
}
interface inMy{void show();
}