Java Generics

Java Advanced Tutorial(Generics) Hamid Ghorbani https://ir.linkedin.com/in/ghorbanihamid
Generics:
Generic methods and generic classes were designed to extend Java's type system to allow “a type or method to
operate on objects of various types while providing compile-time type safety.
‫گاهي‬‫ﻣﻨﻄﻖ‬‫پياده‬‫سازي‬‫يك‬،‫كﻼس‬‫براي‬‫انواع‬‫داده‬‫ﻣﺨﺘﻠﻒ‬‫يكسان‬ً‫ﻼ‬‫ﻣث‬ ،‫است‬‫ﻣﻨﻄﻖ‬‫ﻣﺘﺪ‬add‫در‬‫كﻼس‬ArrayList‫بﻪ‬‫ازاي‬‫ليسﺘي‬‫از‬‫رشﺘﻪ‬‫يا‬
‫عﺪد‬‫ﻣﺘفاوت‬‫ﻣﺘﺪ‬ ‫سازي‬ ‫پياده‬ ‫براي‬ ،‫نيست‬add:‫داشت‬ ‫خواهيم‬ ‫بﻪ‬ ‫راه‬ ‫دو‬
‫راه‬‫اول‬:‫ﺑﻪ‬‫ازاي‬‫ﻫﺮ‬‫نوع‬،‫داده‬‫يك‬‫كﻼس‬ArrayList‫ﺑسازيم‬،ً‫ﻼ‬‫ﻣﺜ‬StringArrayList‫و‬IntegerArrayList‫و‬StudentArrayList،‫اين‬
‫كﻼس‬‫ﻫا‬‫ﻣﺸاﺑﻪ‬)‫كپي‬(‫يكديگﺮند‬
‫راه‬‫دوم‬:‫يك‬‫كﻼس‬ArrayList‫تعﺮيف‬‫كنيم‬‫و‬‫درﻫنگام‬‫استفاده‬‫نوع‬‫آن‬‫را‬‫ﻣحدود‬‫كنيم‬‫اي‬ ‫داده‬ ‫نوع‬ ‫روش‬ ‫اين‬ ‫ﺑﻪ‬ ،‫جنﺮيك‬ ‫يا‬ ‫عام‬.‫گويند‬ ‫ﻣي‬
‫اي‬ ‫داده‬ ‫نوع‬‫عام‬)‫جﻨريك‬(‫يك‬‫نوع‬‫پياده‬‫سازي‬‫يك‬‫كﻼس‬‫و‬‫يا‬‫يك‬‫ﻣﺘﺪ‬‫با‬‫انواع‬‫ورودي‬‫و‬‫خروجي‬‫ﻣﺨﺘﻠﻒ‬‫و‬‫تعيين‬‫شﺪه‬‫در‬‫زﻣان‬‫فراخواني‬‫هست‬.
‫يعﻨي‬‫راه‬‫حﻠي‬‫ا‬‫ست‬‫كﻪ‬‫شﻤا‬‫از‬‫طريﻖ‬‫اون‬‫ﻣي‬‫تو‬‫ا‬‫نيﺪ‬‫نوع‬‫برگشﺘي‬‫و‬‫يا‬‫پاراﻣﺘرهاي‬‫ورودي‬‫ﻣﺘﺪ‬‫ر‬‫ا‬‫تعيين‬‫نكﻨيﺪ‬‫و‬‫آ‬‫ن‬‫ر‬‫ا‬‫بسپريﺪ‬‫بﻪ‬‫زﻣان‬‫فراخواني‬.‫ﻣثﻼ‬
‫شﻤا‬‫ﻣي‬‫تو‬‫ا‬‫نيﺪ‬‫يك‬‫ﻣﺘﺪ‬‫تعريﻒ‬‫كﻨيﺪ‬‫كﻪ‬‫يك‬‫ليست‬‫رو‬‫دريافت‬‫كﻨ‬‫ﺪ‬‫و‬‫آ‬‫ن‬‫ر‬‫ا‬‫ﻣرتﺐ‬‫كﻨ‬‫ﺪ‬‫و‬‫برگرد‬‫ا‬‫ن‬‫ﺪ‬‫فارغ‬‫از‬‫ايﻨكﻪ‬‫عﻨاﺻر‬‫اون‬‫ليست‬‫ﭼﻪ‬‫نوعي‬‫دارن‬.
‫كﻼس‬ArrayList‫يك‬‫نوع‬‫داده‬‫عام‬‫يا‬Generic‫است‬.
Generic Methods:
‫براي‬‫ساخت‬‫يك‬‫ﻣﺘﺪ‬‫يا‬ ‫عام‬‫جﻨريك‬‫بايﺪ‬‫ﻣوراد‬‫زير‬‫رو‬‫در‬‫نﻈر‬‫بگيريم‬:
‫داده‬ ‫انواع‬ ‫از‬ ‫كﻪ‬ ‫اين‬ ‫جاي‬ ‫بﻪ‬ ‫تعريﻒ‬ ‫هﻨگام‬ ‫كﻪ‬ ‫دارنﺪ‬ ‫پاراﻣﺘر‬ ‫براي‬ ‫داده‬ ‫نوع‬ ‫يك‬ ‫جﻨريك‬ ‫ﻣﺘﺪهاي‬ ‫ي‬ ‫هﻤﻪ‬primitive‫شاخص‬ ‫يك‬ ‫از‬ ‫كﻨﻨﺪ‬ ‫اسﺘفاده‬
‫كاراكﺘر‬ ‫دو‬ ‫بين‬< >‫كﻪ‬ ‫باشﺪ‬ ‫قرار‬ ‫اگر‬ ‫و‬ ‫شود‬ ‫ﻣي‬ ‫اسﺘفاده‬‫اسﺘفاده‬ ‫قبﻠي‬ ‫داده‬ ‫انواع‬ ‫جاي‬ ‫بﻪ‬ ‫شاخص‬ ‫هﻤين‬ ‫از‬ ‫برگردانﺪ‬ ‫جﻨريك‬ ‫ﻣقﺪار‬ ‫يك‬ ‫ﻣﺘﺪي‬
‫انو‬ ‫از‬ ‫اسﺘفاده‬ ‫جاي‬ ‫بﻪ‬ ‫باشﺪ‬ ‫جﻨريك‬ ‫هم‬ ‫ها‬ ‫پاراﻣﺘر‬ ‫داده‬ ‫نوع‬ ‫بﺨواهيم‬ ‫كﻪ‬ ‫اين‬ ‫براي‬ ‫هﻤچﻨين‬ .‫شﺪ‬ ‫خواهﺪ‬‫ا‬‫ﻣي‬ ‫اسﺘفاده‬ ‫ها‬ ‫شاخص‬ ‫از‬ ‫اوليﻪ‬ ‫داده‬ ‫ع‬
‫كﻨيم‬.‫هسﺘﻨﺪ‬ ‫رفرنس‬ ‫ازنوع‬ ‫پاراﻣﺘرها‬ ‫كﻪ‬ ‫كﻨيﺪ‬ ‫توجﻪ‬.
‫شاخﺼ‬ ‫بﻪ‬‫اسﺘفاده‬ ‫برناﻣﻪ‬ ‫در‬ ‫هم‬ ‫از‬ ‫جﺪا‬ ‫داده‬ ‫نوع‬ ‫دو‬ ‫از‬ ‫كﻪ‬ ‫باشﺪ‬ ‫قرار‬ ‫اگر‬ ‫و‬ ‫شود‬ ‫ﻣي‬ ‫گفﺘﻪ‬ ‫نوع‬ ‫پاراﻣﺘر‬ ‫دهيم‬ ‫ﻣي‬ ‫قرار‬ ‫اﺻﻠي‬ ‫داده‬ ‫نوع‬ ‫جاي‬ ‫بﻪ‬ ‫كﻪ‬ ‫ي‬
‫از‬ ‫اسﺘفاده‬ ‫با‬ ‫را‬ ‫آنها‬ ‫كﻪ‬ ‫كرد‬ ‫اسﺘفاده‬ ‫ﻣﺘفاوت‬ ‫نوع‬ ‫پاراﻣﺘر‬ ‫ﭼﻨﺪ‬ ‫از‬ ‫بايﺪ‬ ‫شود‬‫ويرگول‬‫كﻨيم‬ ‫ﻣي‬ ‫جﺪا‬.
‫ﻣﺘﺪها‬ ‫بقيﻪ‬ ‫بﺪنﻪ‬ ‫ﻣانﻨﺪ‬ ‫جﻨريك‬ ‫ﻣﺘﺪ‬ ‫يك‬ ‫بﺪنﻪ‬‫اسﺘفاده‬ ‫نوع‬ ‫پاراﻣﺘر‬ ‫از‬ ‫شﺪ‬ ‫ﻣي‬ ‫اسﺘفاده‬ ‫آن‬ ‫از‬ ‫قبﻼ‬ ‫كﻪ‬ ‫اي‬ ‫داده‬ ‫نوع‬ ‫از‬ ‫اسﺘفاده‬ ‫جاي‬ ‫بﻪ‬ ‫فقط‬ ‫باشﺪ‬ ‫ﻣي‬
‫كﻨيم‬ ‫ﻣي‬.
Example:
public class GenericMethodTest {
public static < E > void printArray( E[] inputArray ) { // generic method printArray
for(E element : inputArray) { // Display array elements
System.out.printf("%s ", element);
}
}
public static void main(String args[]) {
Integer[] intArray = { 1, 2, 3, 4, 5 };
Double[] doubleArray = { 1.1, 2.2, 3.3, 4.4 };
Character[] charArray = { 'H', 'E', 'L', 'L', 'O' };
System.out.println("Array contains:");
printArray(intArray); // pass an Integer array
printArray(doubleArray); // pass a Double array
printArray(charArray); // pass a Character array
}
}

Generic sub-typing:
Generics doesn’t support sub-typing, so:
‫از‬ ‫اسﺘفاده‬ ‫اﻣكان‬sub-Typing:‫نﺪارد‬ ‫وجود‬ ‫جﻨريك‬ ‫نوع‬ ‫در‬
List<Number> numbers = new ArrayList<Integer>(); // compile Error
Bounded Type Parameters:
There may be times when you'll want to restrict the kinds of types that are allowed to be passed to a type parameter.
For example, a method that operates on numbers might only want to accept instances of Number or its subclasses.
This is what bounded type parameters are for.
‫خواهيﺪ‬ ‫ﻣي‬ ‫شﻤا‬ ‫كﻪ‬ ‫دارد‬ ‫وجود‬ ‫ﻣواقعي‬‫تابع‬ ‫بﻪ‬ ‫دارنﺪ‬ ‫اجازه‬ ‫كﻪ‬ ‫را‬ ‫هايي‬ ‫داده‬ ‫نوع‬Generic‫كﻨيﺪ‬ ‫ﻣحﺪود‬ ‫شونﺪ‬ ‫ارسال‬‫بﻪ‬ ‫بايﺪ‬ ‫نوع‬ ‫پاراﻣﺘر‬ ‫ﺻورت‬ ‫اين‬ ‫در‬ .
‫بر‬ .‫نﺪهﺪ‬ ‫برناﻣﻪ‬ ‫بﻪ‬ ‫اجرا‬ ‫اجازه‬ ‫باشﺪ‬ ‫نﺪاشﺘﻪ‬ ‫را‬ ‫نﻈر‬ ‫ﻣورد‬ ‫شروط‬ ‫نﻈر‬ ‫ﻣورد‬ ‫داده‬ ‫نوع‬ ‫اگر‬ ‫فراخواني‬ ‫حين‬ ‫در‬ ‫كﻪ‬ ‫باشﺪ‬ ‫اي‬ ‫گونﻪ‬‫اعﺪاد‬ ‫روي‬ ‫بر‬ ‫كﻪ‬ ‫تابع‬ ‫يك‬ ،‫ﻣثال‬ ‫اي‬
‫نوع‬ ‫از‬ ‫هايي‬ ‫داده‬ ‫تﻨها‬ ‫بﺨواهﺪ‬ ‫است‬ ‫ﻣﻤكن‬ ،‫دهﺪ‬ ‫ﻣي‬ ‫انجام‬ ‫عﻤﻠيات‬Number.‫كﻨﺪ‬ ‫قبول‬ ‫را‬ ‫آن‬ ‫فرزنﺪ‬ ‫هاي‬ ‫كﻼس‬ ‫يا‬ ‫و‬‫از‬ ‫بايﺪ‬ ‫كار‬ ‫اين‬ ‫براي‬‫با‬ ‫هاي‬ ‫پاراﻣﺘر‬
‫شﺪه‬ ‫ﻣحﺪود‬ ‫نوع‬‫كﻨيم‬ ‫اسﺘفاده‬.‫ب‬‫را‬ ‫نوع‬ ‫پاراﻣﺘر‬ ‫خود‬ ‫نام‬ ‫ابﺘﺪا‬ ‫بايﺪ‬ ‫كار‬ ‫اين‬ ‫انجام‬ ‫راي‬‫كﻠيﺪي‬ ‫كﻠﻤﻪ‬ ‫آن‬ ‫از‬ ‫بعﺪ‬ ‫و‬ ‫بياوريم‬Extends‫كﻼس‬ ‫نام‬ ‫آن‬ ‫از‬ ‫بعﺪ‬ ‫و‬
‫كﻠيﺪي‬ ‫كﻠﻤات‬ ‫از‬ ‫توان‬ ‫ﻣي‬ ‫نوع‬ ‫پاراﻣﺘرهاي‬ ‫كردن‬ ‫ﻣحﺪود‬ ‫براي‬ .‫بياوريم‬ ‫را‬ ‫پﺪر‬extends , implements.‫كرد‬ ‫اسﺘفاده‬
Example:
We know that all wrapper classes(Integer,Long,Double,Boolean .. etc) are Sub Classes of Number class
‫نوع‬ ‫از‬ ‫اي‬ ‫ﻣجﻤوعﻪ‬ ‫زير‬ ‫عﺪدي‬ ‫انواع‬ ‫هﻤﻪ‬ ‫كﻪ‬ ‫دانيم‬ ‫ﻣي‬Number.‫هسﺘﻨﺪ‬‫نوع‬ ‫از‬ ‫هايي‬ ‫داده‬ ‫تﻨها‬ ‫بﺨواهيم‬ ‫ايﻨكﻪ‬ ‫براي‬number‫زير‬ ‫شكل‬ ‫بﻪ‬ ‫بايﺪ‬ ‫بپذيريم‬ ‫را‬
:‫كﻨيم‬ ‫عﻤل‬
class BoundedTest<T extends Number>{
private T num;
public void setNum(T num) {
this.num = num;
}
public T getNum() {
return num;
}
}
public static void main(String args[]) {
BoundedTest <Integer> myVar = new BoundedTest<>(); //Correct
myVar.setNum( Integer.valueOf(10) );
Integer i = myVar.getNum();
BoundedTest<Double> u1 = new BoundedTest<Double>();//Correct
BoundedTest<String> u2 = new BoundedTest<String>();//Compile Error(String is not in bound)
}
Example:
We know that Thread class is implementation class of Runnable interface
class BoundedTest<T extends Runnable>{
}
BoundedTest<Runnable> u1 = new BoundedTest<Runnable>(); //Correct
BoundedTest<Thread> u2 = new BoundedTest<Thread>(); //Correct
BoundedTest<String> u3 = new BoundedTest<String>(); //Compile Time Error(String is not in its bound)

Generic Classes:
A generic class declaration looks like a non-generic class declaration, except that the class name is followed by a
type parameter section.
‫بين‬ ‫نوع‬ ‫پاراﻣﺘرهاي‬ ‫كﻼس‬ ‫نام‬ ‫از‬ ‫بعﺪ‬ ‫كﻪ‬ ‫است‬ ‫اين‬ ‫آن‬ ‫تفاوت‬ ‫تﻨها‬ .‫است‬ ‫ﻣعﻤولي‬ ‫كﻼس‬ ‫يك‬ ‫تعريﻒ‬ ‫بﻪ‬ ‫شبيﻪ‬ ‫بسيار‬ ‫جﻨريك‬ ‫كﻼس‬ ‫يك‬ ‫تعريﻒ‬<>‫خواهﺪ‬
.‫كﻨيم‬ ‫جﺪا‬ (,) ‫كاﻣا‬ ‫اسﺘفاده‬ ‫با‬ ‫را‬ ‫آنها‬ ‫بايﺪ‬ ‫باشيم‬ ‫داشﺘﻪ‬ ‫نوع‬ ‫پاراﻣﺘر‬ ‫يك‬ ‫از‬ ‫بيش‬ ‫اگر‬ .‫آﻣﺪ‬
: ‫نكﺘﻪ‬‫اين‬ ‫براي‬‫ﻣانﻨﺪ‬ ‫اﺻﻠي‬ ‫هاي‬ ‫داده‬ ‫انواع‬ ‫توانيم‬ ‫نﻤي‬ ‫كﻨيم‬ ‫اسﺘفاده‬ ‫جﻨريك‬ ‫ﻣﺘﺪ‬ ‫يا‬ ‫كﻼس‬ ‫از‬ ‫كﻪ‬int‫يا‬ ‫و‬double‫كﻼس‬ ‫بايﺪ‬ ‫و‬ ‫بﺪهيم‬ ‫آن‬ ‫بﻪ‬ ‫را‬
wrapper‫يعﻨي‬ ‫آنها‬Integer‫و‬Double‫دهيم‬ ‫ﻣي‬ ‫اخﺘﺼاص‬ ‫جﻨريك‬ ‫كﻼس‬ ‫بﻪ‬ ‫را‬.
Example:
public class Box<T> {
private T myVar;
public void add(T testVar) {
this.myVar = testVar;
}
public T get() {
return myVar;
}
public static void main(String[] args) {
Box<Integer> integerBox = new Box<Integer>();
Box<String> stringBox = new Box<String>();
integerBox.add(new Integer(10));
stringBox.add(new String("Hello World"));
System.out.printf("Integer Value :%dnn", integerBox.get());
System.out.printf("String Value :%sn", stringBox.get());
}
}
Example2:
‫كنيد‬ ‫فﺮض‬‫ليستهاي‬‫پيوندي‬‫كنيم‬ ‫سازي‬ ‫پياده‬ ‫را‬،‫ليست‬ ‫ﻫاي‬ ‫گﺮه‬ ‫ﺑﺮاي‬‫يك‬‫كﻼس‬‫ﺑا‬‫نام‬Node‫تعﺮيف‬‫ﻫ‬ ،‫كنيم‬ ‫ﻣي‬‫ﺮ‬‫گﺮه‬‫دو‬‫فيلد‬‫ﻣهم‬‫دارد‬:
1(‫ﻣقدار‬‫كﻪ‬ ‫گﺮه‬‫از‬‫ﻫﺮ‬‫نوعي‬‫ﻣي‬‫تواند‬‫ﺑاﺷد‬.٢(‫آدرس‬‫گﺮه‬‫ﺑعدي‬
public class Node <E> {
E item;
Node<E> nextElement;
public void Node(E item, Node<E> nextElement) {
this.item= item;
this. nextElement = nextElement;
}
}
Node<String> last= new Node("Taghi", null);
Node<String> first= new Node("Ali", last);

Generic Classes and Subtyping
We can subtype a generic class or interface by extending or implementing it.
‫اﻣكان‬subtype.‫دارد‬ ‫وجود‬ ‫جﻨريك‬ ‫كﻼسهاي‬ ‫از‬ ‫گرفﺘن‬
Example:
ArrayList<E> implements List<E> that extends Collection<E>
So:
ArrayList<String> is a subtype of List<String> and List<String> is subtype of Collection<String>.
Raw Type:
‫انواع‬‫داده‬‫عام‬‫را‬‫بﺪون‬‫پاراﻣﺘر‬ ‫تﺼريح‬‫نوع‬‫هم‬‫ﻣي‬‫توان‬‫اسﺘفاده‬.‫گويﻨﺪ‬ ‫خام‬ ‫داده‬ ‫نوع‬ ‫آن‬ ‫بﻪ‬ ‫كﻪ‬ ‫كرد‬‫در‬‫اين‬،‫ﺻورت‬‫كاﻣپايﻠر‬ِ‫ل‬‫حﺪاق‬‫ﻣحﺪوديت‬‫ﻣﻤكن‬
‫را‬‫براي‬‫اين‬‫انواع‬‫اعﻤال‬‫ﻣي‬‫كﻨﺪ‬.
ArrayListlist= new ArrayList();
list.add("A");
list.add(new Integer(5));
list.add(new Character('#'));
Wildcards:
In generic code, the question mark (?), called the wildcard, represents an unknown type. The wildcard can be used
in a variety of situations: as the type of a parameter, field, or local variable; sometimes as a return type.
The wildcard is never used as a type argument for a generic method invocation, a generic class instance creation,
or a supertype.
‫داده‬ ‫نوع‬ ‫يك‬ ‫عﻨوان‬ ‫بﻪ‬ ‫؟‬ ‫عﻼﻣت‬ ،‫نويسي‬ ‫برناﻣﻪ‬ ‫در‬ ‫عﻤوﻣي‬ ‫حالت‬ ‫در‬‫يا‬ ‫ناﻣشﺨص‬wildcard.‫شود‬ ‫ﻣي‬ ‫شﻨاخﺘﻪ‬Wildcard‫از‬ ‫ﻣﺨﺘﻠفي‬ ‫هاي‬ ‫ﻣوقعيت‬ ‫در‬
‫ر‬ ‫ﻣي‬ ‫كار‬ ‫بﻪ‬ ‫برگشﺘي‬ ‫ﻣقادير‬ ‫براي‬ ‫داده‬ ‫نوع‬ ‫يك‬ ‫عﻨوان‬ ‫بﻪ‬ ‫هم‬ ‫ﻣواقع‬ ‫بعضي‬ .‫شود‬ ‫ﻣي‬ ‫اسﺘفاده‬ ‫ﻣحﻠي‬ ‫ﻣﺘغير‬ ‫يك‬ ‫يا‬ ،‫فيﻠﺪ‬ ،‫پاراﻣﺘر‬ ‫يك‬ ‫نوع‬ ‫قبيل‬.‫ود‬
.‫كﻨﺪ‬ ‫ﻣي‬ ‫ايجاد‬ ‫خﻄا‬ ‫كاﻣپايل‬ ‫هﻨگام‬ ‫دسﺘور‬ ‫اين‬ ،‫بگيريﺪ‬ ‫نﻈر‬ ‫در‬ ‫را‬ ‫زير‬ ‫دسﺘور‬‫نوع‬ ‫كﻪ‬ ‫زيرا‬String‫نوع‬ ‫از‬Object‫نيست‬:
ArrayList<Object> lst = new ArrayList<String>(); // Compilation Error
: ‫داريم‬ ‫نيز‬ ‫زير‬ ‫حالت‬ ‫براي‬ ‫هﻤچﻨين‬
List<String> strLst = new ArrayList<String>(); // 1
List<Object> objLst = strList; // 2 - Compilation Error
To resolve this problem, a wildcard (?) is provided in generics, which stands for any unknown type.
‫نوع‬ ‫از‬ ، ‫ﻣشكل‬ ‫اين‬ ‫حل‬ ‫براي‬wildcard‫كﻨيم‬ ‫ﻣي‬ ‫اسﺘفاده‬‫باشيم‬ ‫داشﺘﻪ‬ ‫ناﻣشﺨص‬ ‫داده‬ ‫نوع‬ ‫بﺘوانيم‬ ‫كﻪ‬.

Unbounded Wildcards:
‫نوع‬wildcard)‫ﻣحﺪوديت‬ ‫آن‬ ‫براي‬ ‫توان‬ ‫ﻣي‬ ‫هم‬ ‫و‬ ‫برد‬ ‫كار‬ ‫بﻪ‬ ‫ﻣحﺪوديت‬ ‫بﺪون‬ ‫توان‬ ‫ﻣي‬ ‫هم‬ ‫را‬bound‫نوع‬ ‫اگر‬ .‫كرد‬ ‫ايجاد‬ (wildcard‫ﻣحﺪوديت‬ ‫بﺪون‬ ‫را‬
‫آن‬ ‫بﻪ‬ ، ‫كﻨيم‬ ‫تعريﻒ‬unbounded wildcard‫ﻣثال‬ ‫عﻨوان‬ ‫بﻪ‬ .‫گوييم‬ ‫ﻣي‬‫ﻣي‬ ‫كﻪ‬ ‫بگيرد‬ ‫نﻈر‬ ‫در‬ ‫را‬ ‫زير‬ ‫ﻣﺘﺪ‬‫ﭼاپ‬ ‫براي‬ ‫آن‬ ‫بﻪ‬ ‫را‬ ‫دلﺨواه‬ ‫داده‬ ‫نوع‬ ‫هر‬ ‫توان‬
‫كرد‬ ‫ارسال‬ ‫شﺪن‬:
public static void printList(List<?> list){
for(Object obj : list){
System.out.print(obj);
}
}
Upper bound Wildcards: <? extends type>
‫نوع‬ ‫براي‬ ‫اگر‬wildcard‫روش‬ ‫از‬ ‫كﻨيم‬ ‫كﻤﺘر‬ ‫را‬ ‫ﻣحﺪوديت‬ ‫بﺨواهيم‬Upper bound Wildcards.‫كﻨيم‬ ‫ﻣي‬ ‫اسﺘفاده‬
‫كﻠﻤﻪ‬extend‫دهﻨﺪه‬ ‫نشان‬Upper bound Wildcards‫ﻣﺘﺪ‬ ‫خواهيم‬ ‫ﻣي‬ ‫زير‬ ‫ﻣثال‬ ‫در‬ .‫باشﺪ‬ ‫ﻣي‬printlist‫فقط‬‫يعﻨي‬ ،‫كﻨﺪ‬ ‫ﭼاپ‬ ‫را‬ ‫عﺪدي‬ ‫نوع‬ ‫از‬ ‫ﻣقادير‬
.‫باشﺪ‬ ‫نﺪاشﺘﻪ‬ ‫اعﺪاد‬ ‫براي‬ ‫ﻣحﺪوديﺘي‬
public static void printList(List<? Extends Number> list){
for(Object obj : list){
System.out.print(obj);
}
}
Lower bound Wildcards: <? super type>
‫بﺨواهيم‬ ‫اگر‬wildcard‫كﻠﻤﻪ‬ ‫از‬ ‫بپذيرد‬ ‫را‬ ‫آن‬ ‫باﻻدسﺘي‬ ‫نوعهاي‬ ‫و‬ ‫نوع‬ ‫خود‬ ‫كﻪ‬ ‫باشﺪ‬ ‫اي‬ ‫گونﻪ‬ ‫بﻪ‬super‫را‬ ‫روش‬ ‫اين‬ ‫و‬ ‫كﻨيم‬ ‫ﻣي‬ ‫اسﺘفاده‬ ‫آن‬ ‫تعيين‬ ‫براي‬
lower bound Wildcards‫نوع‬ ‫كﻪ‬ ‫باشيم‬ ‫داشﺘﻪ‬ ‫ليسﺘي‬ ‫خواهيم‬ ‫ﻣي‬ ‫كﻨيﺪ‬ ‫فرض‬ ‫ﻣثﻼ‬ .‫ناﻣيم‬ ‫ﻣي‬Integer‫نوع‬ ‫يعﻨي‬ ‫آن‬ ‫باﻻدسﺘي‬ ‫نوعهاي‬ ‫اﻣا‬ ،‫بپذيرد‬ ‫را‬
Number‫نوع‬ ‫و‬Object:‫كﻨيم‬ ‫ﻣي‬ ‫عﻤل‬ ‫زير‬ ‫بﺼورت‬ ‫حالت‬ ‫اين‬ ‫براي‬ ،‫باشﺪ‬ ‫عﺪد‬ ‫شاﻣل‬ ‫توانﺪ‬ ‫ﻣي‬ ‫هم‬
public static void addIntegers(List<? super Integer> list){
list.add(new Integer(50));
}
Subtyping using Generics Wildcard:
‫از‬ ‫ﻣجﻤوعﻪ‬ ‫زير‬ ‫يك‬ ‫دهي‬ ‫ﻣقﺪار‬wildcard:‫باشﺪ‬ ‫ﻣي‬ ‫پذير‬ ‫اﻣكان‬ ‫خودش‬ ‫از‬ ‫باﻻتر‬ ‫ﻣجﻤوعﻪ‬ ‫بﻪ‬
List<? extends Integer> intList = new ArrayList<>();
List<? extends Number> numList = intList; // OK.
// List<? extends Integer> is a subtype of List<? extends Number>

Erasure: ‫حو‬َ‫م‬ ‫فرايند‬
‫اگر‬‫از‬‫يك‬»‫پاراﻣﺘر‬‫نوع‬«‫براي‬‫ايجاد‬‫يك‬‫شيء‬‫اسﺘفاده‬،‫كﻨيم‬‫اين‬»‫پاراﻣﺘر‬‫نوع‬«‫توسط‬ ‫فقط‬‫كاﻣپايﻠر‬‫ﭼك‬‫ﻣ‬‫ي‬‫شود‬‫حقيقت‬ ‫در‬ .‫كﻨﺘرل‬‫انواع‬‫داده‬‫عام‬
‫فقط‬‫ﻣربوط‬‫بﻪ‬‫زﻣان‬‫كاﻣپايل‬‫است‬) ‫شﺪه‬ ‫كاﻣپايل‬ ‫فايل‬ ‫در‬ ‫و‬.class‫و‬ (‫در‬‫زﻣان‬،‫اجرا‬‫اطﻼع‬‫و‬‫اثري‬‫از‬‫پاراﻣﺘر‬‫نوع‬Type Parameter‫نيست‬.ً‫ﻼ‬‫ﻣث‬‫در‬‫زﻣان‬
‫اجرا‬‫ﻣعﻠوم‬‫نيست‬‫كﻪ‬‫يك‬‫شيء‬‫از‬‫نوع‬List‫بﻪ‬‫شكل‬List<String>‫ايجاد‬( new )‫شﺪه‬‫يا‬‫بﻪ‬‫شكل‬List<Integer>.
‫در‬‫واقع‬‫هﻤﻪ‬‫انواع‬،‫عام‬‫بﻪ‬‫ﺻور‬‫ت‬‫نوع‬‫خام‬)raw type(‫خود‬‫ترجﻤﻪ‬‫ﻣي‬‫شونﺪ‬.‫بﻪ‬‫اين‬‫رفﺘار‬‫جاوا‬‫در‬‫قبال‬‫انواع‬،‫عام‬‫فرايﻨﺪ‬‫َحو‬‫ﻣ‬( Erasure )‫گفﺘﻪ‬‫ﻣي‬
‫شود‬.
Example:
‫كﺪ‬‫ترجﻤﻪ‬‫شﺪه‬‫هر‬‫ﭼهار‬‫دسﺘور‬‫زير‬‫در‬byte code‫يكسان‬‫است‬‫شود‬ ‫ﻣي‬ ‫كﻨﺘرل‬ ‫و‬ ‫است‬ ‫ﻣﺘفاوت‬ ‫كاﻣپايل‬ ‫زﻣان‬ ‫در‬ ‫اﻣا‬ ،‫كاﻣپايﻠر‬ ‫اول‬ ‫دسﺘور‬ ‫براي‬ ‫ﻣثﻼ‬ ،
‫دسﺘور‬ ‫هﻨگام‬ ‫كﻪ‬ ‫ﻣيكﻨﺪ‬ ‫كﻨﺘرل‬add‫حﺘﻤا‬ ‫شﺪه‬ ‫افزوده‬ ‫ﻣقﺪار‬ ،‫آن‬ ‫بﻪ‬ ‫ﻣقﺪار‬ ‫يك‬ ‫افزودن‬ ‫براي‬String‫ﺻادق‬ ‫نيز‬ ‫سوم‬ ‫و‬ ‫دوم‬ ‫دسﺘور‬ ‫براي‬ ‫ﻣسالﻪ‬ ‫هﻤين‬ .‫باشﺪ‬
‫است‬‫كاﻣپايل‬ ‫بعﺪ‬ ‫و‬ ‫قبل‬ ‫حالت‬ ‫حقيقت‬ ‫در‬ ‫و‬ ‫گگيرد‬ ‫نﻤي‬ ‫ﺻورت‬ ‫كاﻣپايﻠر‬ ‫تسوط‬ ‫آن‬ ‫براي‬ ‫نيز‬ ‫كﻨﺘرلي‬ ‫نشﺪه‬ ‫ﻣشﺨص‬ ‫آن‬ ‫براي‬ ‫نوعي‬ ‫ﭼون‬ ‫آخر‬ ‫دسﺘور‬ ‫اﻣا‬ ،‫آن‬
‫است‬ ‫يكي‬:
ArrayList<String> list = new ArrayList<>();
ArrayList<Integer> list = new ArrayList<>();
ArrayList<Object> list = new ArrayList<>();
ArrayListlist = new ArrayList(); // raw type

Java Generics

More Related Content

More from Hamid Ghorbani (13)

Java Generics