Java

javac java源文件的路径

在DOS窗口中使用

一个java源文件可以编译生成多个.class文件，.class文件是最终要执行的文件

(跨平台性)编译结束后也可以将.class文件复制到其他操作系统中运行

int i = 20; // set
System.out.println(i); // get

int i; // 不进行赋值无法开辟出内存空间
System.out.println(i)； // 编译报错，变量i未初始化

二进制最左边为符号位，0表示正数，1表示负数

byte类型最大值:01111111 (10000000-1=01111111)

byte类型最大值：2的7次方-1，127

byte类型的范围：-128~127 表示256个不同的二进制位

int a = 10; 结果为10
int b = 010; 结果为8
int c = 0x10; 结果为16
int d = a+b+c;结果为34

不会报错

456整数型字面值被当作int类型，占4个字节，x变量在声明时是long类型，占8个字节，int类型的字面值456赋值给long类型的变量x，存在类型转换，int是小容量，转换成long类型的大容量，小容量可以自动转换成大容量，称为自动类型转换

会报错

2147483648被当作int类型4个字节处理，但是这个字面值超出了int类型的处理范围

不会报错

在2447483648后面添加L会使该字面值一上来就被当long类型来处理，当然也不会存在类型转换了

int y = x;// 编译报错(大容量转小容量)

小容量可以直接转换成大容量

大容量转小容量需要进行强制类型转换

强制类型转换需要加"强制类型转换符"

虽然加上强制类型转换符之后可以通过，但是进入到运行阶段可能会损失精度

强制转换原理

class Bird{
int age;
public Bird(int age){
this.age = age;
}

@Override
public String toString() {
return "Bird{" +
"age=" + age +
'}';
}
}

// 单独写一个比较器
class BirdComparator implements Comparator<Bird>{

@Override
public int compare(Bird o1, Bird o2) {
return o1.age - o2.age;
}
}

public class Test03 {
public static void main(String[] args) {
         TreeSet<Object> birds = new TreeSet(new BirdComparator());
         birds.add(new Bird(100));
         birds.add(new Bird(80));
         for (Object bird : birds) {
                   System.out.println(bird);
         }
}
}

public class Test03 {
public static void main(String[] args) {
        // 静态内部类的方式
        TreeSet<Object> birds = new TreeSet(new Comparator<Bird>() {
        @Override
         public int compare(Bird o1, Bird o2) {
             return o1.age - o2.age;
         }
        });
        birds.add(new Bird(100));
        birds.add(new Bird(80));
        for (Object bird : birds) {
           System.out.println(bird);
        }
}
}

file文件内：a中

a占一个字节，中占两个字节

第一次读：一个字节，正好读到'a'

第二次读：一个字节，读到'中'字符的一半

第三次读：一个字节，读到'中'字符的另一半

file.txt中的内容：a中

第一次读：一个字符，读到'a'字符

第二次读：一个字符，读到'中'字符

我写了一个类Student implements Serializable
小明写了一个类Student implements Serializable
不同的人编写了同一个类Student，但这两个类确实不是同一个类，这时使用序列化版本号来区分，这时JVM可以通过序列化版本号区分出来

select * from t_user where loginName = ? and loginPwd = ?

?称为占位符，问好只能填充值

问号不能带引号，否则会认为是字符串

一个问号代表一个占位符

简答实用

不管用不用，类加载时就完成实例化

package pers.chenjiahao.review;

/**
 * review饿汉式
 * 类加载到内存后，就实例化一个单例，JVM保证线程安全
 * 简单实用，推荐使用
 * 唯一缺点：不管用不用，类加载时就完成实例化
 * @Author ChenJiahao
 * @Date 2021/7/31 16:01
 */
public class ReviewMgr01 {
    private static final ReviewMgr01 INSTANCE = new ReviewMgr01();
    private ReviewMgr01() {
    }
    public static ReviewMgr01 getInstance(){
        return INSTANCE;
    }
    public static void main(String[] args) {
        ReviewMgr01 instance = ReviewMgr01.getInstance();
        ReviewMgr01 instance1 = ReviewMgr01.getInstance();
        System.out.println(instance == instance1);
    }
}

按需进行初始化

线程不安全，两个线程同时访问的话可能会造成创建了两个实例对象的问题

package pers.chenjiahao.review;

/**
 * review
 * 懒汉式
 * 虽然达到了按需初始化的目的，但却带来线程不安全的问题,两个线程同时访问的话可能会造成创建了两个实例对象的问题
 * @Author ChenJiahao
 * @Date 2021/7/31 16:05
 */
public class ReviewMgr03 {
    // 这里不能写final 写了final必须初始化
    private static ReviewMgr03 INSTANCE;
    private ReviewMgr03(){
    }
    public static ReviewMgr03 getInstance(){
        if (INSTANCE == null){
            INSTANCE = new ReviewMgr03();
        }
        return INSTANCE;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                System.out.println(ReviewMgr03.getInstance().hashCode());
            }).start();
        }
    }
}

package pers.chenjiahao.review;

/**
 * review
 * 懒汉式
 * 虽然达到了按需初始化的目的，但却带来线程不安全的问题,两个线程同时访问的话可能会造成创建了两个实例对象的问题
 * @Author ChenJiahao
 * @Date 2021/7/31 16:05
 */
public class ReviewMgr03 {
    // 这里不能写final 写了final必须初始化
    private static ReviewMgr03 INSTANCE;
    private ReviewMgr03(){
    }
    public static ReviewMgr03 getInstance(){
        if (INSTANCE == null){
            // 问题就出在这里,如果当前线程睡眠一下，别的线程也能进来，那么会创造出多个对象
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            INSTANCE = new ReviewMgr03();
        }
        return INSTANCE;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                System.out.println(ReviewMgr03.getInstance().hashCode());
            }).start();
        }
    }
}

可以通过synchronized解决，但也带来了效率下降的问题,每次都要先判断锁

package pers.chenjiahao.review;

/**
 * review
 * 懒汉式
 * 可以通过synchronized解决，但也带来了效率下降的问题,每次都要先判断锁
 * @Author ChenJiahao
 * @Date 2021/7/31 16:05
 */
public class ReviewMgr04 {
    private static ReviewMgr04 INSTANCE;
    private ReviewMgr04(){
    }
    // ReviewMgr04.class对象
    public static synchronized ReviewMgr04 getInstance(){
        if (INSTANCE == null){
            try{
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            INSTANCE = new ReviewMgr04();
        }
        return INSTANCE;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                System.out.println(ReviewMgr04.getInstance().hashCode());
            }).start();
        }
    }
}

package pers.chenjiahao.review;

/**
 * review
 * 懒汉式
 * 试着通过减小同步代码块的方式提高效率，!!!!!!!!!!!不可行!!!!!!!
 * 反而会造成无法确保只有一个实例对象
 * 比如说两个线程都进入null了，一个先拿到锁，另外一个等。所以就创建了两个实例化对象
 * @Author ChenJiahao
 * @Date 2021/7/31 16:05
 */
public class ReviewMgr05 {
    private static ReviewMgr05 INSTANCE;
    private ReviewMgr05(){
    }
    // 减小同步代码块的范围
    public static ReviewMgr05 getInstance(){
        if (INSTANCE == null){
            synchronized (ReviewMgr05.class){
                try{
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                INSTANCE = new ReviewMgr05();
            }
        }
        return INSTANCE;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                System.out.println(ReviewMgr05.getInstance().hashCode());
            }).start();
        }
    }
}

package pers.chenjiahao.review;

/**
 * review
 * 懒汉式
 * 双重检查
 * @Author ChenJiahao
 * @Date 2021/7/31 16:05
 */
public class ReviewMgr06 {
    // 不能加final 需要加volatile，要保证有序性，跟synchronized意思差不多
    private static volatile ReviewMgr06 INSTANCE;
    private ReviewMgr06(){
    }
    public static ReviewMgr06 getInstance(){
        // 双重检查
        if (INSTANCE == null){
            synchronized (ReviewMgr06.class){
                // 双重检查
                if (INSTANCE == null){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    INSTANCE = new ReviewMgr06();
                }
            }
        }
        return INSTANCE;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                System.out.println(ReviewMgr06.getInstance().hashCode());
            }).start();
        }
    }
}

