Java基础语法(单例、final、内部类、Lambda、方法引用)

一、单例模式（懒汉式和饿汉式）

/**
 * 懒汉式单例模式
 */
public class Person {
    // 私有的静态的实例变量
    private static Person instance = null;
    // 构造方法私有化
    private Person() {}
    // 公共的静态方法，返回唯一的那个实例
    public static Person getInstance() {
        if (instance == null) { //这里线程不安全
            instance = new Person();
        }
        return instance;
    }
}

/**
 * 饿汉式单例模式，线程安全
 */
public class Person {
    // 私有的静态的实例变量
    private static Person instance = new Person();
    // 构造方法私有化
    private Person() {}
    // 公共的静态方法，返回唯一的那个实例
    public static Person getInstance() {
        return instance;
    }
}

二、final关键字

• 被final修饰的类：不能被继承
• 被final修饰的方法：不能被重写
• 被final修饰的变量：只能被赋值一次

    // 常量的基本写法：一般名字大写
 
    public static final double PI = 3.1415926;
    public  static final int NOT_FOUND = -1;
    private static final int DEFAULT_SIZE = 10;

三、内部类 

public class Person { //外部类 ，顶级类
   
    // 非静态嵌套类（内部类）
    class InnerClass {
        public int age = 10;
    }
}

1. 跟实例变量、实例方法一样，内部类与外部类的实例相关联
2. 必须先创建外部类实例，然后再用外部类实例创建内部类实例 
3. 内部类不能定义除编译时常量以外的任何static成员
4. 内部类可以直接访问外部类中的所有成员（即使被声明为private）
5. 外部类可以直接访问内部类实例成员变量、方法（即使被声明为private）

 public static void main(String[] args) {
        Person person = new Person();
        Person.InnerClass innerClass = person.new InnerClass();
        System.out.println(innerClass.age);
    }

 四、静态嵌套类

• 静态嵌套类：被static修饰的嵌套类
• 静态嵌套类在行为上就是一个顶级类，只是定义的代码写在了另一个类中
• 对比一般的顶级类，静态嵌套类多了一些特殊权限

1. 可以直接访问外部类中除实例变量、实例方法外的其他成员（即使被声明为private）

public class Person { //外部类 ，顶级类
    // 静态嵌套类
    static class StaticClass {

    }
}

 Person.staticClass staticClass = new Person.staticClass(); // 不报错

public class Person { //外部类 ，顶级类
    
    private static int count = 1;
    private static void run() {}
    
    public static class staticClass {
        public void run() {
            Person.count = 2;
            Person.run();
        }
    }
}

五、Lambda表达式

• 函数式接口（Functional Interface）：只包含1个抽象方法的接口
• 可以在接口上面加上@FunctionalInterface 注解，表示它是一个函数式接口
• 匿名类只有一个抽象方法才能进行lambda进行简写
• 参数列表可以省略参数类型
• 当只有一条语句时：可以省略大括号、分号、return
• 当只有一个参数时：可以省略小括号
• 当没有参数时：不能省略小括号

   Integer[] array = {12, 34, 34, 67};
        Arrays.sort(array, (o1, o2) -> {
            return o1 - o2;
        });

    // 只有一条语句的时候
      Arrays.sort(array, (o1, o2) -> o1 - o2);

六、方法引用（Method Reference） 

如果Lambda中的内容仅仅是调用某个方法，可以使用方法引用来简化

引用静态方法：ClassName::staticMethodName

引用特定对象的实例方法：ObjectName::instanceMethodName

引用特定类型的任意对象实例方法：ClassName::methodName

@FunctionalInterface
public interface Testable {
    int test(int v1, int v2);
}

       Testable test = new Testable() {
            @Override
            public int test(int v1, int v2) {
                return v1 - v2;
            }
        };
        Testable testable = ((v1, v2) -> v1 - v2);
        Testable testable1 = (v1, v2) -> {
            return Math.max(v1, v2);
        };
        Testable testable2 = (v1, v2) -> Math.max(v1, v2);
        Testable testable3 =  Math::max;
        int result = test.test(12,45);
        System.out.println(result);