java小知识点

语法糖

• 语法糖（Syntactic sugar），也译为糖衣语法，是由英国计算机科学家彼得·约翰·兰达（Peter J. Landin）发明的一个术语，指计算机语言中添加的某种语法，这种语法对语言的功能并没有影响，但是更方便程序员使用。通常来说使用语法糖能够增加程序的可读性，从而减少程序代码出错的机会。

JavaBean的冷藏与解冻

即javaBean的 串行化 (Serializable)与 并行化 (DeSerializable)

Java serialVersionUID

serialVersionUID使用于java序列化机制。

简单来说，JAVA序列化的机制是通过判断类的serialVersionUID来验证的版本一致的。在进行反序列化时，JVM会把传来的字节流中的serialVersionUID于本地相应实体类的serialVersionUID进行比较。如果相同说明是一致的，可以进行反序列化，否则会出现反序列化版本一致的异常，即抛出 InvalidCastException。

相当于 GitHub 上下载文件时看到的 sha码

• serialVersionUID有两种显示的生成方式
  • 默认的1L，比如：private static final long serialVersionUID = 1L;
  • 根据包名，类名，继承关系，非私有的方法和属性，以及参数，返回值等诸多因子计算得出的，极度复杂生成的一个64位的哈希字段。基本上计算出来的这个值是唯一的。比如：private static final long serialVersionUID = xxxxL;
    注意：显示声明serialVersionUID可以避免对象不一致，

当一个类实现类Serializable接口，需要显示定义serialVersionUID

Java 调试

步过：就是遇到方法，不进入，直接下一行
步入：就是遇到函数会进入函数
步出：就是运行到退出本函数、返回上一级的下一行

Java 泛型

服务提供者框架

• 服务提供者框架的几个概念：
  • 服务接口，相当于 service
  • 具体的服务实现类，相当于 serviceImpl
  • 服务提供者接口（可选），相当于 serviceFactory
  • 具体的服务提供者实现类，相当于 serviceFactoryImpl
  • 服务提供者的注册类，相当于 eureka

服务是一个很抽象的概念，既然是服务，它肯定有个作用啊，对应到java中，它应该具有方法，事实上，服务的种类有很多，学过java的都知道，我们可以用一个接口来定义一个服务，然后让不同的实现类去实现这个接口从而实现具体的服务内容。

服务接口：定义了抽象的服务，以及一个或多个方法
服务实现类：实现服务接口，实现具体的方法
服务提供者接口：定义了抽象的服务提供者，提供一个获取服务的方法
服务提供者实现类：实现服务提供者接口，实现具体的方法
服务提供者注册类：提供一个注册服务与调用服务的方法，它是面向服务消费者的

Java Singleton

饱汉模式(懒汉模式)

// 饱汉
// UnThreadSafe
public class Singleton1 {
  private static Singleton1 singleton = null;
  private Singleton1() {
  }
  public static Singleton1 getInstance() {
    if (singleton == null) {
      singleton = new Singleton1();
    }
    return singleton;
  }
}

优点：懒加载启动快，资源占用小，使用时才实例化，无锁。
缺点：非线程安全。

饱汉模式(懒汉模式)–线程安全

1 public class Singleton {

    /**
     * 定义一个变量来存储创建好的类实例
     */

    private static Singleton uniqueInstance = null;

    /**
     * 私有化构造方法，好在内部控制创建实例的数目
     */

    private Singleton(){
    }

    /**
     * 定义一个方法来为客户端提供类实例
     * @return 一个Singleton的实例
     */

    public static synchronized Singleton getInstance(){

        //判断存储实例的变量是否有值
        if(uniqueInstance == null){
            //如果没有，就创建一个类实例，并把值赋值给存储类实例的变量
            uniqueInstance = new Singleton();
        }

        //如果有值，那就直接使用
        return uniqueInstance;
    }

    /**
     * 示意方法，单例可以有自己的操作
     */

    public void singletonOperation(){

//功能处理

    }

    /**
     * 示意属性，单例可以有自己的属性
     */

    private String singletonData;

    /**
     * 示意方法，让外部通过这些方法来访问属性的值
     * @return 属性的值
     */

    public String getSingletonData(){

        return singletonData;

    }

}

优点：同上，但加锁了。
缺点：synchronized 为独占排他锁，并发性能差。即使在创建成功以后，获取实例仍然是串行化操作。

饱汉模式(懒汉模式)–双重加锁检查DCL（Double Check Lock）

public class Singleton {

    /**
     * 对保存实例的变量添加volatile的修饰
     */

    private volatile static Singleton instance = null;

    private Singleton(){

    }

    public static Singleton getInstance(){

//先检查实例是否存在，如果不存在才进入下面的同步块

        if(instance == null){

//同步块，线程安全的创建实例

            synchronized(Singleton.class){

//再次检查实例是否存在，如果不存在才真的创建实例

                if(instance == null){

                    instance = new Singleton();

                }

            }

        }

        return instance;

    }

}

优点：懒加载，线程安全。
注：实例必须有 volatile 关键字修饰，其保证初始化完全。

饿汉模式

public class Singleton {

//4：定义一个静态变量来存储创建好的类实例

//直接在这里创建类实例，只会创建一次

    private static Singleton instance = new Singleton();

//1：私有化构造方法，好在内部控制创建实例的数目

    private Singleton(){

    }

//2：定义一个方法来为客户端提供类实例

//3：这个方法需要定义成类方法，也就是要加static

//这个方法里面就不需要控制代码了

    public static Singleton getInstance(){

//5：直接使用已经创建好的实例

        return instance;

    }

}

优点：饿汉模式天生是线程安全的，使用时没有延迟。

缺点：启动时即创建实例，启动慢，有可能造成资源浪费。

Holder模式

public class Singleton {
    /**
     * 类级的内部类，也就是静态的成员式内部类，该内部类的实例与外部类的实例
     * 没有绑定关系，而且只有被调用到才会装载，从而实现了延迟加载
     */
    private static class SingletonHolder{
        /**
         * 静态初始化器，由JVM来保证线程安全
         */
        private static Singleton instance = new Singleton();
    }
    /**
     * 私有化构造方法
     */
    private Singleton(){
    }
    public static  Singleton getInstance(){
        return SingletonHolder.instance;
    }
}

优点：将懒加载和线程安全完美结合的一种方式（无锁）。（推荐）

使用枚举来实现单例

public enum Singleton {
 uniqueInstance;// 定义一个枚举的元素，它 就代表了Singleton的一个实例

 public void singletonOperation() {
 // 功能处理
 System.err.println("功能处理");
 }
}