Java学习 DAY23 模块关系、反射、jdk1.5新特性、jdk1.8新特性

模块之间有关系—耦合度

（高内聚、低耦合）

反射—解析类

，通过字节码对象来获取实例对象的过程

Class—代表类的类（产生对象就是一个具体的类（字节码对象））
Field—代表属性的类（产生的对象就是一个具体的属性）
Method—代表方法的类（产生的对象就是一个具体的方法）
Constructor—代表构造方法的类（产生的对象就是一个具体的构造方法）

获取字节码的方式

1.通过类型.calss来获取字节码对象
2.通过对象.getClass()来获取字节码对象你
3.通过Class.forName("")把字符串内容转成对应的字节码对象

package cn.tedu.reflect;

import java.util.List;

public class ClassDemo1 {
    public static void main(String[] args) throws ClassNotFoundException {
        //1.通过类型.calss来获取字节码对象
        //String类的字节码对象
        /*Class<String> clz=String.class;
        //接口的字节码文件
        Class<List> clz1=List.class;
        //基本类型的字节码对象
        Class clz2=int.class;
        System.out.println(clz);
        System.out.println(clz1);
        System.out.println(clz2);*/


        //2.由对象.getClass()来获取字节码对象你
        /*Class<String> clz=(Class<String>)"abc".getClass();
        //
        System.out.println(clz);*/


        //3.通过字符串来获取字节码对象
        Class<List> clz= (Class<List>) Class.forName("java.util.List");
        System.out.println(clz);
    }
}

获取实例对象

1.字节码对象.newinstance()执行无参构造返回实例对象
2.先获取有参构造，通过newinstance(参数)有参形式来执行有参构造并且给构造方法来赋值，返回实例对象

package cn.tedu.reflect;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class ClassDemo2 {
    public static void main(String[] args) throws IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
        //字节码对象
        Class<String> clz=String.class;

        //通过字节码对象来获取实例对象
        //执行无参构造来创建实例对象
        //String  str=clz.newInstance();

        //先获取有参构造---（String orginal）
        //参数类型需要以字节码形式来传入才能找到对应的构造方法
        /*Constructor<String> c=clz.getConstructor(String.class);
        //执行有参构造并且赋值返回实例对象
        String str=c.newInstance("abc");
        //
        String str1=new String("abc");

        //
        System.out.println(str);*/

        //通过反射来获取Integer类的实例对象
        //获取字节码对象
        Class<Integer> clz1=Integer.class;
        //获取有参构造---(int)
        Constructor<Integer> c=clz1.getConstructor(int.class);
        //执行有参构造并且赋值返回实例对象
        Integer in=c.newInstance(123);
        System.out.println(in);

    }
}


package cn.tedu.reflect;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class ClassDemo3 {
    public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        //
        Class<String> clz=String.class;

        //获取构造方法
        //getDeclaredConstructor---获取指定构造方法（不受修饰符影响）
        Constructor<String> c=clz.getDeclaredConstructor(char[].class,boolean.class);

        //暴力破解---允许给值
        c.setAccessible(true);

        //执行构造方法并且给构造方法赋值返回实例对象
        String str=c.newInstance(new char[]{'1','2'},true);
        //
        System.out.println(str);
    }
}

缺点
打破封装原则
跳过泛型的类型检测

package cn.tedu.reflect;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;

public class ClassDemo7 {
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        //
        List<String> list=new ArrayList<>();
        list.add("abc");

        //在编译时期泛型会有类型检测，如果不符合指定类型就会报错
        //在运行时期反射改变存储数据元素类型（跳过泛型类型检测）
        Class<List> clz= (Class<List>) list.getClass();
        Method m=clz.getDeclaredMethod("add",Object.class);
        //
        m.invoke(list,123);
        //
        System.out.println(list);
    }
}

jdk新特性
jdk1.5新特性
静态导入
可以导入静态方法，可以直接使用
静态导入信息会优先加载

package cn.tedu.jdk.jdk5;
//静态导入
import static java.lang.Math.*;

public class StaticImportDemo {
    public static void main(String[] args) {
        //
        System.out.println(random());
        System.out.println(abs(1.2));
        System.out.println(floor(2.23));
    }
}

可变参数

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

package cn.tedu.jdk.jdk5;

public class VariableDemo {
    public static void main(String[] args) {
        System.out.println(sum(1,2));
        System.out.println(sum(1));
        System.out.println(sum(1,2,3));
        System.out.println(sum(new int[]{1,2,3,4,5}));
    }


    //定义方法求和
    //参数类型...---可变参数
    //可以接收任意多个参数
    //可变参数底层是一个大大的数组，把参数值赋值给对应的数组元素
    //可变参数只能出现在参数列表的最右边（最多只能出现一次）
    public static int sum(int...i){
        int sum=0;
        for (int j = 0; j < i.length; j++) {
            sum+=i[j];
        }
        return sum;

    }
    /*public static int sum(int i,int j){
        return i+j;
    }
    public static int sum(int i,int j,int z){
        return i+j+z;
    }*/
    /*public static int sum(int arr[]){
        int m=0;
        for (int a:arr
             ) {m+=a;
        }
        return m;
    }*/
}