package pers.chenjiahao.review;

/**
 * review
 * 静态内部类方式
 * JVM保证单例 JVM只加载一次外部类 调用内部类后只加载一次内部类
 * 加载外部类时不会加载内部类，这样可以实现懒加载
 * 完美的写法之一
 * @Author ChenJiahao
 * @Date 2021/7/31 16:06
 */
public class ReviewMgr07 {
    private ReviewMgr07(){
    }
    private static class ReviewMgr07Holder{
        private static final ReviewMgr07 INSTANCE = new ReviewMgr07();
    }
    public static ReviewMgr07 getInstance(){
        return ReviewMgr07Holder.INSTANCE;
    }

    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                System.out.println(ReviewMgr07.getInstance().hashCode());
            }).start();
        }
    }
}

package pers.chenjiahao.review;

/**
 * 枚举单例
 * 不仅可以解决线程同步，还可以防止反序列化
 * @Author ChenJiahao
 * @Date 2021/7/31 16:06
 */
public enum ReviewMgr08 {
    INSTANCE;

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            new Thread(()->{
                System.out.println(ReviewMgr08.INSTANCE.hashCode());
            }).start();
        }
    }
}

在类中定义的比较规则，一般用于两个相同的类进行比较

通常会将需要比较的对象数组和对应对象类型的比较器传入到一个排序比较的方法中，一般用于多个相同的类进行比较排序使用，较为方便

比较接口

实现比较接口的具体实现类

测试类

实体类(被比较的对象)

比较器接口

实现比较器接口的具体比较器

排序类

测试类

定义Comparable<T>接口

Comparable接口的实现类

测试类

比较的实体类

Comparator<T>接口

Comparator接口实现类

Sorter<T>(排序类，传入对象数组以及对应对象的比较器)

测试类

灵活控制生产过程

控制权限、修饰、日志等等

产品维度好扩展

不好扩族

我们将创建一个 Moveable接口和实现 Moveable 接口的实体类。下一步是定义工厂类 CarFactory和CarFactory。
Test 类使用 CarFactory 来获取 Car 对象，使用 PlaneFactory 来获取 Plane对象

图

类的接口

类(实现类)

简单工厂(创造这个类的)

额外的一个测试方法(正常情况下不需要)

以创造交通工具为例

接口Moveable(可移动)

实现类

简单工厂

测试类

测试结果

每个工厂没有规范，里面的方法都可以随便写

如果两个工厂的方法名称不一样，同一套代码就不可行了

假设给每个工厂增加一个抽象父类去统一一下每个工厂的生产名

增加一个抽象类TrafficFactory

CarFactory继承TrafficFactory

PlaneFactory继承TrafficFactory

这样就使两个简单工厂中的方法名统一了

但是没有使测试类中的两行代码统一

继续改造

给TrafficFactory中增加一个Map

后期设想，每个简单工厂在初始化的时候自动加载到TrafficFctory的Map中

在测试类中Moveable m = TrafficFactory.trafficFactoryMap.get("PlaneFactory").create();

改造结果：一半一半(给简单工厂初始化的时候失败了)

修改测试类改造成功，有瑕疵，暂时先这样

产品一族号扩展

不好扩展单个产品(IOC可以解决)

创建抽象工厂，由子工厂继承，通过子工厂去创建具体的抽象实现，这样可以实现一族的扩展，例如，下图中，现代工厂和魔法工厂生产出的武器和移动工具是不同的

抽象工厂(定义了抽象方法，返回值都是返回抽象类)

抽象类

继承了抽象类的实现类

工厂方法(继承抽象工厂)

额外的一个测试方法(正常情况下不需要)

以创造食物、武器、交通工具为例

抽象工厂AbstractFactory

抽象类

实体类

工厂方法

额外的一个测试方法(正常情况下不需要)

面向政府的各个部门之间，来回跑，很累

有了门面之后，只用去面向门面，轻松了不好啊

门面中需要聚合被代理的具体事物

在无参构造中，需要给聚合的事物赋值(new相应事物的无参构造)

分别提供对应具体事物的方法

package pers.chenjiahao.facade;

/**
 * @Author ChenJiahao
 * @Date 2021/8/16 22:02
 */
public interface Shape {
    void draw();
}

Circle

Rectangle

Square

package pers.chenjiahao.facade;

/**
 * 管理Shape的门面
 * @Author ChenJiahao
 * @Date 2021/8/16 22:04
 */
public class ShapeFacade {
    private Shape circle;
    private Shape rectangle;
    private Shape square;

    public ShapeFacade() {
        circle = new Circle();
        rectangle = new Rectangle();
        square = new Square();
    }

    public void drawCircle(){
        circle.draw();
    }

    public void drawRectangle(){
        rectangle.draw();
    }

    public void drawSquare(){
        square.draw();
    }

}

package pers.chenjiahao.facade;

/**
 * 测试类
 * @Author ChenJiahao
 * @Date 2021/8/16 22:04
 */
public class Test {
    public static void main(String[] args) {
        ShapeFacade shapeFacade = new ShapeFacade();
        shapeFacade.drawCircle();
        shapeFacade.drawRectangle();
        shapeFacade.drawSquare();
    }
}

package pers.chenjiahao.facadeplus;

/**
 * 管理Shape的门面
 * @Author ChenJiahao
 * @Date 2021/8/16 22:04
 */
public class ShapeFacade {
    private Shape circle;
    private Shape rectangle;
    private Shape square;

    public ShapeFacade() {
        circle = new Circle();
        rectangle = new Rectangle();
        square = new Square();
    }

    public ShapeFacade drawCircle(){
        circle.draw();
        return this;
    }

    public ShapeFacade drawRectangle(){
        rectangle.draw();
        return this;
    }

    public ShapeFacade drawSquare(){
        square.draw();
        return this;
    }

}

package pers.chenjiahao.facadeplus;

/**
 * 测试类
 * @Author ChenJiahao
 * @Date 2021/8/16 22:04
 */
public class Test {
    public static void main(String[] args) {
        ShapeFacade shapeFacade = new ShapeFacade();
        shapeFacade.drawCircle().drawRectangle().drawSquare();
    }
}

在发送消息的方法中，嵌入中介类

package pers.chenjiahao.mediator;

/**
 * @Author ChenJiahao
 * @Date 2021/8/18 21:32
 */
public class User {
    private String name;

    public User() {
    }

    public User(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

    public void sendMessage(String message){
        ChatRoom.showMessage(this,message);
    }
}

package pers.chenjiahao.mediator;

import java.util.Date;

/**
 * 中介类
 * @Author ChenJiahao
 * @Date 2021/8/18 21:32
 */
public class ChatRoom {
    public static void showMessage(User user,String message){
        System.out.println(new Date().toString() + "[" + user.getName() + "]：" + message);
    }
}

package pers.chenjiahao.mediator;

/**
 * @Author ChenJiahao
 * @Date 2021/8/18 21:39
 */
public class Main {
    public static void main(String[] args) {
        User chen = new User("Jiahao Chen");
        User yang = new User("Qinhang Yang");
        chen.sendMessage("hi yang");
        yang.sendMessage("hi chen");
    }
}

package pers.chenjiahao.multiple;

/**
 * @Author ChenJiahao
 * @Date 2021/8/18 21:45
 */
public abstract class People {
    String name;
    public abstract void sendMessage(String message);
}

package pers.chenjiahao.multiple;

/**
 * @Author ChenJiahao
 * @Date 2021/8/18 21:32
 */
public class User extends People{

    public User() {
    }

    public User(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public void sendMessage(String message){
        ChatRoom.showMessage(this,message);
    }
}

package pers.chenjiahao.multiple;

/**
 * @Author ChenJiahao
 * @Date 2021/8/18 21:45
 */
public class Manager extends People{

    public Manager() {
    }

