上杉丶零
上杉丶零

面向对象练习题

package leif.tests;

import java.util.Calendar;
import java.util.Scanner;

import org.junit.Test;

public class OOPExercises {
    /*
     * 猜数字游戏
     * 一个类A有一个成员变量v
     * 随机给v赋一个1~100的值
     * 定义一个类对A类的成员变量v进行猜
     * 如果大了则提示大了，小了则提示小了，等于则提示猜测成功
     */
    @Test
    public void test1() {
        int v = A.getInstance().getV();
        Scanner scanner = new Scanner(System.in);

        while (true) {
            int i = scanner.nextInt();

            if (i < v) {
                System.out.println("小了");
            } else if (i > v) {
                System.out.println("大了");
            } else {
                System.out.println("猜测成功");
                break;
            }
        }

        scanner.close();
    }

    /*
     * 定义一个交通工具（Vehicle）的类
     * 其中有属性：速度（speed）、体积（size）
     * 方法：移动（move()）、设置速度（setSpeed(int speed)）、设置体积（setSize(int size)）、加速（speedUp()）、减速（speedDown()）
     * 最后在测试类中的main()中实例化一个交通工具对象
     * 通过方法给它初始化speed、size的值并打印出来
     * 另外调用加速减速的方法对速度进行改变
     */
    @Test
    public void test2() {
        Vehicle vehicle = Vehicle.getInstance();
        vehicle.setSize(10);
        vehicle.setSpeed(10);
        vehicle.move();
        vehicle.speedUp();
        vehicle.move();
        vehicle.speedDown();
        vehicle.move();
    }

    /*
     * 在程序中经常要对时间进行操作但是并没有时间类型的数据，那么我们可以自己实现一个时间类来满足程序中的需要
     * 定义名为MyTime的类
     * 其中应有三个整型成员：时hour、分minute、秒second
     * 为了保证数据的安全性，这三个成员变量应声明为私有
     * 为MyTime类定义构造方法以方便创建对象时初始化成员变量
     * 再定义display方法用于将时间信息打印出来
     * 为MyTime类添加方法：addSecond(int second)、addMinute(int minute)、addHour(int hour)、subSecond(int second)、subMinute(int minute)、subHour(int hour)
     * 分别对时、分、秒进行加减运算
     */
    @Test
    public void test3() {
        MyTime myTime = MyTime.getInstance();
        System.out.println(myTime.display());
        myTime.addHour(1);
        myTime.addMinute(1);
        myTime.addSecond(1);
        System.out.println(myTime.display());
        myTime.subHour(1);
        myTime.subMinute(1);
        myTime.subSecond(1);
        System.out.println(myTime.display());
    }

    /*
     * 编写Java程序模拟简单的计算器
     * 定义名为Number的类，其中有两个整型数据成员n1和n2，应声明为私有
     * 编写构造方法赋予n1和n2初始值
     * 再为该类定义加addition、减subtration、乘multiplication、除division等公共成员方法
     * 分别对两个成员变量执行加、减、乘、除的运算
     * 在main方法中创建Number类的对象调用各个方法并显示计算结果
     */
    @Test
    public void test4() {
        Number number = Number.getInstance(3, 5);
        System.out.println(number.addition());
        System.out.println(number.subtration());
        System.out.println(number.multiplication());
        System.out.println(number.division());
    }

    /*
     * 定义一个人类Person用于显示人的姓名和年龄
     * 该类中应该有两个私有属性姓名name和年龄age
     * 定义构造方法用来初始化数据成员
     * 再定义显示display方法将姓名和年龄打印出来
     * 在main方法中创建人类的实例然后将信息显示。
     */
    @Test
    public void test5() {
        Person person = Person.getInstance("Leif", 23);
        person.display();
    }

    /*
     * 定义一个Computer类
     * 该类有一个私有成员变量品牌type
     * 提供该变量的get和set方法
     * 在main方法中设置type的值并打印出来
     */
    @Test
    public void test6() {
        Computer computer = Computer.getInstance();
        computer.setType("戴尔");
        System.out.println(computer.getType());
    }

    /*
     * 为“无名的粉”写一个类WuMingFen
     * 要求：
     * 1、有三个属性，面码：String theMa、粉的分量：int quantity、是否带汤：boolean likeSoup
     * 2、写一个构造方法以便于简化初始化过程，如WuMingFen f1 = new WuMingFen("牛肉", 3, true);
     * 3、重载构造方法使得初始化过程可以多样化，如WuMingFen f2 = new WuMingFen("牛肉", 2);
     * 4、如何使WuMingFen f3 = new WuMingFen();语句构造出来的粉的对象是酸辣面码、2两、带汤的
     * 5、写一个普通方法check()用于查看粉是否符合要求，即将对象的三个属性打印在控制台上
     */
    @Test
    public void test7() {
        WuMingFen f1 = new WuMingFen("牛肉", 3, true);
        f1.check();
        WuMingFen f2 = new WuMingFen("牛肉", 2);
        f2.check();
        WuMingFen f3 = new WuMingFen();
        f3.check();
    }

    /*
     * 定义一个名为Vehicles交通工具的基类
     * 该类中应包含String类型的成员属性brand商标和color颜色
     * 还应包含成员方法run行驶：在控制台显示“我已经开动了”和showInfo显示信息：在控制台显示商标和颜色
     * 并编写构造方法初始化其成员属性
     * 编写Car小汽车类继承于Vehicles类并编写构造方法
     * 增加int型成员属性seats座位
     * 还应增加成员方法showCar：在控制台显示小汽车的信息
     * 编写Truck卡车类继承于Vehicles类并编写构造方法
     * 增加float型成员属性load载重
     * 还应增加成员方法showTruck：在控制台显示卡车的信息
     * 在main方法中测试以上各类
     */
    @Test
    public void test8() {
        Vehicles vehicles = new Vehicles("捷安特", "黄色");
        vehicles.showInfo();
        Vehicles car = new Car("奔驰", "黑色", 4);
        ((Car)car).showCar();
        Vehicles truck = new Truck("皮卡", "白色", 10);
        ((Truck)truck).showTruck();
    }

    /*
     * 定义一个网络用户类
     * 要处理的信息有用户ID、用户密码、email地址
     * 在建立类的实例时把以上三个信息都作为构造函数的参数输入
     * 其中用户ID和用户密码是必须的，缺省的email地址是用户ID加上字符串"@gameschool.com"
     */
    @Test
    public void test9() {
        WebUser webUser1 = new WebUser(1, "123", "[email protected]");
        System.out.println(webUser1.toString());
        WebUser webUser2 = new WebUser(2, "123");
        System.out.println(webUser2.toString());
    }

