JAVA语言基础-反射、特性

时间 2019-12-07

标签 java 语言基础反射特性栏目 Java 繁體版

原文原文链接

Reflect反射

Bean：Person类

package com.heima.bean;

public class Person {
	private String name;
	private int age;
	public Person() {
		super();
		
	}
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (this.getClass() != obj.getClass())		//判断调用对象和传入对象的字节码文件是不是同一个字节码文件
			return false;
		Person other = (Person) obj;
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
	
	public void eat() {
		System.out.println("今天吃了一顿金钱豹");
	}
	
	public void eat(int num) {
		System.out.println("今天吃了" + num + "顿金钱豹");
	}
}

Reflect 1

package com.heima.reflect;

import com.heima.bean.Person;

public class Demo1_Reflect {

	/**
	 * @param args
	 * @throws ClassNotFoundException 
	 */
	public static void main(String[] args) throws ClassNotFoundException {
		Class clazz1 = Class.forName("com.heima.bean.Person");
		Class clazz2 = Person.class;
		
		Person p = new Person();
		Class clazz3 = p.getClass();
		
		System.out.println(clazz1 == clazz2);
		System.out.println(clazz2 == clazz3);
	}

}

Reflect 2

package com.heima.reflect;

import java.io.BufferedReader;
import java.io.FileReader;

public class Demo2_Reflect {

	/**
	 * * 榨汁机(Juicer)榨汁的案例
	 * 分别有水果(Fruit)苹果(Apple)香蕉(Banana)桔子(Orange)榨汁(squeeze)
	 * @throws IOException 
	 */
	public static void main(String[] args) throws Exception {
		Juicer j = new Juicer();									//建立榨汁机
		//j.run(new Apple());
		//j.run(new Orange());
		BufferedReader br = new BufferedReader(new FileReader("config.properties"));
		Class clazz = Class.forName(br.readLine());					//获取该类的字节码文件
		Fruit f = (Fruit) clazz.newInstance();						//建立实例对象
		j.run(f);
		
	}
}
interface Fruit {
	public void squeeze();
}
class Apple implements Fruit {
	public void squeeze() {
		System.out.println("榨出一杯苹果汁儿");
	}
}

class Orange implements Fruit {
	public void squeeze() {
		System.out.println("榨出一杯橘子汁儿");
	}
}

class Juicer {
	/*public void run(Apple a) {
		a.squeeze();
	}
	
	public void run(Orange o) {
		o.squeeze();
	}*/
	
	public void run(Fruit f) {
		f.squeeze();
	}
}

Constructor

package com.heima.reflect;

import java.lang.reflect.Constructor;

import com.heima.bean.Person;

public class Demo3_Constructor {

	/**
	 * Class类的newInstance()方法是使用该类无参的构造函数建立对象, 若是一个类没有无参的构造函数,
	 * 就不能这样建立了,能够调用Class类的getConstructor
	 * (String.class,int.class)方法获取一个指定的构造函数而后再调用Constructor类的newInstance
	 * ("张三",20)方法建立对象
	 * @throws Exception 
	 */
	public static void main(String[] args) throws Exception {
		Class clazz = Class.forName("com.heima.bean.Person");
		//Person p = (Person) clazz.newInstance();				经过无餐构造建立对象
		//System.out.println(p);
		Constructor c = clazz.getConstructor(String.class,int.class);	//获取有参构造
		Person p = (Person) c.newInstance("张三",23);						//经过有参构造建立对象
		System.out.println(p);
	}

}

Field

package com.heima.reflect;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;

import com.heima.bean.Person;

public class Demo4_Field {

	/**
	 * Class.getField(String)方法能够获取类中的指定字段(可见的),
	 * 若是是私有的能够用getDeclaedField("name")方法获取,经过set(obj, "李四")方法能够设置指定对象上该字段的值,
	 * 若是是私有的须要先调用setAccessible(true)设置访问权限,用获取的指定的字段调用get(obj)能够获取指定对象中该字段的值
	 * @throws Exception 
	 */
	public static void main(String[] args) throws Exception {
		Class clazz = Class.forName("com.heima.bean.Person");
		Constructor c = clazz.getConstructor(String.class,int.class);	//获取有参构造
		Person p = (Person) c.newInstance("张三",23);						//经过有参构造建立对象
		
		//Field f = clazz.getField("name");								//获取姓名字段
		//f.set(p, "李四");												//修改姓名的值
		Field f = clazz.getDeclaredField("name");						//暴力反射获取字段
		f.setAccessible(true);											//去除私有权限
		f.set(p, "李四");	
		
		System.out.println(p);
	}

}

