【Java】网络编程,JUnit单元测试,设计模式（二）

//第一个参数表示期望值
//第二个参数表示实际值
// 如果实际值和期望值相同，说明结果正确就测试通过,如果不相同，说明结果是错误的,就会报错
Assert.assertEquals( 期望值, 实际值);
Assert.assertEquals("异常原因"， 期望值, 实际值);
//例如：
int result = add(100,200);
Assert.assertEquals(300, result);  

public static void main(String[] args) {
  // 正常情况下一个类可以创建多个对象
  Person p1 = new Person();
  Person p2 = new Person();
  Person p3 = new Person();
}

public class Singleton {
    // 1.将构造方法私有化，使其不能在类的外部通过new关键字实例化该类对象。
    private Singleton() {}
    // 2.在该类内部产生一个唯一的实例化对象，并且将其封装为private static 类型的成员变量。
    private static final Singleton instance = new Singleton();
    // 3.定义一个静态方法返回这个唯一对象。
    public static Singleton getInstance() {
        return instance;
    }
}

package com.itheima.singledesign;
/*
    需求 : 使用单例模式(饿汉式) , 要求此类只能有一个对象
    步骤 :
        1. 将构造方法私有化，使其不能在类的外部通过new关键字实例化该类对象。
        2. 在该类内部产生一个唯一的实例化对象，并且将其封装为private static 类型的成员变量。
        3. 定义一个静态方法返回这个唯一对象。
 */
public class King {
    // 1. 将构造方法私有化，使其不能在类的外部通过new关键字实例化该类对象。
    private King(){
    }
    // 2. 在该类内部产生一个唯一的实例化对象，并且将其封装为private static 类型的成员变量。
    private static final King KING = new King();
    // 3. 定义一个静态方法返回这个唯一对象。
    public static King getInstance(){
        return KING;
    }
}

 // 1.将构造方法私有化，使其不能在类的外部通过new关键字实例化该类对象。
private Singleton() {}
// 2.在该类内部产生一个唯一的实例化对象，并且将其封装为private static类型的成员变量。
private static Singleton instance;
// 3.定义一个静态方法返回这个唯一对象。要用的时候才例化出对象
public static synchronized Singleton getInstance() {
    if(instance == null) {
        instance = new Singleton();
    }
    return instance;
}

- ##### 注意 ：
- 懒汉单例设计模式在多线程环境下可能会实例化出多个对象，不能保证单例的状态，所以加上关键字：synchronized，保证其同步安全。
- 需求：使用懒汉单例 ，改写皇帝类的单例模式
```java
package com.itheima.singledesign;
/*
    需求 : 使用单例模式(懒汉式) , 要求此类只能有一个对象
    步骤 :
        1. 将构造方法私有化，使其不能在类的外部通过new关键字实例化该类对象。
        2. 在该类内部定义一个private static修饰的成员变量 . 此变量不需要赋值
        3. 定义一个静态方法返回这个唯一对象。 此方法需要加上synchronized关键字保证在多线程中也只有一个实例对象
 */
public class King2 {
    // 1. 将构造方法私有化，使其不能在类的外部通过new关键字实例化该类对象。
    private King2() {
    }
    //  2. 在该类内部定义一个private static修饰的成员变量 . 此变量不需要赋值
    private static King2 king2;
    // 3. 定义一个静态方法返回这个唯一对象。 此方法需要加上synchronized关键字保证在多线程中也只有一个实例对象
    public static synchronized King2 getInstance() {
        if (king2 == null) {
            king2 = new King2();
        }
        return king2;
    }
}

package com.itheima.moreinstance_demo;
import java.util.ArrayList;
import java.util.Random;
/*
    需求  : 某一个学科有固定3位老师，年级中上该课程的老师就是这三位老师其中一位
            要求使用多例模式 ,每次获取的都是这三位老师其中一位
    实现步骤 :
        1.创建一个类,  将构造方法私有化，使其不能在类的外部通过new关键字实例化该类对象。
        2.在类中定义该类被创建对象的总数量
        3.在类中定义存放类实例的list集合
        4.在类中提供静态代码块,在静态代码块中创建类的实例
        5.提供获取类实例的静态方法
 */
public class Teacher {
    // 1.创建一个类,  将构造方法私有化，使其不能在类的外部通过new关键字实例化该类对象。
    private Teacher() {
    }
    // 2.在类中定义该类被创建对象的总数量
    private static int maxCount = 3;
    // 3.在类中定义存放类实例的list集合
    private static ArrayList<Teacher> list = new ArrayList<>();// {teacher1  , teacher2 , teacher3}
    // 4.在类中提供静态代码块,在静态代码块中创建类的实例
    static {
        for (int i = 0; i < maxCount; i++) {
            list.add(new Teacher());
        }
    }
    // 5.提供获取类实例的静态方法
    public static Teacher getInstance() {
        int index = new Random().nextInt(3);// [0 - 2]
        return list.get(index);
    }
}

package com.itheima.factorydesign_demo;
/*
  - 需求：定义汽车工厂类，生产各种品牌的车
  - 实现步骤
      - 编写一个Car接口, 提供run方法
      - 编写一个Falali类实现Car接口,重写run方法
      - 编写一个Benchi类实现Car接口
      =============================================
      - 提供一个CarFactory(汽车工厂),用于生产汽车对象
      - 定义CarFactoryTest测试汽车工厂
 */
public class CarTest {
    public static void main(String[] args) {
        Car benchi = CarFactory.getInstance(Brand.BENCHI);
        System.out.println(benchi);
    }
}
// 汽车接口
interface Car {
    public abstract void run();
}
// 编写一个Falali类实现Car接口,重写run方法
class Falali implements Car {
    public Falali() {
    }
    @Override
    public void run() {
        System.out.println("法拉利破百需要3秒...");
    }
}
// 编写一个Benchi类实现Car接口
class Benchi implements Car {
    @Override
    public void run() {
        System.out.println("奔驰破百需要5秒...");
    }
}
// 汽车品牌枚举
enum Brand {
    BENCHI, FALALI, BAOMA, BINLI, AODI;
}
// 提供一个CarFactory(汽车工厂),用于生产汽车对象
class CarFactory {
    private CarFactory() {
    }
    public static Car getInstance(Brand brand) {
        switch (brand) {
            case FALALI:
                return new Falali();
            case BENCHI:
                return new Benchi();
            default:
                return null;
        }
    }
}
 提供一个CarFactory(汽车工厂),用于生产汽车对象
//class CarFactory{
//    private CarFactory(){}
//
//    public static Car getInstance(String brand) {
//        if(brand.equals("Falali")){
//            return new Falali(10);
//        }else if(brand.equals("Benchi")) {
//            return new Benchi();
//        }else {
//            return null;
//        }
//    }
//}