（高内聚、低耦合）
，通过字节码对象来获取实例对象的过程
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(); }*/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; } }用于去重写函数式接口的抽象方法 函数式接口里只含有一个抽象方法
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); }操作集合元素 提供大量的函数式接口
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)); } }时间和日期可以分开操作
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); } }