From：Java中泛型 Class<T>、T 与 Class<?>、 Object类 和 Class类、 object.getClass() 和 Object.class

        ：https://www.cnblogs.com/zhaoyanhaoBlog/p/9362267.html

Class<T>和 Class<?>类型 有什么区别：https://www.jianshu.com/p/fecafcc83fba

 

 

Java中泛型

 

Java中泛型 Class<T>、T 与 Class<?>、 Object类 和 Class类、 object.getClass() 和 Object.class

 

 

一. 区别

 

• 单独的 T  代表一个类型（表现形式是一个类名而已）
• Class<T>  代表这个类型所对应的类（又可以称做类实例、类类型、字节码文件）
• Class<?>  表示类型不确定的类

Class<T> 表示 T类型 的 字节码文件，意思是：Class<T> 相当于Class<T> c=T.class，T  t  new T() ; 
或者 Class<T> c= t.getClass(); 通过以上可以获取类名为 c.getName();

解释：Class<T> ct=T.class，T  t  new T() ; 与 Class c=T.class，T  t  new T() ; 

ct 泛型指的是 ct 只能是 T 的字节码，而 c 可以是任何类的字节码。所以用 ct 用法更好

平时看 java源代码的时候，如果碰到了泛型，像 ?、T 、K 、V、 E 这些是经常出现的，但是不知道代表什么意思，今天特地整理下：

 E    ---  Element (在集合中使用，因为集合中存放的是元素)T    ---  Type（表示 Java 类型）K V  ---  分别代表 java 键值中的 Key Value。N    ---  Number（数值类型）?    ---  表示 不确定的 Java类型

举例说明：

Set<T>  表示 集合里 是  T类的实例 
List<E> 表示 集合里 是  E类的实例 
List<?> 表示 集合里的对象类型不确定，未指定 List 同 List<?> 是一样的。 

泛型的作用： 

1、用泛型： List<T> list = new ArrayList<T>();  T t=list.get(0);  2、不用泛型： List  list = new ArrayList();  T t = (T)list.get(0); 

 

 

二、如何创建一个 Class<T> 类型 的 实例？

 

      就像使用非泛型代码一样，有两种方式：

• 调用方法 Class.forName() 
• 或者使用类常量 X.class。

Class.forName() 被定义为返 回 Class<?>。另一方面，类常量 X.class 被定义为具有类型 Class<X>，所 以 String.class 是 Class<String> 类型的。

 

 

三、方法中为什么需要 <T> T 修饰呢

 

泛型的声明，必须在方法的修饰符（public,static,final,abstract等）之后，返回值声明之前。

public static <T> T request2Bean(HttpServletRequest request,Class<T> clazz){}

其中第一个 <T> 是与传入的参数 Class<T> 相对应的，相当于返回值的一个泛型，后面的 T 是返回值类型，代表方法必须返回T类型的（由传入的 Class<T> 决定）

 

 

四、Object类 和 Class类

 

Object类 和 Class类 没有直接的关系。

• Object类 是一切 Java类的父类，对于普通的 java类，即便不声明，也是默认继承了 Object 类。典型的，可以使用 Object 类中的toString()方法。
• Class类 是用于 Java反射机制的，一切 java类，都有一个对应的 Class对象，他是一个final类。Class 类的实例表示，正在运行的 Java 应用程序中的类和接口。 

平时看代码时，总是碰到这些即熟悉又陌生的名字，每天都与他们相见，但见面后又似曾没有任何的交集，所以今天我就来认识下这两个江湖侠客的背景：

 

Object 和 泛型 通配符 区别?

Object 是所有类的根类，是具体的一个类，使用的时候可能需要类型强制转换的，但是用通配符 ?、T 、K 、V、 E 等这些的话，在实际用之前类型就已经确定了，不需要强制转换。

• 也就是说，如果一个方法能知道返回的是哪种类型（父类），就用 T，如果完全不知道的就用 ? 。。。用 T 得到的对象就不需要类型转换了，而用 ? 的就必需用强转了。

• 第一种是固定的一种泛型，第二种是只要是Object类的子类都可以，换言之，任何类都可以，因为Object是>所有类的根基类，固定的泛型指类型是固定的，比如：Interge, String 就是 <T extends Collection>

