java反射获取接口

⑴ java的反射机制

反射机制其实就是用java的Class对象，动态地获取类的方法、属性、类的接口等。。
问题：参数里面的对象的属性不是已经知道了吗？
其实这个类的方法就是让你动态的获取属性值。
getProperty(Object owner, String fieldName)。

你要获取的属性值的时候，属性名通过fieldName参数传入的，而不是写死的。

⑵ java反射机制详解

在Java运行时刻，能否知道一个类的属性方法并调用改动之？对于任意一个对象，能否知道他的所属类，并调用他的方法？答案是肯定的。这种动态的获取信息及动态调用方法的机制在Java中称为“反射”（reflection）。
Java反射机制主要提供以下功能：
在运行时判断任意一个对象所属的类；
在运行时构造任意一个类的对象；
在运行时判断任意一个类所具有的成员变量和方法；
在运行时调用任意一个对象的方法。
Reflection 是Java被视为动态（或准动态）语言的一个关键性质。这个机制允许程序在运行时透过Reflection APIs取得任何一个已知名称的class的内部信息，包括其modifiers（诸如public, static 等等）、superclass（例如Object）、实现之interfaces（例如Serializable），也包括fields和methods 的所有信息，并可于运行时改变fields内容或调用methods。
一般而言，开发者社群说到动态语言，大致认同的一个定义是：“程序运行时，允许改变程序结构或变量类型，这种语言称为动态语言”。
在JDK中，主要由以下类来实现Java反射机制，这些类都位于java.lang.reflect包中：
Class类：代表一个类；
Field 类：代表类的成员变量（成员变量也称为类的属性）；
Method类：代表类的方法；
Constructor 类：代表类的构造方法；
Array类：提供了动态创建数组，以及访问数组的元素的静态方法；

至于全部的你可以看看参考资料。我看这个资料不错

⑶ java课程分享Java的反射机制

Java反射机制是一个非常强大的功能，在很多大型项目比如Spring,Mybatis都可以看见反射的身影。通过反射机制我们可以在运行期间获取对象的类型信息，利用这一特性我们可以实现工厂模式和代理模式等设计模式，同时也可以解决Java泛型擦除等令人苦恼的问题。下面java课程http://www.kmbdqn.com/就从实际应用的角度出发，来应用一下Java的反射机制。

反射基础

p.s:本文需要读者对反射机制的API有一定程度的了解，如果之前没有接触过的话，建议先看一下官方文档的QuickStart。

在应用反射机制之前，首先我们先来看一下如何获取一个对象对应的反射类Class，在Java中我们有三种方法可以获取一个对象的反射类。

通过getClass方法

在Java中，每一个Object都有一个getClass方法，通过getClass方法我们可以获取到这个对象对应的反射类：

Strings="ziwenxie";

Class<?>c=s.getClass();

通过forName方法

我们也可以调用Class类的静态方法forName：

Class<?>c=Class.forName("java.lang.String");

使用.class

或者我们也可以直接使用.class：

Class<?>c=String.class;

获取类型信息

在文章开头我们就提到反射的一大好处就是可以允许我们在运行期间获取对象的类型信息，下面我们通过一个例子来具体看一下。

首先我们在typeinfo.interfacea包下面新建一个接口A：

packagetypeinfo.interfacea;

publicinterfaceA{voidf();}

接着我们在typeinfo.packageaccess包下面新建一个接口C，接口C继承自接口A，并且我们还另外创建了几个用于测试的方法，注意下面几个方法的权限都是不同的。

⑷ java反射获取接口修饰符

谁说的？都说接口中的变量,常量,方法都是public static final？？？？
变量被final了那还叫变量么专？被final的都叫常量
确实，在属接口中定义的属性是public static final
但是方法就不是，它只是public abstract型的，没有static和final

我刚写的，你自己运行一下看看

import java.lang.reflect.Method;

public class Refect {
public static void main(String[] args) {
Class a=BaiDu.class;
Method[] method=a.getDeclaredMethods();
for(int i=0;i<method.length;i++){
System.out.println(method[i]);
}

}

}
interface BaiDu{
String a="2";
void add();
}

⑸ 如何利用java反射，获取属性接口的具体类

你可以这么写：
class BodyImpl implements Body{
//do something
public static void main(String[] args) {
Type[] interfaces = BodyImpl.class.getInterfaces();
ParameterizedType firstInterface = (ParameterizedType) interfaces[0];
Class c = (Class) firstInterface.getActualTypeArguments()[0];
System.out.println(c.getName()); // prints "AtomEntry"
}
}

