模块之间有关系—耦合度
(高内聚、低耦合)
反射—解析类
,通过字节码对象来获取实例对象的过程
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);
}
}