java-反射，接口新特性，Lambda表达式

反射

概念

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

在程序执行过程中动态的调用没有书写调用其他类的代码.

类加载器

将编译好的class二进制字节码文件交由jvm进行执行

三种默认类加载器

**启动类加载器：**将启动jvm的class文件进行加载执行

**扩展加载器：**将java运行基本jar包进行加载执行

**系统加载器：**将我们编写的class文件进行加载执行

类对象Class

java中万物皆对象，在使用反射时，将所有自定义类都当做类对象，都是class 的对象

获取类对象的三种方式

Class c1=Class.forName(“类名”);

使用Class类静态方法内部通过类加载器加载指定类class对象

Class c2=类名.class;

通过指定类class属性获取指定类class对象

Class c3=obj.getClass();

通过指定类对象的getClass方法获取指定class对象

		// Class可以代表所有类与Object不同的是object是所有类的父类
		// 所有类都是Class类的对象
		// 获取一个类class对象的方式
		// 1、使用Class类静态方法获取
		Class c1 = Class.forName("com.yunhe.day1106.Student");

		// 2、使用类的class属性获取(这种方式获取class对象必须声明变量保存)
		Class c2 = Student.class;

		// 3、使用指定类对象的getClass方法获取
		Student s = new Student();
		Class c3 = s.getClass();
		
	
		Object newInstance = c1.newInstance();//调用指定class对象代表类的无参构造方法
		System.out.println(newInstance);

反射获取构造方法

通过clas类提供的获取构造方法的方法,返回构造方法对象代表指定类的构造方法

Constructor getConstructor(Class<?>… parameterTypes)
返回一个 Constructor 对象，它反映此 Class 对象所表示的类的指定公共构造方法。
Constructor<?>[] getConstructors()
返回一个包含某些 Constructor 对象的数组，这些对象反映此 Class 对象所表示的类的所有公共构造方法。
Constructor getDeclaredConstructor(Class<?>… parameterTypes)
返回一个 Constructor 对象，该对象反映此 Class 对象所表示的类或接口的指定构造方法。
Constructor<?>[] getDeclaredConstructors()
返回 Constructor 对象的一个数组，这些对象反映此 Class 对象表示的类声明的所有构造方法。

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
//通过反射获取构造方法
public class ConstructorTest {
	public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException,
			InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
		Class<?> c = Class.forName("com.yunhe.day1106.Student");

		// 通过反射获取指定类的class对象
		// 通过class对象获取指定类的构造方法对象
		// getConstructor(Class<?>... parameterTypes)
		// 通过参数获取指定参数个数与类型的构造方法
		Constructor<?> c1 = c.getConstructor();// 无参公开的构造方法
		Object c1o = c1.newInstance();
		// System.out.println(c1o);
		// 执行构造方法 并传入执行时需要的数据
		Constructor<?> c2 = c.getConstructor(String.class);// 获取公开的参数类型为String的构造方法
		Object c2o = c2.newInstance("张三");
		// System.out.println(c2o);

		// Constructor<?>[] getConstructors()
		// 获取当前class对象代表类的所有公开的构造方法
		Constructor<?>[] constructors = c.getConstructors();
		// for (Constructor<?> constructor : constructors) {
		// System.out.println(constructor);
		// }

		// Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)
		// 获取指定参数的构造方法（包括私有构造方法）
		Constructor<?> c3 = c.getDeclaredConstructor(String.class, int.class);
		c3.setAccessible(true);// 为私有构造方法赋权
		Object c3o = c3.newInstance("张三", 18);
		System.out.println(c3o);

		// Constructor<?>[] getDeclaredConstructors()
		// 返回 Constructor 对象的一个数组，这些对象反映此 Class 对象表示的类声明的所有构造方法。

		Constructor<?>[] declaredConstructors = c.getDeclaredConstructors();
		for (Constructor<?> constructor : declaredConstructors) {
			System.out.println(constructor);
		}

	}

}

反射获取属性