就得到你所要的回接口参数了！答

⑹ JAVA中反射是什么

JAVA中反射是动态获取信息以及动态调用对象方法的一种反射机制。

Java反射就是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；并且能改变它的属性。而这也是Java被视为动态语言的一个关键性质。

Java反射的功能是在运行时判断任意一个对象所属的类，在运行时构造任意一个类的对象，在运行时判断任意一个类所具有的成员变量和方法，在运行时调用任意一个对象的方法，生成动态代理。

(6)java反射获取接口扩展阅读：

JAVA中反射实例：

1、Class superClass=clazz.getSuperclass();//获取父类。

System.out.println("getSuperclass："+superClass)。

2、Class[] interfaces=clazz.getInterfaces();//获取实现接口。

System.out.println("getInterfaces:"+interfaces.length)。

3、Constructor[] cons=clazz.getConstructors();//构造方法。

System.out.println("getConstructors:"+cons.length)。

参考资料来源：网络： JAVA反射机制

⑺ java中反射实例类装载的步骤及简要阐述

1、认识Java的反射机制：
在正常情况下，必须知道一个类的完整路径之后才可以实例化对象，但是在java中也允许通过一个对象找到其所在的类的信息，那么实际上就是class类的功能。
2、Object类对反射的支持
在Object类中定义了以下的方法，此方法将被所有子类继承：
·public final Class<?> getClass()
以上方法返回值的类型是一个“class”类，实际上此类是Java反射的源头，所谓反射：即可以通过对象反射求出类的名称。
3、Class类
Class本身表示一个类的本身，通过Class可以完整的得到一个类中和完整结构，包括此类中的方法定义，属性定义等等。
4、实例化Class类对象的方法有三种：
第一种：通过forname()方法
第二种：类.class
第三种：对象.getClass()
package org.zhh.getclassdemo;
class X{
}
public class GetClassDemo02{
public static void main(String args[]){
Class<?> c1 = null;//指定泛型
Class<?> c2 = null;//指定泛型
Class<?> c3 = null;//指定泛型
try{
//以下的操作形式是开发中最常用一种形式
c1 = Class.forName("org.zhh.getclassdemo.X");
}catch(ClassNotFoundException e){
e.printStackTrace();
}
c2 = new X().getClass();//通过Object类中的方法实例化
c3 = X.class;//通过类本身实例化
c3 = X.class;//通过类本身实例化
System.out.println("类名称：" + c1.getName());
System.out.println("类名称：" + c2.getName());
System.out.println("类名称：" + c3.getName());
}
}
一旦可以实例Class类之后，就可以进行反射的操作了。

有问题欢迎提问，满意请采纳，谢谢！

⑻ java中的反射机制是什么有什么作用呢求解，谢谢。

Java反射机制详解

1. 反射机制是什么

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

2. 反射机制能做什么

反射机制主要提供了以下功能：

• 在运行时判断任意一个对象所属的类；

• 在运行时构造任意一个类的对象；

• 在运行时判断任意一个类所具有的成员变量和方法；

• 在运行时调用任意一个对象的方法；

• 生成动态代理。

3. 反射机制的相关API

通过一个对象获得完整的包名和类名

packagenet.xsoftlab.ke;
publicclassTestReflect{
publicstaticvoidmain(String[]args)throwsException{
TestReflecttestReflect=newTestReflect();
System.out.println(testReflect.getClass().getName());
//结果net.xsoftlab.ke.TestReflect
}
}

实例化Class类对象

packagenet.xsoftlab.ke;
publicclassTestReflect{
publicstaticvoidmain(String[]args)throwsException{
Class<?>class1=null;
Class<?>class2=null;
Class<?>class3=null;
//一般采用这种形式
class1=Class.forName("net.xsoftlab.ke.TestReflect");
class2=newTestReflect().getClass();
class3=TestReflect.class;
System.out.println("类名称"+class1.getName());
System.out.println("类名称"+class2.getName());
System.out.println("类名称"+class3.getName());
}
}

获取一个对象的父类与实现的接口

packagenet.xsoftlab.ke;
importjava.io.Serializable;
{
=-2862585049955236662L;
publicstaticvoidmain(String[]args)throwsException{
Class<?>clazz=Class.forName("net.xsoftlab.ke.TestReflect");
//取得父类
Class<?>parentClass=clazz.getSuperclass();
System.out.println("clazz的父类为："+parentClass.getName());
//clazz的父类为：java.lang.Object
//获取所有的接口
Class<?>intes[]=clazz.getInterfaces();
System.out.println("clazz实现的接口有：");
for(inti=0;i<intes.length;i++){
System.out.println((i+1)+"："+intes[i].getName());
}
//clazz实现的接口有：
//1：java.io.Serializable
}
}