Method

package com.heima.reflect;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;

import com.heima.bean.Person;

public class Demo5_Method {

	/**
	 * Class.getMethod(String, Class...) 和 Class.getDeclaredMethod(String,
	 * Class...)方法能够获取类中的指定方法,调用invoke(Object,
	 * Object...)能够调用该方法,Class.getMethod("eat") invoke(obj)
	 * Class.getMethod("eat",int.class) invoke(obj,10)
	 * @throws Exception 
	 */
	public static void main(String[] args) throws Exception {
		Class clazz = Class.forName("com.heima.bean.Person");
		Constructor c = clazz.getConstructor(String.class,int.class);	//获取有参构造
		Person p = (Person) c.newInstance("张三",23);						//经过有参构造建立对象
		
		Method m = clazz.getMethod("eat");								//获取eat方法
		m.invoke(p);
		
		Method m2 = clazz.getMethod("eat", int.class);					//获取有参的eat方法
		m2.invoke(p, 10);
	}

}

动态代理

Studentjava

package com.heima.动态代理;

public interface Student {
	public void login();
	
	public void submit();
}

StudentImpl设计模式

package com.heima.动态代理;

public class StudentImp implements Student {

	@Override
	public void login() {
		System.out.println("登陆");
	}

	@Override
	public void submit() {
		System.out.println("提交");
	}

}

Useride

package com.heima.动态代理;

public interface User {
	public void add();
	
	public void delete();
}

UserImpl函数

package com.heima.动态代理;

public class UserImp implements User {

	@Override
	public void add() {
		//System.out.println("权限校验");
		System.out.println("添加功能");
		//System.out.println("日志记录");
	}

	@Override
	public void delete() {
		//System.out.println("权限校验");
		System.out.println("删除功能");
		//System.out.println("日志记录");
	}

}

动态代理 ui

package com.heima.动态代理;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class MyInvocationHandler implements InvocationHandler {
	private Object target;
	
	public MyInvocationHandler(Object target) {
		this.target = target;
	}
	@Override
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		System.out.println("权限校验");
		method.invoke(target, args);					//执行被代理target对象的方法
		System.out.println("日志记录");
		return null;
	}

}

Testthis

package com.heima.动态代理;

import java.lang.reflect.Proxy;

public class Test {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		/*UserImp ui = new UserImp();
		ui.add();
		ui.delete();
		
		System.out.println("-------------------------------");*/
		/*
		 * public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,
		 * InvocationHandler h)
		 */
		/*MyInvocationHandler m = new MyInvocationHandler(ui);
		User u = (User)Proxy.newProxyInstance(ui.getClass().getClassLoader(), ui.getClass().getInterfaces(), m);
		u.add();
		u.delete();*/
		
		StudentImp si = new StudentImp();
		si.login();
		si.submit();
		
		System.out.println("-------------------------------");
		MyInvocationHandler m = new MyInvocationHandler(si);
		Student s = (Student)Proxy.newProxyInstance(si.getClass().getClassLoader(), si.getClass().getInterfaces(), m);
		
		s.login();
		s.submit();
	}

}

Enum：枚举

Enum

package com.heima.枚举;

public class Demo1_Enum {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		//demo1();
		//demo2();
		Week3 mon = Week3.MON;
		mon.show();
	}

	public static void demo2() {
		Week2 mon = Week2.MON;
		System.out.println(mon.getName());
	}

	public static void demo1() {
		Week mon = Week.MON;
		Week tue = Week.TUE;
		Week wed = Week.WED;
		
		System.out.println(mon);
	}

}

Weekspa

package com.heima.枚举;

public class Week {
	
	public static final Week MON = new Week();
	public static final Week TUE = new Week();
	public static final Week WED = new Week();
	
