精华内容
下载资源
问答
  • 状态码都是3位数字 分类:1xx:服务器就收客户端消息,但没有接受完成,等待一段时间后,发送1xx多状态码 2xx:成功。代表:200 3xx:重定向。代表:302(重定向),304(访问缓存) 4xx:客户端错误。 * 404(请求...

    response

    HTTP响应消息

    1. 响应行

    组成:协议/版本 响应状态码 状态码描述

    响应状态码:服务器告诉客户端浏览器本次请求和响应的一个状态。

    状态码都是3位数字

    分类:

    1xx:服务器就收客户端消息,但没有接受完成,等待一段时间后,发送1xx多状态码
    2xx:成功。代表:200
    3xx:重定向。代表:302(重定向),304(访问缓存)
    4xx:客户端错误。
    * 404(请求路径没有对应的资源) 
    * 405:请求方式没有对应的doXxx方法
    5xx:服务器端错误。代表:500(服务器内部出现异常)	

    2. 响应头:

    格式:头名称: 值

    常见的响应头:

    Content-Type:服务器告诉客户端本次响应体数据格式以及编码格式

    Content-disposition:服务器告诉客户端以什么格式打开响应体数据

    值:

    in-line:默认值,在当前页面内打开

    attachment;filename=xxx:以附件形式打开响应体。文件下载

    3. 响应空行

    4. 响应体:传输的数据

    一个完整的响应字符串:

    HTTP/1.1 200 OK
    Content-Type: text/html;charset=UTF-8
    Content-Length: 101
    Date: Wed, 06 Jun 2018 07:08:42 GMT
    
    <html>
      <head>
    	<title>$Title$</title>
      </head>
      <body>
      hello , response
      </body>
    </html>
    设置状态码:setStatus(int sc) 
    设置响应头:setHeader(String name, String value) 

    设置响应体:

    // 解决乱码

    response.setContentType("text/html;charset=utf-8");

    1. 获取输出流

    字符输出流:PrintWriter getWriter()
    字节输出流:ServletOutputStream getOutputStream()

    2. 使用输出流,将数据输出到客户端浏览器

    //ResponseDemo1

    package cn.figo.web.response;
    
    import javax.servlet.ServletException;
    import javax.servlet.annotation.WebServlet;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import java.io.IOException;
    
    @WebServlet("/ResponseDemo1")
    public class ResponseDemo1 extends HttpServlet {
    	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    		System.out.println("ResponseDemo1 1111111111");
    
    		request.setAttribute("msg","hello");
    		// 重定向
    		//response.setStatus(302);
    		//response.setHeader("location","/servlet_learn/ResponseDemo2");
    
    		//简单重定向
    		//response.sendRedirect("/servlet_learn/ResponseDemo2");
    		//重定向可以重定向到其他站点
    		//response.sendRedirect("https://www.baidu.com/");
    		//这个是绝对路径,实际路径为http://localhost:8080/ResponseDemo2,
    		// 但是ResponseDemo2的真实路径为 http://localhost:8080/servlet_learn/ResponseDemo2
    		//response.sendRedirect("/ResponseDemo2");  //访问失败
    		// 可以使用相对路径
    		//response.sendRedirect("./ResponseDemo2");
    
    		// 请求转发 可以使用 request域共享数据
    		request.getRequestDispatcher("/ResponseDemo2").forward(request,response);
    		// 转发就不需要加虚拟目录,给服务器用不需要加虚拟路径,给浏览器用需要加虚拟目录,
    		// 因为重定向浏览器地址栏要变,因此必须加虚拟目录
    
    	}
    
    	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    
    		this.doPost(request,response);
    	}
    }

    // /ResponseDemo2

    package cn.figo.web.response;
    
    import javax.servlet.ServletException;
    import javax.servlet.ServletOutputStream;
    import javax.servlet.annotation.WebServlet;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import java.io.IOException;
    import java.io.PrintWriter;
    
    @WebServlet("/ResponseDemo2")
    public class ResponseDemo2 extends HttpServlet {
    	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    
    		System.out.println("ResponseDemo2 2222222222");
    		//重定向是两次请求。不能使用request对象来共享数据
    		Object msg = request.getAttribute("msg");
    		System.out.println(msg);
    
    		//再请求转发回ResponseDemo1,会造成死循环,浏览器提示重定向次数过多
    		//request.getRequestDispatcher("/ResponseDemo1").forward(request,response);
    
    		//  服务器输出字节数据到浏览器
    		//简单的形式,设置编码
    		response.setContentType("text/html;charset=utf-8");
    		//1.获取字符输出流
    		//PrintWriter pw = response.getWriter();
    		//2.输出数据
    		//pw.write("<h1>hello response</h1>");
    		//pw.write("你好啊啊啊 response");
    
    		//1.获取字节输出流
    		ServletOutputStream sos = response.getOutputStream();
    		//2.输出数据
    		sos.write("你好".getBytes("utf-8"));
    	}
    
    	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    
    		this.doPost(request,response);
    	}
    }

    9870dce76c070122d72a4c76441006e0.png

    7e754a2a9c9bcfe84d019780d850adb8.png
    ResponseDemo1 1111111111
    ResponseDemo2 2222222222
    hello

    ServletContext对象:代表整个web应用,可以和程序的容器(服务器)来通信

    获取该对象有两种方式:

    通过request对象获取

    		request.getServletContext();

    通过HttpServlet获取

    		this.getServletContext();

    获取MIME类型:

    MIME类型:在互联网通信过程中定义的一种文件数据类型

    格式: 大类型/小类型 text/html

    	String getMimeType(String file)

    共享数据

    	setAttribute(String name,Object value)
    	getAttribute(String name)
    	removeAttribute(String name)

    ServletContext对象范围:所有用户所有请求的数据

    获取文件的真实(服务器)路径

    	String getRealPath(String path)

    // ServletContentDemo1

    package cn.figo.web.servletContent;
    
    import javax.servlet.ServletContext;
    import javax.servlet.ServletException;
    import javax.servlet.ServletOutputStream;
    import javax.servlet.annotation.WebServlet;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import java.io.IOException;
    import java.io.PrintWriter;
    
    @WebServlet("/ServletContentDemo1")
    public class ServletContentDemo1 extends HttpServlet {
    	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    
    		//1. 通过request对象获取
    		ServletContext context1 = request.getServletContext();
    		//2. 通过HttpServlet获取
    		ServletContext context2 = this.getServletContext();
    
    		System.out.println(context1);
    		System.out.println(context2);
    
    		System.out.println(context1 == context2);//true
    
    		//3. 定义文件名称
    		String filename = "a.jpg";//image/jpeg
    		//4.获取MIME类型
    		String mimeType = context2.getMimeType(filename);
    		System.out.println(mimeType);
    
    		// 获取文件的服务器路径
    		String b = context2.getRealPath("/b.txt");//web目录下资源访问
    		System.out.println(b);
    
    		//设置数据
    		context2.setAttribute("msg","haha");
    		//获取数据
    		Object msg = context1.getAttribute("msg");
    		System.out.println(msg);
    	}
    
    	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    
    		this.doPost(request,response);
    	}
    }

    0ffb168b754bd8d3c3a01cf4bfba9f2e.png
    org.apache.catalina.core.ApplicationContextFacade@7c6c6fd7
    org.apache.catalina.core.ApplicationContextFacade@7c6c6fd7
    true
    image/jpeg
    D:1_CodejavajavaWebjavaWeb_outartifactsservlet_learn_war_explodedb.txt
    haha
    展开全文
  • 68、你所知道的集合类都有哪些?主要方法? 47 69、两个对象值相同(x.equals(y) == true),但却可有不同的hash code,这句话对不对? 48 70、TreeSet里面放对象,如果同时放入了父类和子类的实例对象,那比较时使用的...
  • 什么是反射Java反射说的是在运行状态中,对于任何一个类,我们能够直到这个类有哪些方法和属性。对于任何一个对象,我们能够对它的方法和属性进行调用。这种动态获取对象信息和调用对象方法的功能就是Java的反射...

    理解Java的反射机制对学习Java框架有很大帮助,比如Spring框架的核心就是使用Java反射实现的,同时对做一些Java底层操作也会有帮助,比如字节码操作、自定义注解等。

    什么是反射

    Java反射说的是在运行状态中,对于任何一个类,我们都能够直到这个类有哪些方法和属性。对于任何一个对象,我们都能够对它的方法和属性进行调用。这种动态获取对象信息和调用对象方法的功能就是Java的反射机制。

    反射的三种方式

    反射其实就是获取类的字节码文件,也就是.class文件,那么我们就可以通过Class这个对象进行获取。

    【类.class】获取类的字节码文件

    Class clazz = ReflectTest.class;

    System.out.println(clazz.getName());//com.yanggb.test.ReflectTest

    【实例.getClass()】获取类的字节码文件

    List list = new ArrayList<>();

    Class clazz=list.getClass();

    System.out.println(clazz.getName());//java.util.ArrayList

    【Class.forName(类的全路径名)】获取类的字节码文件

    try{

    Class clazz= Class.forName("com.yanggb.test.ReflectTest");

    System.out.println(clazz.getName());//com.yanggb.test.ReflectTest

    } catch(ClassNotFoundException e) {

    e.printStackTrace();

    }

    要注意的是,通过类的全路径名获取Class对象,如果找不到这个类会抛出异常,必须手动处理异常。

    这三种方式中,第一种需要导入类的包,依赖性太强;第二种方式已经创建了对象,这个时候其实已经不需要去反射了,显得有些多此一举;第三种方式则不需要这个类一定存在,不存在时可以进行另外的操作(异常处理)。因此一般选用第三种方式做反射操作。

    通过反射获取类的成员变量、成员方法

    获取所有构造方法

    Constructor[] constructors =clazz.getConstructors();for(Constructor constructor : constructors) {

    System.out.println(constructor);

    }

    获取所有成员变量

    Field[] fields =clazz.getFields();for(Field field : fields) {

    System.out.println(field);

    }

    获取所有成员方法

    Method[] methods =clazz.getMethods();for(Method method : methods) {

    System.out.println(method);

    }

    这些方法都封装在Class类中,使用的话可以去查阅API,它提供了丰富的API来满足各种各样的要求,这里就只列举上面这三个方法了。

    反射调用类的成员方法

    反射调用类的方法是通过invoke方法去执行的。

    Method[] methods =clazz.getMethods();for(Method method : methods) {

    method.invoke();

    }

    总结

    以上内容就是Java反射机制入门的全部内容了,就是对反射能有一个简单的了解。

    反射机制还有很多的内容呢,要学的东西还很多。但是反射是个好东西,希望你也学得会。

    "你必须精力充沛,才能扛得住世事艰难。"

    展开全文
  • Java反射

    2019-09-25 05:25:52
    Java反射说的是在运行状态中,对于任何一个类,我们能够知道这个类有哪些方法和属性。对于任何一个对象,我们能够对它的方法和属性进行调用。我们把这种动态获取对象信息和调用对象方法的功能称之为反射机制。...

    一、什么是反射?

    Java反射说的是在运行状态中,对于任何一个类,我们都能够知道这个类有哪些方法和属性。对于任何一个对象,我们都能够对它的方法和属性进行调用。我们把这种动态获取对象信息和调用对象方法的功能称之为反射机制。反射就是获取字节码(.class)文件,可以通过Class对象进行获取。java.lang.Class类是Java中的反射中心,Class类的一个对象表示运行时程序中的一个类,并且它是一个通用类。

    二、反射的三种方式

    1、第一种:使用Object下的getClass()方法,getClass()返回此Object的运行时类,Class继承了Object,我们可以直接使用。

    Student stu=new Student();
    Class clazz=stu.getClass();
    

    2、第二种:使用类文字直接获取,耦合度极高。

    Class clazz = Student.class;
    

    3、第三种:使用Class类的forName()方法,Class类forName() static方法返回对Class对象的引用。

    Class forName(String  className)
    Class clazz=Class.forName("com.vangen.bean.Student"); 

    上面的forName()方法接受完全该类的限定名(例如:com.vangen.bean.Student)作为参数,并加载该类,并返回其对象的引用。

    Class forName(String name,  boolean initialize, ClassLoader loader)

    上面的forName()方法可以控制是否初始化或不初始化该类在加载时。 我们也可以传入类加载器。

    三、类反射

    我们可以使用Java反射来获取关于类的信息,例如包名,访问修饰符等。

    1、获取简单的类名,可以使用Class中的getSimpleName()方法:

    String simpleName=clazz.getSimpleName();
    

    2、获取类的修饰符(如:abstract,public),使用Class中的getModifiers()方法,返回类的所有修饰符。但是getModifiers()方法返回的是一个整数。我们需要使用java.lang.reflect.Modifier.toString(int modifiers)才能获得修饰符的文本形式。

    3、获取超类的名称,使用Class中的getSuperclass()方法,可以获取到其超类。如果对Object使用getSuperclass()方法,它将返回null,因为Object没有超类。

    4、获取类实现的所有接口的名称,使用getInterfaces();

    Class[] interfaces=clazz.getInterfaces();
    package com.vangen.test;
    
    import java.io.Serializable;
    import java.lang.reflect.Modifier;
    import java.lang.reflect.TypeVariable;
    
    class Test4 implements Serializable, Cloneable {
    	private int id = -1;
    	private String name = "Unknown";
    
    	public Test4(int id, String name) {
    		this.id = id;
    		this.name = name;
    	}
    
    	public Object clone() {
    		try {
    			return super.clone();
    		} catch (CloneNotSupportedException e) {
    			throw new RuntimeException(e.getMessage());
    		}
    	}
    
    	public String toString() {
    		return "Test: id=" + this.id + ", name=" + this.name;
    	}
    }
    
    public class Main {
    	
    	
    	public static void main(String[] args) {
    		String classDesciption = getClassDescription(Test4.class);
    		System.out.println(classDesciption);
    	}
    
    	public static String getClassDescription(@SuppressWarnings("rawtypes") Class c) {
    		StringBuilder classDesc = new StringBuilder();
    		int modifierBits = 0;
    		String keyword = "";
    		if (c.isInterface()) {
    			modifierBits = c.getModifiers() & Modifier.interfaceModifiers();
    			if (c.isAnnotation()) {
    				keyword = "@interface";
    			} else {
    				keyword = "interface";
    			}
    		} else if (c.isEnum()) {
    			modifierBits = c.getModifiers() & Modifier.classModifiers();
    			keyword = "enum";
    		}
    		modifierBits = c.getModifiers() & Modifier.classModifiers();
    		keyword = "class";
    
    		String modifiers = Modifier.toString(modifierBits);
    		classDesc.append(modifiers);
    		classDesc.append(" " + keyword);
    		String simpleName = c.getSimpleName();
    		classDesc.append(" " + simpleName);
    
    		String genericParms = getGenericTypeParams(c);
    		classDesc.append(genericParms);
    
    		Class superClass = c.getSuperclass();
    		if (superClass != null) {
    			String superClassSimpleName = superClass.getSimpleName();
    			classDesc.append("  extends " + superClassSimpleName);
    		}
    		String interfaces = Main.getClassInterfaces(c);
    		if (interfaces != null) {
    			classDesc.append("  implements " + interfaces);
    		}
    		return classDesc.toString();
    	}
    
    	public static String getClassInterfaces(Class c) {
    		Class[] interfaces = c.getInterfaces();
    		String interfacesList = null;
    		if (interfaces.length > 0) {
    			String[] interfaceNames = new String[interfaces.length];
    			for (int i = 0; i < interfaces.length; i++) {
    				interfaceNames[i] = interfaces[i].getSimpleName();
    			}
    			interfacesList = String.join(", ", interfaceNames);
    		}
    		return interfacesList;
    	}
    
    	public static String getGenericTypeParams(Class c) {
    		StringBuilder sb = new StringBuilder();
    		TypeVariable<?>[] typeParms = c.getTypeParameters();
    
    		if (typeParms.length > 0) {
    			String[] paramNames = new String[typeParms.length];
    			for (int i = 0; i < typeParms.length; i++) {
    				paramNames[i] = typeParms[i].getTypeName();
    			}
    			sb.append("<");
    			String parmsList = String.join(",", paramNames);
    			sb.append(parmsList);
    			sb.append(">");
    		}
    		return sb.toString();
    	}
    }
    

      

    四、字段反射

    获取类中字段的信息,我们可以使用java.lang.reflect.Field类来获取。

    Field[] getFields()//返回所有可以访问的公共字段(在类中声明或者继承的)。
    Field[] getDeclaredFields()//返回所有字段(只出现在类的声明中的)。
    Field getField(String name)//通过字段名获取Field对象
    Field getDeclaredField(String name)//通过字段名获取声明的Field对象       
    public static void main(String[] args) throws Exception {
    		// 获取字节码对象
    		Class clazz = Class.forName("com.vangen.bean.Student");
    		// 获取多个公有方法,成员变量
    		Field[] files = clazz.getFields();
    		for (Field f : files) {
    			System.out.println(f);
    		}
    		System.out.println("-----------------------");
    		// 获取所有成员变量
    		Field[] files1 = clazz.getDeclaredFields();
    		for (Field f : files1) {
    			System.out.println(f);
    		}
    
    		// 获取单个成员变量
    		System.out.println("-----------------------");
    		Field f1 = clazz.getField("name");
    		System.out.println(f1);
    
    		System.out.println("----------------");
    		Field f2 = clazz.getDeclaredField("money");
    		System.out.println(f2);
    		// 获取对象
    		Object obj = clazz.newInstance();
    		// 给对象属性设置值
    		f2.setAccessible(true);
    		f2.set(obj, 56);
    		System.out.println(obj);
    	}
    

        

    五、方法反射

    java.lang.reflect.Method类的实例表示一个方法,反射方法可以使用Class类中以下方法获取方法的信息:

    Method[]  getMethods()
    Method[]  getDeclaredMethods()
    Method getMethod(String name,  Class...  parameterTypes)
    Method getDeclaredMethod(String name,  Class...  parameterTypes)
    

    getMethods()方法返回该类的所有可以访问的公共方法(无论是从类中还是继承自超类)。

    getDeclaredMethods()方法返回所有只在类中声明的方法(继承自超类的方法将不会返回)。

    getMethod(String name,Class ... parameterTypes)和getDeclaredMethod(String name,Class ... parameterTypes)通过方法名和参数类型获取Method对象。

    Method类中的getReturnType()方法返回包含有关返回类型信息的Class对象。

    public static void main(String[] args) throws Exception {
    		// 获取Class对象
    		Class clazz = Class.forName("com.vangen.bean.Student");
    		// 获取方法
    
    		Method m = clazz.getDeclaredMethod("method3", String.class);
    		m.setAccessible(true);
    		System.out.println(m);
    
    }
    

      

    六、构造函数反射

    构造函数反射可以使用以下方法:

    Constructor[] getConstructors()
    Constructor[]  getDeclaredConstructors()
    Constructor<T> getConstructor(Class...  parameterTypes)
    Constructor<T> getDeclaredConstructor(Class...  parameterTypes)
    

    getConstructors()方法返回当前和超类的所有公共构造函数。

    getDeclaredConstructors()方法返回当前类的所有声明的构造函数。

    getConstructor(Class ... parameterTypes)和getDeclaredConstructor(Class ... parameterTypes)通过参数类型获取构造函数对象。

    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
    		// 获取字节码对象
    		Class<?> clazz = Class.forName("com.vangen.bean.Student");
    		// 获取构造方法
    		// 获取多个(公有)构造方法
    		Constructor[] constructors = clazz.getConstructors();
    		for (Constructor c : constructors) {
    			System.out.println(c);
    
    		}
    		// 获取所有的构造方法
    		System.out.println("------------------------------");
    		Constructor[] constructors1 = clazz.getDeclaredConstructors();
    		for (Constructor c : constructors1) {
    			System.out.println(c);
    		}
    
    		// 获取单个构造方法
    		// 获取单个公有构造方法
    		System.out.println("------------------------------");
    		Constructor c = clazz.getConstructor();
    		System.out.println(c);
    		System.out.println("-------------------------------");
    
    		Constructor c1 = clazz.getDeclaredConstructor(String.class);
    		System.out.println(c1);
    		System.out.println("--------------------------------");
    		Constructor c2 = clazz.getDeclaredConstructor(int.class, String.class);
    		System.out.println(c2);
    		
    		
    		//调用构造方法
    		clazz.newInstance();
    		//取消构造方法的权限
    		c1.setAccessible(true);
    		c1.newInstance("张三");
    	}
    

      

    七、反射对象的创建

    1、使用无参构造函数

    如果已经获取到一个Class对象的引用,可以创建一个对象类对Class使用newInstance()方法,此方法不使用参数。

    package com.vangen.test;
    
    class TestClass{
    	public TestClass() {
    		System.out.println("called");
    	}
    }
    public class Main {
    	public static void main(String[] args) throws InstantiationException{
    		Class<TestClass> personClass=TestClass.class;
    		try {
    		      TestClass p = personClass.newInstance();
    		      System.out.println(p);
    		    } catch (InstantiationException | IllegalAccessException e) {
    		      System.out.println(e.getMessage());
    		    }
    	}
    }
    

      

    2、有参构造函数

    可以通过调用特定的构造函数使用反射创建对象。它涉及两个步骤。

      • 获取构造函数的实例
      • 调用newInstance来调用它

     

     

    package com.vangen.test;
    
    import java.lang.reflect.Constructor;
    import java.lang.reflect.InvocationTargetException;
    
    class MyClass {
    	  public MyClass(int i, String s) {
    	    System.out.println("called");
    	    System.out.println(i);
    	    System.out.println(s);
    	  }
    	}
    	public class Main {
    	  public static void main(String[] args) throws NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException    {
    	    Class<MyClass> myClass = MyClass.class;
    	  
    	      Constructor<MyClass> cons = myClass.getConstructor(int.class,
    	          String.class);
    	      MyClass vangen = cons.newInstance(1, "abc");
    	      System.out.println(vangen);
    	   
    	  }
    	}
    

      

     

    八、反射字段访问

    可以使用反射在两个步骤中获取或设置字段。

      • 获取字段的引用。
      • 要读取字段的值,请在字段上调用getXxx()方法,其中Xxx是字段的数据类型。
      • 要设置字段的值,请调用相应的setXxx()方法。

    以相同的方式访问静态和实例字段。

    package com.vangen.test;
    
    import java.lang.reflect.Field;
    
    class TestClass {
    	public String name = "Unknown";
    
    	public TestClass() {
    	}
    
    	public String toString() {
    		return "name=" + this.name;
    	}
    }
    
    public class Main {
    	public static void main(String[] args) {
    		Class<TestClass> ppClass = TestClass.class;
    		try {
    			TestClass p = ppClass.newInstance();
    			Field name = ppClass.getField("name");
    			String nameValue = (String) name.get(p);
    			System.out.println("Current name is " + nameValue);
    			name.set(p, "abc");
    			nameValue = (String) name.get(p);
    			System.out.println("New  name is " + nameValue);
    		} catch (InstantiationException | IllegalAccessException | NoSuchFieldException | SecurityException
    				| IllegalArgumentException e) {
    			System.out.println(e.getMessage());
    		}
    	}
    }
    

      

     

    转载于:https://www.cnblogs.com/vangen/p/11372131.html

    展开全文
  •  本问题讨论变量的初始化,所以先来看一下Java有哪些种类的变量。  1. 类的属性,或者叫值域  2. 方法里的局部变量  3. 方法的参数 对于第一种变量,Java虚拟机会自动进行初始化。如果给出了初始值,则初始...
  • 热更新的时候需要注意哪些点呢? 下面是从网上找到的两种解决方法: 解决方案一 : 自定义类加载器。 首先需要明白一点,class相等的判断条件不仅仅是类名相同,还需要加载它的ClassLoader相同。JVM内部规定一...
  • java反射

    2019-11-01 15:13:37
    Java反射说的是在运行状态中,对于任何一个类,我们能够知道这个类有哪些方法和属性。对于任何一个对象,我们能够对它的方法和属性进行调用。我们把这种动态获取对象信息和调用对象方法的功能称之为反射机制。 ...

    一、什么是反射?

    Java反射说的是在运行状态中,对于任何一个类,我们都能够知道这个类有哪些方法和属性。对于任何一个对象,我们都能够对它的方法和属性进行调用。我们把这种动态获取对象信息和调用对象方法的功能称之为反射机制。

    二、反射的三种方式

    这里需要跟大家说一下,所谓反射其实是获取类的字节码文件,也就是.class文件,那么我们就可以通过Class这个对象进行获取。

    //getClass
    Student student2 = new Student();
    Class cl = student2.getClass();
    
    //class
    Class c2 = Student.class;
    
    //Class.forName
    Class student = Class.forName("com.company.Student");

    三、通过反射获取类的构造方法、方法以及属性

           其中,公有不包括protected

            //获取公有构造方法
            Constructor[] cs = student.getConstructors();
            for (Constructor con:cs) {
                System.out.println(con);
            }
            //获取所有构造方法
            Constructor[] cs2 = student.getDeclaredConstructors();
            for (Constructor con:cs2) {
                System.out.println(con);
            }
            //获取无参构造方法
            Constructor c1 = student.getConstructor();
            System.out.println(c1);
    
            //获取有参构造方法
            Constructor c2 = student.getConstructor(new Class[]{String.class,String.class});
            System.out.println(c2);
    
    
            //获取类公有属性
            Field[] fields = student.getFields();
            for(Field field:fields) {
                System.out.println(field);
            }
    
            //获取类所有属性
            Field[] fields2 = student.getDeclaredFields();
            for(Field field:fields) {
                System.out.println(field);
            }
    
    
            //获取类属性  DeclaredField为所有属性  Field为公有属性
            Field field = student.getDeclaredField("name");
            Object obj = student.getConstructor().newInstance();
            //暴力反射私有属性
            field.setAccessible(true);
            field.set(obj,"张三");
            Student st = (Student)obj;
            String name = st.getName();
            System.out.println(name);
    
            //获取公有方法
            Method[] methods = student.getMethods();
            for (Method method:methods) {
                System.out.println(method);
            }
    
            //获取所有方法
            Method[] methods2 = student.getDeclaredMethods();
            for (Method method:methods2) {
                System.out.println(method);
            }
    
    
            //获取构造方法实例化对象,进行赋值
            Method method = student.getMethod("getName",String.class);
            Object object = student.getConstructor().newInstance();
            Object invoke = method.invoke(object,"007");
            System.out.println(invoke);

    四、应用

    目前只发现了这个,后续的再补充

    //根据字段名获取对应的值
    public Object getFieldValueByName(String fieldName,Object object) throws Exception{
        String firstLetter = fieldName.substring(0,1).toUpperCase();
        String getter = "get"+firstLetter+fieldName.substring(1);
        Method method = object.getClass().getMethod(getter,new Class[]{});
        return method.invoke(object);
    }

     

    展开全文
  • redirect就是服务端根据逻辑,发送一个状态码,告诉浏览器重新去请求那个地址,一般来说浏览器会用刚才请求的所有参数重新请求,所以session,request参数可以获取。 23、EJB与JAVA BEAN的区别?  Java Bean 是可...
  • java反射机制

    2019-11-03 21:14:04
    Java反射说的是在运行状态中,对于任何一个类,我们能够知道这个类有哪些方法和属性。 对于任何一个对象,我们能够对它的方法和属性进行调用。我们把这种动态获取对象信息和调用对象方法的功能称之为反射机制。 ...
  • java的反射机制入门

    2019-05-06 00:34:00
    Java反射说的是在运行状态中,对于任何一个类,我们能够直到这个类有哪些方法和属性。对于任何一个对象,我们能够对它的方法和属性进行调用。这种动态获取对象信息和调用对象方法的功能就是Java的反...
  • 7.java 中操作字符串都有哪些类?它们之间有什么区别? 8.String str="i"与 String str=new String(“i”)一样吗? 9.如何将字符串反转? 10.String 类的常用方法都有那些? 11.抽象类必须要有抽象方法吗? 12.普通...
  • Java反射机制

    2019-09-28 10:58:59
    Java反射说的是在运行状态中,对于任何一个类,我们能够知道这个类有哪些方法和属性。对于任何一个对象,我们能够对它的方法和属性进行调用。我们把这种动态获取对象信息和调用对象方法的功能称之为反射机制。 ...
  • Java的反射

    2019-08-14 17:48:15
    Java反射说的是在运行状态中,对于任何一个类,我们能够知道这个类有哪些方法和属性。对于任何一个对象,我们能够对它的方法和属性进行调用。我们把这种动态获取对象信息和调用对象方法的功能称之为反射机制。...
  • java反射总结

    2019-05-14 14:45:15
    Java反射说的是在运行状态中,对于任何一个类,我们能够知道这个类有哪些方法和属性。对于任何一个对象,我们能够对它的方法和属性进行调用。我们把这种动态获取对象信息和调用对象方法的功能称之为反射机制。 ...
  • java面试题典 java 面试题 经典

    热门讨论 2010-06-18 13:42:36
    34. 你所知道的集合类都有哪些?主要方法? 13 35. 描述一下JVM加载class文件的原理机制? 13 36. char型变量中能不能存贮一个中文汉字?为什么? 13 37. 简述逻辑操作(&,|,^)与条件操作(&&,||)的区别。 13 38. XML文档...
  • java面试宝典

    2013-02-28 16:04:01
    171、AJAX都有哪些有点和缺点? 41 172、Ajax和javascript的区别? 41 Servlet部分 42 174、JAVA SERVLET API中forward() 与redirect()的区别? 42 178、如何现实servlet的单线程模式 42 179、页面间对象传递的方法 ...
  • java面试题

    2018-01-01 15:35:15
    25. 集合类都有哪些?主要方法? 14 26. 简述逻辑操作(&,|,^)与条件操作(&&,||)的区别。 14 27. XML文档定义有几种形式?它们之间有何本质区别?解析XML文档有哪几种方式? 14 28. JSP和Servlet有哪些相同点和不同点...
  • Java之反射

    2019-10-21 15:34:28
    反射就是在运行状态中,对于某一个类我们可以知道这个类有哪些方法和属性。对于任意一个对象,我们能对他的方法和属性进行调用。我们把这种动态获取对象信息和动态获取对象方法的功能称为反射机制。 反射其实...
  • Java--反射机制

    2019-08-01 15:12:23
    反射说的是在运行状态中,对于任何一个类,我们能够知道这个类有哪些方法和属性,对于任何一个对象,我们能够对它的方法和属性进行调用,我们把这种动态获取对象信息和调用方法的对象的功能称之为反射机制。...
  • [java]-反射

    2019-05-07 13:18:26
    Java反射说的是在运行状态中,对于任何一个类,我们能够知道这个类有哪些方法和属性。对于任何一个对象,我们能够对它的方法和属性进行调用。我们把这种动态获取对象信息和调用对象方法的功能称之为反射机制。 ...
  • 7. java 中操作字符串都有哪些类?它们之间有什么区别? 4 8. String str="i"与 String str=new String("i")一样吗? 5 9. 如何将字符串反转? 5 10. String 类的常用方法都有那些? 5 11. 抽象类必须要有抽象方法吗...
  • 并且,状态码,代码注入,markdown文档等附加功能应有尽有。 2.接口调试运行,一个不能少,可以对参数进行加密,从md5到aes一应俱全,返回参数与模型实时分析对比,给出不一致的地方,找出接口可能出现的问题。...
  • JAVA反射简洁整理

    2021-03-21 11:18:18
    一.反射定义: 反射是一种能力,在程序运行状态中动态获取类信息及调用对象方法的功能为反射 1.对任意一个类,能动态的获取到这个类的属性和...类的组成部分有哪些 1.属性(共有+私有) 2.方法 3.构造方法 ..
  • java面试宝典2012

    2012-12-16 20:43:41
    68、你所知道的集合类都有哪些?主要方法? 51 69、两个对象值相同(x.equals(y) == true),但却可有不同的hash code,这句话对不对? 52 70、TreeSet里面放对象,如果同时放入了父类和子类的实例对象,那比较时使用的...
  • 反射机制的应用场景有哪些? 反射是框架设计的灵魂。 在我们平时的项目开发过程中,基本上很少会直接使用到反射机制,但这不能说明反射机制没有用,实际上有很多设计、开发与反射机制有关,例如模块化的开发,通过...
  • JAVA面试宝典2010

    2011-12-20 16:13:24
    68、你所知道的集合类都有哪些?主要方法? 47 69、两个对象值相同(x.equals(y) == true),但却可有不同的hash code,这句话对不对? 48 70、TreeSet里面放对象,如果同时放入了父类和子类的实例对象,那比较时使用的...

空空如也

空空如也

1 2 3 4 5 6
收藏数 107
精华内容 42
关键字:

java状态码都有哪些

java 订阅