一 : 反射
1.定义
Java的反射(reflection)机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意方法和属性,既然能拿到,那么,我们就可以修改部分类型信息;这种动态获取信息以及动态调用对象方法的功能称为java语言的反射(reflection)机制。
2.用途
- 在日常的第三方应用开发过程中,经常会遇到某个类的某个成员变量、方法或是属性是私有的或是只对系统应用开放,这时候就可以利用Java的反射机制通过反射来获取所需的私有成员或是方法 。
- 反射最重要的用途就是开发各种通用框架,比如在spring中,我们将所有的类Bean交给spring容器管理,无论是XML配置Bean还是注解配置,当我们从容器中获取Bean来依赖注入时,容器会读取配置,而配置中给的就是类的信息,spring根据这些信息,需要创建哪些Bean,spring就动态的创建这些类。
3.反射相关的类
4.Class类(反射机制的起源)
4.1简介
Class类代表类的实体,在运行的Java应用程序中表示类和接口 .
Java文件被编译后,生成了.class文件,JVM此时就要去解读.class文件 .class也被JVM解析为一个对象,这个对象就是 java.lang.Class .这样当程序在运行时,每个java文件就最终变成了Class类对象的一个实例。我们通过Java的反射机制应用到这个实例,就可以去获得甚至去添加 , 改变这个类的属性和动作,使得这个类成为一个动态的类 .
4.2Class类的相关方法
4.2.1常用获得类相关的方法
4.2.2常用获得类中属性相关的方法
4.2.3获得类中注解相关的方法
4.2.4获得类中构造器相关的方法
4.2.5获得类中方法相关的方法
5.反射示例
5.1获得Class对象的三种方式
在反射之前,我们需要做的第一步就是先拿到当前需要反射的类的Class对象,然后通过Class对象的核心方法,达到反射的目的,即:在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意方法和属性,既然能拿到那么,我们就可以修改部分类型信息。
package reflectdemo;
class Student {
//私有属性name
private String name = "zhangsan";
//公有属性age
public 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);
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
public class Test {
public static void main(String[] args) {
Student student = new Student();
Class<?> c1 = student.getClass();// 使用类对象的getClass方法
Class<?> c2 = Student.class;// 使用.class方法
Class<?> c3 = null;
try {
c3 = Class.forName("reflectdemo.Student");// 使用Class.forName("类的全路径名")
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
System.out.println(c1.equals(c2));
System.out.println(c1.equals(c3));
System.out.println(c3 .equals(c2));
/*
* 三个class对象都相等,说明一个类对应一个class对象
* */
}
}
5.2反射的使用
package reflectdemo;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class ReflectClassDemo {
/**
* 反射获取对象
*/
public static void reflectNewInstance() {
Class<?> c3 = null;
try {
c3 = Class.forName("reflectdemo.Student");
Student student = (Student)c3.newInstance();
System.out.println(student);
student.sleep();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
/**
* 通过反射,调用构造方法[公开和私有的都可以]
*/
public static void reflectPrivateConstructor() {
Class<?> c3 = null;
try {
c3 = Class.forName("reflectdemo.Student");
Constructor<?> constructor =
c3.getDeclaredConstructor(String.class,int.class);
//因为构造方法是私有的,所以将该属性设置为true,就认为可以调用私有的方法
constructor.setAccessible(true);
Student student = (Student)constructor.newInstance("laobai",20);
System.out.println(student);
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
/**
* 通过反射,调用属性
*/
public static void reflectPrivateField() {
Class<?> c3 = null;
try {
c3 = Class.forName("reflectdemo.Student");
Student student = (Student) c3.newInstance();
Field field = c3.getDeclaredField("name");
field.setAccessible(true);
field.set(student,"laojin");
System.out.println(student);
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (NoSuchFieldException e) {
e.printStackTrace();
}
}
/**
* 通过反射,调用私有方法
*/
public static void reflectPrivateMethod() {
Class<?> c3 = null;
try {
c3 = Class.forName("reflectdemo.Student");
Student student = (Student) c3.newInstance();
Method method = c3.getDeclaredMethod("function", String.class);// 方法名,方法参数
method.setAccessible(true);
method.invoke(student,"我传一个参数试试!");// 调用的实例,参数
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
//reflectNewInstance();
//reflectPrivateConstructor();
//reflectPrivateField();
reflectPrivateMethod();
}
}
6.反射优缺点
优点:
- 对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意一个方法 ;
- 增加程序的灵活性和扩展性,降低耦合性,提高自适应能力 ;
- 反射已经运用在了很多流行框架如:Struts、Hibernate、Spring 等等。
缺点:
- 使用反射会有效率问题。会导致程序效率降低。具体参考
- 反射技术绕过了源代码的技术,因而会带来维护问题。反射代码比相应的直接代码更复杂 。
重点总结 :
- 反射的意义
- 反射重要的几个类: Class类 、Field类、 Method类、 Constructor类
- 学会合理利用反射,一定要在安全环境下使用
二 : 枚举
1 背景及定义
枚举是在JDK1.5以后引入的。主要用途是:将一组常量组织起来,在这之前表示一组常量通常使用定义常量的方式:
public static final int YANLONG = 1;
public static final int FENGYING = 2;
public static final int XUEAO = 3;
但是常量举例有不好的地方,例如:可能碰巧有个数字1,但是他有可能误认为是YANLONG,现在我们可以直接用枚举来进行组织,这样一来,就拥有了枚举类型 , 而不是普通的整形1 .
public enum TestEnum {
YANLOGN,FENGYING,HEIXI,XUEAO;
}
优点:将常量组织起来统一进行管理 ;
场景:错误状态码,消息类型,颜色的划分,状态机等等…
本质:是java.lang.Enum 的子类,也就是说,自己写的枚举类,就算没有显示的继承Enum ,但是其默认继承了这个类。
2.枚举的使用
2.1switch语句
package enumdemo;
public enum TestEnum {
//枚举对象
YANLONG("炎龙侠",0),
FENGYING("风鹰侠",1),
HEIXI("黑犀侠",2),
XUEAO("雪獒侠",3);
public String armour;
public int ordinal;
//枚举的构造方法默认是私有的
private TestEnum() {
}
private TestEnum(String armour,int ordinal) {
this.armour = armour;
this.ordinal = ordinal;
}
public static void main(String[] args) {
TestEnum testEnum = TestEnum.YANLONG;
switch (testEnum) {
case YANLONG:
System.out.println("炎龙侠 升腾炎上就是焰火的力量");
break;
case FENGYING:
System.out.println("风鹰侠 曲直屈伸就是巨木的力量");
break;
case HEIXI:
System.out.println("黑犀侠 滋润掩藏但发出狂啸的力量");
break;
case XUEAO:
System.out.println("雪獒侠 他有能刚能柔之金的力量");
break;
default:
break;
}
}
}
2.2常用方法
Enum类的常用方法 :
示例一 :
package enumdemo;
public enum TestEnum {
//枚举对象
YANLONG("炎龙侠",0),
FENGYING("风鹰侠",1),
HEIXI("黑犀侠",2),
XUEAO("雪獒侠",3);
public String armour;
public int ordinal;
//枚举的构造方法默认是私有的
TestEnum() {
}
private TestEnum(String armour,int ordinal) {
this.armour = armour;
this.ordinal = ordinal;
}
public static void main(String[] args) {
TestEnum[] testEnums = TestEnum.values();
for (int i = 0; i < testEnums.length; i++) {
System.out.println(testEnums[i]+" -> "+ testEnums[i].ordinal());
//testEnums[i].ordinal()输出枚举对象的序号,默认从0开始
}
}
}
Enum枚举类没有values()方法,却可以在枚举类中使用,为什么?
示例二 :
package enumdemo;
public enum TestEnum {
//枚举对象
YANLONG("炎龙侠",0),
FENGYING("风鹰侠",1),
HEIXI("黑犀侠",2),
XUEAO("雪獒侠",3);
public String armour;
public int ordinal;
//枚举的构造方法默认是私有的
private TestEnum() {
}
private TestEnum(String armour,int ordinal) {
this.armour = armour;
this.ordinal = ordinal;
}
public static void main(String[] args) {
TestEnum test = TestEnum.valueOf("YANLONG");
System.out.println(test);
System.out.println(YANLONG.compareTo(FENGYING));// 比较的是序号
}
}
3.枚举优缺点
4.枚举和反射
枚举是否可以通过反射,拿到实例对象呢?
我们刚刚在反射里面看到,任何一个类,哪怕其构造方法是私有的,我们也可以通过反射拿到他的实例对象,那么枚举的构造方法也是私有的,我们是否可以拿到呢?接下来,我们来实验一下:
package enumdemo;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
public class Test {
public static void main(String[] args) {
Class<?> c = null;
try {
c = Class.forName("enumdemo.TestEnum");
Constructor<?> constructor = c.getDeclaredConstructor(String.class, int.class);
constructor.setAccessible(true);
TestEnum testEnum = (TestEnum)constructor.newInstance("DIHU",23);
System.out.println(testEnum);
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
}
异常信息是: java.lang.NoSuchMethodException: enumdemo.TestEnum.(java.lang.String, int) ,什么意思 , 就是没有对应的构造方法 . 我的天呐!我们提供的枚举的构造方法就是两个参数分别是String 和int啊 ? 问题出现在哪里呢 ?
我们所有的枚举类,都是默认继承于java.lang.Enum ,说到继承,继承了什么?继承了父类除构造函数外的所有东西,并且子类要帮助父类进行构造!而我们写的类,并没有帮助父类构造!那意思是,我们要在自己的枚举类里面,提供super吗?不是的,枚举比较特殊,虽然我们写的是两个,但是默认他还添加了两个参数,哪两个参数呢?我们看一下Enum类的源码:
也就是说,我们自己的构造函数有两个参数一个是String , 一个是int,同时他默认后边还会给两个参数,一个是String , 一个是int . 即这里我们正确给的是4个参数 :
package enumdemo;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
public class Test {
public static void main(String[] args) {
Class<?> c = null;
try {
c = Class.forName("enumdemo.TestEnum");
Constructor<?> constructor = c.getDeclaredConstructor(String.class, int.class,
String.class, int.class);
constructor.setAccessible(true);
TestEnum testEnum = (TestEnum)constructor.newInstance("DIHU",23);
System.out.println(testEnum);
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
}
此时又又又报错了 ! 不过异常信息发生了变化 , 此时的异常信息显示,是我的一个方法newInstance() 报错了!没错,问题就是这里,我们来看一下这个方法的源码,为什么会抛出java.lang.IllegalArgumentException: 异常呢?
源码 :
引申问题 : 为什么枚举实现单例模式是安全的 ?
总结:
- 枚举本身就是一个类,其构造方法默认为私有的,且都是默认继承于java.lang.Enum
- 枚举可以避免反射和序列化问题
- 枚举的优点和缺点
拓展 : 写一个单例模式 .
三 : Lambda表达式
1.背景
Lambda表达式是Java SE 8中一个重要的新特性。lambda表达式允许你通过表达式来代替功能接口。 lambda表达式就和方法一样,它提供了一个正常的参数列表和一个使用这些参数的主体(body,可以是一个表达式或一个代码块)。
2.基本语法
3.函数式接口
要了解lambda表达式 , 就要知道什么是函数式接口 . 函数式接口定义:一个接口有且只有一个抽象方法 .
注意:
- 如果一个接口只有一个抽象方法,那么该接口就是一个函数式接口 ;
- 如果我们在某个接口上声明了 @FunctionalInterface 注解,那么编译器就会按照函数式接口的定义来要求该接口,这样如果有两个抽象方法,程序编译就会报错的 . 所以,从某种意义上来说,只要你保证你的接口中只有一个抽象方法,你可以不加这个注解 . 加上就会自动进行检测 .
@FunctionalInterface // 声明该接口为函数式接口,有且只有一个抽象方法
interface NoParameterNoReturn {
void test();
}
4.Lambda表达式的基本使用
1.在使用比较器时 , 可以使用lambda表达式简化代码 .
public static void main(String[] args) {
PriorityQueue<Integer> priorityQueue = new PriorityQueue<>(new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o1-o2;
}
});
}
使用lambda表示式简化后 :
public static void main(String[] args) {
PriorityQueue<Integer> priorityQueue2 = new PriorityQueue<>(((o1, o2) -> o1-o2));
}
2.演示有/无返回值 , 无参/一个参数/两个参数的Lambda表达式的用法 :
2.1无返回值
package lambdademo;
import java.util.Comparator;
import java.util.PriorityQueue;
@FunctionalInterface // 声明该接口为函数式接口,有且只有一个抽象方法
interface NoParameterNoReturn {
//注意:只能有一个抽象方法
void test();
}
//无返回值一个参数
@FunctionalInterface
interface OneParameterNoReturn {
void test(int a);
}
//无返回值多个参数
@FunctionalInterface
interface MoreParameterNoReturn {
void test(int a,int b);
}
//有返回值无参数
@FunctionalInterface
interface NoParameterReturn {
int test();
}
//有返回值一个参数
@FunctionalInterface
interface OneParameterReturn {
int test(int a);
}
//有返回值多参数
@FunctionalInterface
interface MoreParameterReturn {
int test(int a,int b);
}
public class Test {
public static void main3(String[] args) {
//NoParameterReturn noParameterReturn = ()-> {return 10;};
NoParameterReturn noParameterReturn = ()->10;
int ret = noParameterReturn.test();
System.out.println(ret);
OneParameterReturn oneParameterReturn = a -> a;
ret = oneParameterReturn.test(99);
System.out.println(ret);
MoreParameterReturn moreParameterReturn = (a,b)->a+b;
ret = moreParameterReturn.test(99,1);
System.out.println(ret);
}
public static void main2(String[] args) {
//1无参
//1.1常规写法
NoParameterNoReturn noParameterNoReturn = new NoParameterNoReturn(){
@Override
public void test() {
System.out.println("无参 + 不带返回值 常规写法");
}
};
noParameterNoReturn.test();
//1.2写法优化:使用lambda表达式
NoParameterNoReturn noParameterNoReturn2 = () -> {
System.out.println("无参 + 不带返回值 使用lambda表达式");
};
noParameterNoReturn2.test();
//1.3写法优化:省略花括号
NoParameterNoReturn noParameterNoReturn3 = () -> System.out.println("无参 + 不带返回值 使用lambda表达式 省略花括号");
noParameterNoReturn3.test();
//2.有1个参数 + 不带返回值
//如果有1个参数 那么小括号可以省略 如果方法体只有一行代码 那么花括号可以省略
OneParameterNoReturn oneParameterNoReturn = a -> System.out.println("有1个参数 + 不带返回值"+a);
oneParameterNoReturn.test(10);
//3.有2个参数 + 不带返回值
MoreParameterNoReturn moreParameterNoReturn = (int a,int b) -> {System.out.println("有2个参数 + 不带返回值"+a+b);};
moreParameterNoReturn.test(1,2);
//参数类型如果都要省略 请同时省略
MoreParameterNoReturn moreParameterNoReturn1 = (a,b) -> System.out.println("有2个参数 + 不带返回值 + 省略参数类型"+a+b);
moreParameterNoReturn1.test(1,2);
}
}
2.2有返回值
public static void main(String[] args) {
//有返回值,在->后填写返回值
//NoParameterReturn noParameterReturn = ()-> {return 10;};
NoParameterReturn noParameterReturn = ()->10;
int ret = noParameterReturn.test();
System.out.println("无参 " + ret);
OneParameterReturn oneParameterReturn = a -> a;
ret = oneParameterReturn.test(99);
System.out.println("一个参数 " + ret);
MoreParameterReturn moreParameterReturn = (a,b)->a+b;
ret = moreParameterReturn.test(99,1);
System.out.println("两个返回值 " + ret);
}
5.变量捕获
5.1匿名内部类中的变量捕获
Lambda 表达式中存在变量捕获 . Java当中的匿名类中,会存在变量捕获 .
package InnerClass;
class Test {
public void func() {
System.out.println("func()");
}
}
public class TestDemo {
public static void main(String[] args) {
new Test(){
@Override
public void func() {
System.out.println("我是内部类,且重写了func这个方法!");
}
};
}
}
在上述代码当中的main函数当中,我们看到的就是一个匿名内部类的简单的使用 .
package InnerClass;
class Test {
public void func() {
System.out.println("func()");
}
}
public class TestDemo {
public static void main(String[] args) {
int a = 10;
new Test(){
@Override
public void func() {
System.out.println("我是内部类,且重写了func这个方法!");
System.out.println("捕获了变量a = " + a);
}
};
}
}
在上述代码当中的变量a就是捕获的变量 . 这个变量要么是被final修饰,如果不是被final修饰的 你要保证在使用之前,没有修改 .
5.2Lambda中的变量捕获
不能修改变量a的值 , 否则会报错 ; 建议将a变量使用final进行修饰 .
6.Lambda在集合中的应用
为了能够让Lambda和Java的集合类集更好的一起使用,集合当中,也新增了部分接口,以便与Lambda表达式对接 .
Collection接口的forEach() 方法演示 , 该方法在接口Iterable 当中,原型如下:
default void forEach(Consumer<? super T> action) {
Objects.requireNonNull(action);
for (T t : this) {
action.accept(t);
}
}
该方法表示 , 对容器中的每一个元素执行action指定动作 .
List接口的sort源码 :
public void sort(Comparator<? super E> c) {
final int expectedModCount = modCount;
Arrays.sort((E[]) elementData, 0, size, c);
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
modCount++;
}
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
list.add("yes");
list.add("no");
list.add("double");
list.add("lambda");
/*list.forEach(new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s);
}
});*/
list.forEach(str->System.out.println(str));
System.out.println("排序:");
/*list.sort(new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return o1.compareTo(o2);
}
});*/
list.sort((o1,o2)->o1.compareTo(o2));
list.forEach(str->System.out.println(str));
}
HashMap的forEach()方法源码 :
default void forEach(BiConsumer<? super K, ? super V> action) {
Objects.requireNonNull(action);
for (Map.Entry<K, V> entry : entrySet()) {
K k;
V v;
try {
k = entry.getKey();
v = entry.getValue();
} catch(IllegalStateException ise) {
// this usually means the entry is no longer in the map.
throw new ConcurrentModificationException(ise);
}
action.accept(k, v);
}
}
作用是对Map中的每个映射执行action指定的操作 .
使用Lambda表达式 :
public static void main(String[] args) {
HashMap<Integer, String> map = new HashMap<>();
map.put(1, "yes");
map.put(2, "no");
map.put(3, "hello");
map.put(4, "lambda");
/* map.forEach(new BiConsumer<Integer, String>() {
@Override
public void accept(Integer integer, String s) {
System.out.println("key:"+integer+" val: "+s);
}
});
*/
map.forEach((key,val)->System.out.println("key:"+key+" val: "+val));
}
7.总结
本文到此结束 !