面向对象(高级)章节练习题

//练习题1:输出:9.0	red
//          100.0	red
public class hello {
    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;
    }
}
//练习题2：在Frock类中声明私有的静态属性currentNum[int类型]，初始值为100000,
// 作为衣服出厂的序列号起始值。
// 声明公有的静态方法getNextNum,作为生成上衣唯一-序列号的方法。每调用一次，
// 将currentNum增加100,并作为返回值。
//在TestFrock类的main方法中，分两次调用getNextNum方法，获取序列号并打印输出。
//在Frock类中声明serialNumber(序列号)属性，并提供对应的get方法;
//在Frock类的构造器中，通过调用getNextNum方法为Frock对象获取唯-序列号，
// 赋给serialNumber属性。
//在TestFrock类的main方法中，分别创建三个Frock对象，并打印三个对象的序列号，验
//证是否为按100递增。
public class hello {
    public static void main(String[] args) {
        System.out.println(Frock.getNextNum());
        System.out.println(Frock.getNextNum());
        Frock f1 = new Frock();
        Frock f2= new Frock();
        Frock f3= new Frock();
    System.out.println(f1.getSerialNumber()+"\t"+f2.getSerialNumber()+"\t"+f3.getSerialNumber());
    }
}
class Frock {
    private static int currentNum= 100000;
    private int serialNumber;
    public int getSerialNumber() {
        return serialNumber;
    }
    public Frock() {
        this.serialNumber = getNextNum();
    }

    public static int getNextNum(){
        currentNum+=100;
        return currentNum;
    }
}
//练习题3：动物类Animal包含了抽象方法shout();
//Cat类继承了Animal,并实现方法shout,打印"猫会喵喵叫"
//Dog类继承了'Animal,并实现方法shout,打印"狗会汪汪E叫"
//在测试类中实例化对象Animal cat =new Cat(),并调用cat的shout方法
//在测试类中实例化对象Animal dog=new Dog(,并调用dog的shout方法
public class hello {
    public static void main(String[] args) {
        Animal cat =new Cat();
        Animal dog=new Dog();
        cat.shout();
        dog.shout();
    }
}
abstract class Animal {
    public abstract void shout();
}
class Cat extends Animal{
    @Override
    public void shout() {
        System.out.println("小猫喵喵叫......");
    }
}
class Dog extends Animal{
    @Override
    public void shout() {
        System.out.println("小狗汪汪叫......");
    }
}
//练习题4：计算器接口具有work方法，功能是运算，有一个手机类Cellphone,
// 定义方法testWork.测试计算功能，调用计算接口的work方法，
//要求调用CellPhone对象的testWork方法，使用上匿名内部类
public class hello {
    public static void main(String[] args) {
        Cellphone.testWork(new caculate() {
            @Override
            public void work() {
                System.out.println("计算器在计算......");
            }
        });
    }
}
interface caculate{
    public void work();
}
class Cellphone{
    public static void testWork(caculate c){
        c.work();
    }
}
//练习题5：1. 编一个类A,在类中定义局部内部类B，B中有一个私有常量name,有一个方法show()打
//印常量name。进行测试
//2. 进阶: A中也定义- -个私有的变量name,在show方法中打印测试计算器接口具有work方法，
public class hello {
    public static void main(String[] args) {
        A a = new A();
        a.test();
    }
}
class A{
    private String name="lalal";
    public void test() {
        class B {
            private String name = "hhh";

            public void show() {
                System.out.println(name);
                System.out.println(A.this.name);
            }
        }
        B b = new B();
        b.show();
    }
}
//练习题6：有一个交通工具接口类Vehicles,有work接口有Horse类和Boat类
// 分别实现Vehicles
//创建交通工具工厂类，有两个方法分别获得交通工具Horse和Boat
//有Person类，有name和Vehicles属性，在构造器中为两个属性赋值
//实例化Person对象"唐僧”,要求一般情况下用Horse作为交通工具遇到大河时用Boat作为交通工具
public class hello {
    public static void main(String[] args) {
    }
}
interface Vehicles{
    public 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 VehiclesFactory {
    public static Horse horse=new Horse();
    //创建交通工具工厂类，有两个方法分别获得交通工具Horse和Boat
    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 String getName() { return name; }
    public void setVehicles(Vehicles vehicles) { this.vehicles = vehicles; }
    public void passRiver() {
        if(vehicles instanceof Boat) {
            //先得到船
            Boat boat = VehiclesFactory.getBoat();
            boat.work();
        }else{
            vehicles.work();
        }
    }
    public void common() {
        if (vehicles instanceof Horse) {
            //得到马儿
            Horse horse = VehiclesFactory.getHorse();
            horse.work();
        }else{
            vehicles.work();
        }
    }
}
//练习题7：有一个Car类，有属性temperature (温度) ,车内有Air (空调)类，有吹风的功能flow,
//Air会监视车内的温度，如果温度超过40度则吹冷气。如果温度低于0度则吹暖气，如果在这之
//间则关掉空调。实例化具有不同温度的Car对象，调用空调的flow方法，测试空调吹的风是否
//正确.
public class hello {
    public static void main(String[] args) {
    }
}
interface Vehicles{
    public void work();
}
class Car{
    private double temperture;
    public double Air(){
        return temperture;
    }
    public void flow(){
        if(Air()>40){
            System.out.println("开始吹热风......");
        }else{
            System.out.println("开始吹冷风......");
        }
    }
}
//练习题6：创建一个Color枚举类
//有RED,BLUE,BLACK,YELLOW,GREEN这个五个枚举值/对象;
//Color有三个属性redValue, greenValue, blueValue,
//创建构造方法，参数包括这三个属性，
//每个枚举值都要给这三个属性赋值，三个属性对应的值分别是
//red: 255,0,0 blue:0,0,255 black:0,0,0 yellow:255,255,0 green:0,255,0
//定义接口，里面有方法show,要求Color实现该接口
//show方法中显示三属性的值
//将枚举对象在switch语句中匹配使用
public class hello {
    public static void main(String[] args) {
        Color color=Color.GREEN;
        switch (color){
            case GREEN:
                System.out.println("匹配到绿色......");
            case RED:
                System.out.println("匹配到红色......");
            case BLACK:
                System.out.println("匹配到黑色......");
            case BLUE:
                System.out.println("匹配到蓝色......");
            case YELLOW:
                System.out.println("匹配到黄色......");
        }
    }
}
interface showvalue{
    public void show();
}
enum Color implements showvalue{
    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;
    private Color(int redvalue, int greenvalue, int bluevalue) {
        this.redvalue = redvalue;
        this.greenvalue = greenvalue;
        this.bluevalue = bluevalue;
    }
    @Override
    public void show() {
        System.out.println(redvalue+"\t"+greenvalue+"\t"+bluevalue);
    }
}