赤峰北京网站建设,小程序代理模板,网页截图快捷键是哪个,什么软件可以做企业网站目录
1、反射
1.1、定义
1.2、用途
1.3、反射基本信息
1.4、反射相关的类【重点】
1.5、Class类#xff08;反射机制的起源#xff09;
1.6、Class类中相关的方法
1.7、获得Class对象的三种方式
1.8、反射的使用
1.9、反射的优点、缺点
2、枚举
2.1、背景及定义 …目录
1、反射
1.1、定义
1.2、用途
1.3、反射基本信息
1.4、反射相关的类【重点】
1.5、Class类反射机制的起源
1.6、Class类中相关的方法
1.7、获得Class对象的三种方式
1.8、反射的使用
1.9、反射的优点、缺点
2、枚举
2.1、背景及定义
2.2、使用
2.2.1、Switch语句
2.2.2、常用方法
2.3、枚举优缺点
3、Lambda表达式
3.1、背景
前置小知识函数式接口
3.2、Lambda表达式的基本使用
3.3、Lambda优点、缺点 1、反射
1.1、定义 Java的反射机制是在运行状态中对于任意一个类都能够知道这个类的所有属性和方法对于任意一个对象都能够调用他的任意方法和属性既然能拿到那我们就可以修改部分类型信息。这种动态获取信息以及动态调用对象方法的功能称为Java语言的反射机制。
1.2、用途
在日常的第三方应用开发过程中遇到某个类的某个成员变量、方法、属性是私有的、只对系统应用开放的这时我们可以通过反射获取所需要的私有成员或者是方法反射最重要的用途就是开发各种通用框架比如在Spring中我们将所有的Bean交给Spring容器管理无论是XML配置Bean还是注解配置当我们从容器中获取Bean来依赖注入时容器会读取配置而配置中给的就是类的信息spring根据这些类信息需要创建需要的BeanSpring就动态的创建这些类~
1.3、反射基本信息 Java程序中许多对象在运行时会出现两种类型运行时类型和编译时类型例如Person p new Student(); 这段代码中P就是在编译时类型为Person运行时类型为Student。程序需要在运行时发现对象和类的真实信息。而通过使用反射程序就能判断出该对象和类属于哪些类。
1.4、反射相关的类【重点】 1.5、Class类反射机制的起源 Java文件被编译后生成了.class文件JVM此时就要去解读.class文件被编译后的java文件也被JVM解析为一个对象这个对象就是java.lang.Class。这样当程序在运行时没每个java文件就最终变成了Class类对象的一个实例。我们通过java反射机制应用到这个实例就可以去获得甚至去添加改变这个类的属性和工作使得这个类成为一个动态的类。
1.6、Class类中相关的方法 常用获得类相关的方法【重要】 常用获得类中属性相关方法【重要】 一下方法返回值为Field 获得类中注解相关方法【了解】 获得类中构造器相关方法【重要】 获得类中方法相关方法【重要】 1.7、获得Class对象的三种方式 在我们进行反射之前我们需要做的第一步就是先拿到当前需要反射的类的Class对象然后通过Class对象的核心方法达到反射的目的即在运行状态中对于任意一个类都能够知道这个类的所有属性和方法对象任意一个对象都能调用他的任意方法和属性并修改部分类型信息。
方式一使用Class.forName(类的全路径名)静态方法【前提已明确类的全路径名】
方式二使用.class方法【前提在编译之前就已经明确要操作的Class】
方式三使用类对象的getClass()方法
代码
准备一个Student类
public class Student{//私有属性nameprivate String name lyj;//公有属性agepublic int age 18;//不带参数的构造方法public Student(){System.out.println(Student());}private Student(String name,int age) {this.name name;this.age age;System.out.println(Student(String,name));}private void eat(){System.out.println(i am eat);}public void sleep(){System.out.println(i am pig);}private void function(String str) {System.out.println(str);}Overridepublic String toString() {return Student{ name name \ , age age };}
}
demo类
public class TestDemo {public static void main(String[] args) {//1.通过getClass获取Class对象Student s1 new Student();Class c1 s1.getClass();//2.直接通过 类名.class 的方式得到,该方法最为安全可靠程序性能更高这说明任何一个类都有一个隐含的静态成员变量 classClass c2 Student.class;//3、通过 Class 对象的 forName() 静态方法来获取用的最多//但可能抛出 ClassNotFoundException 异常Class c3 null;try {//注意这里是类的全路径如果有包需要加包的路径c3 Class.forName(Student);} catch (ClassNotFoundException e) {e.printStackTrace();}//一个类在 JVM 中只会有一个 Class 实例,即我们对上面获取的//c1,c2,c3进行 equals 比较System.out.println(c1.equals(c2));System.out.println(c1.equals(c3));System.out.println(c2.equals(c3));}
}
上述就是三种获取方式代码运行结果都是true也就是说一个类在JVM中只会有一个Class实例~
1.8、反射的使用
代码
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;public class ReflectClassDemo {// 创建对象public static void reflectNewInstance() {try {Class? classStudent Class.forName(Student);Object objectStudent classStudent.newInstance();Student student (Student) objectStudent;System.out.println(获得学生对象student);} catch (Exception ex) {ex.printStackTrace();}}// 反射私有的构造方法 屏蔽内容为获得公有的构造方法public static void reflectPrivateConstructor() {try {Class? classStudent Class.forName(Student);//注意传入对应的参数Constructor? declaredConstructorStudent classStudent.getDeclaredConstructor(String.class,int.class);//Constructor? declaredConstructorStudent classStudent.getConstructor();//设置为true后可修改访问权限declaredConstructorStudent.setAccessible(true);Object objectStudent declaredConstructorStudent.newInstance(龙洋静,15);//Object objectStudent declaredConstructorStudent.newInstance();Student student (Student) objectStudent;System.out.println(获得私有构造哈数且修改姓名和年龄student);} catch (Exception ex) {ex.printStackTrace();}}// 反射私有属性public static void reflectPrivateField() {try {Class? classStudent Class.forName(Student);Field field classStudent.getDeclaredField(name);field.setAccessible(true);//可以修改该属性的值Object objectStudent classStudent.newInstance();Student student (Student) objectStudent;field.set(student,小明);String name (String) field.get(student);System.out.println(反射私有属性修改了name name);} catch (Exception ex) {ex.printStackTrace();}}// 反射私有方法public static void reflectPrivateMethod() {try {Class? classStudent Class.forName(Student);Method methodStudent classStudent.getDeclaredMethod(function,String.class);System.out.println(私有方法的方法名为methodStudent.getName());//私有的一般都要加methodStudent.setAccessible(true);Object objectStudent classStudent.newInstance();Student student (Student) objectStudent;methodStudent.invoke(student,我是给私有的function函数传的参数);} catch (Exception ex) {ex.printStackTrace();}}public static void main(String[] args) {reflectNewInstance();// 创建对象reflectPrivateConstructor();// 反射私有的构造方法 屏蔽内容为获得公有的构造方法reflectPrivateField();// 反射私有属性reflectPrivateMethod();// 反射私有方法}
}
运行 1.9、反射的优点、缺点
优点
对于任意一个类都能够知道这个类的所有属性和方法对于任意一个对象都能够调用它的任意一个方法增加程序的灵活性和扩展性降低耦合性提高自适应能力反射已经运用在了很多流行框架如Struts、Hibernate、Spring 等等。
缺点
使用反射会有效率问题。会导致程序效率降低。反射技术绕过了源代码的技术因而会带来维护问题。反射代码比相应的直接代码更复杂 。 2、枚举
2.1、背景及定义 枚举是在JDK1.5后引入的主要用途是将一组常量组织起来在这之前表示一组常量通常使用定义常量的方式
public static int final RED 1;
public static int final GREEN 2;
public static int final BLACK 3; 但是常量举例有不好的地方例如可能碰巧有个数字1但是他有可能误会为是RED现在我们可以直接用枚举来进行组织这样一来就拥有了类型枚举类型。而不是普通的整形1.
枚举
/*** Created with IntelliJ IDEA.* Description:* User:龙宝* Date:2023-11-26* Time:17:19*/
public enum Test {RED,BLACK,GREEN;
}优点 将常量组织起来统一进行管理
场景 错误状态码消息类型颜色的划分状态机等...
本质 是java.lang.Enum的子类也就是说自己写的枚举类就算没显示继承Enum但是是默认继承了这个类~
2.2、使用
2.2.1、Switch语句
/*** Created with IntelliJ IDEA.* Description:* User:龙宝* Date:2023-11-26* Time:17:19*/
public enum Test {RED,BLACK,GREEN,WHITE;public static void main(String[] args) {Test test Test.BLACK;switch (test) {case RED:System.out.println(red);break;case BLACK:System.out.println(black);break;case WHITE:System.out.println(WHITE);break;case GREEN:System.out.println(green);break;default:break;}}
}2.2.2、常用方法 使用1
/*** Created with IntelliJ IDEA.* Description:* User:龙宝* Date:2023-11-26* Time:17:19*/
public enum Test {RED,BLACK,GREEN,WHITE;public static void main(String[] args) {Test[] testEnum2 Test.values();for (int i 0; i testEnum2.length; i) {System.out.println(testEnum2[i] testEnum2[i].ordinal());}System.out.println();System.out.println(Test.valueOf(GREEN));}
}使用2
/*** Created with IntelliJ IDEA.* Description:* User:龙宝* Date:2023-11-26* Time:17:19*/
public enum Test {RED,BLACK,GREEN,WHITE;public static void main(String[] args) {//拿到枚举实例BLACKTest testEnum Test.BLACK;//拿到枚举实例REDTest testEnum21 Test.RED;System.out.println(testEnum.compareTo(testEnum21));System.out.println(BLACK.compareTo(RED));System.out.println(RED.compareTo(BLACK));}
}使用3 1 、当枚举对象有参数后需要提供相应的构造函数 2 、枚举的构造函数默认是私有的 这个一定要记住 /*** Created with IntelliJ IDEA.* Description:* User:龙宝* Date:2023-11-26* Time:17:36*/
public enum Test2 {RED(red,1),BLACK(black,2),WHITE(white,3),GREEN(green,4);private String name;private int key;Test2 (String name,int key) {this.name name;this.key key;}
}/*** Created with IntelliJ IDEA.* Description:* User:龙宝* Date:2023-11-26* Time:17:36*/
public enum Test2 {RED(red,1),BLACK(black,2),WHITE(white,3),GREEN(green,4);private String name;private int key;Test2 (String name,int key) {this.name name;this.key key;}public static Test2 getEnumKey (int key) {for (Test2 t: Test2.values()) {if(t.key key) {return t;}}return null;}public static void main(String[] args) {System.out.println(getEnumKey(2));}
}2.3、枚举优缺点
优点
枚举常量更简单安全枚举具有内置方法代码更优雅
缺点
不可继承无法扩展 注意 不能通过反射获取枚举类的实例枚举可以避免反射和序列化问题 3、Lambda表达式
3.1、背景
Lambda表达式是允许通过表达式来代替功能接口语法(parameters) - expression 或 (parameters) -{ statements; }
语法说明
paramaters类似方法中的形参列表这里的参数是函数式接口里的参数。这里的参数类型可以明确的声明也可不声明而由JVM隐含的推断。另外当只有一个推断类型时可以省略掉圆括号。 -可理解为“被用于”的意思 方法体可以是表达式也可以代码块是函数式接口里方法的实现。代码块可返回一个值或者什么都不反回这里的代码块块等同于方法的方法体。如果是表达式也可以返回一个值或者什么都不反回。
如下
// 1. 不需要参数,返回值为 2
() - 2
// 2. 接收一个参数(数字类型),返回其2倍的值
x - 2 * x
// 3. 接受2个参数(数字),并返回他们的和
(x, y) - x y
// 4. 接收2个int型整数,返回他们的乘积
(int x, int y) - x * y
// 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)
(String s) - System.out.print(s) 前置小知识函数式接口 函数式接口的意思就是一个接口有且只有一个抽象方法可以有其他方法其他方法需要是Default方法
Lambda表达式的前提条件 1.方法的参数或变量的类型是接口。 2.这个接口中只能有一个抽象方法。
3.2、Lambda表达式的基本使用
看看代码
package com.jdktest01.day01;import java.util.ArrayList;
import java.util.Collections;/*** author a1002*/
public class LambdaTest02 {public static void main(String[] args) {ArrayListPerson persons new ArrayList();persons.add(new Person(张三, 58, 174));persons.add(new Person(李四, 58, 176));persons.add(new Person(王五, 54, 171));persons.add(new Person(伞兵, 19, 177));// Collections.sort(persons, new ComparatorPerson() {
// Override
// public int compare(Person o1, Person o2) {
// return o1.getAge() - o2.getAge();
// }
// });// persons.forEach((p) - {
// System.out.println(p);
// });System.out.println();Collections.sort(persons, (Person o1, Person o2) - {return o1.getAge() - o2.getAge();});Collections.sort(persons, (o1, o2) - o2.getAge() - o1.getAge());persons.forEach((p) - {System.out.println(p);});System.out.println(-----------------------------);persons.forEach(t - System.out.println(t));// 对集合中的数据进行排序/*Collections.sort(persons, new ComparatorPerson() {Overridepublic int compare(Person o1, Person o2) {return o1.getAge() - o2.getAge(); // 升序排序}});*/// Collections.sort(persons, (Person o1, Person o2) - {
// return o2.getAge() - o1.getAge(); // 降序
// });
//
// for (Person person : persons) {
// System.out.println(person);
// }
//
// System.out.println(-----------);
// persons.forEach((t) - {
// System.out.println(t);
// });}
} 对集合中的数据进行排序 Collections.sort(persons, new ComparatorPerson() {Overridepublic int compare(Person o1, Person o2) {return o1.getAge() - o2.getAge();//升序}});
Lambda写法
Collections.sort(persons, (Person o1, Person o2) - {return o1.getAge() - o2.getAge();});
简化
Collections.sort(persons, (o1, o2) - o2.getAge() - o1.getAge()); 在Lambda标准格式的基础上使用省略写法的规则为 1. 小括号内参数的类型可以省略 2. 如果小括号内 有且仅有一个参数 则小括号可以省略 3. 如果大括号内 有且仅有一个语句 可以同时省略大括号、 return 关键字及语句分号 Lambda遍历写法 persons.forEach((p) - {System.out.println(p);});//简化
persons.forEach(t - System.out.println(t)); Lambda和匿名内部类的区别 1.所需类型不一样 匿名内部类所需要的类型可以是抽象类接口。 lambda表达式需要的类型必须是接口。
2.抽象方法的数量不一样 匿名内部类所需要的接口中抽象方法的数量随意。 lambda表达式所需要的接口只有一个抽象方法。
3.实现原理不同 匿名内部类是在编译以后形成class。 lambda表达式是在程序运行时动态生成class。
3.3、Lambda优点、缺点 优点 1. 代码简洁开发迅速 2. 方便函数式编程 3. 非常容易进行并行计算 4. Java 引入 Lambda 改善了集合操作 缺点 1. 代码可读性变差 2. 在非并行计算中很多计算未必有传统的 for 性能要高 3. 不容易进行调试