    /*
     * 编写Addition类
     * 该类中应包含一组实现两数相加运算的重载方法
     * 实现加法运算的方法应接受两个参数，即加数和被加数
     * 方法将两个参数进行加法运算后返回相加结果
     * 考虑可能针对不同的数据类型进行计算，重载方法
     * 包括整型、长整型、浮点型、双精度浮点型、还有字符串
     * 在main方法中创建Addition类的实例，分别调用重载方法测试其效果
     */
    @Test
    public void test10() {
        Addition addition = Addition.getInstance();
        System.out.println(addition.add(1, 2));
        System.out.println(addition.add(3L, 4L));
        System.out.println(addition.add(5.0F, 6.0F));
        System.out.println(addition.add(7.0, 8.0));
        System.out.println(addition.add("9", "0"));
    }

    /*
     * 建立一个汽车类
     * 包括轮胎个数、汽车颜色、车身重量等属性
     * 并通过不同的构造方法创建事例
     * 至少要求汽车能够加速、减速、停车
     * 再定义一个小汽车类继承汽车类
     * 并添加空调、CD等属性
     * 覆盖加速、减速、停车的方法
     */
    @Test
    public void test11() {
        Automobile automobile = new Automobile(4, "Black", 50);
        automobile.speedUp();
        automobile.speedDown();
        automobile.stop();
        LittleAutomobile littleAutomobile = new LittleAutomobile(4, "Write", 50, "格力", "云烟成雨");
        littleAutomobile.speedUp();
        littleAutomobile.speedDown();
        littleAutomobile.stop();
    }

    /*
     * 创建一个名称为StaticDemo的类
     * 并声明一个静态变量和一个普通变量
     * 对变量分别赋予10和5的初始值
     * 在main()方法中输出变量值。
     */
    @Test
    public void test12() {
        System.out.println("x = " + StaticDemo.x);
        System.out.println("y = " + new StaticDemo().y);
    }

    /*
     * 创建一个父类和子类
     * 父类有一个数据成员
     * 子类继承父类
     * 通过子类构造函数初始化并显示该数据成员的值。
     */
    @Test
    public void test13() {
        Sun sun = new Sun(10);
        System.out.println(sun.toString());
    }

    /*
     * 创建一个Vehicle2类并将它声明为抽象类
     * 在Vehicle2类中声明一个numberOfWheels方法，使它返回一个字符串值
     * 创建两个类Car2和Motorbike2继承于Vehicle2类并在这两个类中实现numberOfWheels方法
     * 在Car2类中应当显示“四轮车”
     * 而在Motorbike类中应当显示“双轮车”
     * 创建Car2和Motorbike2的实例并在控制台中显示信息
     */
    @Test
    public void test14() {
        Car2 car2 = Car2.getInstance();
        car2.numberOfWheels();
        Motorbike2 motorbike2 = Motorbike2.getInstance();
        motorbike2.numberOfWheels();
    }

    /*
     * 创建一个名称为Vehicle的接口
     * 在接口中分别添加带有一个参数的方法start()和stop()
     * 在两个名称分别为Bike和Bus的类中实现Vehicle接口
     * 创建Bike和Bus对象并访问start()和stop()方法
     */
    @Test
    public void test15() {
        Bike bike = Bike.getInstance();
        bike.start("Bike");
        bike.stop("Bike");
        Bus bus = Bus.getInstance();
        bus.start("Bus");
        bus.stop("Bus");
    }

    /*
     * 设计一张抽象的门Door
     * 那么对于这张门来说就应该拥有所有门的共性：开门openDoor()和关门closeDoor()
     * 然后对门进行另外的功能设计：防盗theftProof()、防水waterProof()、防弹bulletProof()
     * 实例化一个拥有所有功能的门
     */
    @Test
    public void test16() {
        Door door = DoorDemo.getInstance();
        door.openDoor();
        door.closeDoor();
        ((DoorDemo)door).theftProof();
        ((DoorDemo)door).waterProof();
        ((DoorDemo)door).bulletProof();
    }

    /*
     * 设计一个纯净水生产线
     * 目前流程是从某个地方把水取出来，然后经过缓冲、过滤、加热、放糖等步骤
     */
    @Test
    public void test17() {
        Water water = PurifiedWater.getInstance();
        water.water();
        ((PurifiedWater)water).buffer();
        ((PurifiedWater)water).filter();
        ((PurifiedWater)water).heating();
        ((PurifiedWater)water).sugar();
        ((PurifiedWater)water).purifiedWater();
    }

    /*
     * 定义一个抽象的Role类
     * 有姓名、年龄、性别等成员变量
     * 要求尽可能隐藏所有变量(能够私有就私有,能够保护就不要公有)
     * 再通过GetXXX()和SetXXX()方法对各变量进行读写
     * 具有一个抽象的play()方法
     * 该方法不返回任何值
     * 同时至少定义两个构造方法
     * Role类中要体现出this的几种用法。
     * 从Role类派生出一个Employee类
     * 该类具有Role类的所有成员，构造方法除外
     * 并扩展salary成员变量
     * 同时增加一个静态成员变量“职工编号 ID ”
     * 同样要有至少两个构造方法
     * 要体现出this和super的几种用法
     * 还要求覆盖play()方法
     * 并提供一个final sing()方法
     * Manager类继承Employee类
     * 有一个final成员变量vehicle
     * 创造Manager和Employee对象，并测试这些对象的方法
     */
    @Test
    public void test18() {
        Manager manager = new Manager("Berton", 37, "male", 100000);
        manager.display();
        manager.sing();
        manager.play();
        Employee employee = new Employee("Leif", 23, "male", 7500);
        employee.display();
        employee.sing();
        employee.play();

        Role role = new Role("Hellen", 22, "female") {
            @Override
            public void play() {
                System.out.println("Role play");
            }
        };

        role.display();
        role.play();
    }

    /*
     * 1、建立一个Java抽象类Drink
     * a）声明一个抽象方法taste()，该方法负责输出饮料的味道
     * b）声明int型常量来代表不同的饮料类型：咖啡、啤酒、牛奶
     * c）声明静态工厂方法getDrink(int drinkType)，根据传入的参数创建不同的饮料对象并返回该对象，建议使用switch语句
     * 2、建立Drink的具体子类
     * a）分别建立Drink的子类Coffee代表咖啡、Beer代表啤酒、Milk代表牛奶
     * b）实现taste()方法，要求在控制台打印各自的味道特征
     * 3、建立异常类DrinkNotFoundException
     * a）继承Exception
     * b）在Drink的方法getDrink(int drinkType)中声明引发DrinkNotFoundException异常，当没有相对应的饮料类型时抛出该异常
     * c）在使用getDrink方法的类中捕捉该异常
     * 4、建立Test测试类，测试以上内容的正确性
     * a）编写main方法，通过命令行传参的方式传入某种饮料的类型
     * b）在main方法中调用Drink类的getDrink方法，获得相应的饮料对象，注意捕获DrinkNotFoundException
     * c）调用饮料对象的taste()方法，输出该饮料的味道
     * 5、编译程序并运行
     */
    @Test
    public void test19() {
        Scanner scanner = new Scanner(System.in);
        Drink drink = null;

        try {
            drink = Drink.getDrink(scanner.nextInt());
        } catch (DrinkNotFoundException e) {
            e.drinkNotFound();
        }

        drink.taste();
        scanner.close();
    }
}

class A {
    private int v;