Field getField(String name)
返回一个 Field 对象，它反映此 Class 对象所表示的类或接口的指定公共成员字段。
Field[] getFields()
返回一个包含某些 Field 对象的数组，这些对象反映此 Class 对象所表示的类或接口的所有可访问公共字段。
Field getDeclaredField(String name)
返回一个 Field 对象，该对象反映此 Class 对象所表示的类或接口的指定已声明字段。
Field[] getDeclaredFields()
返回 Field 对象的一个数组，这些对象反映此 Class 对象所表示的类或接口所声明的所有字段。

import java.lang.reflect.Field;
import java.util.Arrays;

//通过反射获取属性
public class FieldTest {
	public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, SecurityException, InstantiationException, IllegalAccessException {
		Class<?> c = Student.class;
		Object o = c.newInstance();
		// Field getField(String name)
		// 获取指定class对象所代表类的指定名字的公开属性
		Field field = c.getField("name");
		//System.out.println(field);
		
		// Field[] getFields()
		// 返回一个包含某些 Field 对象的数组，这些对象反映此 Class 对象所表示的类或接口的所有可访问公共字段。
		Field[] fields = c.getFields();
		//System.out.println(Arrays.toString(fields));

		
		// Field getDeclaredField(String name)
		// 获取指定class对象代表的类的指定名字的属性对象（包含私有属性）
		Field declaredField = c.getDeclaredField("age");
		//System.out.println(declaredField);
		
		// Field[] getDeclaredFields()
		// 返回 Field 对象的一个数组，这些对象反映此 Class 对象所表示的类或接口所声明的所有字段。
		Field[] declaredFields = c.getDeclaredFields();
		//System.out.println(Arrays.toString(declaredFields));
		System.out.println(o);
		
		//Field属性对象的使用
		//私有属性使用前进行赋权操作
		declaredField.setAccessible(true);
		//set方法为指定对象进行赋值
		declaredField.set(o, 18);
		field.set(o, "张三");

		//get方法获取指定对象属性的属性
		Object object = field.get(o);
		System.out.println(object);	
	}
}

反射获取方法

Method getMethod(String name, Class<?>… parameterTypes)
返回一个 Method 对象，它反映此 Class 对象所表示的类或接口的指定公共成员方法。
Method[] getMethods()
返回一个包含某些 Method 对象的数组，这些对象反映此 Class 对象所表示的类或接口（包括那些由该类或接口声明的以及从超类和超接口继承的那些的类或接口）的公共 member 方法。
Method getDeclaredMethod(String name, Class<?>… parameterTypes)
返回一个 Method 对象，该对象反映此 Class 对象所表示的类或接口的指定已声明方法。
Method[] getDeclaredMethods()
返回 Method 对象的一个数组，这些对象反映此 Class 对象表示的类或接口声明的所有方法，包括公共、保护、默认（包）访问和私有方法，但不包括继承的方法。

import java.lang.reflect.Method;

public class MethodTest {
	public static void main(String[] args) throws Exception {
		Class<?> c = Student.class;
		Object o = c.newInstance();
		// Method getMethod(String name, Class<?>... parameterTypes)
		// 返回一个 Method 对象，获取指定名称指定参数列表的方法对象(公开的)
		Method method = c.getMethod("setName", String.class);
		// System.out.println(method);

		// Method[] getMethods()
		// 返回一个包含某些 Method 对象的数组，这些对象反映此 Class
		// 返回所有公开的方法（包括继承父类的方法）
		Method[] methods = c.getMethods();
		// for (Method method2 : methods) {
		// System.out.println(method2);
		// }

		// Method getDeclaredMethod(String name, Class<?>... parameterTypes)
		// 获取指定方法（包括私有）
		// 获取的是在当前类中定义的方法
		Method declaredMethod = c.getDeclaredMethod("a",String.class);
		// System.out.println(declaredMethod);

		// Method[] getDeclaredMethods()
		// 返回 Method 对象的一个数组，这些对象反映此 Class
		// 对象表示的类或接口声明的所有方法，包括公共、保护、默认（包）访问和私有方法，但不包括继承的方法。
		Method[] declaredMethods = c.getDeclaredMethods();
		// for (Method method2 : declaredMethods) {
		// System.out.println(method2);
		// }
		
		//方法的执行
		//私有方法执行前需要赋权
		method.invoke(o, "张三");
		
		declaredMethod.setAccessible(true);
		//使用方法对象invole方法调用传入调用的对象与参数（无参则不写）
		declaredMethod.invoke(o, "asd");
	}
}

