反射one之code

页面一
package com.oracle.reflect;

public class Person {
	//属性 
	public String pname;
	private Integer age;
	private String password;
	
	public Person(){
		
	}
	
	public Person(Integer age){
		this.age = age;
	}
	
	public Person(String name,String password){
		this.pname =name;
		this.password = password;
	}
	
	public String getPname() {
		return pname;
	}
	public void setPname(String pname) {
		this.pname = pname;
	}
	public int getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	//方法  无返回值 无参数
	public void eat1(){
		System.out.println("吃好吃的");
	}
	// 无返回值 有参数
	public void buy(int money){
		System.out.println(money + "元的水");
	}
	// 有返回值  无参数
	public int a(){
		return 1+1;
	}
	// 有返回值 有参数
	public void test(String name,String password){
		System.out.println("我是test2");
		System.out.println("姓名为："+name + " \n密码为："+password );
	}
	
	public void test1(String n ,String p){
		System.out.println("我是test1");
	}
	
}
页面二
package com.oracle.reflect;

import java.lang.reflect.Field;

public class Demo  {
 
	public static void main(String[] args) throws Exception {
		
		//获取Person类的结构

		//第一种方式
		//Class c = Class.forName("com.oracle.reflect.Person");
		
		//第二种方式 获取 反射Class的类
	    Class c = Person.class;//最常用的
		
		//第三种
		//Person p =new Person();
		//Class c = p.getClass();//一般情况下不用
		
		//获取类名
		String simpleName = c.getSimpleName();
		System.out.println("类名为： "+simpleName);
		
		//获取类的 公有属性
		Field[] fields = c.getFields();
		for (Field field : fields) {
			System.out.println(field.getName());//只可以获取公有属性
		}
		System.out.println("=============================");
		//获取类的所有属性
		Field[] df = c.getDeclaredFields();
		for (Field field : df) {
			System.out.println(field.getName());//获取所有属性
		}
		
		
		
	}
	
}
页面三
package com.oracle.reflect;

import java.lang.reflect.Constructor;

public class TestConstructor {
	
	public static void main(String[] args) throws Exception, SecurityException {
		
		Person p = new Person();
		Class c = p.getClass();
		
		Constructor con = c.getConstructor(Integer.class);//获取指定参数的构造器
		
		Person person =(Person) con.newInstance(45);
		System.out.println("年龄为："+person.getAge());
		
		Constructor[] constr = c.getConstructors();//获取 Person类中所有的构造器
		
		for (Constructor constructor : constr) {
			
			//System.out.println(constructor.getName());
			//System.out.println(constructor.getParameterCount());
			
			Class[] cc = constructor.getParameterTypes();
			for (Class r : cc) {
				System.out.println(r.getSimpleName());
			}
			
			
		}
		
	}
}
页面四
package com.oracle.reflect;
//反射包
import java.lang.reflect.Field;

