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

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获取RemoteService
            Object 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;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        mReboot = findViewById(R.id.btn_shutdown);
        mReboot.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                // 由于权限限制，并未生效
                ReflectClass.shutDown();
                ReflectClass.shutdownOrReboot(true,true);
            }
        });
    }

    @Override
    protected void onResume() {
        super.onResume();
        try {
            // 创建对象
            ReflectClass.reflectNewInstance();

            // 反射私有的构造方法
            ReflectClass.reflectPrivateConstructor();

            // 反射私有属性
            ReflectClass.reflectPrivateField();

            // 反射私有方法
            ReflectClass.reflectPrivateMethod();
        } catch (Exception ex) {
            ex.printStackTrace();
        }

        Log.d(TAG," zenmode = " + ReflectClass.getZenMode());
    }

    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
    }

    @Override
    protected void onPause() {
        super.onPause();
    }

    @Override
    protected 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");
    }
 
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
 
        // Example of a call to a native method
        TextView 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属性，需要设置Accessible
        Field 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