    public Manager(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

    @Override
    public void sendMessage(String message) {
        ChatRoom.showMessage(this,message);
    }
}

package pers.chenjiahao.multiple;

import java.util.Date;

/**
 * 中介类
 * @Author ChenJiahao
 * @Date 2021/8/18 21:32
 */
public class ChatRoom {
    public static void showMessage(People people, String message){
        System.out.println(new Date().toString() + "[" + people.name + "]：" + message);
    }
}

package pers.chenjiahao.multiple;

/**
 * @Author ChenJiahao
 * @Date 2021/8/18 21:39
 */
public class Main {
    public static void main(String[] args) {
        new User("Jiahao Chen").sendMessage("hi yang");
        new User("Qinhang Yang").sendMessage("hi chen");
        new Manager("Kun Fang").sendMessage("hi chen、hi yang");
        /*People chen = new User("Jiahao Chen");
        People yang = new User("Qinhang Yang");
        People fang = new Manager("Kun Fang");
        chen.sendMessage("hi yang");
        yang.sendMessage("hi chen");
        fang.sendMessage("hi chen、hi yang");*/
    }
}

内嵌一个接口的对象，再给一个有参构造对此对象进行赋值

在再实现的方法中使用上述对象去调用

重写接口中的方法，在原有的方法基础上，增加新的方法，实现了装饰

package pers.chenjiahao.decorator;

/**
 * @Author ChenJiahao
 * @Date 2021/8/19 21:22
 */
public interface Shape {
    void draw();
}

Circle

Rectangle

package pers.chenjiahao.decorator;

/**
 * @Author ChenJiahao
 * @Date 2021/8/19 21:23
 */
public abstract class ShapeDecorator implements Shape {

    protected Shape decoratedShape;

    public ShapeDecorator(Shape decoratedShape) {
        this.decoratedShape = decoratedShape;
    }

    @Override
    public void draw() {
        decoratedShape.draw();
    }
}

package pers.chenjiahao.decorator;

/**
 * @Author ChenJiahao
 * @Date 2021/8/19 21:31
 */
public class RedShapeDecorator extends ShapeDecorator {
    public RedShapeDecorator(Shape decoratedShape) {
        super(decoratedShape);
    }

    @Override
    public void draw() {
        decoratedShape.draw();
        setRedBorder(decoratedShape);
    }

    private void setRedBorder(Shape decoratedShape){
        System.out.println("Border Color: Red");
    }
}

package pers.chenjiahao.decorator;

/**
 * @Author ChenJiahao
 * @Date 2021/8/19 21:23
 */
public class Test {
    public static void main(String[] args) {
        Shape circle = new Circle();
        // ShapeDecorator redCircle = new RedShapeDecorator(new Circle());
        // ShapeDecorator redRectangle = new RedShapeDecorator(new Rectangle());
        Shape redCircle = new RedShapeDecorator(new Circle());
        Shape redRectangle = new RedShapeDecorator(new Rectangle());
        System.out.println("Circle with normal border");
        circle.draw();

        System.out.println("\nCircle of red border");
        redCircle.draw();

        System.out.println("\nRectangle of red border");
        redRectangle.draw();
    }
}

Shape(接口)

实体类(实现接口)

ShapeDecorator(实现接口的抽象类)

RedShapeDecorator(继承装饰器的扩展装饰器类)

BlackShapeDecorator(继承装饰器的扩展装饰器类)

ShapeDecoratorChain(继承装饰器的链式装饰器类)

测试类

后台要经过信息处理才能发表或进入数据库

图解

含有有一个普通方法doFilter(Msg m)

interface Filter{
    boolean doFilter(Msg m);
}

FaceFilter

HtmlFilter

SensitiveFilter

实现Filter

含有一个Filter集合

额外增加一个add方法

重写doFilter方法
对Filter集合进行遍历

class FilterChain implements Filter{
    List<Filter> filters = new ArrayList<>();
    public FilterChain add(Filter f){
        filters.add(f);
        return this;
    }
    public boolean doFilter(Msg msg){
        for (Filter filter : filters) {
            if (!filter.doFilter(msg)){
                return false;
            }
        }
        return true;
    }
}

class Msg{
    String name;
    String msg;