public class TestField {
	 
	
	public static void main(String[] args) {
		
		try {
		//Class类 获取反射对象的 类
		Class c = Class.forName("com.oracle.util.DBTools");
	
		//常用的方法
		String name = c.getName(); //获取当前类的全限定名
		System.out.println("类的全限定名： "+name);
			
		String simpleName = c.getSimpleName(); //获取 当前类的 简单的名字
		System.out.println("简单类名： "+simpleName);
			
		Field[] f = c.getDeclaredFields(); //获取 当前类中 所有的属性
		//是数组需要循环  来 封装了 拼接的sql 语句
		for (Field field : f) {
			String fName = field.getName();
			System.out.println(fName);
			Class clazz = field.getType();
			System.out.println("当前属性的类型是 ： "+clazz.getName());
			System.out.println("当前属性的简单类型 ："+clazz.getSimpleName());
			int modifiers = field.getModifiers();
			System.out.println("修饰符: " + modifiers);
		}
		
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}
class TestFieldTwo{
	
	
	
	public static void main(String[] args) throws Exception, SecurityException {
		
		
		Class clazz = Person.class;
		
		//获取 指定 属性
		Field f = clazz.getField("pname");//获取 指定名字的 属性方法
		
		String name = f.getName();
		System.out.println("属性的名： "+f.getName());
		
		Class<?> type = f.getType();
		System.out.println("属性的类型为： "+type.getSimpleName());
		Person p = new Person();
	
		f.set(p, "李四");//赋值
		
		Object obj = f.get(p);
		System.out.println("属性的值为："+ obj);
		
		f.set(p, "张三");//赋值
		
		Object newObj = f.get(p);
		System.out.println("重新赋值后的属性的值为："+ newObj);
		
		
		
	}
	
}
页面五
package com.oracle.reflect;

import java.lang.reflect.Method;

/**
 * 通过反射 来获取 类中的方法
 * @author Administrator
 */
public class TestMethod {

	
	public static void main(String[] args) throws Exception, SecurityException {
		
		//反射
		Class c = Person.class;
		
		Method a = c.getMethod("test", String.class,String.class);//获取指定方法
		
		String name = a.getName();
		System.out.println(name);
		
		Class<?> returnType = a.getReturnType();
		
		System.out.println(returnType.getSimpleName());
		
		int parameterCount = a.getParameterCount();
		System.out.println(name+"方法的 参数个数为： "+ parameterCount);
		
		//我现在想调用 Person类中的 test方法
		//我在没有创建 person 对象后 调用方法的情况下
		//通过反射的 Method类中的 invoke方法 执行了指定方法
		Object obj = a.invoke(new Person(), "张三","123");
		System.out.println(obj);
		
		
		/*Method[] m = c.getDeclaredMethods(); //获取 Person类中所有的方法
		for (Method method : m) {
			
			System.out.println("方法的返回值为： "+ method.getName());
			
			System.out.println("返回值类型为："+method.getReturnType().getName());
	
			System.out.println("方法参数的个数为： "+method.getParameterCount());
		
			System.out.println("方法的修饰符为： " +method.getModifiers());//没有用
			
			Class[] clazz = method.getParameterTypes();
			
			for (Class cc: clazz) {
				System.out.println("方法参数的类型为："+cc.getSimpleName());
			}
		}*/
		
		
		
		/*
		 * boolean flag = false;
		 * for (Method method : m) {
			if(method.getName().equals("eat")){
				flag = true;
			}
		}
		
		String str = flag ? "有" : "沒有";
 		System.out.println(str);*/
		
	}

	
	
}
页面六
package com.oracle.util;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

/**
 * 
 * DBTools: database 数据库 工具类 
 * 
 * @author Administrator
 * 
 * 理解封装的好处
 * 
 */
public class DBTools{
	//将 三个参数 提取出去 作为全局 静态 常量  变量
	private static final String URL = "jdbc:mysql://localhost:3306/java18?characterEncoding=utf8&useSSL=false&serverTimezone=UTC";
	private static final String USERNAME = "root";
	private static final String PASSWORD = "zhihua678";

	private static Connection conn;
	private static PreparedStatement ps;
	
	
	//java 中 静态块儿 只执行一次

	static{ 
		try {
			//类 加载时 只运行 一次  就是 反射
			Class.forName("com.mysql.jdbc.Driver");
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	//最终的目的就是 获取 Connection  设计 个方法 来 获取 连接 
	
	//封装 通过这个 方法 获取 Connection 对象
	public static Connection getConnection(){
		conn = null;//初始化一个 Connection
		try {
		conn = DriverManager.getConnection(URL, USERNAME, PASSWORD);
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return conn;
	}
	
	
	/**
	 * 万能方法： 
	 * 
	 * 封装 ： 增  删  改 的万能方法 
	 * 
	 * 入参：  形参 String sql
	 */
	public static boolean executeUpdate(String sql,Object...objs){
		//获取连接
		conn = DBTools.getConnection();
		int result = 0;
		try {
		ps = conn.prepareStatement(sql);
		//给 ? 赋值 没写
		for (int i = 0; i < objs.length; i++) {
			ps.setObject(i+1,objs[i]);
		}
		//发送 并执行sql语句
		result = ps.executeUpdate();
		
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			
			DBTools.close(conn, ps, null);
		}
		
		return result > 0 ? true : false;
	}

	//资源的关闭    关闭 资源 不需要 返回值
	// 关闭 什么呢 ? Connection , Statement , ResultSet 所以 要当作 入参传入进来
	public static void close(Connection conn,PreparedStatement ps,ResultSet rs){
		//在方法入参 的地方  定义 形参 ,
			try {
				if(null != rs){ // 这样写 不会出现 空指针异常 
				  rs.close();
				}
				if(null != ps){
				 ps.close();	
				}
				if(null != conn){
					conn.close();
				}
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
}