<？ extends Collection> 这里 ? 代表一个未知的类型，但是，这个未知的类型实际上是 Collection 的一个子类，Collection 是这个通配符的上限。

举个例子：class Test <T extends Collection> { }

• <T extends Collection> 中限定了构造此类实例的时候，T 是一个确定类型(具体类型)，这个类型实现了Collection接口，但是实现 Collection 接口的类很多很多，如果针对每一种都要写出具体的子类类型，那也太麻烦了，干脆还不如用 Object 通用一下。
• <? extends Collection> 中的 ? 表示是一个未知类型，是一个通配符泛型，这个类型是实现 Collection 接口即可。

************************ 上面讲的是什么鬼，当你知道引入通配符泛型的由来之后 ************************

当引入泛型之后，遇到这种情况，参数怎么写都不适合，总有2个方法不适用，为了给泛型类写一个通用的方法，这时候就需要引入了 ？通配符的概念。

示例代码：

public class Demo<T extends Animal> {private T ob;public T getOb() {return ob;}public void setOb(T ob) {this.ob = ob;}public Demo(T ob) {super();this.ob = ob;}public void print() {System.out.println("T的类型是：" + ob.getClass().getName());}
}

 

CLASS

    在Java中，每个 class 都有一个相应的 Class 对象。也就是说，当我们编写一个类，编译完成后，在生成的.class文件中，就会产生一个 Class 对象，用于表示这个类的类型信息

 

获取 Class 实例的三种方式：

• (1) ：利用 对象调用 getClass()方法 获取该对象的Class实例；
• (2) ：使用 Class类的静态方法 forName()，用类的名字获取一个Class实例（staticClass forName(String className) Returns the Classobject associated with the class or interface with the given stringname. ）；
• (3) ：运用 .class 的方式来获取 Class 实例，对于基本数据类型的封装类，还可以采用 .TYPE 来获取相对应的基本数据类型的Class实例

        在 newInstance() 调用类中缺省的构造方法 ObjectnewInstance()（可在不知该类的名字的时候，创建这个类的实例） Creates a new instance of the class represented by this Classobject.

        在运行期间，如果要产生某个类的对象，Java虚拟机(JVM)会检查该类型的Class对象是否已被加载。如果没有被加载，JVM会根据类的名称找到 .class 文件并加载它。一旦某个类型的Class对象已被加载到内存，就可以用它来产生该类型的所有对象

  

  Class对象的生成方式如下：

    1. Class.forName("类名字符串") （注意：类名字符串必须是全称，包名+类名）。
    2. 类名.class  （ Object.class ）。
    3. 实例对象.getClass() （object.getClass() ）。

 

 

五、Object.class 和 instanceObj.getClass() 的区别

 

两者的区别如下： 

• 类名.class 叫做 "类字面量"，因 class 是关键字, 所以 类名.class 编译时确定。
• 而 getclass() 是某个具体的方法来调用，是运行时根据实际实例确定，getClass()是动态而且是 final 的。 

例如： 

• String.class 是能对类名的引用取得在内存中该类型class对象的引用，
• 而 new String().getClass() 是通过实例对象取得在内存中该实际类型class对象的引用。 

 

 

六、示例代码

 

示例 1

 ReflectClass.java