	private Week(){}						//私有构造,不让其余类建立本类对象
}

Week2设计

package com.heima.枚举;

public class Week2 {
	
	public static final Week2 MON = new Week2("星期一");
	public static final Week2 TUE = new Week2("星期二");
	public static final Week2 WED = new Week2("星期三");
	
	private String name;
	private Week2(String name){
		this.name = name;
	}						//私有构造,不让其余类建立本类对象
	public String getName() {
		return name;
	}
	
	
}

Week3代理

package com.heima.枚举;

public abstract class Week3 {
	
	public static final Week3 MON = new Week3("星期一") {
		public void show() {
			System.out.println("星期一");
		}
	};
	public static final Week3 TUE = new Week3("星期二"){
		public void show() {
			System.out.println("星期二");
		}
	};
	public static final Week3 WED = new Week3("星期三"){
		public void show() {
			System.out.println("星期三");
		}
	};
	
	private String name;
	private Week3(String name){
		this.name = name;
	}						//私有构造,不让其余类建立本类对象
	public String getName() {
		return name;
	}
	
	public abstract void show();
}

Enum 2

Enum

package com.heima.枚举2;

public class Demo1_Enum {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		//demo1();
		//demo2();
		//demo3();
		Week3 mon = Week3.TUE;
		switch (mon) {
		case MON:
			System.out.println("星期一");
			break;
		case TUE:
			System.out.println("星期二");
			break;
		}
	}

	public static void demo3() {
		Week3 mon = Week3.MON;
		mon.show();
	}

	public static void demo2() {
		Week2 mon = Week2.MON;
		System.out.println(mon.getName());
	}

	public static void demo1() {
		Week mon = Week.MON;
		System.out.println(mon);
	}

}

enum2

package com.heima.枚举2;

public class Demo2_Enum {

	/**
	 * int ordinal()
	* int compareTo(E o)
	* String name()
	* String toString()
	* <T> T valueOf(Class<T> type,String name)
	* values() 
	* 此方法虽然在JDK文档中查找不到，但每一个枚举类都具备该方法，它遍历枚举类的全部枚举值很是方便
	 */
	public static void main(String[] args) {
		//demo1();
//		Week2 mon = Week2.valueOf(Week2.class, "MON");		//经过字节码对象获取枚举项
//		System.out.println(mon);
		
		Week2[] arr = Week2.values();
		for (Week2 week2 : arr) {
			System.out.println(week2);
		}
	}

	public static void demo1() {
		Week2 mon = Week2.MON;
		Week2 tue = Week2.TUE;
		Week2 wed = Week2.WED;
		
		/*System.out.println(mon.ordinal());				//枚举项都是有编号的
		System.out.println(tue.ordinal());
		System.out.println(wed.ordinal());
		
		System.out.println(mon.compareTo(tue));			//比较的是编号
		System.out.println(mon.compareTo(wed));*/
		
		System.out.println(mon.name()); 				//获取实例名称
		System.out.println(mon.toString()); 			//调用重写以后的toString方法
	}

}

Week

package com.heima.枚举2;

public enum Week {
	MON,TUE,WED;
}

Week2

package com.heima.枚举2;

public enum Week2 {
	MON("星期一"),TUE("星期二"),WED("星期三");
	
	private String name;
	private Week2(String name) {
		this.name = name;
	}
	public String getName() {
		return name;
	}
	
	public String toString() {
		return name;
	}
}

Week3

package com.heima.枚举2;

public enum Week3 {
	MON("星期一"){
		public void show() {
			System.out.println("星期一");
		}
	},TUE("星期二"){
		public void show() {
			System.out.println("星期二");
		}
	},WED("星期三"){
		public void show() {
			System.out.println("星期三");
		}
	};
	
	private String name;
	private Week3(String name) {
		this.name = name;
	}
	public String getName() {
		return name;
	}
	
	public abstract void show();
	
}

模板方法设计模式

package com.heima.模版方法设计模式;

public class Demo1_Template {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		/*long start = System.currentTimeMillis();
		for(int i = 0; i < 1000000; i++) {
			System.out.println("x");
		}
		long end = System.currentTimeMillis();
		System.out.println(end - start);*/
		Demo d = new Demo();
		System.out.println(d.getTime());
	}

}