获取某个类中的全部构造函数 - 详见下例

通过反射机制实例化一个类的对象

packagenet.xsoftlab.ke;
importjava.lang.reflect.Constructor;
publicclassTestReflect{
publicstaticvoidmain(String[]args)throwsException{
Class<?>class1=null;
class1=Class.forName("net.xsoftlab.ke.User");
//第一种方法，实例化默认构造方法，调用set赋值
Useruser=(User)class1.newInstance();
user.setAge(20);
user.setName("Rollen");
System.out.println(user);
//结果User[age=20,name=Rollen]
//第二种方法取得全部的构造函数使用构造函数赋值
Constructor<?>cons[]=class1.getConstructors();
//查看每个构造方法需要的参数
for(inti=0;i<cons.length;i++){
Class<?>clazzs[]=cons[i].getParameterTypes();
System.out.print("cons["+i+"](");
for(intj=0;j<clazzs.length;j++){
if(j==clazzs.length-1)
System.out.print(clazzs[j].getName());
else
System.out.print(clazzs[j].getName()+",");
}
System.out.println(")");
}
//结果
//cons[0](java.lang.String)
//cons[1](int,java.lang.String)
//cons[2]()
user=(User)cons[0].newInstance("Rollen");
System.out.println(user);
//结果User[age=0,name=Rollen]
user=(User)cons[1].newInstance(20,"Rollen");
System.out.println(user);
//结果User[age=20,name=Rollen]
}
}
classUser{
privateintage;
privateStringname;
publicUser(){
super();
}
publicUser(Stringname){
super();
this.name=name;
}
publicUser(intage,Stringname){
super();
this.age=age;
this.name=name;
}
publicintgetAge(){
returnage;
}
publicvoidsetAge(intage){
this.age=age;
}
publicStringgetName(){
returnname;
}
publicvoidsetName(Stringname){
this.name=name;
}
@Override
publicStringtoString(){
return"User[age="+age+",name="+name+"]";
}
}

获取某个类的全部属性

packagenet.xsoftlab.ke;
importjava.io.Serializable;
importjava.lang.reflect.Field;
importjava.lang.reflect.Modifier;
{
=-2862585049955236662L;
publicstaticvoidmain(String[]args)throwsException{
Class<?>clazz=Class.forName("net.xsoftlab.ke.TestReflect");
System.out.println("===============本类属性===============");
//取得本类的全部属性
Field[]field=clazz.getDeclaredFields();
for(inti=0;i<field.length;i++){
//权限修饰符
intmo=field[i].getModifiers();
Stringpriv=Modifier.toString(mo);
//属性类型
Class<?>type=field[i].getType();
System.out.println(priv+""+type.getName()+""+field[i].getName()+";");
}

System.out.println("==========实现的接口或者父类的属性==========");
//取得实现的接口或者父类的属性
Field[]filed1=clazz.getFields();
for(intj=0;j<filed1.length;j++){
//权限修饰符
intmo=filed1[j].getModifiers();
Stringpriv=Modifier.toString(mo);
//属性类型
Class<?>type=filed1[j].getType();
System.out.println(priv+""+type.getName()+""+filed1[j].getName()+";");
}
}
}

通过反射机制调用某个类的方法

packagenet.xsoftlab.ke;
importjava.lang.reflect.Method;
publicclassTestReflect{
publicstaticvoidmain(String[]args)throwsException{
Class<?>clazz=Class.forName("net.xsoftlab.ke.TestReflect");
//调用TestReflect类中的reflect1方法
Methodmethod=clazz.getMethod("reflect1");
method.invoke(clazz.newInstance());
//Java反射机制-调用某个类的方法1.
//调用TestReflect的reflect2方法
method=clazz.getMethod("reflect2",int.class,String.class);
method.invoke(clazz.newInstance(),20,"张三");
//Java反射机制-调用某个类的方法2.
//age->20.name->张三
}
publicvoidreflect1(){
System.out.println("Java反射机制-调用某个类的方法1.");
}
publicvoidreflect2(intage,Stringname){
System.out.println("Java反射机制-调用某个类的方法2.");
System.out.println("age->"+age+".name->"+name);
}
}

通过反射机制操作某个类的属性