总结

反射的功能：通过预先一定格式的代码书写，可以在程序运行过程中动态的进行类的使用

反射的使用：

1、获取指定类的class对象

①使用类加载器进行加载指定类的全路径

②使用类的class属性进行获取

③使用类对象的getclass方法进行获取

2、构造方法

①构造方法的获取：四种方法进行构造方法的获取

②构造方法的使用：赋权、创建对象

3、属性

①属性的获取：四种方法进行属性的获取（注意获取属性时是否可以获取继承的属性）

②属性的使用：赋权、赋值、获取值（注意需要传入赋值的对象与值）

4、方法

①方法的获取：四种方式进行方法的获取（注意获取方法时是否可以获取继承的方法）

②方法的使用：赋权、执行（注意需要传入执行方法的对象与参数）

接口中新特性

接口中的默认方法jdk1.8以后接口的新特性

定义：在接口中，使用关键字default修饰的方法

可以在接口中书写拥有方法体的方法,使用 default进行修饰，实现接口的方法可以直接使用

public class InterFaceTest {
	public static void main(String[] args) {
		myTestInterface mif = new myTestInterface() {
			@Override
			public void a() {
				System.out.println("aaaaaaaa");
			}
		};
		mif.b();

	}
}

interface myTestInterface {
	public abstract void a();
	// 接口新特性
	// jdk1.8以后接口可以进行方法体方法的书写
	// 称之为接口的默认方法 使用default进行修饰
	default public void b() {
		System.out.println("bbbbbbb");
	}
}

如果一个实现类实现了多个接口，但是多个接口中存在方法名与参数都相同的默认方法，那么实现类必须重写这个方法，在方法中觉得调用哪个接口提供的默认方法

interface myTestInterface {
	public abstract void a();

	// 接口新特性
	// jdk1.8以后接口可以进行方法体方法的书写
	// 称之为接口的默认方法 使用default进行修饰
	default public void b() {
		System.out.println("1bbbbbbb");
	}
}

interface myTestInterface1 {
	// 接口新特性
	// jdk1.8以后接口可以进行方法体方法的书写
	// 称之为接口的默认方法 使用default进行修饰
	default public void b() {
		System.out.println("2bbbbbbb");
	}
}

class T implements myTestInterface,myTestInterface1{

	@Override
	public void a() {
	}
	@Override
	public void b() {
		//使用第一个接口的b方法进行实现
		//myTestInterface.super.b();
		//使用第二个接口的b方法进行实现
		//myTestInterface1.super.b();
		//自己实现
		System.out.println("3bbbbbb");
	}
}

Lambda表达式

Lambda 表达式是 jdk1.8 新增的重要特性，Lambda 使 Java 具有了类似函数式编程的风格，其实 Lambda 表达式也是一个 “语法块”，其实质也是由编译器根据表达式推断最终生成原始语法的字节码方式。
Lambda 表达式允许把函数作为一个方法的参数，或者把代码看成数据。用于简化java中接口式的匿名内部类。(被称为函数式接口：只用一个方法的普通接口)
lambda表达式用于简化java中接口式的匿名内部类书写，被称为函数式接口（函数式接口：具有方法的接口）

lambda表达式,函数式编程(由固定语法组成的公式进行代码编辑)的语法，主要用于实现函数式接口

函数式接口

指的是只有一个抽象方法的接口,例如：runnable接口

使用注解@FunctionalInterface

用于进行函数式接口限制

@FunctionalInterface
public interface MyFunctionInterface {
	// 函数式接口
	// 只能书写一个抽象方法
	// 使用注解@FunctionalInterface 进行限制
	public abstract void a();
}

lambda表达式的作用

lambda是一个可以传递的代码块，可以在以后执行一次或多次。lambda表达式允许把函数作为一个方法的参数（函数作为参数传递进方法中）

基本语法

①无参方法的实现

lambda表达式可以看做是实现函数式接口的最佳实现方式

语法:()->{}

()内填写参数

{}内书写方法执行代码

@FunctionalInterface
public interface MyFunctionInterface {
	// 函数式接口
	// 只能书写一个抽象方法
	// 使用注解@FunctionalInterface 进行限制
	public abstract void a();
}