    public String getName() {
        return name;
    }

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

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    @Override
    public String toString() {
        return "Msg{" +
                "msg='" + msg + '\'' +
                '}';
    }
}

/**
 * @Author ChenJiahao(程序员五条)
 * @Date 2021/8/1 13:50
 */
public class Main {
    public static void main(String[] args) {
        Message message = new Message();
        message.setMsg("大家好:)，<script>，我是程序员五条，大家都是996");
        // 过滤表情和HTML的链条
        FilterChain filterChain = new FilterChain();
        filterChain.add(new FaceFilter()).add(new HtmlFilter());

        // 过滤996的链条
        FilterChain filterChain1 = new FilterChain();
        filterChain1.add(new SensitiveFilter());

        // 两个链条合并(也可以单用)
        filterChain.add(filterChain1);

        // 执行链条
        filterChain.doFilter(message);
        System.out.println(message);
    }
}

拦截接口SqlInterceptor

拦截接口的实现类

拦截链SqlCheckInterceptorChain

测试类

在构造方法中可以进行一些信息的设置，便于后面使用

在方法中传入事件

进行观察到事件后进行的响应操作

内聚事件对象

源对象(事件本身)

定义一个观察者的集合对象，责任链的思想(责任链：https://blog.csdn.net/qq_42874315/article/details/120229565)

定义一个触发方法，这个方法中主要是进行事件的触发，然后通过遍历责任链(同时传入事件)去做出响应

创建抽象类Event

其中含有一个抽象方法

/**
 * 事件抽象类
 * @Author ChenJiahao(程序员五条)
 * @Date 2021/9/11 15:20
 */
public abstract class Event<T> {
    abstract T getSource();
}

继承事件接口

定义一下事件

/**
 * @Author ChenJiahao(程序员五条)
 * @Date 2021/9/11 15:21
 */
public class WakeUpEvent extends Event<Child> {
    long timestamp;
    String loc;
    Child source;
    public WakeUpEvent(long timestamp, String loc, Child source){
        this.timestamp = timestamp;
        this.loc = loc;
        this.source = source;
    }

    @Override
    Child getSource() {
        return source;
    }
}

创建接口Observer，还要创建一个监听的方法，参数为事件

/**
 * 观察者接口
 * @Author ChenJiahao(程序员五条)
 * @Date 2021/9/11 15:23
 */
public interface Observer {
    void actionOnWakeUp(Event event);
}

Dad

Mum

Dog

创建一个Child类

添加属性List<Observer> observers，监听器链

将具体的监听器注入到监听器链中

创建一个方法，作为触发唤醒监听事件
在这个方法中需要进行事件的创建，以及监听器链的遍历触发

/**
 * 被观察者
 * @Author ChenJiahao(程序员五条)
 * @Date 2021/9/11 15:22
 */
public class Child {
    private String name;
    private Event event;

    public Child(String name) {
        this.name = name;
    }

    private List<Observer> observers = new ArrayList<>();
    {
        observers.add(new Dad());
        observers.add(new Mum());
        observers.add(new Dog());
    }

    public void wakeUp(){
        this.event = new WakeUpEvent(System.currentTimeMillis(),"bed",this);
        for (Observer observer : observers) {
            observer.actionOnWakeUp(event);
        }
    }

    @Override
    public String toString() {
        return "Child{" +
                "name='" + name + "'}";
    }
}

创建Child对象

执行wakeUp()方法，作为触发事件

/**
 * @Author ChenJiahao(程序员五条)
 * @Date 2021/9/11 15:29
 */
public class Test {
    public static void main(String[] args) {
        Child child = new Child("五条宝宝");
        child.wakeUp();
    }
}

Child(不再进行观察者的注册了)

ObserverStrategy(策略接口)

策略接口实现类

Event(未修改)

Observer(未修改)

具体观察者(未修改)

测试类

上述引入的策略不是很优雅，可以再引入工厂，这里不再详细概述了，详情参考下述链接(优雅的干掉if-else)

https://blog.csdn.net/qq_42874315/article/details/119877790

存储一个或多个叶子的集合

还包含一个add方法，主要的作用是向集合中添加叶子的

存储内容

测试类中包含一个打印树状格式的方法

/**
 * @Author ChenJiahao(程序员五条)
 * @Date 2021/9/14 19:35
 */
public abstract class Node {
    abstract public void print();
}

/**
 * @Author ChenJiahao(程序员五条)
 * @Date 2021/9/14 19:42
 */
public class BranchNode extends Node{
    List<Node> nodes = new ArrayList<>();
    String name;

    public BranchNode(String name) {
        this.name = name;
    }

    @Override
    public void print() {
        System.out.println(name);
    }

    public void add(Node node){
        nodes.add(node);
    }
}

/**
 * @Author ChenJiahao(程序员五条)
 * @Date 2021/9/14 19:50
 */
public class LeafNode extends Node{
    String content;

    public LeafNode(String content){
        this.content = content;
    }

    @Override
    public void print() {
        System.out.println(content);
    }
}

/**
 * @Author ChenJiahao(程序员五条)
 * @Date 2021/9/14 19:42
 */
public class Test {
    public static void main(String[] args) {
        BranchNode root = new BranchNode("root");
        BranchNode chapter1 = new BranchNode("chapter1");
        BranchNode chapter2 = new BranchNode("chapter2");
        Node c11 = new LeafNode("c11");
        Node c12 = new LeafNode("c12");
        BranchNode b21 = new BranchNode("section21");
        Node c211 = new LeafNode("c211");
        Node c212 = new LeafNode("c212");

        root.add(chapter1);
        root.add(chapter2);
        chapter1.add(c11);
        chapter1.add(c12);
        chapter2.add(b21);
        b21.add(c211);
        b21.add(c212);
        // 递归打印出树 第二个参是为了看结构的 深度
        tree(root,0);
    }

    static void tree(Node b, int depth) {
        for (int i = 0; i < depth; i++) {
            System.out.print("--");
        }
        b.print();
        if (b instanceof BranchNode){
            // 说明下面有子节点
            for (Node n :((BranchNode) b).nodes){
                tree(n,depth + 1);
            }
        }
    }
}

创建一个 Shape 接口和实现了 Shape 接口的实体类 Circle。
定义工厂类 ShapeFactory。ShapeFactory 有一个 Circle 的 HashMap，其中键名为 Circle 对象的颜色。无论何时接收到请求，都会创建一个特定颜色的圆。ShapeFactory 检查它的 HashMap 中的 circle 对象，如果找到 Circle 对象，则返回该对象，否则将创建一个存储在 hashmap 中以备后续使用的新对象，并把该对象返回到客户端。
在测试类中使用 ShapeFactory 来获取 Shape 对象。它将向 ShapeFactory 传递信息（red / green / blue/ black / white），以便获取它所需对象的颜色。

工厂中定义一个map属性，这个map就是存储实现类的池

通过工厂构造出实现类(在构造实现类的时候调用了池)

/**
 * @Author ChenJiahao(程序员五条)
 * @Date 2021/9/13 20:40
 */
public interface Shape {
    void draw();
}

/**
 * @Author ChenJiahao(程序员五条)
 * @Date 2021/9/13 20:41
 */
public class Circle implements Shape {
    private String color;
    private int x;
    private int y;
    private int radius;

    public Circle(String color, int x, int y, int radius) {
        this.color = color;
        this.x = x;
        this.y = y;
        this.radius = radius;
    }

    @Override
    public void draw() {
        System.out.println("Circle: Draw() [Color : " + color + ", x : " + x +", y :" + y +", radius :" + radius);
    }
}

/**
 * circleMap属性就是池的概念
 * @Author ChenJiahao(程序员五条)
 * @Date 2021/9/13 20:43
 */
public class ShapeFactory {
    private static final Map<String, Shape> circleMap = new HashMap<>();

    public static Shape getCircle(String color) {
        Circle circle = (Circle)circleMap.get(color);

        if(circle == null) {
            circle = new Circle(color,10,20,30);
            circleMap.put(color, circle);
            System.out.println("Creating circle of color : " + color);
        }
        return circle;
    }
}

/**
 * @Author ChenJiahao(程序员五条)
 * @Date 2021/9/13 20:44
 */
public class Test {
    private static final String colors[] =
            { "Red", "Green", "Blue", "White", "Black" };
    public static void main(String[] args) {
        for(int i = 0; i < 5; ++i) {
            Circle circle = (Circle)ShapeFactory.getCircle(colors[i]);
            circle.draw();
        }
    }
}

在主方法中面向代理去执行

被代理的类抽象出的接口

被代理的类(实现接口)

代理类(实现接口，聚合接口，构造的时候就赋值)

测试类(面向代理去调用)

Movable接口

Tank(被代理的实体类，实现Movable)

代理类(实现Movable)

测试类

实现JDK中的Proxy类

Proxy.newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)

newProxyInstance()会返回一个代理对象

// 第一个参:(跟被代理对象用同一个就好)用哪个Classloader来把将来返回来的代理对象漏到内存
        // 第二个参:(被new出来的对象要实现这个接口)代理对象应该实现哪些接口
        // 第三个参：调用处理器 其实就是实现了InvocationHandler的对象

被代理的类抽象出的接口

被代理的类(实现接口)

代理类(实现InvocationHandler接口)

测试类

Movable接口

Tank(实现Movable)

代理类：实现InvocationHandler接口

测试类

public class LogHandler implements InvocationHandler {
    // 这里先代理坦克类 后面可以代理任何类型
    Movable movable;

    public LogHandler(Movable movable) {
        this.movable = movable;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        before(method);
        Object o = method.invoke(movable,args);
        after(method);
        return o;
    }

    private void after(Method method) {
        System.out.println("method" + method.getName() + "end!");
    }

    private void before(Method method) {
        System.out.println("method" + method.getName() + "start ...");
    }
}

对需要迭代的实体类进行赋值，然后通过用户获取迭代器的接口中的getIterator方法获取迭代器，最后遍历迭代器

package pers.chenjiahao.iterator.v6;

/**
 * @Author ChenJiahao(程序员五条)
 * @Date 2021/8/28 21:02
 */
public interface Iterator {
    public boolean hasNext();
    public Object next();
}

package pers.chenjiahao.iterator.v6;

/**
 * @Author ChenJiahao(程序员五条)
 * @Date 2021/8/28 21:02
 */
public interface Container {
    public Iterator getIterator();
}

package pers.chenjiahao.iterator.v6;

/**
 * @Author ChenJiahao(程序员五条)
 * @Date 2021/8/28 21:03
 */
public class NameRepository implements Container {
    public String[] names;

    public NameRepository(String[] names) {
        this.names = names;
    }

    @Override
    public Iterator getIterator() {
        return new NameIterator();
    }

    private class NameIterator implements Iterator{
        int index;

        @Override
        public boolean hasNext() {
            if(index < names.length){
                return true;
            }
            return false;
        }

        @Override
        public Object next() {
            if(this.hasNext()){
                return names[index++];
            }
            return null;
        }
    }
}

package pers.chenjiahao.iterator.v6;

/**
 * @Author ChenJiahao(程序员五条)
 * @Date 2021/8/28 21:03
 */
public class NameRepository implements Container {
    public String[] names;

    public NameRepository(String[] names) {
        this.names = names;
    }

    @Override
    public Iterator getIterator() {
        return new NameIterator();
    }

    private class NameIterator implements Iterator{
        int index;

        @Override
        public boolean hasNext() {
            if(index < names.length){
                return true;
            }
            return false;
        }

        @Override
        public Object next() {
            if(this.hasNext()){
                return names[index++];
            }
            return null;
        }
    }
}

package pers.chenjiahao.iterator.v6;

/**
 * @Author ChenJiahao(程序员五条)
 * @Date 2021/8/28 21:05
 */
public class Main {
    public static void main(String[] args) {
        String[] names = {"Robert" , "John" ,"Julie" , "Lora"};
        NameRepository namesRepository = new NameRepository(names);

        for(Iterator iter = namesRepository.getIterator(); iter.hasNext();){
            String name = (String)iter.next();
            System.out.println("Name : " + name);
        }
    }
}

实现Visitor接口，编写一些自己的属性逻辑，实现三个具体的方法，在这里进行对不同访问者的不同操作

/**
 * 水果抽象类
 * @Author ChenJiahao
 * @Date 2021/8/1 20:06
 */
public abstract class FruitPart {
    abstract void accept(Visitor visitor);
    abstract double getPrice();
}

需要注意的是，在accept方法中，调用访问者的具体相关自身实体类的方法

Apple

Banana

Watermelon

/**
 * @Author ChenJiahao
 * @Date 2021/8/1 20:09
 */
public class Fruit{
    private FruitPart banana = new Banana();
    private FruitPart apple = new Apple();
    private FruitPart watermelon = new Watermelon();