packagenet.xsoftlab.ke;
importjava.lang.reflect.Field;
publicclassTestReflect{
privateStringproprety=null;
publicstaticvoidmain(String[]args)throwsException{
Class<?>clazz=Class.forName("net.xsoftlab.ke.TestReflect");
Objectobj=clazz.newInstance();
//可以直接对private的属性赋值
Fieldfield=clazz.getDeclaredField("proprety");
field.setAccessible(true);
field.set(obj,"Java反射机制");
System.out.println(field.get(obj));
}
}

4. 反射机制的应用实例

在泛型为Integer的ArrayList中存放一个String类型的对象。

packagenet.xsoftlab.ke;
importjava.lang.reflect.Method;
importjava.util.ArrayList;
publicclassTestReflect{
publicstaticvoidmain(String[]args)throwsException{
ArrayList<Integer>list=newArrayList<Integer>();
Methodmethod=list.getClass().getMethod("add",Object.class);
method.invoke(list,"Java反射机制实例。");
System.out.println(list.get(0));
}
}

通过反射取得并修改数组的信息

packagenet.xsoftlab.ke;
importjava.lang.reflect.Array;
publicclassTestReflect{
publicstaticvoidmain(String[]args)throwsException{
int[]temp={1,2,3,4,5};
Class<?>demo=temp.getClass().getComponentType();
System.out.println("数组类型："+demo.getName());
System.out.println("数组长度"+Array.getLength(temp));
System.out.println("数组的第一个元素:"+Array.get(temp,0));
Array.set(temp,0,100);
System.out.println("修改之后数组第一个元素为："+Array.get(temp,0));
}
}

将反射机制应用于工厂模式

packagenet.xsoftlab.ke;
interfacefruit{
publicabstractvoideat();
}
classAppleimplementsfruit{
publicvoideat(){
System.out.println("Apple");
}
}
classOrangeimplementsfruit{
publicvoideat(){
System.out.println("Orange");
}
}
classFactory{
publicstaticfruitgetInstance(StringClassName){
fruitf=null;
try{
f=(fruit)Class.forName(ClassName).newInstance();
}catch(Exceptione){
e.printStackTrace();
}
returnf;
}
}
/**
*对于普通的工厂模式当我们在添加一个子类的时候，就需要对应的修改工厂类。当我们添加很多的子类的时候，会很麻烦。
*Java工厂模式可以参考
*http://ke.xsoftlab.net/view/java-factory-pattern
*
*现在我们利用反射机制实现工厂模式，可以在不修改工厂类的情况下添加任意多个子类。
*
*但是有一点仍然很麻烦，就是需要知道完整的包名和类名，这里可以使用properties配置文件来完成。
*
*java读取properties配置文件的方法可以参考
*http://ke.xsoftlab.net/view/java-read-the-properties-configuration-file
*
*@authorxsoftlab.net
*/
publicclassTestReflect{
publicstaticvoidmain(String[]args)throwsException{
fruitf=Factory.getInstance("net.xsoftlab.ke.Apple");
if(f!=null){
f.eat();
}
}
}

我有一个微信公众号，经常会分享一些Java技术相关的干货，还有一些学习资源。
如果你喜欢我的分享，可以用微信搜索“Java团长”或者“javatuanzhang”关注。

⑼ 请问利用Java反射实现一个类中的接口是如何实现的呢

在理解反射的时候，不得不说一下内存。
先理解一下JVM的三个区：堆区，栈区，和方法去（静态区）。
堆区：存放所有的对象，每个对象都有一个与其对应的class信息。在JVM中只有一个堆区，堆区被所有的线程共享。
栈区：存放所有基础数据类型的对象和所有自定义对象的引用，每个线程包含一个栈区。每个栈区中的数据都是私有的，其他栈不能访问。
栈分为三部分：
基本类型变量区、执行环境上下文、操作指令区(存放操作指令)。
方法区：即静态区，被所有的线程共享。方法区包含所有的class和static变量。它们都是唯一的。

在启动一个java虚拟机时，虚拟机要加载你程序里所用到的类 ，这个进程会首先跑到jdk中（在jdk的jre/lib/ext文件夹里找那些jar文件），如果没有找到，会去classpath里设置的路径去找。
在找到要执行的类时：
1.首先将找到的类的信息加载到运行时数据区的方法区。这个过程叫做类的加载。所以一下static类型的在类的加载过程中就已经放到了方法区。所以不用实例化就能用一个static类型的方法。
2.加载完成后，在new一个类时，首先就是去方法区看看有没有这个类的信息。如果没有这个类的信息，先装载这个类。then，加载完成后，会在堆区为new的这个类分配内存，有了内存就有了实例，而这个实例指向的是方法区的该类信息。其实就是存放了在方法区的地址。而反射就是利用了这一点。