abstract class GetTime {
	public final long getTime() {
		long start = System.currentTimeMillis();
		code();
		long end = System.currentTimeMillis();
		return end - start;
	}

	public abstract void code();
}

class Demo extends GetTime {

	@Override
	public void code() {
		int i = 0;
		while(i < 100000) {
			System.out.println("x");
			i++;
		}
	}
}

Test

package com.heima.test;

public class DemoClass {
	public void run() {
		System.out.println("welcome to heima!");
	}
}

test1

package com.heima.test;

import java.lang.reflect.Method;
import java.util.ArrayList;

public class Test1 {

	/**
	 * @param args
	 * ArrayList<Integer>的一个对象，在这个集合中添加一个字符串数据，如何实现呢？
	 * 泛型只在编译期有效,在运行期会被擦除掉
	 * @throws Exception 
	 */
	public static void main(String[] args) throws Exception {
		ArrayList<Integer> list = new ArrayList<>();
		list.add(111);
		list.add(222);
		
		Class clazz = Class.forName("java.util.ArrayList");				//获取字节码对象
		Method m = clazz.getMethod("add", Object.class);				//获取add方法
		m.invoke(list, "abc");
		
		System.out.println(list);
		
	}

}

test2

package com.heima.test;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;

public class Test2 {

	/**
	 * * 已知一个类，定义以下： 
	 * package cn.itcast.heima;
	 * 		public class DemoClass {
				public void run() {
					System.out.println("welcome to heima!");
				}
			}
	 * (1) 写一个Properties格式的配置文件，配置类的完整名称。 
	 * (2) 写一个程序，读取这个Properties配置文件，得到类的完整名称并加载这个类，用反射的方式运行run方法。
	 * @throws Exception 
	 */
	public static void main(String[] args) throws Exception {
		BufferedReader br = new BufferedReader(new FileReader("xxx.properties"));	//建立输入流关联xxx.properties
		Class clazz = Class.forName(br.readLine());									//读取配置文件中类名,获取字节码对象
		
		DemoClass dc = (DemoClass) clazz.newInstance();								//经过字节码对象建立对象
		dc.run();
	}

}

test3

package com.heima.test;

public class Test3 {

	/**
	 * * A:案例演示
	* public void setProperty(Object obj, String propertyName, Object value){}，
	* 此方法可将obj对象中名为propertyName的属性的值设置为value。
	 * @throws Exception 
	 */
	public static void main(String[] args) throws Exception {
		Student s = new Student("张三", 23);
		System.out.println(s);
		
		Tool t = new Tool();
		t.setProperty(s, "name", "李四");
		System.out.println(s);
	}

}

class Student {
	private String name;
	private int age;
	public Student() {
		super();
		
	}
	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "Student [name=" + name + ", age=" + age + "]";
	}
	
	
}

test4

package com.heima.test;

import java.lang.reflect.Field;

public class Tool {
	//此方法可将obj对象中名为propertyName的属性的值设置为value。
	public void setProperty(Object obj, String propertyName, Object value) throws Exception {
		Class clazz = obj.getClass();					//获取字节码对象
		Field f = clazz.getDeclaredField(propertyName);	//暴力反射获取字段
		f.setAccessible(true);							//去除权限
		f.set(obj, value);
	}
}

JDK7新特性

package com.heima.jdk7;

public class Demo1_JDK7 {

	/**
	 	* A:二进制字面量
		* B:数字字面量能够出现下划线
		* C:switch 语句能够用字符串
		* D:泛型简化,菱形泛型
		* E:异常的多个catch合并,每一个异经常使用或|
		* F:try-with-resources 语句,1.7版标准的异常处理代码
		* 
		* 100_000
	 */
	public static void main(String[] args) {
		System.out.println(0b110);
		System.out.println(100_000);
	}

}

JAVA语言基础-反射、特性

Reflect反射

Bean：Person类

Reflect 1

Reflect 2

Constructor

Field

Method

动态代理

Enum：枚举

Enum

Enum 2

Enum

enum2

Week

Week2

Week3

模板方法设计模式

Test

test1

test2

test3

test4

JDK7新特性