jdk新特性——1.5-1.8（主要）新特性

jdk1.5新特性：---->里程碑式的版本

	静态导入：
			可以导入静态方法，可以直接使用，静态导入的信息会优先加载

	可变参数：
			参数类型...
			可以接收任意多个参数
			底层是由数组来实现的，参数值都是存放在对应的数组元素中
			可变参数只能出现在参数列表的最右边，最多只能出现一次

public class StaticImport {

    //JDk1.5新特性
    //支持静态导入的方式---->静态导入的是导入的是静态的类资源，非静态的不能进行导入操作，JDK1.5进行导入的操作。
    public static void main(String[]args){

        System.out.println(Math.random());
        System.out.println(Math.abs(-9));
        System.out.println(Math.floor(2.3));
        Scanner sc=new Scanner(System.in);


        //静态导入的时候必须要将包的导入到类的外面进行导入，所以进行静态导入的时候，需要带上关键字static
        //静态资源将会优先加载到内存中，便于更好的初始化操作
        System.out.println(ceil(3.4));
        System.out.println(cbrt(5.3));
    }
}

	枚举：
			将值一一列举
			列举式枚举常常
			构造方法一定要私有化
			定义属性和方法
			定义抽象方法
			switch表达式类型支持枚举类型

public class EnumDemo1 {
    //测试枚举的结果
    public static void main(String[]args){
        //测试使用枚举的效果
        Season s=Season.spring;
        //利用switch进行测试
        switch(s){
            case spring:System.out.println("春游");
            break;
            case summer:System.out.println("游泳");
            break;
            case autumn:System.out.println("爬山");
            break;
            case winter:System.out.println("休眠");
            break;
            default:System.out.print("睡着了");
        }
    }

}

//枚举类的操作
enum Season{
    //用来列举值的方式  枚举的值的不能进行改变，等效于  public final static Season spring=new Season()
    spring{
        @Override
        public void n() {

        }
    },summer {
        @Override
        public void n() {

        }
    },autumn {
        @Override
        public void n() {

        }
    },winter {
        @Override
        public void n() {

        }
    };

    //声明的变量定义操作--->相当于相等
    Season season;

    //枚举的列举值必须要在首行进行设置，不是首行不行
    //1.可以定义变量
    int num=0;
    //2.可以定义方法
    public void m(){}
    //3.可以定义构造方法---底层通过默认private修饰符进行修饰
    private Season(){
    }

    //4.可以定义抽象方法---->但是类的本身不是抽象类，定义抽象方法的时候必须使用的是内部类的展示
    //4.1定义抽象方法的时候，抽象方法必须要进行实现的操作，所以由枚举的值进行操作
    public abstract void n();


}

//定义类----代表枚举的类，类产生的对象就是具体的季节
//只有四个季节，类只能产生四个季节，所以类只能产生四个对象
/*
class Season{

    //当类在外不不想被访问的时候，将构造方法进行私有化的操作
    private Season(){
        //private保证对象在外不不能进行初始化了
    }

    //创建类的四个对象   --->关键字是被默认进行修饰的化呈现颜色是黄色
    public final static Season spring=new Season();
    public final static Season summer=new Season();
    public final static Season autnmn=new Season();
    public final static Season winter=new Season();

    //1.保证类的对象不能被改变，只有四种方式  final--->最终的声明
    //2.保证类能够被外界进行访问，由于已经构造方法的私有化，所以只能提供静态资源进行操作  static--->s静态属性
    //3.保证外界能够获取当前的对象----public
}

class test{
    //能够进行类的属性的调用操作，静态资源能够被类或者对象进行调用,可以进行获取私有化信息的属性操作
    Season s=Season.spring;
}
*/

方向：数据结构、java编程思想、JVM(深入了解JVM)、线程（内存，通信、锁）、设计模式

jdk1.8新特性：

	-  接口能够定义实体方法---default默认表达式进行修饰符的修饰
	- 接口能够定义静态的实体方法---static关键字进行修饰
	- 出现了Lambda表达式--->针对函数式接口编程思想
 
    - Stream:流式结构

public class StreamDemo1 {

    public static void main(String[]args){

        //创建结合对象
        List<String> list=new ArrayList<String>();

        //添加元素
        list.add("C");
        list.add("Python");
        list.add("PHP");
        list.add("C++");
        list.add("C#");
        list.add("GO");

        //筛选出以C开头的元素
        for(String s:list){
            if (s.startsWith("C")){
                System.out.println(s);
            }
        }

        //使用流结构的返回流是结构
        Stream<String> s = list.stream();
        //开始进行过滤
        s.filter(new Predicate<String>() {
            @Override
            public boolean test(String s) {

                return s.startsWith("C");
            }
        }).forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });

        //使用Lambda表达式
        //str1 表示第一个接口的对象  Predicate对象
        //Str2 表示第二个接口的对象  Consumer对象
       // s.filter(str1->{str1.startsWith("C");})->str2.forEach(str2-> System.out.println(str2)));
    }
}

    - time包---时间和日期可以分开操作

package cn.tedu.jdk;
//jdk1.8新特性的写法

public class LambdaDemo1 {

    public static void main(String[]args){
        //匿名内部类----接口的实现类
        Calc c=new Calc() {
            @Override
            public int max(int x, int y) {
                return x>y?x:y;
            }
        };

        //调用匿名内部类（接口的是是实现类）的重写方法--c代表的是匿名内部类的对象
        c.max(5,6);


        //Lambda表达式--->简便的书写--->（针对函数式接口编程）
        //左边是接口的声明
        //右边是接口方法的声明->{抽象方法的重写的方法体}
        //->是固定的写法--->表示对象执行方法体的执行

        //由前面的抽象方法参数类型可以推导出此时的参数类型，不用写参数类型
        //当方法体中只有一条语句的时候，花括号可以不写，进行各种的书写操作
 /*       Calc c1=(int x,int y)->{return x>y?x:y;};
        c1.max(6,3);*/

        Calc c1=(x,y)->x>y?x:y;
        c1.max(1,2);


    }
}


//接口---计算器
//接口中只有抽象方法的时候---函数式接口(专门的注解---函数式编程(不属于面向对象过程))
@FunctionalInterface
interface Calc{

    //求最大值
    int max(int x,int y);


    //实体方法---默认方法---必须加入default关键字
    public default int m(int i,int j){
        return i+j;
    }



    //实体方法---静态方法
    public static int n(int x,int y){
        return x+y;
    }


}