枚举

把值一一列举
列举是枚举常量，在首行并且在一行
构造方法一定要私有化
定义属性、方法
定义抽象方法
switch表达式支持枚举类型

package cn.tedu.jdk.jdk5;

public class EnumDemo {
    public static void main(String[] args) {
        Season spring=Season.spring;
        switch (spring) {
            case spring:
                System.out.println("春游");
                break;
            case summer:
                System.out.println("游泳");
                break;
            case autumn:
                System.out.println("爬山");
                break;
            case winter:
                System.out.println("冬泳");
                break;
        }
    }
}

//枚举
enum Season{
    //列举值
    //spring等效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() {

        }
    };
    //定义属性
    int i=1;
    //方法
    public void m(){}
    //构造方法
    private Season(){}
    //抽象方法
    public abstract void n();
}


//定义类---代表季节的类，类产生的对象就是具体的季节
//只有四个季节，类只能产生四个对象
/*
class Season{
    //构造方法私有化，保证外部不能调用构造方法来创建对象
    public Season(){}

    //创建四个对象---四个季节
    public final static Season spring=new Season();
    public final static Season summer=new Season();
    public final static Season autumn=new Season();
    public final static Season winter=new Season();
}*/

jdk1.8新特性

1.接口里可以定义实体方法（默认方法、静态方法）

package cn.tedu.jdk8;

public class LambdaDemo1 {
    public static void main(String[] args) {
        //创建实现类对象
       /* CalcImpl c=new CalcImpl();
        //调用接口里的实体方法---默认方法
        System.out.println(c.sum(1,2));*/
       /* //由接口名称直接调用实体方法---静态方法
        Calc.cj(2,3);*/



       /* //创建实现类对象
        CalcImpl c=new CalcImpl();
        //调用接口重写方法
        c.max(1,2);*/
        //匿名内部类
        //c是匿名内部类的对象
        /*Calc c=new Calc() {
            @Override
            public int max(int x, int y) {
                return x>y?x:y;
            }
        };
        //调用匿名内部类（接口的实现类）的重写方法
        c.max(1,2);*/
        //Lambda表达式（针对函数式接口）
        //(参数列表)->{抽象方法的重写的方法体}
        //Calc c=(int x,int y)->{return x>y?x:y;};
        //有前面的抽象方法参数类型推导出此时的参数类型，不用写参数类型
        //如果重写方法的方法体只有一句话就可以把return以及{}省略
        Calc c=(x,y)->x>y?x:y;
        c.max(1,2);
   }
}

//接口---计算器
//接口里只有一个抽象方法---函数式接口（函数式编程）
@FunctionalInterface
interface Calc{

    //求最大值---抽象方法
    int max(int x,int y);

    //实体方法---默认方法
    public default int sum(int x,int y){return x+y;}

    //实体方法---默认方法
    public static int cj(int x,int y){return x*y;}
}

//实现类---重写抽象方法
class CalcImpl implements Calc{

    @Override
    public int max(int x, int y) {
        return x>y?x:y;
    }
}

Lambda表达式

用于去重写函数式接口的抽象方法
函数式接口里只含有一个抽象方法

package cn.tedu.jdk8;

import java.io.File;
import java.io.FilenameFilter;
import java.util.ArrayList;
import java.util.Arrays;

public class LambdaDemo2 {
    public static void main(String[] args) {
        int[] arr1={1,2,3};
        //Lambda表达式
        //SortArray s=(arr)-> Arrays.sort(arr);
        //当参数只有一个时可以省略（）
        //SortArray s=arr->Arrays.sort(arr);
        //::传递静态方法  前后只使用一个参数就可以省略
        //SortArray s=Arrays::sort;
        //比较器是函数式接口
        //new ArrayList<String>().sort();
        //FileFiter---函数式接口
        //new File("").listFiles(new FileFiter)
        //FilenameFilter---函数式接口
        //new File("").list(new FilenameFilter)
    }
}
interface SortArray{
    //排序---抽象方法
    void sort(int[] arr);
}

Stream—流式结构

操作集合元素
提供大量的函数式接口

package cn.tedu.stream;

import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.stream.Stream;

public class StreamDemo {
    public static void main(String[] args) {
        //创建集合对象
        List<String> list=new ArrayList<>();
        //添加元素
        list.add("C");
        list.add("Python");
        list.add("JAVA");
        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表达式
        //筛选出以C开头的元素并且排序
        s.filter(str1->str1.startsWith("C")).
                sorted((s1,s2)->s2.compareTo(s1)).
                forEach(str2-> System.out.println(str2));

    }
}

time包

时间和日期可以分开操作

package cn.tedu.time;

import java.time.LocalDate;
import java.time.LocalTime;
import java.time.temporal.ChronoUnit;
import java.util.Locale;

public class TimeDemo {
    public static void main(String[] args) {
        //只有时间
        //LocalTime l=LocalTime.now();
        //只有日期
        LocalDate l=LocalDate.now();
        System.out.println(l);

    }
}