使用匿名内部类实现函数式接口

public class T1 {
	public static void main(String[] args) {
		// 使用匿名内部类实现
		MyFunctionInterface mi1 = new MyFunctionInterface() {
			@Override
			public void a() {
				System.out.println("aaaaaa");
			}
		};
		mi1.a();
	}
}

使用lambda表达式实现函数式接口

public class T2 {
public static void main(String[] args) {

	// 使用lambda表达式实现
	MyFunctionInterface mi2 = () -> {
		System.out.println("aaaaaa");
	};
	mi2.a();
}

}

②有参方法的实现

lambda表达式对于方法的参数类型可以自动推导

@FunctionalInterface
public interface MyFunctionInterface {
	// 函数式接口
	// 只能书写一个抽象方法
	// 使用注解@FunctionalInterface 进行限制
	public abstract void a(String name,int age);
}

使用匿名内部类实现函数式接口

public class T3 {
	public static void main(String[] args) {
		// 使用匿名内部类实现
		MyFunctionInterface mi1 = new MyFunctionInterface() {
			@Override
			public void a(String name, int age) {
				System.out.println("我叫" + name + ",今年" + age + "岁");
			}
		};
		mi1.a("张三", 18);
	}
}

使用lambda表达式实现函数式接口

public class T4 {
	public static void main(String[] args) {
		// 使用lambda表达式实现
		MyFunctionInterface mi2=(String name,int age)->{
			System.out.println("我叫" + name + ",今年" + age + "岁");
		};
		
		mi2.a("张三", 18);
		
		//lambda表达式可以根据方法进行数据类型的推导，所以在进书写时可以省略数据类型的声明
		MyFunctionInterface mi3=(name,age)->{
			System.out.println("我叫" + name + ",今年" + age + "岁");
		};
		mi3.a("张三", 18);
		
		//如果lambda表达式实现的方法参数只有唯一一个那么（）可以省略
	}
}

③有返回值方法的实现

使用匿名内部类实现函数式接口

public class T5 {
	public static void main(String[] args) {
		// 使用匿名内部类实现
		MyFunctionInterface mi1 = new MyFunctionInterface() {
			@Override
			public String a(String name) {
				return "我叫" + name;
			}
		};
		System.out.println(mi1.a("张三"));
	}
}

使用lambda表达式实现函数式接口

public class T6 {
	public static void main(String[] args) {
		// 使用lambda表达式实现
		// lambda表达式会自定识别方法的返回值类型无需书写
		MyFunctionInterface mi2 = name -> {
			return "我叫" + name;
		};
		System.out.println(mi2.a("李四"));
	}
}

lambda表达式的优缺点

优点：1、简洁 2、非常容易并行计算 3、可能代表未来的编程趋势

缺点：1、如果不用并行计算，lambda表达式的计算速度一般不如for循环快（并行计算有时候也需要预热才会显示出效率优势）

2、不容易调试

3、如果其他人也没学过lambda表达式，代码不容易让其他语言的程序员看懂

4、lambda表达式只能用于实现函数式接口，如果接口中存在多个抽象方法将不能使用lambda表达式实现

使用lambda表达式进行map集合的遍历

	public static void main(String[] args) {
		HashMap<Integer, Integer> map = new HashMap<>();
		for (int i = 0; i < 10; i++) {
			map.put(i, i);
		}

		// 使用循环遍历
		// Set<Integer> keySet = map.keySet();
		// for (Integer integer : keySet) {
		// System.out.println(integer + "=>" + map.get(integer));
		// }

		// 这是一个用lambda表达式遍历map的示例
		System.out.println("lambda");
		map.forEach((k, v) -> {
			System.out.println(k + "=>" + v);
		});
		//等价于
		map.forEach(new BiConsumer<Integer, Integer>() {
			@Override
			public void accept(Integer t, Integer u) {
				System.out.println(t + "=>" + u);
			}
		});
		
		//使用lambda表达式最常用例子
		//多线程的实现
		new Thread(()->{
			//多线程实现的方法
		}).start();
		
		new Thread(new Runnable() {
			@Override
			public void run() {
				//多线程实现的方法
			}
		}).start();
		
	}