https://www.cnblogs.com/AaronCui/p/4913642.html
1，Java反射机制得到一个类的父类
使用Class类中的getSuperClass()方法能够得到一个类的父类
如果此 Class 表示 Object 类、一个接口、一个基本类型或 void，则返回 null。如果此对象表示一个数组类，则返回表示该 Object 类的 Class 对象。
测试代码：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
package
com.aaron.reflect;
public
class
Demo4 {
public
static
void
main(String[] args) {
Class<?> c = Integer.
class
;
System.out.println(
"Integer的父类是："
+c.getSuperclass());
c = Number.
class
;
System.out.println(
"Number的父类是："
+c.getSuperclass());
c = Object.
class
;
System.out.println(
"Object的父类是："
+c.getSuperclass());
}
}
|
运行结果：
|
1
2
3
|
Integer的父类是：
class
java.lang.Number
Number的父类是：
class
java.lang.Object
Object的父类是：
null
|
由于Java没有多继承，一个类最多只能有一个父类，因此返回类型并不是一个数组。
2，Java反射机制返回一个类实现的接口
当我们开发一个接口，并用一个类去实现它，我们看到某个类，就知道它实现了对应的什么接口，但是机器本身得到一个类时，并不知道它实现的接口是什么样子。通过反射机制，可以取到某个类实现的接口的Class对象，从而可以探查这个接口内部的结构。
本文中给出了一个简单的Demo。
首先，接口的定义如下;
|
1
2
3
4
5
6
|
package
com.aaron.reflect;
public
interface
Animal {
public
static
final
String name =
"animal"
;
public
String sayHello(String name);
}
|
然后，定义一个类去实现这个接口
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
package
com.aaron.reflect;
import
java.util.jar.Attributes.Name;
public
class
Dog
implements
Animal {
public
final
static
String name =
"dog"
;
@Override
public
String sayHello(String str) {
return
String.format(
"%s says : %s"
,
this
.name, str);
}
}
|
接口和实现类中都只有一个方法。
测试类的代码如下：
|
1
2
3
4
5
6
7
8
9
10
11
|
package
com.aaron.reflect;
public
class
Demo3 {
public
static
void
main(String[] args) {
Class<?> c = Dog.
class
;
//得到Dog对应的Class对象
Class<?> interfaces[] = c.getInterfaces();
//获得Dog所实现的所有接口
for
(Class<?> inte : interfaces) {
//打印
System.out.println(
"Dog实现接口："
+inte);
}
}
}
|
运行结果：
|
1
|
Dog实现接口：
interface
com.aaron.reflect.Animal
|
当然，Java没有多继承，但是可以实现多个接口，因此这里返回了一个数组。
需要注意的是：
Class<?>[] getInterfaces()得到的数组中，接口对象顺序和这个对象所表示的类中implements子句中接口名的顺序，是一致的。
1，Java反射机制得到一个类的父类
使用Class类中的getSuperClass()方法能够得到一个类的父类
如果此 Class 表示 Object 类、一个接口、一个基本类型或 void，则返回 null。如果此对象表示一个数组类，则返回表示该 Object 类的 Class 对象。
测试代码：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
package
com.aaron.reflect;
public
class
Demo4 {
public
static
void
main(String[] args) {
Class<?> c = Integer.
class
;
System.out.println(
"Integer的父类是："
+c.getSuperclass());
c = Number.
class
;
System.out.println(
"Number的父类是："
+c.getSuperclass());
c = Object.
class
;
System.out.println(
"Object的父类是："
+c.getSuperclass());
}
}
|
运行结果：
|
1
2
3
|
Integer的父类是：
class
java.lang.Number
Number的父类是：
class
java.lang.Object
Object的父类是：
null
|
由于Java没有多继承，一个类最多只能有一个父类，因此返回类型并不是一个数组。
2，Java反射机制返回一个类实现的接口
当我们开发一个接口，并用一个类去实现它，我们看到某个类，就知道它实现了对应的什么接口，但是机器本身得到一个类时，并不知道它实现的接口是什么样子。通过反射机制，可以取到某个类实现的接口的Class对象，从而可以探查这个接口内部的结构。
本文中给出了一个简单的Demo。
首先，接口的定义如下;
|
1
2
3
4
5
6
|
package
com.aaron.reflect;
public
interface
Animal {
public
static
final
String name =
"animal"
;
public
String sayHello(String name);
}
|
然后，定义一个类去实现这个接口
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
package
com.aaron.reflect;
import
java.util.jar.Attributes.Name;
public
class
Dog
implements
Animal {
public
final
static
String name =
"dog"
;
@Override
public
String sayHello(String str) {
return
String.format(
"%s says : %s"
,
this
.name, str);
}
}
|
接口和实现类中都只有一个方法。
测试类的代码如下：
|
1
2
3
4
5
6
7
8
9
10
11
|
package
com.aaron.reflect;
public
class
Demo3 {
public
static
void
main(String[] args) {
Class<?> c = Dog.
class
;
//得到Dog对应的Class对象
Class<?> interfaces[] = c.getInterfaces();
//获得Dog所实现的所有接口
for
(Class<?> inte : interfaces) {
//打印
System.out.println(
"Dog实现接口："
+inte);
}
}
}
|
运行结果：
|
1
|
Dog实现接口：
interface
com.aaron.reflect.Animal
|
当然，Java没有多继承，但是可以实现多个接口，因此这里返回了一个数组。
需要注意的是：
Class<?>[] getInterfaces()得到的数组中，接口对象顺序和这个对象所表示的类中implements子句中接口名的顺序，是一致的。