    public void accept(Visitor visitor){
        banana.accept(visitor);
        apple.accept(visitor);
        watermelon.accept(visitor);
    }
}

/**
 * @Author ChenJiahao
 * @Date 2021/8/1 20:07
 */
public interface Visitor {
    void visitBanana(Banana banana);
    void visitApple(Apple apple);
    void visitWatermelon(Watermelon watermelon);
}

PersonalVisitor

Wholesaler

/**
 * @Author ChenJiahao
 * @Date 2021/8/1 20:16
 */
public class Main {
    public static void main(String[] args) {
        // 个人原价 70
        PersonalVisitor personalVisitor = new PersonalVisitor();
        new Fruit().accept(personalVisitor);
        System.out.println(personalVisitor.totalPrice);

        // 商户七折 49
        Wholesaler wholesaler = new Wholesaler();
        new Fruit().accept(wholesaler);
        System.out.println(wholesaler.totalPrice);
    }
}

需要构造的实体类

实体类中需要一个具体的构造类

构造类中需要聚合一个需要构造的实体类对象

构造类中需要写各种构造该实体类中不同属性的方法

构造类中还需要一个构造结束的方法build()，返回的对象是内聚的实体类

额外的一个测试方法(正常情况下不需要)

注：构造类中方法的返回值均为构造类本身(return this)，这样做的目的是为了能够链式构造

构建器接口

需要构造的实体类

构造器接口实现类(里面要聚合一个将要构造的具体对象)

额外的一个测试方法(正常情况下不需要)

Person(需要构造的类，构造器放在其内部，用静态内部类表示)

Location(Person中以用的类)

测试类

TerrainBuilder(构造器接口)

Terrain(需要构造的实体类)

ComplexTerrainBuilder(构造器接口实现类)

测试类

电压转换头：220V的插头在110V上用不了，这时就需要一个转接头了

Java中想去使用SQLServer，但是Java提供的是JDBC，SQLServer提供的是ODBC

这时在它们之间就需要一个转换器：JDBC-ODBC-Bridge

图解

package pers.chenjiahao.mediaadapter;

/**
 * 基本媒体
 * @Author ChenJiahao
 * @Date 2021/8/21 17:35
 */
public interface MediaPlayer {
    public void play(String audioType,String fileName);
}

package pers.chenjiahao.mediaadapter;

/**
 * 高级媒体
 * @Author ChenJiahao
 * @Date 2021/8/21 17:36
 */
public interface AdvancedMediaPlayer {
    public void playVlc(String fileName);
    public void playMp4(String fileName);
}

VlcPlayer

Mp4Player

package pers.chenjiahao.mediaadapter;

/**
 * 基本媒体的适配器
 * @Author ChenJiahao
 * @Date 2021/8/21 17:40
 */
public class MediaAdapter implements MediaPlayer {

    private AdvancedMediaPlayer advancedMusicPlayer;

    public MediaAdapter(String audioType) {
        if("vlc".equalsIgnoreCase(audioType)){
            advancedMusicPlayer = new VlcPlayer();
        } else if ("mp4".equalsIgnoreCase(audioType)){
            advancedMusicPlayer = new Mp4Player();
        }
    }

    @Override
    public void play(String audioType, String fileName) {
        if("vlc".equalsIgnoreCase(audioType)){
            advancedMusicPlayer.playVlc(fileName);
        }else if("mp4".equalsIgnoreCase(audioType)){
            advancedMusicPlayer.playMp4(fileName);
        }
    }
}

package pers.chenjiahao.mediaadapter;

/**
 *
 * @Author ChenJiahao
 * @Date 2021/8/21 17:46
 */
public class AudioPlayer implements MediaPlayer {

    private MediaAdapter mediaAdapter;

    @Override
    public void play(String audioType, String fileName) {
        //播放 mp3 音乐文件的内置支持
        if ("mp3".equalsIgnoreCase(audioType)){
            System.out.println("Playing mp3 file. Name: "+ fileName);
        }else if ("vlc".equalsIgnoreCase(audioType) || "mp4".equalsIgnoreCase(audioType)){
            //mediaAdapter 提供了播放其他文件格式的支持
            mediaAdapter = new MediaAdapter(audioType);
            mediaAdapter.play(audioType,fileName);
        }else {
            System.out.println("Invalid media. " + audioType + " format not supported");
        }
    }
}

package pers.chenjiahao.mediaadapter;

/**
 * @Author ChenJiahao
 * @Date 2021/8/21 17:53
 */
public class Main {
    public static void main(String[] args) {
        AudioPlayer audioPlayer = new AudioPlayer();
        audioPlayer.play("mp3", "beyond the horizon.mp3");
        audioPlayer.play("mp4", "alone.mp4");
        audioPlayer.play("vlc", "far far away.vlc");
        audioPlayer.play("avi", "mind me.avi");
    }
}

问题1：AdvancedMediaPlayer中有多种方法，对于不需要的实现类来说，必需得实现，空着放在那儿

问题2：AudioPlayer中如果不是基本的mp3，就不用再进行判断了，直接调用适配器，将原来别的mp4、vlc判断交给适配器，
这样AudioPlayer的代码就不用再改变了
(如果不这样做的话，后面再加一种mp5，AudioPlayer代码就得改了)

问题3：适配器MediaAdapter中，if太多了，应该想办法消灭一些

问题1

问题2

问题3

package pers.chenjiahao.mediaadapterplus;

/**
 * 基本媒体
 * @Author ChenJiahao
 * @Date 2021/8/21 17:35
 */
public interface MediaPlayer {
    public void play(String audioType, String fileName);
}

package pers.chenjiahao.mediaadapterplus; /**  * 高级媒体  * @Author ChenJiahao  * @Date 2021/8/21 17:36  */ public interface AdvancedMediaPlayer {     void playAdvanced(String fileName); }

VlcPlayer

Mp4Player

package pers.chenjiahao.mediaadapterplus;

/**
 * 基本媒体的适配器
 * @Author ChenJiahao
 * @Date 2021/8/21 17:40
 */
public class MediaAdapter implements MediaPlayer {

    private AdvancedMediaPlayer advancedMusicPlayer;

    public MediaAdapter(String audioType) {
        // 判断一下工厂中是否有这个高级类型
        if (AdvancedMediaPlayerFactory.advancedMediaFactory.containsKey(audioType)){
            advancedMusicPlayer = AdvancedMediaPlayerFactory.advancedMediaFactory.get(audioType);
        } else {
            System.out.println("Invalid media. " + audioType + " format not supported");
            // 真实的场景中，在这里抛出异常，就不会用空的对象去执行play方法了(就不会造成空指针异常了)
            System.exit(0);
        }
    }

    @Override
    public void play(String audioType, String fileName) {
        advancedMusicPlayer.playAdvanced(fileName);
    }
}

package pers.chenjiahao.mediaadapterplus;

/**
 *
 * @Author ChenJiahao
 * @Date 2021/8/21 17:46
 */
public class AudioPlayer implements MediaPlayer {

    private MediaAdapter mediaAdapter;

    @Override
    public void play(String audioType, String fileName) {
        //播放 mp3 音乐文件的内置支持
        if ("mp3".equalsIgnoreCase(audioType)){
            System.out.println("Playing mp3 file. Name: "+ fileName);
        }else {
            mediaAdapter = new MediaAdapter(audioType);
            mediaAdapter.play(audioType,fileName);
        }
    }
}

package pers.chenjiahao.mediaadapterplus;

import java.util.HashMap;
import java.util.Map;

/**
 * 创造高级实体类的工厂
 * @Author ChenJiahao
 * @Date 2021/8/21 18:25
 */
public class AdvancedMediaPlayerFactory {
    public static Map<String,AdvancedMediaPlayer> advancedMediaFactory = new HashMap<>();

