public class FinalizeTest {
    private static FinalizeTest ft = null;

    public void info() {
        System.out.println("测试资源清理的finalize方法");
    }

    public static void main(String[] args) throws Exception {
        // 创建FinalizeTest对象立即进入可恢复状态
        new FinalizeTest();
        // 通知系统进行资源回收
        System.gc(); // ①
        // 强制垃圾回收机制调用可恢复对象的finalize()方法
        // Runtime.getRuntime().runFinalization(); // ②
        System.runFinalization(); // ③
        // 执行对象的方法,如果注释掉上面的`System.gc();`,则不会强制垃圾回收,finalize方法不会执行,ft为null,则下面语句将会抛出空指针异常.
        // 如果注释掉上面的`System.runFinalization();`,则finalize方法要等到系统进行垃圾回收时才会执行,系统可以不会进行垃圾回收,下面语句还是会抛出空指针异常.
        // `System.runFinalization();`将会强制执行所有可恢复对象的finalize方法.
        // 下面语句将会抛出空指针异常
        ft.info();
    }

    public void finalize() {
        // 重新引用 可恢复状态的对象,该对象将重新变成可达状态
        ft = this;
    }
}

public class GcTest {
    public static void main(String[] args) {
        for (int i = 0; i < 40; i++) {
            new GcTest();
            // 下面两行代码的作用完全相同，强制系统进行垃圾回收
            // System.gc();
            Runtime.getRuntime().gc();
        }
    }

    public void finalize() {
        System.out.println("系统正在清理GcTest对象的资源...");
    }
}

public enum Operation {
    // 枚举值必须在第一行定义
    PLUS {
        // 枚举值必须实现枚举类中的抽象方法
        public double eval(double x, double y) {
            return x + y;
        }
    },
    MINUS {
        public double eval(double x, double y) {
            return x - y;
        }
    },
    TIMES {
        public double eval(double x, double y) {
            return x * y;
        }
    },
    DIVIDE {
        public double eval(double x, double y) {
            return x / y;
        }
    };

    // 为枚举类定义一个抽象方法
    // 这个抽象方法由不同的枚举值提供不同的实现
    public abstract double eval(double x, double y);

    public static void main(String[] args) {
        System.out.println(Operation.PLUS.eval(3, 4));
        System.out.println(Operation.MINUS.eval(5, 4));
        System.out.println(Operation.TIMES.eval(5, 4));
        System.out.println(Operation.DIVIDE.eval(5, 4));
    }
}

public interface GenderDesc
{
    void info();
}

public enum Gender implements GenderDesc {
    // 调用构造器实例化成员变量
    MALE("男")
    // 创建当前类的匿名子类
    {
        // 匿名子类中重写父类Gender的方法
        public void info() {
            System.out.println("这个枚举值代表男性");
        }
    },
    FEMALE("女")
    // 创建当前类的匿名子类
    {
        // 匿名子类中重写父类Gender的方法
        public void info() {
            System.out.println("这个枚举值代表女性");
        }
    },
    // 可以不创建匿名子类,则这个枚举默认使用枚举类的info方法
    No_MALE_OR_Female("不男不女");

    // 定义成员变量
    private final String name;

    // 枚举类的构造器只能使用private修饰
    private Gender(String name) {
        this.name = name;
    }

    public String getName() {
        return this.name;
    }

    // 在枚举中实现接口,这个必须要有
    public void info() {
        System.out.println("这是一个用于用于定义性别的枚举类");
    }
}

public class Test {
    public static void main(String[] args) {
        // 获取三个枚举实例
        Gender male = Gender.valueOf("MALE");
        Gender female = Gender.valueOf("FEMALE");
        Gender no_male_or_female = Gender.valueOf("No_MALE_OR_Female");
        // 调用的是枚举值实现的info方法
        male.info();
        female.info();
        // 调用的是枚举类实现的info方法
        no_male_or_female.info();
    }
}

public enum Gender {
    // 隐式调用带参构造器为name成员变量赋值
    MALE("男"), FEMALE("女");

    // 相当于如下代码
    // public static final Gender MALE new Gender("男");
    // public static final Gender FEMALE new Gender("女");
    // 定义成员变量
    private final String name;

