练习作业P1

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;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

步骤分析：
创建对象调用无参构造器，将此对象的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;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

运行结果：
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{
    @Override
    public void shou() {
        System.out.println("小猫喵喵叫");
    }
}
class Dog extends Animal{
    @Override
    public void shou() {
        System.out.println("小狗汪汪叫");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

4.编程题

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

public class testInterface {
    public static void main(String[] args) {
    new Cellphone().testWork(new Calculator() {//匿名内部类
        @Override
        public 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;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

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();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

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{//马类
    @Override
    public void work() {
        System.out.println("正常情况，骑马前进");
    }
}
class Boat implements Vehicles{//船类
    @Override
    public  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();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

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

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 "怕你被热死,给你吹冷气";
            }
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

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

    @Override
    public void show() {
        System.out.println("属性值为："+redValue+","+greenValue+","+blueValue);
    }
}
interface inMy{
    void show();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45