Подробное объяснение размышлений 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] создание объектов других классов через класс
Созданные объекты путем построения непараметров
Пакет отражается; класс Person {public String getName () {return name; } public void setName (string name) {this.name = name; } public int getage () {return Age; } public void setage (int age) {this.age = 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 (); } Человек за = null; try {per = (человек) demo.newinstance (); } catch (instantiationException e) {// todo автоматически сгенерированный блок e.printstacktrace (); } catch (allogalAccessException e) {// todo Автогенерированный блок улова e.printstacktrace (); } per.setName ("rollen"); Per.Setage (20); System.out.println (per); }}【Результаты работы】:
[Rollen 20]
Но обратите внимание, что когда мы отменяем конструктор без параметра по умолчанию лично, например, после того, как мы определим только один конструктор с параметрами, возникнет ошибка: произойдет ошибка:
Например, я определил конструктор:
Public Person (string name, int age) {this.age = age; this.name = name; }Затем продолжайте запускать вышеупомянутую программу, и она появится:
java.lang.instantiationException: Refert.person
на java.lang.class.newinstance0 (class.java:340)
на java.lang.class.newinstance (class.java:308)
at aterly.hello.main (hello.java:39)
Исключение в потоке "Main" java.lang.nullPointerException
at aterly.hello.main (Привет. Java:47)
Поэтому, когда вы пишете объекты, которые используют класс для создания других классов, вы должны определить свой собственный конструктор без параметров.
[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; private int age;} класс 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 (string name, int age);} класс лиц реализует China {public person () {} public perform (строка 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 (); }}}【Результаты работы】:
public java.lang.string getSex ()
public void setsex (java.lang.string arg0)
public void говорит ()
Public void Sayshello (java.lang.string arg0, int arg1)
Общественное окончательное void wat (long arg0) бросает java.lang.Erentertexception
public final void wait () бросает java.lang.terrupruptexception
Публичное окончательное waid wat (long arg0, int arg1) бросает java.lang.terrupruptexception
Public Boolean Equals (java.lang.object arg0)
public java.lang.string tostring ()
Публичный родной int hashcode ()
Публичный финальный уроженец java.lang.class getClass ()
публичный финальный Native void notify ()
публичный финальный родной void notifyall ()
[Случай] Далее, давайте получим все свойства других классов. Наконец, я разбираю их вместе, то есть получить всю структуру класса через класс
класс 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 Speak (String name, int age);} // определить реальное класс проекта RealSubject реализует субъект {@Override public String Specile (String name, int age) {natural 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 (версия).
Подготовка заключается в распределении пространства памяти для статических членов. и установить значения по умолчанию
Распокация относится к процессу преобразования кода в постоянном пуле в качестве прямой ссылки, пока все символические ссылки не будут использоваться программой работы (установить полную переписку)
После завершения тип инициализируется. После инициализации объект класса может использоваться нормально. После того, как объект больше не используется, он будет собранным мусором. Освободить место.
Когда ссылка не указывает на объект класса, он будет удален, заканчивая жизненный цикл класса
Используйте отражение для заводского режима
Давайте посмотрим на заводский режим, если вам не нужно отражение:
http://www.cnblogs.com/rollenholt/archive/2011/08/18/2144851.html
/ *** @Author Rollen-Holt Factory Mode of Design Pattern*/ Interface Fruit {public assoy 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 asbale 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 asbale void eat ();} класс Apple реализует Fruit {public void eat () {System.out.println ("Apple"); }} класс апельсиновый реализует Fruit {public void eat () {System.out.println ("Orange"); }} // Класс Свойства Операции init in in in in init static getpro () бросает filenotfoundexception, ioexception {свойства 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 (); }}}【Запустите результат】: Apple
Выше приведено подробное объяснение механизма отражения Java. Мы будем продолжать добавлять соответствующую информацию в будущем. Спасибо за поддержку этого сайта!