    private A(int v) {
        this.v = v;
    }

    private static volatile A a = null;

    public static A getInstance() {
        if (a == null) {
            synchronized (A.class) {
                if (a == null) {
                    a = new A((int)(Math.random() * 100 + 1));
                }
            }
        }

        return a;
    }

    public int getV() {
        return v;
    }
}

class Vehicle {
    private int speed;
    private int size;

    private Vehicle() {}

    private static volatile Vehicle vehicle = null;

    public static Vehicle getInstance() {
        if (vehicle == null) {
            synchronized (Vehicle.class) {
                if (vehicle == null) {
                    vehicle = new Vehicle();
                }
            }
        }

        return vehicle;
    }

    public void setSpeed(int speed) {
        this.speed = speed;
    }

    public void setSize(int size) {
        this.size = size;
    }

    public void speedUp() {
        speed += 1;
    }

    public void speedDown() {
        speed -= 1;
    }

    public void move() {
        System.out.println("体积：" + size + "，速度：" + speed + "，正在移动");
    }
}

class MyTime {
    private int hour;
    private int minute;
    private int second;

    private MyTime(int hour, int minute, int second) {
        this.hour = hour;
        this.minute = minute;
        this.second = second;
    }

    private static volatile MyTime myTime = null;

    public static MyTime getInstance() {
        if (myTime == null) {
            synchronized (MyTime.class) {
                if (myTime == null) {
                    Calendar calendar = Calendar.getInstance();
                    myTime = new MyTime(calendar.get(Calendar.HOUR_OF_DAY), calendar.get(Calendar.MINUTE), calendar.get(Calendar.SECOND));
                }
            }
        }

        return myTime;
    }

    public String display() {
        return "MyTime [hour=" + hour + ", minute=" + minute + ", second=" + second + "]";
    }

    public void addSecond(int second) {
        this.second += second;
    }

    public void addMinute(int minute) {
        this.minute += minute;
    }

    public void addHour(int hour) {
        this.hour += hour;
    }

    public void subSecond(int second) {
        this.second -= second;
    }

    public void subMinute(int minute) {
        this.minute -= minute;
    }

    public void subHour(int hour) {
        this.hour -= hour;
    }
}

class Number {
    private int n1;
    private int n2;

    private Number(int n1, int n2) {
        this.n1 = n1;
        this.n2 = n2;
    }

    private static volatile Number number = null;

    public static Number getInstance(int n1, int n2) {
        if (number == null) {
            synchronized (Number.class) {
                if (number == null) {
                    number = new Number(n1, n2);
                }
            }
        }

        return number;
    }

    public int addition() {
        return n1 + n2;
    }

    public int subtration() {
        return n1 - n2;
    }

    public int multiplication() {
        return n1 * n2;
    }

    public double division() {
        return (double)n1 / n2;
    }
}

class Person {
    private String name;
    private int age;

    private Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    private static volatile Person person = null;

    public static Person getInstance(String name, int age) {
        if (person == null) {
            synchronized (Person.class) {
                if (person == null) {
                    person = new Person(name, age);
                }
            }
        }

        return person;
    }

    public void display() {
        System.out.println("Person [name=" + name + ", age=" + age + "]");
    }
}

class Computer {
    private String type;

    private Computer() {}

    private static volatile Computer computer = null;

    public static Computer getInstance() {
        if (computer == null) {
            synchronized (Computer.class) {
                if (computer == null) {
                    computer = new Computer();
                }
            }
        }

        return computer;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }
}

class WuMingFen {
    private String theMa;
    private int quantity;
    private boolean likeSoup;

    public WuMingFen() {
        theMa = "酸辣";
        quantity = 2;
        likeSoup = true;
    }

    public WuMingFen(String theMa, int quantity) {
        this.theMa = theMa;
        this.quantity = quantity;
    }

    public WuMingFen(String theMa, int quantity, boolean likeSoup) {
        this.theMa = theMa;
        this.quantity = quantity;
        this.likeSoup = likeSoup;
    }

    public void check() {
        System.out.println("WuMingFen [theMa=" + theMa + ", quantity=" + quantity + ", likeSoup=" + likeSoup + "]");
    }
}

class Vehicles {
    private String brand;
    private String color;

    public Vehicles(String brand, String color) {
        this.brand = brand;
        this.color = color;
    }

    public void run() {
        System.out.println("我已经开动了");
    }

    public void showInfo() {
        System.out.println("Vehicles [brand=" + brand + ", color=" + color + "]");
    }
}

class Car extends Vehicles {
    private int seats;

    public Car(String brand, String color, int seats) {
        super(brand, color);
        this.seats = seats;
    }

    public void showCar() {
        super.showInfo();
        System.out.println("Car [seats=" + seats + "]");
    }
}

class Truck extends Vehicles {
    private float load;

    public Truck(String brand, String color, float load) {
        super(brand, color);
        this.load = load;
    }

    public void showTruck() {
        super.showInfo();
        System.out.println("Truck [load=" + load + "]");
    }
}

class WebUser {
    private int id;
    private String password;
    private String email;

    public WebUser(int id, String password, String email) {
        this.id = id;
        this.password = password;
        this.email = email;
    }

    public WebUser(int id, String password) {
        this.id = id;
        this.password = password;
        email = id + "@gameschool.com";
    }

    @Override
    public String toString() {
        return "WebUser [id=" + id + ", password=" + password + ", email=" + email + "]";
    }
}

class Addition {
    private Addition() {}

    private static volatile Addition addition = null;

    public static Addition getInstance() {
        if (addition == null) {
            synchronized (Addition.class) {
                if (addition == null) {
                    addition = new Addition();
                }
            }
        }

        return addition;
    }

    public int add(int a, int b) {
        return a + b;
    }

    public long add(long a, long b) {
        return a + b;
    }

    public float add(float a, float b) {
        return a + b;
    }

    public double add(double a, double b) {
        return a + b;
    }

    public String add(String a, String b) {
        return a + b;
    }
}

class Automobile {
    private int tyre;
    private String color;
    private double weight;

    public Automobile(int tyre, String color, double weight) {
        this.tyre = tyre;
        this.color = color;
        this.weight = weight;
    }

    public void speedUp() {
        System.out.println("Automobile [tyre=" + tyre + ", color=" + color + ", weight=" + weight + "] speed up");
    }

    public void speedDown() {
        System.out.println("Automobile [tyre=" + tyre + ", color=" + color + ", weight=" + weight + "] speed down");
    }

    public void stop() {
        System.out.println("Automobile [tyre=" + tyre + ", color=" + color + ", weight=" + weight + "] stop");
    }
}

class LittleAutomobile extends Automobile {
    private String airConditioner;
    private String cd;

    public LittleAutomobile(int tyre, String color, double weight, String airConditioner, String cd) {
        super(tyre, color, weight);
        this.airConditioner = airConditioner;
        this.cd = cd;
    }

    @Override
    public void speedUp() {
        super.speedUp();
        System.out.println("LittleAutomobile [airConditioner=" + airConditioner + ", cd=" + cd + "] speed up");
    }

