Углубленный анализ отражения Java (рекомендуется)

Эта статья по-прежнему использует небольшие примеры для иллюстрации, потому что я всегда чувствую, что этот случай является лучшим, иначе, если вы только читаете теорию, вы не поймете ее после прочтения. Тем не менее, рекомендуется оглянуться назад на теорию после прочтения статьи и лучше понимать.

Основной текст начинается ниже.

[Случай 1] Получить полное имя пакета и класса через объект

 Пакет отражается; /*** Получить полное имя пакета и имя класса через объект**/класс Demo {// другие коды ...} класс Hello {public static void main (string [] args) {demo demo = new demo (); System.out.println (demo.getClass (). GetName ()); }}

【Результат работы】: Refert.demo

Добавьте предложение: все объекты классов на самом деле являются экземплярами класса.

【Случай 2】 Остановите объект класса

 Пакет отражается; класс демонстрация {// другие коды ...} класс hello {public static void main (string [] args) {class <?> demo1 = null; Класс <?> Demo2 = null; Класс <?> Demo3 = null; Попробуйте {// Обычно попытаться использовать эту форму demo1 = class.forname ("Refert.demo"); } catch (Exception e) {e.printstackTrace (); } demo2 = new demo (). getClass (); demo3 = demo.class; System.out.println ("Имя класса"+demo1.getName ()); System.out.println ("Имя класса"+demo2.getName ()); System.out.println ("Имя класса"+demo3.getName ()); }}

【Результаты работы】:
Класс namereflect.demo
Класс namereflect.demo
Класс namereflect.demo

[Случай 3] создание объектов других классов через класс

Созданные объекты путем построения непараметров

 Public Person (string name, int age) {this.age = age; this.name = name; }

Затем продолжайте запускать вышеупомянутую программу, и она появится:

Поэтому, когда вы пишете объекты, которые используют класс для создания других классов, вы должны определить свой собственный конструктор без параметров.

[Case] ​​Call Constructors в других классах через класс (вы также можете создавать объекты других классов через класс таким образом)

 Пакет отражается; импортировать java.lang.reflect.constructor; класс Person {public Person () {} public Person (String name) {this.name = name; } public Perfor (int age) {this.age = age; } public Perfor (String name, int age) {this.age = age; this.name = name; } public String getName () {return name; } public int getage () {return Age; } @Override public String toString () {return "["+this.name+""+this.age+"]"; } private String name; частный int возраст; } класс hello {public static void main (string [] args) {class <?> demo = null; try {demo = class.forname ("Reflect.person"); } catch (Exception e) {e.printstackTrace (); } Человек per1 = null; Человек Per2 = null; Человек per3 = null; Человек Per4 = нулевой; // Получить все конструкторы конструктора <?> CONS [] = demo.getConstructors (); try {per1 = (человек) минусы [0] .newinstance (); per2 = (человек) минусы [1] .newinstance ("rollen"); per3 = (человек) минусы [2] .newinstance (20); per4 = (человек) минусы [3] .newinstance ("rollen", 20); } catch (Exception e) {e.printstackTrace (); } System.out.println (per1); System.out.println (PER2); System.out.println (PER3); System.out.println (PER4); }}

【Результаты работы】:

[null 0]
[Rollen 0]
[NULL 20]
[Rollen 20]

【Случай】

Возвращает интерфейс, реализованный классом:

 Пакет отражается; Интерфейс China {public Static Final String name = "Rollen"; Public Static Int Age = 20; Public void Shaychina (); public void Sayshello (название строки, int age); } класс Человек реализует China {public Person () {} public Person (String Sex) {this.sex = sex; } public String getSex () {return Sex; } public void setsex (строка Sex) {this.sex = sex; } @Override public void saychina () {System.out.println ("Привет, Китай"); } @Override public void sayshello (string name, int age) {system.out.println (name+""+age); } private String Sex; } класс hello {public static void main (string [] args) {class <?> demo = null; try {demo = class.forname ("Reflect.person"); } catch (Exception e) {e.printstackTrace (); } // Сохранить все интерфейсы класс <?> Intes [] = demo.getInterfaces (); for (int i = 0; i <intes.length; i ++) {System.out.println ("реализованный интерфейс"+intes [i] .getName ()); }}}

【Результаты работы】:

Реализованный интерфейс Refert.China

(Обратите внимание, что в следующих примерах будет использоваться класс человека в этом примере, поэтому для сохранения места мы больше не будем вставлять здесь кодовую часть человека, только код основного класса Hello)

【Случай】: Получите родительский класс в других классах

 класс hello {public static void main (string [] args) {class <?> demo = null; try {demo = class.forname ("Reflect.person"); } catch (Exception e) {e.printstackTrace (); } // Получить класс родительского класса <?> Temp = demo.getSuperClass (); System.out.println («Унаследованный родительский класс:«+temp.getName ()); }}

【Результаты запуска】

Унаследованный родительский класс: java.lang.object

【Случай】: Получить все конструкторы в других классах

Этот пример требует добавления импорта java.lang.reflect.* В начале программы;
Затем напишите основной класс как:

 класс hello {public static void main (string [] args) {class <?> demo = null; try {demo = class.forname ("Reflect.person"); } catch (Exception e) {e.printstackTrace (); } Конструктор <?> Ans [] = demo.getConstructors (); for (int i = 0; i <cos.length; i ++) {System.out.println ("Constructor:"+cons [i]); }}}

【Результаты работы】:

Метод построения: public enerture.person ()
Конструктор: Public Refert.person (java.lang.string)

Но осторожные читатели обнаружит, что вышеуказанный конструктор не имеет таких модификаторов, как публичные или частные

Давайте получим модификатор в следующем примере

 класс hello {public static void main (string [] args) {class <?> demo = null; try {demo = class.forname ("Reflect.person"); } catch (Exception e) {e.printstackTrace (); } Конструктор <?> Ans [] = demo.getConstructors (); for (int i = 0; i <cons.length; i ++) {class <?> p [] = cons [i] .getParameterTypes (); System.out.print ("Конструктор:"); int mo = cons [i] .getModifiers (); System.out.print (modifier.tostring (mo)+""); System.out.print (ches [i] .getName ()); System.out.print ("("); for (int j = 0; j <p. p.length; ++ j) {system.out.print (p [j] .getName ()+"arg"+i); if (j <p. p.length-1) {System.out.print (",");}} System.out.println (") {}"); }}}

【Результаты работы】:

Конструктор: public enerture.person () {}
Конструктор: Public Refert.person (java.lang.string arg1) {}

Иногда могут быть исключения в методе, ха -ха. Посмотрим:

 класс hello {public static void main (string [] args) {class <?> demo = null; try {demo = class.forname ("Reflect.person"); } catch (Exception e) {e.printstackTrace (); } Метод метода [] = demo.getMethods (); for (int i = 0; i <method.length; ++ i) {class <?> returntype = method [i] .getReturnType (); Класс <?> Para [] = method [i] .getParameterTypes (); int temp = method [i] .getModifiers (); System.out.print (modifier.tostring (temp)+""); System.out.print (returntype.getName ()+""); System.out.print (method [i] .getName ()+""); System.out.print ("("); for (int j = 0; j <para.length; ++ j) {system.out.print (para [j] .getName ()+""+"arg"+j); if (j <para.length-1) {system.out.print (",");}} class <?> Aearcemed [i]. if (exce.length> 0) {System.out.print (") бросает"); for (int k = 0; k <exce.length; ++ k) {System.out.print (exce [k] .getName ()+""); if (k <exce.length-1) {System.out.print (","); }}}} else {System.out.print (")"); } System.out.println (); }}}

[Случай] Далее, давайте получим все свойства других классов. Наконец, я разбираю их вместе, то есть получить всю структуру класса через класс

 класс hello {public static void main (string [] args) {class <?> demo = null; try {demo = class.forname ("Reflect.person"); } catch (Exception e) {e.printstackTrace (); } System.out.println ("================================================================================= ============================================================================================ ============================================================================================ ============================================================================================= Модификатор разрешения int mo = field [i] .getmodifiers (); System.out.println ("=================================================================================================== ========================================================================================== ========================================================================================== ========================================================================================== filed1 = demo.getFields (); for (int j = 0; j <filed1.length; j ++) {// Модификатор разрешения int mo = filed1 [j] .getModifiers (); String priv = modifier.toString (mo); // класс типа свойства <?> Type = filed1 [j] .getType (); System.out.println (priv + "" + type.getName () + "" + filed1 [j] .getName () + ";"); }}}

【Результаты работы】:

=============================================================================
Частный java.lang.string sex;
==================================================================
Общественный статический финал java.lang.string name;
Общественный статический финальный возраст;

[Случай] Фактически, методы в других классах также могут быть вызваны через размышление:

 класс hello {public static void main (string [] args) {class <?> demo = null; try {demo = class.forname ("Reflect.person"); } catch (Exception e) {e.printstackTrace (); } try {// вызов метода SayChina в методе класса человека = demo.getMethod ("saychina"); method.invoke (demo.newinstance ()); // Вызов человека Sayhello Method = demo.getMethod ("sayhello", string.class, int.class); method.invoke (demo.newinstance (), "rollen", 20); } catch (Exception e) {e.printstackTrace (); }}}

【Результаты работы】:

Привет, Китай
Роллен 20

【Случай】 Набор вызова и получение методов других классов

 класс hello {public static void main (string [] args) {class <?> demo = null; Объект obj = null; try {demo = class.forname ("Reflect.person"); } catch (Exception e) {e.printstackTrace (); } try {obj = demo.newinStance (); } catch (Exception e) {e.printstackTrace (); } setter (obj, "sex", "male", string.class); Getter (obj, «секс»); } / ** * @param obj * объект операции * @param att * attributes операции * * / public void getter (объект obj, string att) {try {method method = obj.getClass (). getMethod ("get" + att); System.out.println (method.invoke (obj)); } catch (Exception e) {e.printstackTrace (); }} / ** * @param obj * Объект операции * @param att * attributes операции * @param value * set value * @param type * Атрибуты параметра * * / public static void setter (объект obj, string att, значение объекта, класс <?> Тип) {try {method method = obj.getclass (). getMethod ("set" + att, att, type) {try {method method = obj.getClass (). method.invoke (obj, значение); } catch (Exception e) {e.printstackTrace (); }}} // конечный класс

【Результаты работы】:

мужской

【Случай】 Операция по отражению

 класс hello {public static void main (string [] args) выбрасывает исключение {class <?> demo = null; Объект obj = null; demo = class.forname ("Reflect.person"); obj = demo.newinstance (); Полевое поле = demo.getDeclaredfield ("sex"); Field.SetAccessible (true); Field.set (obj, "мужчина"); System.out.println (Field.get (obj)); }} // конечный класс

[Случай] Получить и изменить информацию массива посредством размышлений:

 импортировать java.lang.reflect.*; класс hello {public static void main (string [] args) {int [] temp = {1,2,3,4,5}; Класс <?> 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)); }}

【Результаты работы】:

Тип массива: инт
Длина массива 5
Первый элемент массива: 1
После модификации первый элемент массива: 100

【Случай】 Изменить размер массива посредством отражения

 класс hello {public static void main (string [] args) {int [] temp = {1,2,3,4,5,6,7,8,9}; int [] newtemp = (int []) arrayinc (temp, 15); Печать (Newtemp); System.out.println ("================================================================================= ========================================================================================== String []) Arrayinc (ATR, 8); System.ArrayCopy (obj, 0, Newarr, 0, co); Array.getlength (obj);

【Результаты работы】:

Длина массива: 15
1 2 3 4 5 6 7 8 9 0 0 0 0 0 0 0 =======================================================================
Длина массива: 8
ABC NULL NULL NULL NULL

Динамический агент

[Случай] Во -первых, давайте посмотрим, как получить загрузчик класса:

 Class Test {} класс hello {public static void main (string [] args) {test t = new Test (); System.out.println ("classloader"+t.getClass (). GetClassLoader (). GetClass (). GetName ()); }}

【Вывод программы】:

Class Loader sun.misc.launcher $ appclassloader

На самом деле, в Java есть три вида загрузчиков класса.

1) Загрузчик начальной загрузки. Этот загрузчик записан в C ++ и редко можно увидеть в общей разработке.

2) Расширение класса загрузки используется для загрузки расширенных классов, как правило, соответствует классам в каталоге JRE/LIB/EXT

3) Appclassloader загружает класс, указанный ClassPath, и является наиболее часто используемым загрузчиком. Это также загружатель по умолчанию в Java.

Если вы хотите завершить динамический прокси, вам сначала необходимо определить подкласс интерфейса InvocationHandler, и конкретная работа прокси была завершена.

 Пакет отражается; импортировать java.lang.reflect.*; // Определите объект интерфейса проекта {public String говорится (string name, int age); } // Определение реального класса проекта RealSubject реализует субъект {@Override public String Specing (String name, int age) {return name + "" + age; }} класс myInvocationHandler реализует vlocationhandler {private object obj = null; public Object Bind (Object obj) {this.obj = obj; return proxy.newproxyinstance (obj.getClass (). getClassLoader (), obj .getClass (). getInterfaces (), это); } @Override public Object invoke (Proxy Object, метод метода, объект [] args) бросает Throwable {Object temp = method.invoke (this.obj, args); вернуть температуру; }} класс hello {public static void main (string [] args) {myInvocation handler demo = new myInvocationHandler (); Субъект sub = (субъект) demo.bind (new RealSubject ()); String info = sub.say ("Rollen", 20); System.out.println (info); }}

【Результаты работы】:
Роллен 20

Жизненный цикл класса

После того, как класс был составлен, следующим шагом является начало использования класса. Если вы хотите использовать класс, он определенно неразделимый от JVM. Во время выполнения программы JVM выполняется через эти три шага: загрузка, связывание и инициализация.

Загрузка класса выполняется с помощью загрузчика класса. Загрузчик загружает двоичный файл файла .class в область метода JVM и создает объект java.lang.class, описывающий этот класс в области кучи. Используется для инкапсуляции данных. Но тот же класс будет загружен только загрузчиком класса до

Ссылки должны собирать двоичные данные в состояние, которое можно запустить.

Ссылка разделена на три этапа: проверка, подготовка и анализ

Проверка обычно используется для подтверждения того, подходит ли этот двоичный файл для текущего JVM (версия).

Подготовка заключается в распределении пространства памяти для статических членов. и установить значения по умолчанию

Распокация относится к процессу преобразования кода в постоянном пуле в качестве прямой ссылки, пока все символические ссылки не будут использоваться программой работы (установить полную переписку)

После завершения тип инициализируется. После инициализации объект класса может использоваться нормально. После того, как объект больше не используется, он будет собранным мусором. Освободить место.

Когда ссылка не указывает на объект класса, он будет удален, заканчивая жизненный цикл класса

Используйте отражение для заводского режима

Давайте посмотрим на заводский режим, если вам не нужно отражение:

 / *** @Author Rollen-Holt Factory Mode of Design Pattern*/ Интерфейс Fruit {public Abstract void eat (); } класс Apple реализует Fruit {public void eat () {System.out.println ("Apple"); }} класс апельсиновый реализует Fruit {public void eat () {System.out.println ("Orange"); }} // Создание заводского класса // Другими словами, если нам нужно только изменить заводский класс при добавлении других экземпляров на будущем классов Factory {public Static Fruit GetInstance (String FruitName) {Fruit f = null; if ("Apple" .equals (fruitname)) {f = new Apple (); } if ("Orange" .equals (fruitName)) {f = new Orange (); } return f; }} класс hello {public static void main (string [] a) {fruit f = factory.getInstance ("Orange"); подвиг(); }}

Таким образом, когда мы добавляем подкласс, нам нужно изменить заводский класс. Если мы добавим слишком много подклассов, мы много изменим.

Теперь давайте посмотрим на механизм отражения с использованием:

 Пакет отражается; Интерфейс Fruit {public asbstic void eat (); } класс Apple реализует Fruit {public void eat () {System.out.println ("Apple"); }} класс апельсиновый реализует Fruit {public void eat () {System.out.println ("Orange"); }} класс фабрика {public static fruit getInstance (String classname) {fruit f = null; try {f = (fruit) class.forname (classname) .newinstance (); } catch (Exception e) {e.printstackTrace (); } return f; }} класс hello {public static void main (string [] a) {fruit f = factory.getInstance ("Reflect.apple"); if (f! = null) {f.eat (); }}}

Теперь, даже если мы добавим столько подклассов, заводский класс не нужно изменять.

Хотя вышеупомянутая любовь может получить экземпляр интерфейса посредством отражения, она должна пройти в полном пакете и имени класса. Более того, пользователи не могут знать, сколько подклассов можно использовать в интерфейсе, поэтому мы настраиваем необходимые подклассы в форме файлов атрибутов.

Давайте посмотрим на: заводской режим, объединяющий файлы атрибутов

Сначала создайте файл ресурса Fruit.properties.

Содержимое:

 Apple = Refert.apple Orange = Refert.orange

Затем напишите основной код класса:

 Пакет отражается; импортировать java.io.*; Импорт java.util.*; Интерфейс Fruit {public asbstic void eat (); } класс Apple реализует Fruit {public void eat () {System.out.println ("Apple"); }} класс апельсиновый реализует Fruit {public void eat () {System.out.println ("Orange"); }} // Работая файл свойств класса свойства init {public static свойства getPro () бросает filenotFoundException, ioException {Properties pro = new Properties (); Файл f = новый файл ("fruit.properties"); if (f.exists ()) {pro.load (new FileInputStream (f)); } else {pro.setProperty ("Apple", "Reflect.Apple"); Pro.SetProperty ("Orange", "Reflect.orange"); Pro.Store (New FileOutputStream (F), "Fruit Class"); } return pro; }} класс фабрика {public static fruit getInstance (String classname) {fruit f = null; try {f = (fruit) class.forname (classname) .newinstance (); } catch (Exception e) {e.printstackTrace (); } return f; }} класс hello {public static void main (string [] a) бросает filenotfoundexception, ioException {Properties pro = init.getPro (); Fruit f = factory.getInstance (pro.getProperty ("Apple")); if (f! = null) {f.eat (); }}}

Вышеупомянутый углубленный анализ отражения Java (рекомендуется)-это весь контент, которым я делюсь с вами. Я надеюсь, что вы можете дать вам ссылку, и я надеюсь, что вы сможете поддержать Wulin.com больше.