最新Java基础系列课程--Day13-高级特性(一)https://developer.aliyun.com/article/1423542
三、反射
各位小伙伴,接下来我们要学习反射技术。在学习反射之前,有几个点需要给同学们提前交代一下,接下来我们学习的反射、动态代理、注解等知识点,在以后开发中极少用到,这些技术都是以后学习框架、或者做框架的底层源码。给同学们讲这些技术的目的,是为了以后我们理解框架、或者自己开发框架给别人用作铺垫的。同时由于这些技术非常抽象,所以按照国际惯例,我们都会采用先带着大家充分的认识它们,然后再了解其作用和应用场景。
接下来,我们就需要带着同学们认识一下什么是反射。其实API文档中对反射有详细的说明,我们去了解一下。在java.lang.reflect包中对反射的解释如下图所示
翻译成人话就是:反射技术,指的是加载类的字节码到内存,并以编程的方法解刨出类中的各个成分(成员变量、方法、构造器等)。
反射有啥用呢?其实反射是用来写框架用的,但是现阶段同学们对框架还没有太多感觉。为了方便理解,我给同学们看一个我们见过的例子:平时我们用IDEA开发程序时,用对象调用方法,IDEA会有代码提示,idea会将这个对象能调用的方法都给你列举出来,供你选择,如果下图所示
问题是IDEA怎么知道这个对象有这些方法可以调用呢? 原因是对象能调用的方法全都来自于类,IDEA通过反射技术就可以获取到类中有哪些方法,并且把方法的名称以提示框的形式显示出来,所以你能看到这些提示了。
那记事本写代码为什么没有提示呢? 因为技术本软件没有利用反射技术开发这种代码提示的功能,哈哈!!
好了,认识了反射是什么之后,接下来我还想给同学们介绍一下反射具体学什么?
因为反射获取的是类的信息,那么反射的第一步首先获取到类才行。由于Java的设计原则是万物皆对象,获取到的类其实也是以对象的形式体现的,叫字节码对象,用Class类来表示。获取到字节码对象之后,再通过字节码对象就可以获取到类的组成成分了,这些组成成分其实也是对象,其中每一个成员变量用Field类的对象来表示、每一个成员方法用Method类的对象来表示,每一个构造器用Constructor类的对象来表示。
如下图所示:
1.1 获取类的字节码
反射的第一步:是将字节码加载到内存,我们需要获取到的字节码对象。
比如有一个Student类,获取Student类的字节码代码有三种写法。不管用哪一种方式,获取到的字节码对象其实是同一个。
public class Test1Class{ public static void main(String[] args){ Class c1 = Student.class; System.out.println(c1.getName()); //获取全类名 System.out.println(c1.getSimpleName()); //获取简单类名 Class c2 = Class.forName("com.itheima.d2_reflect.Student"); System.out.println(c1 == c2); //true Student s = new Student(); Class c3 = s.getClass(); System.out.println(c2 == c3); //true } }
1.2 获取类的构造器
同学们,上一节我们已经可以获取到类的字节码对象了。接下来,我们学习一下通过字节码对象获取构造器,并使用构造器创建对象。
获取构造器,需要用到Class类提供的几个方法,如下图所示:
想要快速记住这个方法的区别,给同学们说一下这些方法的命名规律,按照规律来记就很方便了。
get:获取 Declared: 有这个单词表示可以获取任意一个,没有这个单词表示只能获取一个public修饰的 Constructor: 构造方法的意思 后缀s: 表示可以获取多个,没有后缀s只能获取一个
话不多少,上代码。假设现在有一个Cat类,里面有几个构造方法,代码如下
public class Cat{ private String name; private int age; public Cat(){ } private Cat(String name, int age){ } }
- 接下来,我们写一个测试方法,来测试获取类中所有的构造器
public class Test2Constructor(){ @Test public void testGetConstructors(){ //1、反射第一步:必须先得到这个类的Class对象 Class c = Cat.class; //2、获取类的全部构造器 Constructor[] constructors = c.getDeclaredConstructors(); //3、遍历数组中的每一个构造器对象。 for(Constructor constructor: constructors){ System.out.println(constructor.getName()+"---> 参数个数:"+constructor.getParameterCount()); } } }
运行测试方法打印结果如下
- 刚才演示的是获取Cat类中所有的构造器,接下来,我们演示单个构造器试一试
public class Test2Constructor(){ @Test public void testGetConstructor(){ //1、反射第一步:必须先得到这个类的Class对象 Class c = Cat.class; //2、获取类public修饰的空参数构造器 Constructor constructor1 = c.getConstructor(); System.out.println(constructor1.getName()+"---> 参数个数:"+constructor1.getParameterCount()); //3、获取private修饰的有两个参数的构造器,第一个参数String类型,第二个参数int类型 Constructor constructor2 = c.getDeclaredConstructor(String.class,int.class); System.out.println(constructor2.getName()+"---> 参数个数:"+constructor1.getParameterCount()); } }
打印结果如下
1.3 反射获取构造器的作用
同学们,刚才上一节我们已经获取到了Cat类中的构造器。获取到构造器后,有什么作用呢?
其实构造器的作用:初始化对象并返回。
这里我们需要用到如下的两个方法,注意:这两个方法时属于Constructor的,需要用Constructor对象来调用。
如下图所示,constructor1和constructor2分别表示Cat类中的两个构造器。现在我要把这两个构造器执行起来
由于构造器是private修饰的,先需要调用setAccessible(true)
表示禁止检查访问控制,然后再调用newInstance(实参列表)
就可以执行构造器,完成对象的初始化了。
代码如下:为了看到构造器真的执行, 故意在两个构造器中分别加了两个打印语句
代码的执行结果如下图所示:
1.4 反射获取成员变量&使用
同学们,上一节我们已经学习了获取类的构造方法并使用。接下来,我们再学习获取类的成员变量,并使用。
其实套路是一样的,在Class类中提供了获取成员变量的方法,如下图所示。
这些方法的记忆规则,如下
get:获取 Declared: 有这个单词表示可以获取任意一个,没有这个单词表示只能获取一个public修饰的 Field: 成员变量的意思 后缀s: 表示可以获取多个,没有后缀s只能获取一个
- 假设有一个Cat类它有若干个成员变量,用Class类提供 的方法将成员变量的对象获取出来。
执行完上面的代码之后,我们可以看到控制台上打印输出了,每一个成员变量的名称和它的类型。
- 获取到成员变量的对象之后该如何使用呢?
在Filed类中提供给给成员变量赋值和获取值的方法,如下图所示。
再次强调一下设置值、获取值的方法时Filed类的需要用Filed类的对象来调用,而且不管是设置值、还是获取值,都需要依赖于该变量所属的对象。代码如下
执行代码,控制台会有如下的打印
1.5 反射获取成员方法
各位同学,上面几节我们已经学习了反射获取构造方法、反射获取成员变量,还剩下最后一个就是反射获取成员方法并使用了。
在Java中反射包中,每一个成员方法用Method对象来表示,通过Class类提供的方法可以获取类中的成员方法对象。如下下图所示
接下来我们还是用代码演示一下:假设有一个Cat类,在Cat类中红有若干个成员方法
public class Cat{ private String name; private int age; public Cat(){ System.out.println("空参数构造方法执行了"); } private Cat(String name, int age){ System.out.println("有参数构造方法执行了"); this.name=name; this.age=age; } private void run(){ System.out.println("(>^ω^<)喵跑得贼快~~"); } public void eat(){ System.out.println("(>^ω^<)喵爱吃猫粮~"); } private String eat(String name){ return "(>^ω^<)喵爱吃:"+name; } public void setName(String name){ this.name=name; } public String getName(){ return name; } public void setAge(int age){ this.age=age; } public int getAge(){ return age; } }
接下来,通过反射获取Cat类中所有的成员方法,每一个成员方法都是一个Method对象
public class Test3Method{ public static void main(String[] args){ //1、反射第一步:先获取到Class对象 Class c = Cat.class; //2、获取类中的全部成员方法 Method[] methods = c.getDecalaredMethods(); //3、遍历这个数组中的每一个方法对象 for(Method method : methods){ System.out.println(method.getName()+"-->"+method.getParameterCount()+"-->"+method.getReturnType()); } } }
执行上面的代码,运行结果如下图所示:打印输出每一个成员方法的名称、参数格式、返回值类型
也能获取单个指定的成员方法,如下图所示
获取到成员方法之后,有什么作用呢?
在Method类中提供了方法,可以将方法自己执行起来。
下面我们演示一下,把run()
方法和eat(String name)
方法执行起来。看分割线之下的代码
public class Test3Method{ public static void main(String[] args){ //1、反射第一步:先获取到Class对象 Class c = Cat.class; //2、获取类中的全部成员方法 Method[] methods = c.getDecalaredMethods(); //3、遍历这个数组中的每一个方法对象 for(Method method : methods){ System.out.println(method.getName()+"-->"+method.getParameterCount()+"-->"+method.getReturnType()); } System.out.println("-----------------------"); //4、获取private修饰的run方法,得到Method对象 Method run = c.getDecalaredMethod("run"); //执行run方法,在执行前需要取消权限检查 Cat cat = new Cat(); run.setAccessible(true); Object rs1 = run.invoke(cat); System.out.println(rs1) //5、获取private 修饰的eat(String name)方法,得到Method对象 Method eat = c.getDeclaredMethod("eat",String.class); eat.setAccessible(true); Object rs2 = eat.invoke(cat,"鱼儿"); System.out.println(rs2) } }
打印结果如下图所示:run()方法执行后打印猫跑得贼快~~
,返回null
; eat()方法执行完,直接返回猫最爱吃:鱼儿
1.6 反射的应用
各位小伙伴,按照前面我们学习反射的套路,我们已经充分认识了什么是反射,以及反射的核心作用是用来获取类的各个组成部分并执行他们。但是由于同学们的经验有限,对于反射的具体应用场景还是很难感受到的(这个目前没有太好的办法,只能慢慢积累,等经验积累到一定程度,就会豁然开朗了)。
我们一直说反射使用来写框架的,接下来,我们就写一个简易的框架,简单窥探一下反射的应用。反射其实是非常强大的,这个案例也仅仅值小试牛刀。
需求是让我们写一个框架,能够将任意一个对象的属性名和属性值写到文件中去。不管这个对象有多少个属性,也不管这个对象的属性名是否相同。
分析一下该怎么做
1.先写好两个类,一个Student类和Teacher类 2.写一个ObjectFrame类代表框本架 在ObjectFrame类中定义一个saveObject(Object obj)方法,用于将任意对象存到文件中去 参数:Object obj: 就表示要存入文件中的对象 3.编写方法内部的代码,往文件中存储对象的属性名和属性值 1)参数obj对象中有哪些属性,属性名是什么实现值是什么,中有对象自己最清楚。 2)接着就通过反射获取类的成员变量信息了(变量名、变量值) 3)把变量名和变量值写到文件中去
写一个ObjectFrame表示自己设计的框架,代码如下图所示
public class ObjectFrame{ public static void saveObject(Object obj) throws Exception{ PrintStream ps = new PrintStream(new FileOutputStream("模块名\\src\\data.txt",true)); //1)参数obj对象中有哪些属性,属性名是什么实现值是什么,中有对象自己最清楚。 //2)接着就通过反射获取类的成员变量信息了(变量名、变量值) Class c = obj.getClass(); //获取字节码 ps.println("---------"+class.getSimpleName()+"---------"); Field[] fields = c.getDeclaredFields(); //获取所有成员变量 //3)把变量名和变量值写到文件中去 for(Field field : fields){ String name = field.getName(); Object value = field.get(obj)+""; ps.println(name); } ps.close(); } }
使用自己设计的框架,往文件中写入Student对象的信息和Teacher对象的信息。
先准备好Student类和Teacher类
public class Student{ private String name; private int age; private char sex; private double height; private String hobby; }
public class Teacher{ private String name; private double salary; }
创建一个测试类,在测试中类创建一个Student对象,创建一个Teacher对象,用ObjectFrame的方法把这两个对象所有的属性名和属性值写到文件中去。
public class Test5Frame{ @Test public void save() throws Exception{ Student s1 = new Student("黑马吴彦祖",45, '男', 185.3, "篮球,冰球,阅读"); Teacher s2 = new Teacher("播妞",999.9); ObjectFrame.save(s1); ObjectFrame.save(s2); } }
打开data.txt文件,内容如下图所示,就说明我们这个框架的功能已经实现了
好了,同学们,恭喜大家!学习到这里,反射技术已经学习完毕了。
四、Lambda表达式
接下来,我们学习一个JDK8新增的一种语法形式,叫做Lambda表达式。作用:用于简化匿名内部类代码的书写。
4.1 Lambda表达式基本使用
怎么去简化呢?Lamdba是有特有的格式的,按照下面的格式来编写Lamdba。
(被重写方法的形参列表) -> { 被重写方法的方法体代码; }
需要给说明一下的是,在使用Lambda表达式之前,必须先有一个接口,而且接口中只能有一个抽象方法。(注意:不能是抽象类,只能是接口)
像这样的接口,我们称之为函数式接口,只有基于函数式接口的匿名内部类才能被Lambda表达式简化。
public interface Swimming{ void swim(); }
有了以上的Swimming接口之后,接下来才能再演示,使用Lambda表达式,简化匿名内部类书写。
public class LambdaTest1 { public static void main(String[] args) { // 目标:认识Lambda表达式. //1.创建一个Swimming接口的匿名内部类对象 Swimming s = new Swimming(){ @Override public void swim() { System.out.println("学生快乐的游泳~~~~"); } }; s.swim(); //2.使用Lambda表达式对Swimming接口的匿名内部类进行简化 Swimming s1 = () -> { System.out.println("学生快乐的游泳~~~~"); }; s1.swim(); } }
好的,我们现在已经知道Lamdba表达式可以简化基于函数式接口的匿名内部类的书写。接下来,我们可以把刚才使用Arrays方法时的代码,使用Lambda表达式简化一下了。
public class LambdaTest2 { public static void main(String[] args) { // 目标:使用Lambda简化函数式接口。 double[] prices = {99.8, 128, 100}; //1.把所有元素*0.8: 先用匿名内部类写法 Arrays.setAll(prices, new IntToDoubleFunction() { @Override public double applyAsDouble(int value) { // value = 0 1 2 return prices[value] * 0.8; } }); //2.把所有元素*0.8: 改用Lamdba表达式写法 Arrays.setAll(prices, (int value) -> { return prices[value] * 0.8; }); System.out.println(Arrays.toString(prices)); System.out.println("-----------------------------------------------"); Student[] students = new Student[4]; students[0] = new Student("蜘蛛精", 169.5, 23); students[1] = new Student("紫霞", 163.8, 26); students[2] = new Student("紫霞", 163.8, 26); students[3] = new Student("至尊宝", 167.5, 24); //3.对数组中的元素按照年龄升序排列: 先用匿名内部类写法 Arrays.sort(students, new Comparator<Student>() { @Override public int compare(Student o1, Student o2) { return Double.compare(o1.getHeight(), o2.getHeight()); // 升序 } }); //4.对数组中的元素按照年龄升序排列: 改用Lambda写法 Arrays.sort(students, (Student o1, Student o2) -> { return Double.compare(o1.getHeight(), o2.getHeight()); // 升序 }); System.out.println(Arrays.toString(students)); } }
好的,各位同学,恭喜大家!到这里,你已经学会了Lambda表达式的基本使用了。
4.2 Lambda表达式省略规则
刚才我们学习了Lambda表达式的基本使用。Java觉得代码还不够简单,于是还提供了Lamdba表达式的几种简化写法。具体的简化规则如下
1.Lambda的标准格式 (参数类型1 参数名1, 参数类型2 参数名2)->{ ...方法体的代码... return 返回值; } 2.在标准格式的基础上()中的参数类型可以直接省略 (参数名1, 参数名2)->{ ...方法体的代码... return 返回值; } 3.如果{}总的语句只有一条语句,则{}可以省略、return关键字、以及最后的“;”都可以省略 (参数名1, 参数名2)-> 结果 4.如果()里面只有一个参数,则()可以省略 (参数名)->结果
接下来从匿名内部类开始、到Lambda标准格式、再到Lambda简化格式,一步一步来简化一下。同学们体会一下简化的过程。
public class LambdaTest2 { public static void main(String[] args) { // 目标:使用Lambda简化函数式接口。 double[] prices = {99.8, 128, 100}; //1.对数组中的每一个元素*0.8: 匿名内部类写法 Arrays.setAll(prices, new IntToDoubleFunction() { @Override public double applyAsDouble(int value) { // value = 0 1 2 return prices[value] * 0.8; } }); //2.需求:对数组中的每一个元素*0.8,使用Lambda表达式标准写法 Arrays.setAll(prices, (int value) -> { return prices[value] * 0.8; }); //3.使用Lambda表达式简化格式1——省略参数类型 Arrays.setAll(prices, (value) -> { return prices[value] * 0.8; }); //4.使用Lambda表达式简化格式2——省略() Arrays.setAll(prices, value -> { return prices[value] * 0.8; }); //5.使用Lambda表达式简化格式3——省略{} Arrays.setAll(prices, value -> prices[value] * 0.8 ); System.out.println(Arrays.toString(prices)); System.out.println("------------------------------------ Student[] students = new Student[4]; students[0] = new Student("蜘蛛精", 169.5, 23); students[1] = new Student("紫霞", 163.8, 26); students[2] = new Student("紫霞", 163.8, 26); students[3] = new Student("至尊宝", 167.5, 24); //1.使用匿名内部类 Arrays.sort(students, new Comparator<Student>() { @Override public int compare(Student o1, Student o2) { return Double.compare(o1.getHeight(), o2.getHeight()); // 升序 } }); //2.使用Lambda表达式表达式——标准格式 Arrays.sort(students, (Student o1, Student o2) -> { return Double.compare(o1.getHeight(), o2.getHeight()); // 升序 }); //3.使用Lambda表达式表达式——省略参数类型 Arrays.sort(students, ( o1, o2) -> { return Double.compare(o1.getHeight(), o2.getHeight()); // 升序 }); //4.使用Lambda表达式表达式——省略{} Arrays.sort(students, ( o1, o2) -> Double.compare(o1.getHeight(), o2.getHeight())); System.out.println(Arrays.toString(students)); } }
到这里,恭喜你,对Lamdba表达式的所有写法,就学习完毕了。
最新Java基础系列课程--Day13-高级特性(三)https://developer.aliyun.com/article/1423544