    @Override
    public void speedDown() {
        super.speedDown();
        System.out.println("LittleAutomobile [airConditioner=" + airConditioner + ", cd=" + cd + "] speed down");
    }

    @Override
    public void stop() {
        super.stop();
        System.out.println("LittleAutomobile [airConditioner=" + airConditioner + ", cd=" + cd + "] stop");
    }
}

class StaticDemo {
    public static int x = 10;
    public int y = 5;
}

class Father {
    private int i;

    public Father(int i) {
        this.i = i;
    }

    @Override
    public String toString() {
        return "Father [i=" + i + "]";
    }
}

class Sun extends Father {
    public Sun(int i) {
        super(i);
    }
}

abstract class Vehicle2 {
    public void numberOfWheels() {
        System.out.println("车轮数量");
    }
}

class Car2 extends Vehicle2 {
    private Car2() {}

    private static volatile Car2 car2 = null;

    public static Car2 getInstance() {
        if (car2 == null) {
            synchronized (Car2.class) {
                if (car2 == null) {
                    car2 = new Car2();
                }
            }
        }

        return car2;
    }

    @Override
    public void numberOfWheels() {
        super.numberOfWheels();
        System.out.println("四轮车");
    }
}

class Motorbike2 extends Vehicle2 {
    private Motorbike2() {}

    private static volatile Motorbike2 motorbike2 = null;

    public static Motorbike2 getInstance() {
        if (motorbike2 == null) {
            synchronized (Motorbike2.class) {
                if (motorbike2 == null) {
                    motorbike2 = new Motorbike2();
                }
            }
        }

        return motorbike2;
    }

    @Override
    public void numberOfWheels() {
        super.numberOfWheels();
        System.out.println("双轮车");
    }
}

interface Vehicle3 {
    public abstract void start(String ss);

    public abstract void stop(String ss);
}

class Bike implements Vehicle3 {
    private Bike() {}

    private static volatile Bike bike = null;

    public static Bike getInstance() {
        if (bike == null) {
            synchronized (Bike.class) {
                if (bike == null) {
                    bike = new Bike();
                }
            }
        }

        return bike;
    }

    @Override
    public void start(String ss) {
        System.out.println(ss + " start");
    }

    @Override
    public void stop(String ss) {
        System.out.println(ss + " stop");
    }
}

class Bus implements Vehicle3 {
    private Bus() {}

    private static volatile Bus bus = null;

    public static Bus getInstance() {
        if (bus == null) {
            synchronized (Bike.class) {
                if (bus == null) {
                    bus = new Bus();
                }
            }
        }

        return bus;
    }

    @Override
    public void start(String ss) {
        System.out.println(ss + " start");
    }

    @Override
    public void stop(String ss) {
        System.out.println(ss + " stop");
    }
}

abstract class Door {
    public void openDoor() {
        System.out.println("开门");
    }

    public void closeDoor() {
        System.out.println("关门");
    }
}

interface TheftProof {
    public abstract void theftProof();
}

interface WaterProof {
    public abstract void waterProof();
}

interface BulletProof {
    public abstract void bulletProof();
}

class DoorDemo extends Door implements TheftProof, WaterProof, BulletProof {
    private DoorDemo() {}

    private static volatile DoorDemo doorDemo = null;

    public static DoorDemo getInstance() {
        if (doorDemo == null) {
            synchronized (DoorDemo.class) {
                if (doorDemo == null) {
                    doorDemo = new DoorDemo();
                }
            }
        }

        return doorDemo;
    }

    @Override
    public void theftProof() {
        System.out.println("防盗");
    }

    @Override
    public void waterProof() {
        System.out.println("防水");
    }

    @Override
    public void bulletProof() {
        System.out.println("防弹");
    }
}

abstract class Water {
    public void water() {
        System.out.println("水");
    }
}

interface Buffer {
    public abstract void buffer();
}

interface Filter {
    public abstract void filter();
}

interface Heating {
    public abstract void heating();
}

interface Sugar {
    public abstract void sugar();
}

class PurifiedWater extends Water implements Buffer, Filter, Heating, Sugar {
    private PurifiedWater() {}

    private static volatile PurifiedWater purifiedWater = null;

    public static PurifiedWater getInstance() {
        if (purifiedWater == null) {
            synchronized (PurifiedWater.class) {
                if (purifiedWater == null) {
                    purifiedWater = new PurifiedWater();
                }
            }
        }

        return purifiedWater;
    }

    public void purifiedWater() {
        System.out.println("纯净水");
    }

    @Override
    public void sugar() {
        System.out.println("放糖");
    }

    @Override
    public void heating() {
        System.out.println("加热");
    }

    @Override
    public void filter() {
        System.out.println("过滤");
    }

    @Override
    public void buffer() {
        System.out.println("缓冲");
    }
}

abstract class Role {
    private String name;
    private int age;
    private String gender;

    public Role() {}

    public Role(String name, int age, String gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public void display() {
        System.out.println("Role [name=" + name + ", age=" + age + ", gender=" + gender + "]");
    }

    public abstract void play();
}

class Employee extends Role {
    private static int id;
    private int salary;

    public Employee() {}

    public Employee(String name, int age, String gender, int salary) {
        super(name, age, gender);
        this.salary = salary;
    }

    public static int getId() {
        return id;
    }

    public static void setId(int id) {
        Employee.id = id;
    }

    public int getSalary() {
        return salary;
    }

    public void setSalary(int salary) {
        this.salary = salary;
    }

    @Override
    public void display() {
        super.display();
        System.out.println("Employee [salary=" + salary + "]");
    }

    @Override
    public void play() {
        System.out.println("Employee play");
    }

    public final void sing() {
        System.out.println("Employee sing");
    }
}

class Manager extends Employee {
    private final String VEHICLE = "Car";

    public Manager() {}

    public Manager(String name, int age, String gender, int salary) {
        super(name, age, gender, salary);
    }

    @Override
    public void display() {
        super.display();
        System.out.println("Manager [vehicle=" + VEHICLE + "]");
    }

    @Override
    public void play() {
        System.out.println("Manager play");
    }
}

abstract class Drink {
    private static final int COFFEE = 1;
    private static final int BEER = 2;
    private static final int MILK = 3;

    public static Drink getDrink(int drinkType) throws DrinkNotFoundException {
        switch (drinkType) {
            case COFFEE:
                return new Coffee();
            case BEER:
                return new Beer();
            case MILK:
                return new Milk();
            default:
                throw new DrinkNotFoundException();
        }
    }

    public abstract void taste();
}

class Coffee extends Drink {
    @Override
    public void taste() {
        System.out.println("Coffee");
    }
}

class Beer extends Drink {
    @Override
    public void taste() {
        System.out.println("Beer");
    }
}

class Milk extends Drink {
    @Override
    public void taste() {
        System.out.println("Milk");
    }
}

class DrinkNotFoundException extends Exception {
    private static final long serialVersionUID = 1L;

    public void drinkNotFound() {
        System.out.println("Drink not found");
    }
}

你可能感兴趣的:(面向对象练习题)