    public static AdvancedMediaPlayer getAdvancedMediaFactory(String advancedMediaType){
        return advancedMediaFactory.get(advancedMediaType);
    }

    public static void registerAdvancedMedia(String advancedMediaType,AdvancedMediaPlayer advancedMediaPlayer){
        // 这里最好先判断一下advancedMediaType和advancedMediaPlayer是否为空或""再进行put
        advancedMediaFactory.put(advancedMediaType,advancedMediaPlayer);
    }
}

package pers.chenjiahao.mediaadapterplus;

/**
 * @Author ChenJiahao(五条)
 * @Date 2021/8/21 17:53
 */
public class Main {
    public static void main(String[] args) {
        // 这里模拟Springboot启动后自动注册高级对象到工厂map的操作
        // springboot场景中，可以让AdvancedMediaPlayer接口去继承InitializingBean
        // 这样子类都必须要实现一个方法afterPropertiesSet()，这个方法实在程序之后的时候，默认要执行一次的方法，在这里可以进行一下的注册操作
        // 详见项目：24-eliminate-if-else  文章：利用设计模式优雅的干掉if-else
        AdvancedMediaPlayerFactory.registerAdvancedMedia("mp4",new Mp4Player());
        AdvancedMediaPlayerFactory.registerAdvancedMedia("vlc",new VlcPlayer());

        AudioPlayer audioPlayer = new AudioPlayer();
        audioPlayer.play("mp3", "beyond the horizon.mp3");
        audioPlayer.play("mp4", "alone.mp4");
        audioPlayer.play("vlc", "far far away.vlc");
        audioPlayer.play("avi", "mind me.avi");
    }
}

人类有你我他.......
饭也有很多种，油泼面、炒米饭......

人类是一个抽象类

饭是一个抽象类

人类中
有一个属性，将要吃的饭
有一个方法，吃

从上述描述中可以得知，人类的子类是无穷无尽的，饭的子类也是无穷无尽的，
可以认为人类和饭都是要进行扩展的，这就是两个维度都要扩展

package pers.chenjiahao.newcodebridge;

/**
 * 桥接实现接口
 * @Author ChenJiahao(程序员五条)
 * @Date 2021/8/23 21:46
 */
public interface DrawAPI {
    public void drawCircle(int radius, int x, int y);
}

GreenCircle

RedCircle

package pers.chenjiahao.newcodebridge;

/**
 * @Author ChenJiahao(程序员五条)
 * @Date 2021/8/23 21:49
 */
public abstract class Shape {
    protected DrawAPI drawAPI;

    public Shape(DrawAPI drawAPI) {
        this.drawAPI = drawAPI;
    }

    public abstract void draw();
}

Circle

package pers.chenjiahao.newcodebridge;

/**
 * @Author ChenJiahao(程序员五条)
 * @Date 2021/8/23 21:52
 */
public class Main {
    public static void main(String[] args) {
        Shape redCircle = new Circle(new RedCircle(),100,100, 10);
        Shape greenCircle = new Circle(new GreenCircle(),100, 10,100);
        redCircle.draw();
        greenCircle.draw();
    }
}

package pers.chenjiahao.bridgeplus.bridge;

/**
 * 桥接实现接口
 * @Author ChenJiahao(程序员五条)
 * @Date 2021/8/23 21:46
 */
public interface DrawAPI {
    public void drawCircle(int radius, int x, int y);
}

CircleDrawAPI

SquareDrawAPI

实现CircleDrawAPI

实现SquareDrawAPI

package pers.chenjiahao.bridgeplus;

import pers.chenjiahao.bridgeplus.bridge.DrawAPI;

/**
 * @Author ChenJiahao(程序员五条)
 * @Date 2021/8/23 21:49
 */
public abstract class Shape {
    protected DrawAPI drawAPI;

    public Shape(DrawAPI drawAPI) {
        this.drawAPI = drawAPI;
    }

    public abstract void draw();
}

Circle(修改构造中的DrawAPI为CircleDrawAPI)

Square(修改构造中的DrawAPI为SquareDrawAPI)

package pers.chenjiahao.bridgeplus;

import pers.chenjiahao.bridgeplus.bridge.BlackSquare;
import pers.chenjiahao.bridgeplus.bridge.GreenCircle;
import pers.chenjiahao.bridgeplus.bridge.RedCircle;

/**
 * @Author ChenJiahao(程序员五条)
 * @Date 2021/8/23 21:52
 */
public class Main {
    public static void main(String[] args) {
        Shape redCircle = new Circle(new RedCircle(),100,100, 10);
        // new GreenCircle() 报错
        // Shape greenCircle = new Square(new GreenCircle(),100, 10,100);
        Shape blackSquare = new Square(new BlackSquare(),100, 10,100);
        redCircle.draw();
        blackSquare.draw();
    }
}

package pers.chenjiahao.commandplus;

/**
 * @Author ChenJiahao(程序员五条)
 * @Date 2021/8/25 20:22
 */
public interface Order {
    void execute();
}

package pers.chenjiahao.commandplus;

/**
 * @Author ChenJiahao(程序员五条)
 * @Date 2021/8/25 20:23
 */
public class Stock {

    private String name = "ABC";
    private int quantity = 10;

    public void buy(){
        System.out.println("Stock [ Name:" + name + "Quantity:" + quantity + "] bought");
    }

    public void sell(){
        System.out.println("Stock [ Name:" + name + "Quantity:" + quantity + "] sold");
    }
}

SellStockOrder

BuyStockOrder

package pers.chenjiahao.commandplus;

import java.util.ArrayList;
import java.util.List;

/**
 * 命令调用类
 * @Author ChenJiahao(程序员五条)
 * @Date 2021/8/25 20:33
 */
public class Broker {
    private List<Order> orderList = new ArrayList<>();

    public void takeOrder(Order order){
        orderList.add(order);
    }

    public void placeOrders(){
        for (Order order : orderList) {
            order.execute();
        }
        orderList.clear();
    }
}

package pers.chenjiahao.commandplus;

/**
 * @Author ChenJiahao(程序员五条)
 * @Date 2021/8/25 20:35
 */
public class Main {
    public static void main(String[] args) {
        Broker broker = new Broker();
        broker.takeOrder(new BuyStockOrder(new Stock()));
        broker.takeOrder(new SellStockOrder(new Stock()));
        broker.placeOrders();
    }
}

package pers.chenjiahao.commandpluschain;

import java.util.ArrayList;
import java.util.List;

/**
 * 命令调用类
 * @Author ChenJiahao(程序员五条)
 * @Date 2021/8/25 20:33
 */
public class Broker {
    private List<Order> orderList = new ArrayList<>();

    public Broker takeOrder(Order order){
        orderList.add(order);
        return this;
    }