    // 枚举类的构造器由第一行定义的枚举实例显示调用,所以只能使用private修饰
    private Gender(String name) {
        this.name = name;
    }

    public String getName() {
        return this.name;
    }
}

public class Test {
    public static void main(String[] args) {
        Gender gender = Gender.valueOf("MALE");
        System.out.println("枚举实例MALE的name成员变量的值为:" + gender.getName());
        System.out.println("枚举实例MALE的name成员变量的值为:" + Gender.MALE.getName());
        // 这样只能获取到枚举类对象
        System.out.println("枚举实例MALE的name成员变量的值为:" + Gender.MALE);
    }
}

public enum SeasonEnum
{
    //在第一行列出4个枚举实例
    SPRING,SUMMER,FALL,WINTER;
}

public enum SeasonEnum {
    // 在第一行列出4个枚举实例
    SPRING, SUMMER, FALL, WINTER;
}

public class EnumTest {
    public void judge(SeasonEnum s) {
        // switch语句里的表达式可以是枚举值
        switch (s) {
        case SPRING:
            System.out.println("春暖花开，正好踏青");
            break;
        case SUMMER:
            System.out.println("夏日炎炎，适合游泳");
            break;
        case FALL:
            System.out.println("秋高气爽，进补及时");
            break;
        case WINTER:
            System.out.println("冬日雪飘，围炉赏雪");
            break;
        }
    }

    public static void main(String[] args) {
        // 返回枚举类的所有实例数组
        SeasonEnum[] seasonEnums = SeasonEnum.values();
        // 遍历所有的枚举类实例
        for (int i = 0; i < seasonEnums.length; i++) {
            System.out.println(seasonEnums[i]);
        }
        System.out.println("------------------------------");
        // 枚举类默认有一个values方法，返回该枚举类的所有实例
        for (SeasonEnum s : SeasonEnum.values()) {
            System.out.println(s);
        }
        // 使用枚举实例时，可通过EnumClass.variable形式来访问
        new EnumTest().judge(SeasonEnum.SPRING);
    }
}

import java.util.Arrays;

public class LambdaArrays {
    public static void main(String[] args) {
        String[] strArray = new String[] { "Java", "Hello", "World", "HTML", "JavaScript" };

        Arrays.parallelSort(strArray, (o1, o2) -> o1.length() - o2.length());
        System.out.println("排序:"+Arrays.toString(strArray));

        int[] intArray = new int[] { 3, -4, 25, 16, 30, 18 };
        // left代表数组中前一个所索引处的元素，计算第一个元素时，left为1
        // right代表数组中当前索引处的元素
        Arrays.parallelPrefix(intArray, (left, right) -> left * right);
        System.out.println("累积:"+  Arrays.toString(intArray));

        long[] longArray = new long[5];
        // operand代表正在计算的元素索引
        Arrays.parallelSetAll(longArray, operand -> operand * 5);
        System.out.println("索引*5:"+Arrays.toString(longArray));
    }
}

@FunctionalInterface
interface Displayable {
    // 定义一个抽象方法
    void display();

    // 定义一个默认方法
    default int add(int a, int b) {
        return a + b;
    }

}

public class LambdaAndinner {
    // 实例变量
    private int age = 12;
    // 类变量
    private static String name = "Hello";

    public void test() {
        // 方法局部变量
        String book = "World";
        // final String book = "World";
        // 创建函数式接口实例,通过Lambda表达式实现display方法
        Displayable displayable = () -> {
            // Lambda表达式中不可以修改局部变量的值
            // book = "被局部内部类访问的局部变量 只能赋值一次";
            System.out.println("当前方法 局部变量 book=" + book);
            System.out.println("外部类 类变量 name=" + name);
            System.out.println("外部类 实例变量 age=" + age);
            // Lambda表达式代码体中不允许调用接口默认方法
            // System.out.println(add(1,2));
        };
        // 调用实现的display方法
        displayable.display();
        // 调用从接口中继承得到的add方法
        displayable.add(3, 5);
    }

    public static void main(String[] args) {
        LambdaAndinner lambdaAndinner = new LambdaAndinner();
        lambdaAndinner.test();
    }
}