  • c++ 的iostream 和 c++的stdio的区别和联系 黄卷青灯77 c++算法开发语言iostreamstdio
    在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
  • 高级编程--XML+socket练习题 masa010 java开发语言
    1.北京华北2114.8万人上海华东2,500万人广州华南1292.68万人成都华西1417万人（1）使用dom4j将信息存入xml中（2）读取信息，并打印控制台（3）添加一个city节点与子节点（4）使用socketTCP协议编写服务端与客户端，客户端输入城市ID，服务器响应相应城市信息（5）使用socketTCP协议编写服务端与客户端，客户端要求用户输入city对象，服务端接收并使用dom4j
  • 【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数 广龙宇 一起学Rust#Rust设计模式rust设计模式开发语言
    提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
  • Python快速入门 —— 第三节：类与对象 孤华暗香 Python快速入门python开发语言
    第三节：类与对象目标：了解面向对象编程的基础概念，并学会如何定义类和创建对象。内容：类与对象：定义类：class关键字。类的构造函数：__init__()。类的属性和方法。对象的创建与使用。示例：classStudent:def__init__(self,name,age,major):self.name&#
  • 一文掌握python面向对象魔术方法（二） 程序员neil pythonpython开发语言
    接上篇：一文掌握python面向对象魔术方法（一）-CSDN博客目录六、迭代和序列化：1、__iter__(self):定义迭代器，使得类可以被for循环迭代。2、__getitem__(self,key):定义索引操作，如obj[key]。3、__setitem__(self,key,value):定义赋值操作，如obj[key]=value。4、__delitem__(self,key):定义
  • 系统架构设计师 需求分析篇二 AmHardy 软件架构设计师系统架构需求分析面向对象分析分析模型UML和SysML
    面向对象分析方法1.用例模型构建用例模型一般需要经历4个阶段：识别参与者：识别与系统交互的所有事物。合并需求获得用例：将需求分配给予其相关的参与者。细化用例描述：详细描述每个用例的功能。调整用例模型：优化用例之间的关系和结构，前三个阶段是必需的。2.用例图的三元素参与者：使用系统的用户或其他外部系统和设备。用例：系统所提供的服务。通信关联：参与者和用例之间的关系，或用例与用例之间的关系。3.识别参
  • C++ lambda闭包消除类成员变量 barbyQAQ c++c++java算法
    原文链接：https://blog.csdn.net/qq_51470638/article/details/142151502一、背景在面向对象编程时，常常要添加类成员变量。然而类成员一旦多了之后，也会带来干扰。拿到一个类，一看成员变量好几十个，就问你怕不怕？二、解决思路可以借助函数式编程思想，来消除一些不必要的类成员变量。三、实例举个例子：classClassA{public:...intfu
  • 【2022 CCF 非专业级别软件能力认证第一轮（CSP-J1）入门级 C++语言试题及解析】 汉子萌萌哒 CCFnoi算法数据结构c++
    一、单项选择题(共15题，每题2分，共计30分；每题有且仅有一个正确选项)1.以下哪种功能没有涉及C++语言的面向对象特性支持：()。A.C++中调用printf函数B.C++中调用用户定义的类成员函数C.C++中构造一个class或structD.C++中构造来源于同一基类的多个派生类题目解析【解析】正确答案:AC++基础知识，面向对象和类有关，类又涉及父类、子类、继承、派生等关系，printf
  • Python编程 - 初识面向对象 易辰君 Python核心编程python开发语言
    目录前言一、面向对象二、类和对象（一）类简介定义类（二）对象简介创建对象（三）总结三、实例属性和实例方法（一）实例属性创建的基本语法使用示例（二）实例方法定义实例方法的基本语法调用示例方法的示例（三）总结四、类中的self（一）基本概念（二）作用访问实例属性调用其他实例方法在构造函数中初始化对象（三）总结五、__init__方法（一）__init__方法的特点（二）基本语法（三）示例（四）总结前言
  • C语言---程序设计练习题目及学习方法1 Wanyu677 C语言c语言学习方法算法
    学习方法要多练习在这些题目中的代码和题目自己动手去敲练习也是在熟悉语法，写代码第一步就是熟悉语法练习是在锻炼编程思维，把实际问题转换为代码的能力学会画图画图去理解内存，理解指针这些比较难懂的知识画图可以更好的理清思路辅助理解，强化理解学会调试借助调试，更好的理解代码和感知代码找出代码中的bug和程序逻辑（1）自增自减运算符inta=5,b,c,i=10;b=a++;c=++b;printf("a=
  • python中文版软件下载-Python中文版 编程大乐趣
    python中文版是一种面向对象的解释型计算机程序设计语言。python中文版官网面向对象编程，拥有高效的高级数据结构和简单而有效的方法，其优雅的语法、动态类型、以及天然的解释能力，让它成为理想的语言。软件功能强大，简单易学，可以帮助用户快速编写代码，而且代码运行速度非常快，几乎可以支持所有的操作系统，实用性真的超高的。python中文版软件介绍：python中文版的解释器及其扩展标准库的源码和编
  • 开发游戏的学习规划 杰克逊的日记 游戏学习
    第一阶段：●C#语言快速系统地学习一遍（基础的语法、面向对象、基础的数据结构、基础的设计模式）●Unity的2D和3D部分及UI、动画、物理系统●阶段性测验：需要去用前面所学的这些基础知识来完成一个简单的2d或者3d的案例，将通过一个自制的《Flappybird》游戏案例讲解游戏开发的思想及方法，并将《Flappybird》这个游戏进一步改造成一个横版射击类游戏《Crazybird》以巩固并且升华
  • ruby和python哪个好学 hakesashou python基础知识rubypython开发语言
    Ruby和python都挺好学的。建议学习Python，语法的话，Python相对更简洁。而且Python应用场合更广泛，运维、网站开发、数据处理、科学研究都可以。Ruby和Python十分相似，有很多共同点，但也有一些不同之外，以下是Python和Ruby的对比：1、Python和Ruby都是面向对象的语言，都是动态和灵活的。二者的主要区别在于他们解决问题的方式。Ruby提供了不同的方法，而Py
  • 三对角线型行列式的求法 Mr-Apple 笔记线性代数矩阵算法
    三对角线型行列式摘要典型例题练习题参考答案摘要笔者在复习高等代数行列式这章时,发现三对角行列式问题是行列式计算中经常出现的一类行列式,部分考研院校也曾直接出过三对角行列式的计算,亦或是三对角行列式的变体问题.本文主要介绍了一种通常情况下三对角行列式的解法,即采用特征根法来求解行列式的通项公式.例1:计算nnn阶行列式(ac≠0)(ac\neq0)(ac=0)Dn=∣bc0…000abc…0000
  • AI教你学Python 第5天：面向对象编程（OOP）基础 凡人的AI工具箱 AI教你学Pythonpython开发语言人工智能AIGC
    第5天：面向对象编程（OOP）基础一、面向对象编程概述面向对象编程（OOP）是一种编程范式，使用“对象”来表示数据和数据上可用的操作。OOP的核心概念包括类、对象、继承、多态和封装。概念描述类一种蓝图，定义了对象的属性和方法。对象类的实例，包含具体的数据和方法。继承一个类可以继承另一个类的属性和方法，从而实现代码重用。多态同一操作作用于不同对象时，表现出不同的行为。封装把数据和操作数据的方法绑定在
  • 笔记：Python顺序结构 练习题 辞言i 笔记python
    文章目录前言一、什么是顺序结构？二、练习题1.题目2.填空题3.简答题4.编程题总结前言本次笔记旨在帮助读者加深对Python编程语言中顺序结构和选择题的理解。在学习Python编程过程中，掌握程序的基本结构以及条件语句的使用至关重要。通过本次练习题，读者将有机会测试自己对这些概念的掌握程度，并通过实际应用进一步巩固所学知识。本次练习题将涵盖Python中的顺序结构的练习题，旨在帮助读者提高解决问
  • 6.Java面向对象第六章 抽象类和接口 懒洋洋大魔王 Java面像对象java开发语言
    5.Java面向对象抽象类和接口文章目录5.Java面向对象抽象类和接口一、1.抽象类VS普通类2.抽象方法VS普通方法3.抽象类与抽象方法的使用二、接口1.必须知道的接口特性2.定义接口3.接口使用三、抽象类vs接口相同点不同点多用组合，少用继承针对接口编程针对扩展开放，针对改变关闭多用组合，少用继承针对接口编程针对扩展开放，针对改变关闭一、1.抽象类VS普通类抽象类不能被实例化但可以创建一个引
  • 学生管理系统 wu1113_ java
    文章目录1.案例需求2.编程思路3.运行效果4.案例源码5.小结1.案例需求上次我们完成了一个酒店管理系统，这次我们使用面向对象思维，完成一个学生管理系统。实现一个简单的学生管理系统，它具备5个功能，分别为显示所有的学生信息添加学生修改学生信息删除学生退出本系统功能2.编程思路首先我们要额外定义一个Studnet类，包括学生的学号、姓名、年龄、性别等属性。其次我们定义一个测试类Test，在测试类的
  • JavaScript 基础 - 第13天 +码农快讯+ JavaScript学习笔记javascript开发语言ecmascript
    文章目录JavaScript基础-第13天深入对象创建对象三种方式构造函数new实例化过程实例成员&静态成员实例成员静态成员一切皆对象内置构造函数ObjectArrayStringNumberJavaScript基础-第13天了解面向对象编程的基础概念及构造函数的作用，体会JavaScript一切皆对象的语言特征，掌握常见的对象属性和方法的使用。深入对象内置构造函数综合案例深入对象了解面向对象的基
  • GPT-4-Turbo 和 Claude-3.5-Sonnet 图片识别出答题的是否正确 进行比较 光影3415 模型比较
    1、比较的图片：====================使用GPT-4-Turbo输入的=============================提问：识别图片中的印刷字和手写字，如果写错的给一个正确答案+图片回复：在图片中，印刷字显示的是一系列的英语填空练习题，而手写字则是填入空白处的答案。以下是题目、选项、填入的答案，以及正确答案（如果填写错误）的列表：###印刷字内容与答案1.**Weput
  • 可爱的学生 秋秋历史苑
    上午，上完两节课后，本想在办公室休息一下，正遇上另一位老师临时有急事，她的一个学生交给我帮她管一下，很简单，也就是督促孩子记下词语，多音字以及练习题批改。二年级的一个小男孩，挺腼腆的。自己默默地在本子上记着七八个词语，过了一会儿，告诉我可以听写了。我接过孩子的书就开始了报词语。刚刚记忆了片刻，而且还抄写了几遍，居然合书即忘。其实大人也一样，一个生字，刚学会了它的读音及写法，呆会儿听写估计也得望。我
  • 笔记：JAVA面向对象三大特征——封装继承多态 听原来是雨落 Javajava开发语言后端
    高内聚，低耦合：  高内聚：类的内部数据操作细节自己完成，不允许外部干涉；    低耦合：仅暴露少量的方法给外部使用。一、封装：  含义：1.指把对象的属性和行为看成一个密不可分的整体，将这两者“封装”在一个密不可分的独立单位（即对象）中；     2.指“信息隐藏”，把不需要外界知道的信息隐藏起来，有些对象的属性及行为为允许外界用户知道或使用，但不允许更改，而另一些属性或行为，则不允许外界知道，
  • 【JavaSE】封装、继承与多态 泡芙冰淇淋ya JavaSEjava开发语言
    1、封装1.1简介在Javase中，封装（Encapsulation）是面向对象编程（OOP）的一个重要概念。封装的主要目的是隐藏对象的内部状态和信息，只提供必要的公共方法来访问和操作这些状态和信息。通过封装可以控制对对象内部数据的访问级别，并保护数据不被随意修改，从而提高代码的安全性和可维护性。1.2特点信息隐藏：对象的内部状态（即属性或数据成员）被隐藏起来，外部世界只能通过对象提供的方法来访问
  • 面向对象编程03：封装、继承、多态 Clap of thunder Java从零学起java封装多态继承面向对象编程
    面向对象编程03：封装、继承、多态文章目录面向对象编程03：封装、继承、多态封装继承object类supersuper注意点：`super`VS`this`:方法重写多态多态的注意事项：instanceof关键字父类与子类之间的类型转换封装该露的露、该藏的藏设计程序要追求“高内聚、低耦合”。高内聚就是类的内部数据操作细节由自己完成，不允许外部干涉；低耦合：仅仅暴露少量的方法给外部使用。封装（数据的
  • Java中的多态性（Polymorphism） 天蓝蓝23528 java开发语言
    Java中的多态性（Polymorphism）是面向对象编程（OOP）中的一个核心概念，它允许同一个接口或方法在不同对象上具有不同的实现方式。多态性极大地提高了代码的灵活性和可扩展性，使得程序能够以一种统一的方式处理不同类型的对象。以下是对Java中多态性的详细解释，包括其定义、实现方式、优点以及具体示例。一、多态性的定义多态性是指允许不同类的对象对同一消息作出响应，即同一操作作用于不同的对象，可
  • Java的多态性 zaneily JAVAjava开发语言
    Java的多态性多态性是面向对象编程的一个重要特征，是指在父类中定义的属性和方法被子类继承之后，可以具有不同的数据类型或表现出不同的行为，这使得同一个属性或方法在父类及其各个子类中具有不同的涵义。可以理解为一个事务的多种形态。Java实现多态有三个条件：继承，重写和向上转型。继承：在多态中必须存在有继承关系的子类和父类。重写：子类对父类中某些方法进行重新定义，在调用这些方法时就会调用重写的子类方法
  • java 什么是多态性_Java多态性理解 职路施语 java什么是多态性
    什么是多态面向对象的三大特性：封装、继承、多态。从一定角度来看，封装和继承几乎都是为多态而准备的。这是我们最后一个概念，也是最重要的知识点。多态的定义：指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。(发送消息就是函数调用)实现多态的技术称为：动态绑定(dynamicbinding)，是指在执行期间判断所引用对象的实际类型，根据其实际的类型调用其相应
  • java 动态多态性_Java语言中动态多态性的实现及应用 阿野与阿厉 java动态多态性
    科技信息1.引言多态性(polymorphism)一词来源于拉丁语poly(表示多的意思)和mor-phos(意为形态)，其字面的含义是多种形态。在面向对象系统中，多态性是其核心内容之一，反映了人们在求解问题时，对相似性问题的一种求解方法。Java语言实现了两种多态性：静态多态性和动态多态性。本文重点论述其采用重写机制实现动态多态性的原理，并结合实例讲解动态多态性的应用。2.关于多态的概念2.1继
  • C++快速入门扫盲总结 六竹书生__wa C/C++Qt
    C++快速入门扫盲总结C++语言新特性C++的新特性C++的输入输出方式C++之命名空间namespaceC++面向对象类和对象构造函数与析构函数this指针继承重载函数重载运算符重载多态数据封装数据抽象接口（抽象类）C++语言新特性C++的新特性C++比C语言新增的数据类型是布尔类型（bool）。但是在新的C语言标准里已经有布尔类型了，但是在旧的C语言标准里是没有布尔类型的，编译器也无法解释布尔
  • 类与对象（上） zkydxj c++
    目录一、认识面向过程与面向对象二、类的引入三、类的定义1、类有两种定义方式：1.定义与声明全部放在类体中。2.类声明在.h文件中，成员函数定义在.cpp文件中。2、成员变量命名规则的建议四、类的访问限定符与封装1.封装2.访问限定符五、类的实例化一、认识面向过程与面向对象我们之前学过的c语言是一种面向过程的语言，面向过程指代码关注的是过程，分析求解解决问题的步骤，通过函数调用逐步解决问题。而c++
  • knob UI插件使用 换个号韩国红果果 JavaScriptjsonpknob
    图形是用canvas绘制的 js代码 var paras = { max:800, min:100, skin:'tron',//button type thickness:.3,//button width width:'200',//define canvas width.,canvas height displayInput:'tr
  • Android+Jquery Mobile学习系列(5)-SQLite数据库 白糖_ JQuery Mobile
    目录导航   SQLite是轻量级的、嵌入式的、关系型数据库，目前已经在iPhone、Android等手机系统中使用,SQLite可移植性好，很容易使用，很小，高效而且可靠。   因为Android已经集成了SQLite，所以开发人员无需引入任何JAR包，而且Android也针对SQLite封装了专属的API，调用起来非常快捷方便。   我也是第一次接触S
  • impala-2.1.2-CDH5.3.2 dayutianfei impala
    最近在整理impala编译的东西，简单记录几个要点： 根据官网的信息（https://github.com/cloudera/Impala/wiki/How-to-build-Impala）： 1. 首次编译impala，推荐使用命令： ${IMPALA_HOME}/buildall.sh -skiptests -build_shared_libs -format 2.仅编译BE ${I
  • 求二进制数中1的个数 周凡杨 java算法二进制
    解法一： 对于一个正整数如果是偶数，该数的二进制数的最后一位是 0 ，反之若是奇数，则该数的二进制数的最后一位是 1 。因此，可以考虑利用位移、判断奇偶来实现。   public int bitCount(int x){ int count = 0; while(x!=0){ if(x%2!=0){ /
  • spring中hibernate及事务配置 g21121 Hibernate
    hibernate的sessionFactory配置： <!-- hibernate sessionFactory配置 --> <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <
  • log4j.properties 使用 510888780 log4j
    log4j.properties 使用 一.参数意义说明 输出级别的种类 ERROR、WARN、INFO、DEBUG ERROR 为严重错误 主要是程序的错误 WARN 为一般警告，比如session丢失 INFO 为一般要显示的信息，比如登录登出 DEBUG 为程序的调试信息 配置日志信息输出目的地 log4j.appender.appenderName = fully.qua
  • Spring mvc-jfreeChart柱图（2） 布衣凌宇 jfreechart
    上一篇中生成的图是静态的，这篇将按条件进行搜索，并统计成图表，左面为统计图，右面显示搜索出的结果。 第一步：导包 第二步；配置web.xml(上一篇有代码) 建BarRenderer类用于柱子颜色 import java.awt.Color; import java.awt.Paint; import org.jfree.chart.renderer.category.BarR
  • 我的spring学习笔记14-容器扩展点之PropertyPlaceholderConfigurer aijuans Spring3
    PropertyPlaceholderConfigurer是个bean工厂后置处理器的实现，也就是BeanFactoryPostProcessor接口的一个实现。关于BeanFactoryPostProcessor和BeanPostProcessor类似。我会在其他地方介绍。 PropertyPlaceholderConfigurer可以将上下文（配置文件）中的属性值放在另一个单独的标准java
  • maven 之 cobertura 简单使用 antlove maventestunitcoberturareport
    1. 创建一个maven项目 2. 创建com.CoberturaStart.java package com; public class CoberturaStart { public void helloEveryone(){ System.out.println("=================================================
  • 程序的执行顺序 百合不是茶 JAVA执行顺序
          刚在看java核心技术时发现对java的执行顺序不是很明白了,百度一下也没有找到适合自己的资料,所以就简单的回顾一下吧   代码如下;     经典的程序执行面试题 //关于程序执行的顺序 //例如： //定义一个基类 public class A(){ public A(
  • 设置session失效的几种方法 bijian1013 web.xmlsession失效监听器
    在系统登录后，都会设置一个当前session失效的时间，以确保在用户长时间不与服务器交互，自动退出登录，销毁session。具体设置很简单，方法有三种：（1）在主页面或者公共页面中加入：session.setMaxInactiveInterval(900);参数900单位是秒，即在没有活动15分钟后，session将失效。这里要注意这个session设置的时间是根据服务器来计算的，而不是客户端。所
  • java jvm常用命令工具 bijian1013 javajvm
    一.概述         程序运行中经常会遇到各种问题，定位问题时通常需要综合各种信息，如系统日志、堆dump文件、线程dump文件、GC日志等。通过虚拟机监控和诊断工具可以帮忙我们快速获取、分析需要的数据，进而提高问题解决速度。 本文将介绍虚拟机常用监控和问题诊断命令工具的使用方法，主要包含以下工具:       &nbs
  • 【Spring框架一】Spring常用注解之Autowired和Resource注解 bit1129 Spring常用注解
    Spring自从2.0引入注解的方式取代XML配置的方式来做IOC之后，对Spring一些常用注解的含义行为一直处于比较模糊的状态，写几篇总结下Spring常用的注解。本篇包含的注解有如下几个： Autowired Resource Component Service Controller Transactional 根据它们的功能、目的，可以分为三组，Autow
  • mysql 操作遇到safe update mode问题 bitray update
        我并不知道出现这个问题的实际原理,只是通过其他朋友的博客,文章得知的一个解决方案,目前先记录一个解决方法,未来要是真了解以后,还会继续补全.     在mysql5中有一个safe update mode,这个模式让sql操作更加安全,据说要求有where条件,防止全表更新操作.如果必须要进行全表操作,我们可以执行 SET
  • nginx_perl试用 ronin47 nginx_perl试用
    因为空闲时间比较多，所以在CPAN上乱翻，看到了nginx_perl这个项目(原名Nginx::Engine)，现在托管在github.com上。地址见：https://github.com/zzzcpan/nginx-perl 这个模块的目的，是在nginx内置官方perl模块的基础上，实现一系列异步非阻塞的api。用connector/writer/reader完成类似proxy的功能（这里
  • java-63-在字符串中删除特定的字符 bylijinnan java
    public class DeleteSpecificChars { /** * Q 63 在字符串中删除特定的字符 * 输入两个字符串，从第一字符串中删除第二个字符串中所有的字符。 * 例如，输入”They are students.”和”aeiou”，则删除之后的第一个字符串变成”Thy r stdnts.” */ public static voi
  • EffectiveJava--创建和销毁对象 ccii 创建和销毁对象
    本章内容： 1. 考虑用静态工厂方法代替构造器 2. 遇到多个构造器参数时要考虑用构建器（Builder模式） 3. 用私有构造器或者枚举类型强化Singleton属性 4. 通过私有构造器强化不可实例化的能力 5. 避免创建不必要的对象 6. 消除过期的对象引用 7. 避免使用终结方法 1. 考虑用静态工厂方法代替构造器     类可以通过
  • [宇宙时代]四边形理论与光速飞行 comsci
       从四边形理论来推论 为什么光子飞船必须获得星光信号才能够进行光速飞行？    一组星体组成星座  向空间辐射一组由复杂星光信号组成的辐射频带，按照四边形-频率假说  一组频率就代表一个时空的入口    那么这种由星光信号组成的辐射频带就代表由这些星体所控制的时空通道，该时空通道在三维空间的投影是一
  • ubuntu server下python脚本迁移数据 cywhoyi pythonKettlepymysqlcx_Oracleubuntu server
    因为是在Ubuntu下，所以安装python、pip、pymysql等都极其方便，sudo apt-get install pymysql， 但是在安装cx_Oracle（连接oracle的模块）出现许多问题，查阅相关资料，发现这边文章能够帮我解决，希望大家少走点弯路。http://www.tbdazhe.com/archives/602 1.安装python 2.安装pip、pymysql
  • Ajax正确但是请求不到值解决方案 dashuaifu Ajaxasync
    Ajax正确但是请求不到值解决方案   解决方案：1 .     async: false ,    2.     设置延时执行js里的ajax或者延时后台java方法！！！！！！！   例如：   $.ajax({     &
  • windows安装配置php+memcached dcj3sjt126com PHPInstallmemcache
    Windows下Memcached的安装配置方法 1、将第一个包解压放某个盘下面，比如在c:\memcached。 2、在终端（也即cmd命令界面）下输入 'c:\memcached\memcached.exe -d install' 安装。 3、再输入： 'c:\memcached\memcached.exe -d start' 启动。（需要注意的: 以后memcached将作为windo
  • iOS开发学习路径的一些建议 dcj3sjt126com ios
    iOS论坛里有朋友要求回答帖子，帖子的标题是： 想学IOS开发高阶一点的东西，从何开始，然后我吧啦吧啦回答写了很多。既然敲了那么多字，我就把我写的回复也贴到博客里来分享，希望能对大家有帮助。欢迎大家也到帖子里讨论和分享，地址：http://bbs.csdn.net/topics/390920759   下面是我回复的内容：   结合自己情况聊下iOS学习建议，
  • Javascript闭包概念 fanfanlovey JavaScript闭包
    1.参考资料 http://www.jb51.net/article/24101.htm http://blog.csdn.net/yn49782026/article/details/8549462 2.内容概述 要理解闭包，首先需要理解变量作用域问题 内部函数可以饮用外面全局变量 var n=999; 　　functio
  • yum安装mysql5.6 haisheng mysql
    1、安装http://dev.mysql.com/get/mysql-community-release-el7-5.noarch.rpm   2、yum install mysql   3、yum install mysql-server   4、vi /etc/my.cnf   添加character_set_server=utf8
  • po/bo/vo/dao/pojo的详介 IT_zhlp80 javaBOVODAOPOJOpo
        JAVA几种对象的解释 PO:persistant object持久对象,可以看成是与数据库中的表相映射的java对象。最简单的PO就是对应数据库中某个表中的一条记录，多个记录可以用PO的集合。PO中应该不包含任何对数据库的操作. VO:value object值对象。通常用于业务层之间的数据传递，和PO一样也是仅仅包含数据而已。但应是抽象出的业务对象,可
  • java设计模式 kerryg java设计模式
    设计模式的分类：    一、 设计模式总体分为三大类： 1、创建型模式（5种）：工厂方法模式，抽象工厂模式，单例模式，建造者模式，原型模式。 2、结构型模式（7种）：适配器模式，装饰器模式，代理模式，外观模式，桥接模式，组合模式，享元模式。 3、行为型模式（11种）：策略模式，模版方法模式，观察者模式，迭代子模式，责任链模式，命令模式，备忘录模式，状态模式，访问者
  • [1]CXF3.1整合Spring开发webservice——helloworld篇 木头.java springwebserviceCXF
    Spring 版本3.2.10 CXF 版本3.1.1 项目采用MAVEN组织依赖jar 我这里是有parent的pom，为了简洁明了，我直接把所有的依赖都列一起了，所以都没version，反正上面已经写了版本 <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="ht
  • Google 工程师亲授：菜鸟开发者一定要投资的十大目标 qindongliang1922 工作感悟人生
    身为软件开发者，有什么是一定得投资的？ Google 软件工程师 Emanuel Saringan 整理了十项他认为必要的投资，第一项就是身体健康，英文与数学也都是必备能力吗？来看看他怎么说。（以下文字以作者第一人称撰写）） 你的健康 无疑地，软件开发者是世界上最久坐不动的职业之一。 每天连坐八到十六小时，休息时间只有一点点，绝对会让你的鲔鱼肚肆无忌惮的生长。肥胖容易扩大罹患其他疾病的风险，
  • linux打开最大文件数量1,048,576 tianzhihehe clinux
    File descriptors are represented by the C int type. Not using a special type is often  considered odd, but is, historically, the Unix way. Each Linux process has a maximum number of files th
  • java语言中PO、VO、DAO、BO、POJO几种对象的解释 衞酆夼 javaVOBOPOJOpo
    PO:persistant object持久对象 最形象的理解就是一个PO就是数据库中的一条记录。好处是可以把一条记录作为一个对象处理，可以方便的转为其它对象。可以看成是与数据库中的表相映射的java对象。最简单的PO就是对应数据库中某个表中的一条记录，多个记录可以用PO的集合。PO中应该不包含任何对数据库的操作。 BO:business object业务对象 封装业务逻辑的java对象
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他