Самый простой способ понять дженерики Java - это рассматривать его как удобный синтаксис, который может сэкономить вам некоторые операции на литье типа Java:
Список <pple> box = ...; Apple Apple = box.get (0);
Сам приведенный выше код четко выражен: Box - это список с Apple Objects. Метод GET возвращает экземпляр объекта Apple, и этот процесс не требует преобразования типа. Нет никаких дженериков, приведенный выше код должен быть написан так:
СПИСКОВАЯ BOX = ...;; Apple Apple = (Apple) Box.get (0);
Очевидно, что основным преимуществом генериков является разрешение компилятора сохранить тип информации о параметрах, выполнять проверки типа и выполнять операции преобразования типа: компилятор гарантирует, что эти конверсии типа абсолютно правильны. По сравнению с полагаться на программистов, чтобы запомнить типы объектов и выполнять конверсии типа - это приведет к сбоям при запуске программы, что трудно отладить и решить. Компилятор может помочь программистам заставить большое количество проверок типов во время компиляции и найти ошибки.
Композиция дженериков
Композиция дженериков приводит к концепции переменных типа. Согласно спецификации языка Java, переменные типа являются типом неограниченного глифа, который возникает из следующих ситуаций:
Общее объявление общего класса общее интерфейс объявление общего метода Объявление общего конструктора Объявление
Общие классы и интерфейсы
Если на классе или интерфейсе есть одна или несколько переменных типа, это общее. Переменные типа определяются угловыми кронштейнами и помещаются после класса или имени интерфейса:
Список публичных интерфейсов <T> Extends Collection <T> {...}Проще говоря, роль типовых переменных похожа на параметр, который предоставляет информацию компилятору для проверки типа.
Многие классы в библиотеке классов Java, такие как вся структура коллекции, были изменены в общей форме. Например, интерфейс списка, который мы использовали в первом коде выше, представляет собой общий класс. В этом коде ящик - это объект «Apple>», который является экземпляром реализации класса интерфейса списка с переменной типа Apple. Компилятор использует этот параметр переменной типа для автоматического преобразования метода GET, когда он вызывается, и возвращает объект Apple.
Фактически, этот недавно появляющийся общий тег или метод GET в этом интерфейсе списка выглядит следующим образом:
T Get (int index);
Метод GET фактически возвращает объект типа T, который является переменной типа в объявлении списка <T>.
Общие методы и конструкторы
Очень похожие, если одна или несколько переменных типа объявлены на методе и конструкторе, они также могут быть общими.
public static <t> t getfirst (список <t> list)
Этот метод примет параметр <T> и вернет объект типа T. Вы можете использовать общие классы, представленные в библиотеке классов Java, или вы можете использовать свои собственные общие классы. Тип-безопасные данные записывания ... Следующий код является примером. Мы создаем экземпляры списка <string>, а затем загружаем некоторые данные:
Список <string> str = new ArrayList <string> (); str.add ("Привет"); str.Add ("мир");Если мы попытаемся загрузить другой объект в списке <string>, компилятор заставит ошибку:
str.add (1);
Тип-безопасные данные чтения ...
Когда мы используем объект List <string>, он всегда гарантирует, что мы получаем объект строки:
String myString = str.get (0);
Traversal: Многие классы в библиотеке классов, такие как итератор <t>, имеют улучшенные функции и являются общими. Метод итератора () в интерфейсе списка <T> теперь возвращает итератор <t>. Объект, возвращаемый методом t letle (), не должен быть конвертирован типом, вы напрямую получаете правильный тип.
for (iterator <string> iter = str.iterator (); iter.hasnext ();) {string s = iter.next (); System.out.print (s);}С Foreach синтаксис «для каждого» также выигрывает от дженериков. Предыдущий код может быть написан так:
for (String S: str) {System.out.print (s);}Это легко читать и поддерживать.
Автоматическая инкапсуляция (автобоксинг) и автоматическая распаковка (автоинсангация). При использовании Java Generics будут автоматически использоваться две функции автобоксинга/автофактивного оборудования, как и следующий код:
Список <Integer> ints = new ArrayList <Integer> (); ints.add (0); ints.add (1); int sum = 0; for (int i: ints) {sum += i; }Тем не менее, одна вещь, которую вам нужно понять, это то, что упаковка и распаковка принесут потери производительности, и все общее назначение следует использовать с осторожностью.
Generics - это новая особенность Java SE 1.5. Суть Generics - это параметризованный тип, то есть тип данных, работающий в качестве параметра. Этот тип параметра может использоваться при создании классов, интерфейсов и методов и называется общими классами, общими интерфейсами и общими методами соответственно.
Преимущество внедрения дженериков на языке Java заключается в том, что они безопасны и просты.
Перед Java SE 1,5, без дженериков, «производительность» параметров была достигнута путем ссылки на объект типа. Недостатком «произвольной» было то, что требовалось явное преобразование типа листа, и это преобразование потребовало, чтобы разработчики предсказывали фактический тип параметра. В случае ошибок преобразования типа листа компилятор может не вызвать ошибку, и исключение будет происходить только при запуске, что является риском безопасности.
Преимущество дженериков состоит в том, что они проверяют безопасность типа при компиляции, и все слепки являются автоматическими и неявными, улучшая скорость повторного использования кода.
Есть некоторые правила и ограничения в использовании дженериков:
1. Параметры типа общих типов могут быть только типами классов (включая пользовательские классы), а не простые типы.
2. Один и тот же общий тип может соответствовать нескольким версиям (потому что тип параметра неопределен), а экземпляры общего класса разных версий несовместимы.
3. Может быть несколько параметров типа для дженериков.
4. Общие типы параметров могут использовать, например, операторы Extends. Привычно становиться «ограниченным типом».
5. Тип параметров общего типа также может быть типом подстановочного знака. Например, класс classtype = class.forname (java.lang.string);
Дженерики также имеют интерфейсы, методы и т. Д., С большим количеством контента, и требуются некоторые усилия, чтобы понять, освоить и применять их опытно. Вот два примера, которые я написал, когда узнал о дженеках (написано на основе впечатления, которое я видел), что может реализовать ту же функцию. Один использует дженерики, а другой - нет. По сравнению вы можете быстро изучить применение дженериков. Узнайте это и в основном выучите 70% содержания дженериков.
Пример 1: используются дженерики
открытый класс джентльмен {private t ob; // Определите общую переменную члена Public Gen (t OB) {this.ob = ob; } public t getOb () {return ob; } public void setOb (t ob) {this.ob = ob; } public void showtyep () {System.out.println ("Фактический тип t is:" + ob.getClass (). getName ()); }} открытый класс gendemo {public static void main (string [] args) {// определить целочисленную версию общего класса Gen intob = new Geninteger (88); intob.showtyep (); int i = intob.getOb (); System.out.println ("value =" + i); System.out.println("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------Пример 2: не используются дженерики
открытый класс gen2 {частный объект ob; // Определить общий тип члена Public Gen2 (Object OB) {this.ob = ob; } public Object getOb () {return ob; } public void setOb (объект ob) {this.ob = ob; } public void showtyep () {System.out.println ("Фактический тип t is:" + ob.getClass (). getName ()); }} public class gendemo2 {public static void main (string [] args) {// определить целочисленную версию класса Gen2 gen2 intob = new gen2 (new Integer (88)); intob.showtyep (); int i = (integer) intob.getob (); i);System.out.println("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ strob.getob (); System.out.println ("value =" + s);Результаты работы:
Результаты запуска демонстрации в двух примерах одинаковы, а вывод консоли заключается в следующем:
Фактический тип T:
java.lang.integer
значение = 88
-----------------------------------
Фактический тип t: java.lang.string
Value = Hello Gen!
Процесс завершен с кодом выхода 0
Если вы понимаете это, вы не будете проблемой в будущем, когда основные общие приложения и чтение кода.
Приведенное выше является примером анализа дженериков Java. Друзья, которые изучают дженерики Java, могут ссылаться на это.