查询网站最新域名,免费公司logo图标,网站建设移动时代,网站建设费用要求1. 反射
1.1 定义
java的.class文件在运行时会被编译为一个Class对象#xff0c;既然是对象#xff0c;那么我们就可以通过一定的方式取到这个对象#xff0c;然后对于这个对象进行一系列操作#xff08;改变原本类的属性、方法#xff09;。
这个操作就是反射#xf…1. 反射
1.1 定义
java的.class文件在运行时会被编译为一个Class对象既然是对象那么我们就可以通过一定的方式取到这个对象然后对于这个对象进行一系列操作改变原本类的属性、方法。
这个操作就是反射反射会像一面照妖镜一样将所有的类“照”出来不管它是否是private的还是protected都可以进行访问、创建、修改。 反射的一系列操作都是动态的。 1.2 用途了解
在日常的第三方应用开发中经常有某个属性或者方法只对于系统进行开放这时可以利用反射进行获取。开发各种通用框架也可以用到。
1.3 反射出的基本信息
java程序中许多对象在运行时会出现两种类型运行时类型(RTTI)和编译时类型例如Person p new Student()这句代码中p在编译时类型为Person运行时类型为Student。程序需要在运行时发现对象和类的真实 信息。而通过使用反射程序就能判断出该对象和类属于哪些类。
1.4 反射相关的类重要
类说明Class类代表类的实体在运行的java程序中表示类和接口Field类代表类的成员变量Constructor类代表类的构造方法Method类代表类的方法
1.5 获得Class对象的三种方式
package ReflectDemo;import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;public class ReflectDemo {public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException, ClassNotFoundException {// 方式1Class? student1 Student.class;// 方式2Class? student2 Class.forName(ReflectDemo.Student);// 方式3Student studentTmp new Student(,1);Class? student3 studentTmp.getClass();// 验证是不是同一个Class对象System.out.println(student1 student2);System.out.println(student1 student3);}
}三种方式
使用 “对象名.class” 进行获得使用 Class.forName(“类的路径”)进行获得使用 “已经构造出来的对象.getClass()” 进行获得
只有一个Class对象的原因:
所以通过反射只能得到同一个Class对象。
1.6 反射的使用——Class类中的相关方法重要 出现Declared就能够获取私有变量/方法。 1.6.1 常用获得类相关的方法
方法说明getClassLoader()获得类的加载器getDeclaredClass()返回一个数组数组中包含该类中所有类和接口类的对象(包括私有的forName(String className)根据类名返回类的对象getName()获得类的完整路径名字
创建的Person测试类包含public、private内部类接口各种属性
package ReflectDemo;public class Person implements ComparablePerson{public String name;private int id;private int age;Overridepublic int compareTo(Person o) {return o.age - this.age;}interface interfaceTest{};public class PublicInnerClass {}private class PrivateInnerClass {}public Person(String name, int id) {this.name name;this.id id;}}测试代码
package ReflectDemo;import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Arrays;public class ReflectTest {public static void main(String[] args) {Class? cls;try {cls Class.forName(ReflectDemo.Person);/*// 获取Person类内部的public类、接口返回一个数组Class?[] classes cls.getClasses();*/// 获取Person类内部的包括private的类、接口返回一个数组Class?[] classes cls.getDeclaredClasses();System.out.println(Arrays.toString(classes));System.out.println(Person.class.getName());}catch (ClassNotFoundException e) {e.printStackTrace();}}
}运行结果 1.6.2 重要常用获得类属性的方法以下与Field相关
方法说明getField(String name)获得某个公有属性参数为属性名称getFields()获得所有公共属性返回值为Fields数组getDeclaredField(String name)获得某个属性参数为属性名称、不分权限getDeclaredFields()获得某个属性返回值为Fields数组、不分权限
示例代码:
package ReflectDemo;import java.lang.reflect.Field;
import java.util.Arrays;public class ReflectDemo3 {public static void main(String[] args) throws NoSuchFieldException {Class? personClass Person.class;// 获得公有属性Field name personClass.getField(name);Field[] fields personClass.getFields();System.out.println(获得某个公有属性);System.out.println(name);System.out.println(获得所有公有属性);for (Field field : fields) {System.out.println(field);}System.out.println(获得某个属性不分权限);//获得某个属性不分权限System.out.println(personClass.getDeclaredField(id));System.out.println(获得所有属性不分权限));// 获得所有属性不分权限System.out.println(Arrays.toString(personClass.getDeclaredFields()));}
}运行结果 1.6.3 了解获得类中注解相关的方法
方法说明getAnnotation(Class annotationClass)返回该类中与参数类型匹配的公有注解对象getAnnotations()返回该类所有的公有注解对象getDeclaredAnnotation(Class annotationClass)返回该类中与参数类型匹配的所有注解对象getDeclaredAnnotations()返回该类所有的注解对象
1.6.4 重要获得类中构造器相关的方法以下方法返回值为Constructor相关
方法说明getConstructor(Class… parameterTypes)获得该类中与参数类型匹配的公有构造方法getConstructors()得该类的所有公有构造方法getDeclaredConstructor(Class… parameterTypes)获得该类中与参数类型匹配的构造方法getDeclaredConstructors()获得该类所有构造方法
代码
package ReflectDemo;import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.util.Arrays;public class ReflectDemo4 {public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {Class? personClass Person.class;System.out.println(获得类中特定参数的公有构造方法);Constructor? personConstructor personClass.getConstructor(String.class, int.class);System.out.println(personConstructor);System.out.println(使用特定参数的公有构造方法);System.out.println(personConstructor.newInstance(王五, 2023).toString());System.out.println(获得类中所有的公有构造方法);Constructor?[] personConstructors personClass.getConstructors();System.out.println(Arrays.toString(personConstructors));System.out.println(获得类中所有的公有构造方法);Constructor?[] personConstructors2 personClass.getDeclaredConstructors();System.out.println(Arrays.toString(personConstructors2));System.out.println(获得类中特定参数的、不分权限的构造方法);Constructor? personConstructor2 personClass.getDeclaredConstructor(String.class);personConstructor2.setAccessible(true);// 必须设置为true确认对这个私有方法进行操作System.out.println(personConstructor2);System.out.println(personConstructor2.newInstance(老六).toString());}
}运行结果
1.6.5 (重要)获得类中方法相关的方法以下方法返回值为Method相关 方法获取到后需要使用invoke进行调用第一个参数是这个方法作用的对象后面的参数是要传到函数中的参数。 方法说明getMethod(String name, Class… parameterTypes)获得该类某个公有的方法getMethods()获得该类所有公有的方法getDeclaredMethod(String name, Class… parameterTypes)获得该类某个方法getDeclaredMethods()获得该类所有方法
package ReflectDemo;import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;public class ReflectDemo5 {public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {Class? personClass Person.class;Constructor? perspnConstructor personClass.getConstructor(String.class, int.class);Person p (Person) perspnConstructor.newInstance(老七, 2023001);System.out.println(p.toString());Method setName personClass.getMethod(setName, String.class);p.setName(老八);System.out.println(p.toString());Method eat personClass.getMethod(eat);eat.invoke(p);// 无参函数调用Method swim personClass.getDeclaredMethod(swim);swim.setAccessible(true);// 确认修改访问权限swim.invoke(p);}
}运行结果
1.5 反射优点和缺点
优点
能够获取本来访问受限的属性、方法。增强了程序的灵活性降低耦合度已经运用在了很多流行的框架上如Struts、Hibernate、Spring 等等。
缺点
使用反射的代码效率较低。破坏程序封装性。反射技术绕过了源代码的技术因而会带来维护问题。反射代码比相应的直接代码更复杂 。
1.6 重要总结
反射的意义 意义在于获取一些只对于系统开放的、不让外界看到的方法、属性。 反射的重要类 Field类Constructor类Method类Class类。 合理利用反射不要轻易使用。
2. 枚举
将一组常量组织起来同c语言的枚举相同已经定义好的枚举中常量就代表这个符号这个符号也代表常量。
场景错误状态码消息类型颜色的划分状态机等等。
本质继承自Enum这个类。如同所有的对象都继承自Object类一样都是隐式继承 2.1 常用方法
方法说明values()获得枚举类中所有的成员ordinal()获得成员在枚举类中的索引位置name()获得枚举成员的名称valueOf()将普通字符串转换为枚举实例compareTo()返回成员在定义时的顺序将索引位置进行相减
代码
package EnumDemo;public class Demo2 {public static void main(String[] args) {Color[] color Color.values();for (Color color1 : color) {// ordinal的编号改变不了这是枚举成员在类中的索引位置System.out.println(color1.ordinal() color1.name());}// 将编号与name联系起来System.out.println(Color.getEnumKey(4));Color red Color.RED;Color blue Color.BLUE;System.out.println(red.compareTo(blue));// 索引位置相减}
}运行结果 枚举的构造方法默认是私有的所以还可以在枚举类中加上自己定义的构造函数直接在成员后面进行初始化。 package EnumDemo;public enum Color {RED(4,红色),GREEN(5,绿色),BLUE(6,蓝色);private int key;private String name;Color(int key, String name) {this.key key;this.name name;}public static Color getEnumKey(int key) {// 遍历整个枚举类看有没有keyfor (Color e : Color.values()) {if (key e.key) {return e;}}return null;}// err,默认是私有的
// public Color(int num, String color) {}
// RED,GREEN,BLUE;
}2.2 枚举的优缺点
优点
统一组织便于管理常量优于final简单安全枚举类有内置方法书写更优雅
缺点
不可被继承无法扩展 但是为单例模式提供了很好的思路。 2.3 枚举与反射
枚举既然安全性这么高那么能不能通过反射获取到枚举类呢做个实验验证一下。
package EnumDemo;import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;public class Demo3 {public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {Class? enumClass Color.class;Constructor? enumClassConstructor enumClass.getDeclaredConstructor(int.class, String.class);enumClassConstructor.setAccessible(true);Color o (Color) enumClassConstructor.newInstance(1, 黑色);System.out.println(o);}
}运行结果
报错提示我们并没有这个构造方法但是我们的构造方法就是两个参数
Color(int key, String name) {this.key key;this.name name;
}是不是由于隐藏的super()还需要参数给父类Enum进行初始化
Enum类构造方法
/*** Sole constructor. Programmers cannot invoke this constructor.* It is for use by code emitted by the compiler in response to* enum type declarations.** param name - The name of this enum constant, which is the identifier* used to declare it.* param ordinal - The ordinal of this enumeration constant (its position* in the enum declaration, where the initial constant is assigned* an ordinal of zero).*/
protected Enum(String name, int ordinal) {this.name name;this.ordinal ordinal;
}插播:在给出源码的时候源码上的注解已经能够说明不能进行invoke构造了。 确实看来父类还需要两个参数进行构造修改代码如下
package EnumDemo;import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;public class Demo3 {public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {Class? enumClass Color.class;// 函数的参数需要有四个前两个是父类进行使用后两个才是自己写的本身的参数Constructor? enumClassConstructor enumClass.getDeclaredConstructor(String.class, int.class,int.class, String.class);enumClassConstructor.setAccessible(true);Color o (Color) enumClassConstructor.newInstance(1, 黑色);System.out.println(o);}
}运行结果
看来参数传正确也不能够调用报错指出不能够使用反射进行获取。
然后再返回来看源码中的注释部分: 枚举的源码注释: ** Sole constructor. Programmers can not invoke this constructor.* ** It is for use by code emitted by the compiler in response to* *** enum type declarations. 唯一的构造器程序员不能够激活这个构造器它它供编译器在响应 enum类型声明时发出的代码使用。 newInstance()的源码 结论
枚举类不能够使用反射获取实例。枚举可以避免反射和序列化。枚举简单安全、有内置函数、能够组织常量便于管理优于final
2.4 枚举与单例模式
package EnumDemo;enum SingleEnum {INSTANCE;public SingleEnum getInstance() {return INSTANCE;}
}
public class Demo4 {public static void main(String[] args) {SingleEnum singleEnum1 SingleEnum.INSTANCE;SingleEnum singleEnum2 SingleEnum.INSTANCE;System.out.println(singleEnum2 singleEnum1);}
}用枚举实现单例模式简单优雅。
3. lambda表达式
3.1 背景
Lambda表达式是java SE 8中一个重要的新特性。它能够简化匿名内部类函数式接口的代码量只关注怎么执行这个代码而不是无用的创建过程。
3.2 语法
基本原则要遵循
(parameters)-expresstion(parameters)-{statements;}
lambda表达式由三部分组成
parameters参数部分类似于普通方法当中的形参部分。 这里的参数可以明确声明也可以省略原则是能推导出来就能省略。 比如参数只有一个那么可以省略类型同时也可以省略小括号()比如参数有多个但是类型都一样那么也可省略类型 -lambda表达式的标志性语法结构可以理解为“被用于” 方法体相当于普通方法的方法体可以是表达式也可以是代码块同样也可以省略。 可推导即可省略 如果这个方法只有一个return语句那么就可以省略return省略{} 3.2.1 函数式接口
是一个内部仅含一个抽象方法的接口。
注解FunctionalInterface
3.3 使用
package LambdaDemo;public class demo1 {// 无返回值无参数FunctionalInterfacepublic interface NoParameterNoReturn {void test();}//无返回值一个参数FunctionalInterfaceinterface OneParameterNoReturn {void test(int a);}//无返回值多个参数FunctionalInterfaceinterface MoreParameterNoReturn {void test(int a,int b);}//有返回值无参数FunctionalInterfaceinterface NoParameterReturn {int test();}//有返回值一个参数FunctionalInterfaceinterface OneParameterReturn {int test(int a);}//有返回值多参数FunctionalInterfaceinterface MoreParameterReturn {int test(int a,int b);}public static void main(String[] args) {// 相当于已经覆写了这个接口的test方法NoParameterNoReturn a1 ()- System.out.println(无参数无返回值);a1.test();OneParameterNoReturn a2 ((a)-{System.out.println(无返回值一个参数参数为 a);});a2.test(1);MoreParameterNoReturn a3 ((a,b) - {System.out.println(无返回值多个参数参数有 a b);});a3.test(1,2);NoParameterReturn a4 ()-{System.out.print(有返回值无参数返回值为);return 4;};System.out.println(a4.test());OneParameterReturn a5 ((a)-{System.out.print(有返回值一个参数参数为 a 返回值为平方);return a*a;});System.out.println(a5.test(5));MoreParameterReturn a6 ((a,b)- {System.out.print(有返回值多参数, 参数为 a b 返回值为和);return ab;});System.out.println(a6.test(6, 7));}
}运行结果 3.3.1 精简规则 3.4 变量捕获
3.4.1 匿名内部类
匿名内部类就是没有名字的类用过一次就用不了的类。比如创建线程的时候可以创建匿名内部类进行创建线程。举个例子
package LambdaDemo;class Test{public void func() {System.out.println(未被重写的func()方法);}
}
public class Demo2 {public static void main(String[] args) {Test t new Test(){public void func() {System.out.println(重写func());}};t.func();Test t2 new Test();t2.func();}
}运行结果
这里就是创建了一个匿名的Test类直接对类中的func()方法进行重写。因为只想要利用一下Test类中的func()方法。
3.4.2 匿名内部类的变量捕获
package LambdaDemo;import javax.smartcardio.TerminalFactory;class Test{public void func() {System.out.println(未被重写的func()方法);}
}
public class Demo2 {public static void main(String[] args) {int a 100;Test t new Test(){public void func() {System.out.println(重写func());
// a 99;// err, 不允许改变变量System.out.println(捕获到变量值为 a);}};t.func();}
}结论
匿名内部类中的捕获的变量必须是final或者与final等价未经修改的变量。
3.4.4 Lambda的变量捕获
package LambdaDemo;FunctionalInterface
interface Test2{abstract void func();
}public class Demo3 {public static void main(String[] args) {int a 100;Test2 t (()-{
// a 99;// errSystem.out.println(重写func());System.out.println(a);});t.func();}
}结论与匿名内部类相同方法体中只能由final或者等价于final 的变量存在。
4. Lambda在集合当中的使用
4.1 Collection接口
forEach**() 方法源码**
default void forEach(Consumer action) { Objects.requireNonNull(action); for (T t : this) { action.accept(t); }
}该方法表示对容器中的每个元素执行action指定的动作 。
使用示例
package LambdaDemo;import java.util.ArrayList;
import java.util.function.Consumer;public class Demo4 {public static void main(String[] args) {ArrayListString list new ArrayList();list.add(a);list.add(b);list.add(c);list.add(d);list.forEach(new ConsumerString() {Overridepublic void accept(String s) {// 使用accept方法对 list 中每个元素执行相同的操作System.out.print(s );}});System.out.println(\r\n使用lambda表达式改写后);list.forEach((s)- System.out.print(s ));}
}运行结果 4.2 List接口
sort()方法的源码
default void sort(Comparator? super E c) {Object[] a this.toArray();Arrays.sort(a, (Comparator) c);ListIteratorE i this.listIterator();for (Object e : a) {i.next();i.set((E) e);}
}该方法表示对容器中的元素进行指定规则的排序。
使用示例
package LambdaDemo;import ReflectDemo.Person;import java.util.ArrayList;
import java.util.Comparator;
import java.util.function.Consumer;public class Demo5 {public static void main(String[] args) {Person p1 new Person(张三,2023);Person p2 new Person(李四,2022);Person p3 new Person(王五,2021);ArrayListPerson list new ArrayList();list.add(p1);list.add(p2);list.add(p3);list.sort(new ComparatorPerson() {Overridepublic int compare(Person o1, Person o2) {return o1.getId() - o2.getId();}});list.forEach(new ConsumerPerson() {Overridepublic void accept(Person person) {System.out.println(person);}});System.out.println();System.out.println(使用lambda表达式改写);//int compare(T o1, T o2);list.sort((o1,o2)- o1.getId() - o2.getId());//public void forEach(Consumer? super E action)list.forEach((p)- System.out.println(p));}
}运行结果 4.3 Map接口
HashMap 的 forEach**()** 源码****
Override
public void forEach(BiConsumer? super K, ? super V action) {NodeK,V[] tab;if (action null)throw new NullPointerException();if (size 0 (tab table) ! null) {int mc modCount;for (int i 0; i tab.length; i) {for (NodeK,V e tab[i]; e ! null; e e.next)action.accept(e.key, e.value);}if (modCount ! mc)throw new ConcurrentModificationException();}
}使用示例
package LambdaDemo;import java.util.HashMap;
import java.util.function.BiConsumer;public class Demo6 {public static void main(String[] args) {HashMapString, Integer map new HashMap();map.put(张三,19);map.put(李四,22);map.put(王五,39);map.forEach(new BiConsumer() {Overridepublic void accept(Object o1, Object o2) {System.out.println(o1 o2 岁了);}});System.out.println(\r\n用lambda表达式改写);map.forEach((o1,o2)-System.out.println(o1 o2 岁了));}
}运行结果
4.4 结论
优点:
代码简洁开发迅速方便函数式编程java引入lambda方便了集合的一些操作非常容易进行并行计算
缺点:
可读性极差不容易调试在非并行计算中效率未必有普通for高