package com.android.peter.reflectdemo;import android.content.Context;
import android.os.IBinder;
import android.util.Log;import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;/*** Created by peter on 2018/8/22.*/public class ReflectClass {private final static String TAG = "peter.log.ReflectClass";// 创建对象public static void reflectNewInstance() {try {Class<?> classBook = Class.forName("com.android.peter.reflectdemo.Book");Object objectBook = classBook.newInstance();Book book = (Book) objectBook;book.setName("Android进阶之光");book.setAuthor("刘望舒");Log.d(TAG,"reflectNewInstance book = " + book.toString());} catch (Exception ex) {ex.printStackTrace();}}// 反射私有的构造方法public static void reflectPrivateConstructor() {try {Class<?> classBook = Class.forName("com.android.peter.reflectdemo.Book");Constructor<?> declaredConstructorBook = classBook.getDeclaredConstructor(String.class,String.class);declaredConstructorBook.setAccessible(true);Object objectBook = declaredConstructorBook.newInstance("Android开发艺术探索","任玉刚");Book book = (Book) objectBook;Log.d(TAG,"reflectPrivateConstructor book = " + book.toString());} catch (Exception ex) {ex.printStackTrace();}}// 反射私有属性public static void reflectPrivateField() {try {Class<?> classBook = Class.forName("com.android.peter.reflectdemo.Book");Object objectBook = classBook.newInstance();Field fieldTag = classBook.getDeclaredField("TAG");fieldTag.setAccessible(true);String tag = (String) fieldTag.get(objectBook);Log.d(TAG,"reflectPrivateField tag = " + tag);} catch (Exception ex) {ex.printStackTrace();}}// 反射私有方法public static void reflectPrivateMethod() {try {Class<?> classBook = Class.forName("com.android.peter.reflectdemo.Book");Method methodBook = classBook.getDeclaredMethod("declaredMethod",int.class);methodBook.setAccessible(true);Object objectBook = classBook.newInstance();String string = (String) methodBook.invoke(objectBook,0);Log.d(TAG,"reflectPrivateMethod string = " + string);} catch (Exception ex) {ex.printStackTrace();}}// 获得系统Zenmode值public static int getZenMode() {int zenMode = -1;try {Class<?> cServiceManager = Class.forName("android.os.ServiceManager");Method mGetService = cServiceManager.getMethod("getService", String.class);Object oNotificationManagerService = mGetService.invoke(null, Context.NOTIFICATION_SERVICE);Class<?> cINotificationManagerStub = Class.forName("android.app.INotificationManager$Stub");Method mAsInterface = cINotificationManagerStub.getMethod("asInterface",IBinder.class);Object oINotificationManager = mAsInterface.invoke(null,oNotificationManagerService);Method mGetZenMode = cINotificationManagerStub.getMethod("getZenMode");zenMode = (int) mGetZenMode.invoke(oINotificationManager);} catch (Exception ex) {ex.printStackTrace();}return zenMode;}// 关闭手机public static void shutDown() {try {Class<?> cServiceManager = Class.forName("android.os.ServiceManager");Method mGetService = cServiceManager.getMethod("getService",String.class);Object oPowerManagerService = mGetService.invoke(null,Context.POWER_SERVICE);Class<?> cIPowerManagerStub = Class.forName("android.os.IPowerManager$Stub");Method mShutdown = cIPowerManagerStub.getMethod("shutdown",boolean.class,String.class,boolean.class);Method mAsInterface = cIPowerManagerStub.getMethod("asInterface",IBinder.class);Object oIPowerManager = mAsInterface.invoke(null,oPowerManagerService);mShutdown.invoke(oIPowerManager,true,null,true);} catch (Exception ex) {ex.printStackTrace();}}public static void shutdownOrReboot(final boolean shutdown, final boolean confirm) {try {Class<?> ServiceManager = Class.forName("android.os.ServiceManager");// 获得ServiceManager的getService方法Method getService = ServiceManager.getMethod("getService", java.lang.String.class);// 调用getService获取RemoteServiceObject oRemoteService = getService.invoke(null, Context.POWER_SERVICE);// 获得IPowerManager.Stub类Class<?> cStub = Class.forName("android.os.IPowerManager$Stub");// 获得asInterface方法Method asInterface = cStub.getMethod("asInterface", android.os.IBinder.class);// 调用asInterface方法获取IPowerManager对象Object oIPowerManager = asInterface.invoke(null, oRemoteService);if (shutdown) {// 获得shutdown()方法Method shutdownMethod = oIPowerManager.getClass().getMethod("shutdown", boolean.class, String.class, boolean.class);// 调用shutdown()方法shutdownMethod.invoke(oIPowerManager, confirm, null, false);} else {// 获得reboot()方法Method rebootMethod = oIPowerManager.getClass().getMethod("reboot",boolean.class, String.class, boolean.class);// 调用reboot()方法rebootMethod.invoke(oIPowerManager, confirm, null, false);}} catch (Exception e) {e.printStackTrace();}}}

MainActivity.java

package com.android.peter.reflectdemo;import android.content.Intent;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Button;public class MainActivity extends AppCompatActivity {private final static String TAG = "peter.log.ReflectDemo";private Button mReboot;@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_main);mReboot = findViewById(R.id.btn_shutdown);mReboot.setOnClickListener(new View.OnClickListener() {@Overridepublic void onClick(View v) {// 由于权限限制，并未生效ReflectClass.shutDown();ReflectClass.shutdownOrReboot(true,true);}});}@Overrideprotected void onResume() {super.onResume();try {// 创建对象ReflectClass.reflectNewInstance();// 反射私有的构造方法ReflectClass.reflectPrivateConstructor();// 反射私有属性ReflectClass.reflectPrivateField();// 反射私有方法ReflectClass.reflectPrivateMethod();} catch (Exception ex) {ex.printStackTrace();}Log.d(TAG," zenmode = " + ReflectClass.getZenMode());}@Overrideprotected void onActivityResult(int requestCode, int resultCode, Intent data) {super.onActivityResult(requestCode, resultCode, data);}@Overrideprotected void onPause() {super.onPause();}@Overrideprotected void onDestroy() {super.onDestroy();}
}

 

示例 2

public class MainActivity extends AppCompatActivity {private static final String TAG = "sakura";// Used to load the 'native-lib' library on application startup.static {System.loadLibrary("native-lib");}@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_main);// Example of a call to a native methodTextView tv = (TextView) findViewById(R.id.sample_text);tv.setText(stringWithJNI("sakura"));
//        Log.d(TAG, stringFromJNI());
//        Log.d(TAG, stringWithJNI("sakura"));try {testClass();} catch (ClassNotFoundException e) {e.printStackTrace();} catch (NoSuchFieldException e) {e.printStackTrace();} catch (IllegalAccessException e) {e.printStackTrace();} catch (NoSuchMethodException e) {e.printStackTrace();} catch (InvocationTargetException e) {e.printStackTrace();}}public void testClass() throws ClassNotFoundException, NoSuchFieldException, IllegalAccessException, NoSuchMethodException, InvocationTargetException {Test sakuraTest = new Test();// 获得Class的方法（三种）Class testClazz = MainActivity.class.getClassLoader().loadClass("myapplication.example.com.ndk_demo.Test");Class testClazz2 = Class.forName("myapplication.example.com.ndk_demo.Test");Class testClazz3 = Test.class;Log.i(TAG, "Classloader.loadClass->" + testClazz);Log.i(TAG, "Classloader.loadClass->" + testClazz2);Log.i(TAG, "Classloader.loadClass->" + testClazz3.getName());// 获得类中属性相关的方法Field publicStaticField = testClazz3.getDeclaredField("publicStaticField");Log.i(TAG, "testClazz3.getDeclaredField->" + publicStaticField);Field publicField = testClazz3.getDeclaredField("publicField");Log.i(TAG, "testClazz3.getDeclaredField->" + publicField);//对于Field的get方法，如果是static，则传入null即可;如果不是，则需要传入一个类的实例String valueStaticPublic = (String) publicStaticField.get(null);Log.i(TAG, "publicStaticField.get->" + valueStaticPublic);String valuePublic = (String) publicField.get(sakuraTest);Log.i(TAG, "publicField.get->" + valuePublic);//对于private属性，需要设置AccessibleField privateStaticField = testClazz3.getDeclaredField("privateStaticField");privateStaticField.setAccessible(true);String valuePrivte = (String) privateStaticField.get(null);Log.i(TAG, "modified before privateStaticField.get->" + valuePrivte);privateStaticField.set(null, "modified");valuePrivte = (String) privateStaticField.get(null);Log.i(TAG, "modified after privateStaticField.get->" + valuePrivte);Field[] fields = testClazz3.getDeclaredFields();for (Field i : fields) {Log.i(TAG, "testClazz3.getDeclaredFields->" + i);}// 获得类中method相关的方法Method publicStaticMethod = testClazz3.getDeclaredMethod("publicStaticFunc");Log.i(TAG, "testClazz3.getDeclaredMethod->" + publicStaticMethod);publicStaticMethod.invoke(null);Method publicMethod = testClazz3.getDeclaredMethod("publicFunc", java.lang.String.class);Log.i(TAG, "testClazz3.getDeclaredMethod->" + publicMethod);publicMethod.invoke(sakuraTest, " sakura");}/*** A native method that is implemented by the 'native-lib' native library,* which is packaged with this application.*/public native String stringFromJNI();public native String stringWithJNI(String context);
}
...
public class Test {private static final String TAG = "sakura_test";public static String publicStaticField = "i am a publicStaticField";public String publicField = "i am a publicField";private static String privateStaticField = "i am a privateStaticField";private String privateField = "i am a privateField";public static void publicStaticFunc() {Log.d(TAG, "I`m from publicStaticFunc");}public void publicFunc(String str) {Log.d(TAG, "I`m from publicFunc" + str);}private static void privateStaticFunc() {Log.i(TAG, "I`m from privateFunc");}private void privateFunc() {Log.i(TAG, "I`m from privateFunc");}
}
...
...
12-26 23:57:11.784 17682-17682/myapplication.example.com.ndk_demo I/sakura: Classloader.loadClass->class myapplication.example.com.ndk_demo.Test
12-26 23:57:11.784 17682-17682/myapplication.example.com.ndk_demo I/sakura: Classloader.loadClass->class myapplication.example.com.ndk_demo.Test
12-26 23:57:11.784 17682-17682/myapplication.example.com.ndk_demo I/sakura: Classloader.loadClass->myapplication.example.com.ndk_demo.Test
12-26 23:57:11.785 17682-17682/myapplication.example.com.ndk_demo I/sakura: testClazz3.getDeclaredField->public static java.lang.String myapplication.example.com.ndk_demo.Test.publicStaticField
12-26 23:57:11.785 17682-17682/myapplication.example.com.ndk_demo I/sakura: testClazz3.getDeclaredField->public java.lang.String myapplication.example.com.ndk_demo.Test.publicField
12-26 23:57:11.785 17682-17682/myapplication.example.com.ndk_demo I/sakura: publicStaticField.get->i am a publicStaticField
12-26 23:57:11.785 17682-17682/myapplication.example.com.ndk_demo I/sakura: publicField.get->i am a publicField
12-26 23:57:11.785 17682-17682/myapplication.example.com.ndk_demo I/sakura: modified before privateStaticField.get->i am a privateStaticField
12-26 23:57:11.785 17682-17682/myapplication.example.com.ndk_demo I/sakura: modified after privateStaticField.get->modified
12-26 23:57:11.785 17682-17682/myapplication.example.com.ndk_demo I/sakura: testClazz3.getDeclaredFields->private java.lang.String myapplication.example.com.ndk_demo.Test.privateField
12-26 23:57:11.785 17682-17682/myapplication.example.com.ndk_demo I/sakura: testClazz3.getDeclaredFields->public java.lang.String myapplication.example.com.ndk_demo.Test.publicField
12-26 23:57:11.785 17682-17682/myapplication.example.com.ndk_demo I/sakura: testClazz3.getDeclaredFields->private static final java.lang.String myapplication.example.com.ndk_demo.Test.TAG
12-26 23:57:11.785 17682-17682/myapplication.example.com.ndk_demo I/sakura: testClazz3.getDeclaredFields->private static java.lang.String myapplication.example.com.ndk_demo.Test.privateStaticField
12-26 23:57:11.785 17682-17682/myapplication.example.com.ndk_demo I/sakura: testClazz3.getDeclaredFields->public static java.lang.String myapplication.example.com.ndk_demo.Test.publicStaticField
12-26 23:57:11.785 17682-17682/myapplication.example.com.ndk_demo I/sakura: testClazz3.getDeclaredMethod->public static void myapplication.example.com.ndk_demo.Test.publicStaticFunc()
12-26 23:57:11.785 17682-17682/myapplication.example.com.ndk_demo D/sakura_test: I`m from publicStaticFunc
12-26 23:57:11.786 17682-17682/myapplication.example.com.ndk_demo I/sakura: testClazz3.getDeclaredMethod->public void myapplication.example.com.ndk_demo.Test.publicFunc(java.lang.String)
12-26 23:57:11.786 17682-17682/myapplication.example.com.ndk_demo D/sakura_test: I`m from publicFunc sakura