    public void placeOrders(){
        for (Order order : orderList) {
            order.execute();
        }
        orderList.clear();
    }
}

package pers.chenjiahao.commandpluschain;

/**
 * @Author ChenJiahao(程序员五条)
 * @Date 2021/8/25 20:35
 */
public class Main {
    public static void main(String[] args) {
        Broker broker = new Broker();
        /*broker.takeOrder(new BuyStockOrder(new Stock()));
        broker.takeOrder(new SellStockOrder(new Stock()));*/
        // 修改为链式添加
        broker.takeOrder(new BuyStockOrder(new Stock()))
              .takeOrder(new SellStockOrder(new Stock()));
        broker.placeOrders();
    }
}

Order接口

Broker

创建操作策略接口

创建操作策略接口的实现类

创建操作工厂

修改Stock

修改BuyStockOrder

修改SellStockOrder

修改测试类

克隆后的对象中的属性和被克隆对象的属性指向同一个引用，也就是说被克隆对象改变属性，克隆对象也会变

克隆对象和被克隆对象指向的地址不同，一个对象属性的改变不会造成被克隆对象属性的改变

在clone方法中：return super.clone()

在clone方法中：新建一个对象
新对象 = super.clone()
return 新对象

package pers.chenjiahao.prototype.v1;

/**
 * 这样克隆有个问题
 * 17行p1对象改变了，18行p2对象也变了，不能这样
 * 浅克隆 两个对象指向同一个引用，会有影响
 */
public class Test {
    public static void main(String[] args) {
        Person p1 = new Person();
        try {
            Person p2 = (Person) p1.clone();
            System.out.println(p2.age + " " + p2.score );
            System.out.println(p2.loc);

            System.out.println(p1.loc == p2.loc);
            p1.loc.street = "sh";
            System.out.println(p2.loc);
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}

class Person implements Cloneable{
    int age = 8;
    int score = 100;
    Location loc = new Location("bj",22);

    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
class Location{
    String street;
    int roomNo;

    public Location(String street, int roomNo) {
        this.street = street;
        this.roomNo = roomNo;
    }

    @Override
    public String toString() {
        return "Location{" +
                "street='" + street + '\'' +
                ", roomNo=" + roomNo +
                '}';
    }
}

package pers.chenjiahao.prototype.v3;

/**
 * 深克隆处理
 * 31行、32行
 */
public class Test {
    public static void main(String[] args) {
        Person p1 = new Person();
        try {
            Person p2 = (Person) p1.clone();
            System.out.println(p2.age + " " + p2.score );
            System.out.println(p2.loc);

            System.out.println(p1.loc == p2.loc);
            p1.loc.street = "sh";
            System.out.println(p2.loc);
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}

class Person implements Cloneable{
    int age = 8;
    int score = 100;
    Location loc = new Location("bj",22);

    @Override
    public Object clone() throws CloneNotSupportedException {
        Person p = (Person) super.clone();
        p.loc = (Location) loc.clone();
        return p;
    }
}

class Location implements Cloneable{
    String street;
    int roomNo;

    public Location(String street, int roomNo) {
        this.street = street;
        this.roomNo = roomNo;
    }

    @Override
    public String toString() {
        return "Location{" +
                "street='" + street + '\'' +
                ", roomNo=" + roomNo +
                '}';
    }

    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

需要备份的属性，属性与目标对象一致

有参构造对其赋值

get方法，可以获取到这些属性

自身的属性

set/get方法

将当前状态存储到备忘录的方法，返回值为备忘录类型

从备忘录中获取属性的方法，当前自身对象进行赋值(入参为备忘录，没有返参数)

一个List用来存储多个备忘录

aadd方法，给list中添加备忘录

get方法，通过index获取备忘录

给目标对象赋值

通过目标对象中的保存到备忘录的方法，获取到一个Memento对象

将这个memento对象添加到备忘录管理者中(通过管理者的添加方法)

package pers.chenjiahao.designpattern.memento;

/**
 * @Author ChenJiahao(五条)
 * @Date 2021/8/27 17:53
 */
public class Memento {

    private String state;

    public Memento(String state) {
        this.state = state;
    }

    public String getState(){
        return state;
    }
}

package pers.chenjiahao.designpattern.memento;

/**
 * @Author ChenJiahao(五条)
 * @Date 2021/8/27 17:54
 */
public class Originator {

    private String state;

    public void setState(String state) {
        this.state = state;
    }

    public String getState(){
        return state;
    }

    public Memento saveStateToMemento(){
        return new Memento(state);
    }

    public void getStateFromMemento(Memento memento){
        state = memento.getState();
    }
}

package pers.chenjiahao.designpattern.memento;

import java.util.ArrayList;
import java.util.List;

/**
 * @Author ChenJiahao(五条)
 * @Date 2021/8/27 17:57
 */
public class CareTaker {

    private List<Memento> mementoList = new ArrayList<>();

    public void add(Memento mementoState){
        mementoList.add(mementoState);
    }

    public Memento get(int index){
        return mementoList.get(index);
    }
}

package pers.chenjiahao.designpattern.memento;

/**
 * @Author ChenJiahao(五条)
 * @Date 2021/8/27 17:59
 */
public class Main {
    public static void main(String[] args) {
        Originator originator = new Originator();
        CareTaker careTaker = new CareTaker();
        originator.setState("State #1");
        originator.setState("State #2");

        careTaker.add(originator.saveStateToMemento());
        originator.setState("State #3");

        careTaker.add(originator.saveStateToMemento());
        originator.setState("State #4");

        System.out.println("Current State: " + originator.getState());

        originator.getStateFromMemento(careTaker.get(0));

        System.out.println("First saved State: " + originator.getState());

        originator.getStateFromMemento(careTaker.get(1));
        System.out.println("Second saved State: " + originator.getState());
    }
}

含有两个抽象方法op1和op2

一个模板方法doOp1AndOp2()

模板方法上加了final

/**
 * doOp1AndOp2()为模板方法
 * @Author ChenJiahao(程序员五条)
 * @Date 2021/9/28 23:59
 */
public abstract class Game {
    // 防止恶意操作，模板方法上都会加上final
    final void doOp1AndOp2(){
        op1();
        op2();
    }
    abstract void op1();
    abstract void op2();
}

实现抽象类的抽象方法

/**
 * @Author ChenJiahao(程序员五条)
 * @Date 2021/9/29 0:00
 */
public class GameSubclass extends Game {
    @Override
    void op1() {
        System.out.println("op1");
    }

    @Override
    void op2() {
        System.out.println("op2");
    }
}

/**
 * @Author ChenJiahao(程序员五条)
 * @Date 2021/9/29 0:00
 */
public class Test {
    public static void main(String[] args) {
        Game gameSubclass = new GameSubclass();
        // 不使用模板方法
        gameSubclass.op1();
        gameSubclass.op2();
        // 使用模板方法
        gameSubclass.doOp1AndOp2();
    }
}

先调用接口的实现类中的方法(传入内容类)

再通过内容类内聚的State接口，去调用具体的State中对应的其他方法

package pers.chenjiahao.designpattern.state;

/**
 * @Author ChenJiahao(五条)
 * @Date 2021/8/27 17:26
 */
public interface State {
    public void doAction(Context context);
}

package pers.chenjiahao.designpattern.state;

/**
 * @Author ChenJiahao(五条)
 * @Date 2021/8/27 17:26
 */
public class Context {

    private State state;

    public Context() {
        state = null;
    }

    public State getState() {
        return state;
    }

    public void setState(State state) {
        this.state = state;
    }
}

StartState

StopState

package pers.chenjiahao.designpattern.state;

/**
 * @Author ChenJiahao(五条)
 * @Date 2021/8/27 17:29
 */
public class Main {
    public static void main(String[] args) {
        Context context = new Context();
        StartState startState = new StartState();
        startState.doAction(context);

        System.out.println(context.getState().toString());

        StopState stopState = new StopState();
        stopState.doAction(context);

        System.out.println(context.getState().toString());
    }
}

存储表达式数据的实现类

判断每个规则之间关系的(判断多个上方实现类的关系)

测试类中使用规则类去判断存储数据的实现类

具体的规则

package pers.chenjiahao.designpattern.interpreter;

/**
 * @Author ChenJiahao(五条)
 * @Date 2021/8/27 14:42
 */
public interface Expression {
    public boolean interpret(String context);
}

存储数据的

判断规则之间关系的

规则

完整测试代码

package pers.chenjiahao.self.handler;

import org.springframework.stereotype.Component;
import pers.chenjiahao.self.factory.HandlerFactory;

/**
 * @Author ChenJiahao
 * @Date 2021/8/2 0:42
 */
@Component
public class AppleHandler implements Handler{
    @Override
    public void doSome() {
        System.out.println("判断到了  Apple ~~~~~~");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        HandlerFactory.registerHandler("apple",this);
    }
}

package pers.chenjiahao.self.handler;

import org.springframework.stereotype.Component;
import pers.chenjiahao.self.factory.HandlerFactory;

/**
 * @Author ChenJiahao
 * @Date 2021/8/2 0:42
 */
@Component
public class BananaHandler implements Handler {
    @Override
    public void doSome() {
        System.out.println("判断到了  Banana ~~~~~~");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        HandlerFactory.registerHandler("banana",this);
    }
}

串行(Sequential)，先做任务A，完成后再左任务B，完成后在做任务C，所有的任务逐个完成，
共耗时：15 + 10 + 10 = 35 分钟
任务A -> 任务B -> 任务C

并发(Concurrent)，先做任务A，准备了5分钟后，在等待A完成的这段时间就开始做任务B，
任务B准备了2分钟，在等待B完成的过程中开始做任务C，10分钟后任务C结束，
共耗时：5 + 2 + 10 = 17分钟
任务A
       任务B
         任务C

并行(Parallel)，三个任务同时开始，总耗时取决于需要时间最长的那个任务
总耗时：15分钟
任务A
任务B
任务C

有时候一个类已经有父类的，就不能再继承Thread了，
所以只能通过实现Runnable来实现线程

Thread thread = new MyThread();
thread.start()

Runnable runnable = new MyRunnable();
Thread thread = new Thread(runnable);
thread.start()
因为有构造方法new Thread(Runnable runnable)

Thread thread2 = new Thread(new Runnable() {
      @Override
      public void run() {
           for (int i = 1; i <= 100; i++) {
                 System.out.println("sub thread2 -->" + i);
           }
      }
});
thread2.start();

t1.start(); // 当前线程是Thread-0
t1.run(); // 当前线程是main

package pers.chenjiahao.threadmethod.p3sleep;

/**
* 使用线程休眠Thread.sleep完成一个简易的计时器
*/
public class SimpleTimer {
public static void main(String[] args) {
int remaining = 60; // 从60s开始计时
// 读取main方法的参数
if (args.length > 0) remaining = Integer.parseInt(args[0]);
while (remaining >= 0){
System.out.println("Remaining:" + remaining--);
try {
Thread.sleep(1000); // 线程休眠
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("Done!!!");
}
}

（1）死锁(Deadlock)：类似鹬蚌相争

（2）锁死(Lockout)：类似于睡美人故事中如果王子死了，睡美人活着但是醒不来了

（3）活锁(Livelock)：类似于小猫咬自己尾巴

（4）饥饿(Starvation)：类似于见状的雏鸟总是从母鸟嘴中抢到食物

锁具有排它性，保证共享变量在某一时刻只能被一个线程访问

CAS之类直接在硬件(处理器和内存)层次上实现，看作是硬件锁

源代码顺序：就是源码中指定的内存访问顺序

程序顺序：处理器上运行的目标代码所指定的内存访问顺序

执行顺序：内存访问操作在处理器上的实际执行顺序

感知顺序：给定处理器所感知到的该处理器及其他处理器的内存访问操作的顺序

指令重排序

存储子系统重排序

存在依赖关系例如：
          x = 1 ; y = x + 1; //  后一条语句的操作数包含前一条语句的执行结果；
          y = x ; x = 1;       //  先读取x变量，再更新x变量的值
          x = 1 ; x = 2;       // 两条语句同时对一个变量进行写操作

如果不存再数据依赖关系则可能重排序，如：
          double price = 45.8;  // 1
          int quantity = 10;  // 2
          double sum = price * quantity; // 3
       语句1和语句2可能会重排
       语句3不会重排

存在控制依赖关系的语句允许重排，一条语句(指令)的执行结果会影响另一条语句(指令)能否被执行，
这两条语句(指令)存在控制依赖关系(Control Dependency)，如再if语句中允许重排，可能存在处理器先执行if代码块，
再判断if条件是否成立

1.每个线程都有独立的栈空间

2.每个线程都可以访问堆内存

3.计算机的CPU不直接从主内存中读取数据，CPU读取数据时，
   把主内存的数据读到Cache缓存中，再把Cache中的数据读取到Register寄存器中，
   CPU从Register中读取

4.JVM中共享的数据可能会被分配到Register寄存器中，每个CPU都有自己的Register寄存器，
   一个CPU不能读取其他CPU寄存器中的内容。如果两个线程分别运行在不同的处理器(CPU上)，
   而这个共享的数据被分配到寄存器上，会产生可见性问题

5.即使JVM中的共享数据分配到主内存中，也不能保证数据的可见性，CPU不直接对主内存访问，
   而是通过Cache高速缓存进行的，一个处理器上运行的线程对数据的更新可能只是更新到处理器的写缓冲器(Store Buffer)，
   还没有到达Cache缓存，更不用说主内存了，另外一个处理器不能读取到该处理器写缓冲器上的内容，
   会山城运行在另外一个处理器上的线程无法看到该处理器对共享数据的更新

6.一个处理器的Cache不能直接读取另外一个处理器的Cache，但是一个处理器可以通过缓存一致性协议(Cache Coherence Protocol)来读取其他处理器缓存中的数据，并将读取的数据更新到该处理器的Cache中，这个过程称为缓存同步。缓存同步使得一个处理器上运行的线程可以读取到另外一个处理器上运行的线程对共享数据所做的更新，即保障了可见性，为了保障可见性，必须使一个处理器对共享数据的更新最终被写入该处理器的Cache，这个过程称为冲刷处理器缓存

1.每个线程之间的共享数据都存储在主内存中

2.每个线程都有一个私有的本地内存(工作内存)，线程的工作内存是抽象的概念，
   不是真实存在的，它涵盖写缓冲器，寄存器，其他硬件的优化

3.每个线程从主内存中把数据读取到本地工作内存中，在工作内存中保存共享数据的副本

4.线程在自己的工作内存中处理数据，仅对当前线程可见，对其他线程是不可见的

可重入性(Reentrancy)描述这样一个问题：一个线程持有该锁的时候能否再次(多次)申请该锁

void methodA(){
     申请a锁
     methodB();
     释放a锁
}
void methodB(){
     申请a锁
     。。。。
     释放a锁
}

如果一个线程持有一个锁的时候还能够继续成功申请该锁，称该锁为可重入的，否则就称该锁子为不可重入的

Java平台中内部锁属于非公平锁，而显示Lock锁既支持公平锁又支持非公平锁

一个锁可以保护的共享数据的数量大小称为锁的粒度

锁保护共享数据量大，称该锁的粒度粗，否则就成该锁的粒度细

锁的粒度过粗会导致线程在申请锁的时候会进行不必要的等待，锁的粒度过细会增加锁调度的开销

例：一个银行柜台啥都能办，那么所有业务的人都去这里办理了，那么等待的时间就会长；
       如果开户一个窗口，销户一个窗口，资料变更一个窗口，原来一个窗口的事，现在需要三个窗口，增加了开销

package pers.chenjiahao.intrinsiclock;

/**
* synchronized同步代码块
* @Author ChenJiahao
* @Date 2021/2/5 15:17
*/
public class Test01 {
public static void main(String[] args) {
// 创建两个线程，分别调用mm()方法
// 先创建Test01对象，通过对象名调用mm()方法
Test01 obj = new Test01();
new Thread(new Runnable() {
@Override
public void run() {
obj.mm(); // 使用的锁对象this就是obj对象
}
}).start();

new Thread(new Runnable() {
@Override
public void run() {
obj.mm(); // 使用的锁对象this就是obj对象
}
}).start();
}

// 定义方法，打印100行字符串
public void mm(){
synchronized (this) { // 经常使用this当前对象作为锁对象
for (int i = 1; i <= 100; i++) {
System.out.println(Thread.currentThread().getName() + " --> " + i);
}
}
}
}

package pers.chenjiahao.intrinsiclock;

/**
* synchronized同步代码块
* 一个对象一把锁，两个对象两把锁，无法实现同步
* 想同步，必须使用同一个锁对象
* @Author ChenJiahao
* @Date 2021/2/5 15:17
*/
public class Test02 {
public static void main(String[] args) {
// 创建两个线程，分别调用mm()方法
Test02 obj = new Test02();
Test02 obj2 = new Test02();
new Thread(new Runnable() {
@Override
public void run() {
obj.mm(); // 使用的锁对象this就是obj对象
}
}).start();

new Thread(new Runnable() {
@Override
public void run() {
obj2.mm(); // 使用的锁对象this就是obj2对象
}
}).start();
}

// 定义方法，打印100行字符串
public void mm(){
synchronized (this) { // 经常使用this当前对象作为锁对象
for (int i = 1; i <= 100; i++) {
System.out.println(Thread.currentThread().getName() + " --> " + i);
}
}
}
}