ה Java Generics תכנות מוצג ב-J2SE 5 כדי להתמודד עם אובייקטים בטוחי סוג. זה הופך את הקוד ליציב על ידי זיהוי הבאגים בזמן ההידור.

יוניקס לעומת חלונות

לפני הגנריות, אנו יכולים לאחסן כל סוג של אובייקטים באוסף, כלומר, לא גנרי. כעת גנריות מאלצות את מתכנת ה-Java לאחסן סוג מסוים של אובייקטים.

היתרון של Java Generics

ישנם בעיקר 3 יתרונות של תרופות גנריות. הם כדלקמן:

1) סוג בטיחות: אנחנו יכולים להחזיק רק סוג יחיד של אובייקטים בגנריות. זה לא מאפשר לאחסן חפצים אחרים.

ללא Generics, אנו יכולים לאחסן כל סוג של חפצים.

 List list = new ArrayList(); list.add(10); list.add('10'); With Generics, it is required to specify the type of object we need to store. List list = new ArrayList(); list.add(10); list.add('10');// compile-time error 

2) לא נדרשת יציקה מסוג: אין צורך להקרין את האובייקט.

לפני Generics, אנחנו צריכים להקליד קאסט.

 List list = new ArrayList(); list.add('hello'); String s = (String) list.get(0);//typecasting After Generics, we don't need to typecast the object. List list = new ArrayList(); list.add('hello'); String s = list.get(0); 

3) בדיקת זמן קומפילציה: זה נבדק בזמן ההידור כך שהבעיה לא תתרחש בזמן ריצה. אסטרטגיית התכנות הטובה אומרת שעדיף לטפל בבעיה בזמן קומפילציה מאשר זמן ריצה.

 List list = new ArrayList(); list.add('hello'); list.add(32);//Compile Time Error 

תחביר להשתמש באוסף גנרי

 ClassOrInterface 

דוגמא להשתמש ב-Generics ב-java

 ArrayList 

דוגמה מלאה לגנריות ב-Java

כאן, אנו משתמשים במחלקה ArrayList, אך אתה יכול להשתמש בכל מחלקת אוסף כגון ArrayList, LinkedList, HashSet, TreeSet, HashMap, Comparator וכו'.

 import java.util.*; class TestGenerics1{ public static void main(String args[]){ ArrayList list=new ArrayList(); list.add('rahul'); list.add('jai'); //list.add(32);//compile time error String s=list.get(1);//type casting is not required System.out.println('element is: '+s); Iterator itr=list.iterator(); while(itr.hasNext()){ System.out.println(itr.next()); } } } 

 import java.util.*; class TestGenerics1{ public static void main(String args[]){ ArrayList list=new ArrayList(); list.add('rahul'); list.add('jai'); //list.add(32);//compile time error String s=list.get(1);//type casting is not required System.out.println('element is: '+s); Iterator itr=list.iterator(); while(itr.hasNext()){ System.out.println(itr.next()); } } } 

תְפוּקָה:

 element is: jai rahul jai 

דוגמה ל-Java Generics באמצעות מפה

כעת אנו הולכים להשתמש ברכיבי מפה באמצעות גנריות. כאן, אנחנו צריכים להעביר מפתח וערך. הבה נבין זאת באמצעות דוגמה פשוטה:

 import java.util.*; class TestGenerics2{ public static void main(String args[]){ Map map=new HashMap(); map.put(1,&apos;vijay&apos;); map.put(4,&apos;umesh&apos;); map.put(2,&apos;ankit&apos;); //Now use Map.Entry for Set and Iterator Set<map.entry> set=map.entrySet(); Iterator<map.entry> itr=set.iterator(); while(itr.hasNext()){ Map.Entry e=itr.next();//no need to typecast System.out.println(e.getKey()+&apos; &apos;+e.getValue()); } }} </map.entry></map.entry>

תְפוּקָה

התייחסות לסוגי נתונים ב-java

 1 vijay 2 ankit 4 umesh 

מחלקה גנרית

מחלקה שיכולה להתייחס לכל סוג ידועה כמחלקה גנרית. כאן, אנו משתמשים בפרמטר T type כדי ליצור את המחלקה הגנרית מסוג ספציפי.

בואו נראה דוגמה פשוטה ליצירה ולהשתמש במחלקה הגנרית.

יצירת מחלקה גנרית:

 class MyGen{ T obj; void add(T obj){this.obj=obj;} T get(){return obj;} } 

הסוג T מציין שהוא יכול להתייחס לכל סוג (כמו מחרוזת, מספר שלם ועובד). הסוג שתציין עבור המחלקה ישמש לאחסון ואחזור הנתונים.

שימוש במחלקה גנרית:

בוא נראה את הקוד לשימוש במחלקה הגנרית.

 class TestGenerics3{ public static void main(String args[]){ MyGen m=new MyGen(); m.add(2); //m.add('vivek');//Compile time error System.out.println(m.get()); }} 

תְפוּקָה

 2 

סוג פרמטרים

מוסכמות השמות של פרמטרי הסוג חשובים כדי ללמוד גנריות ביסודיות. פרמטרי הסוג הנפוצים הם כדלקמן:

java אופס מושגים

1. T - סוג
2. E - אלמנט
3. K - מפתח
4. N - מספר
5. V - ערך

שיטה גנרית

כמו המחלקה הגנרית, אנו יכולים ליצור שיטה גנרית שיכולה לקבל כל סוג של טיעונים. כאן, היקף הטיעונים מוגבל לשיטה שבה הוא מוצהר. זה מאפשר שיטות סטטיות וגם לא סטטיות.

בואו נראה דוגמה פשוטה של ​​שיטה גנרית ג'אווה להדפסת רכיבי מערך. אנחנו משתמשים כאן ו כדי לציין את האלמנט.

 public class TestGenerics4{ public static void printArray(E[] elements) { for ( E element : elements){ System.out.println(element ); } System.out.println(); } public static void main( String args[] ) { Integer[] intArray = { 10, 20, 30, 40, 50 }; Character[] charArray = { 'J', 'A', 'V', 'A', 'T','P','O','I','N','T' }; System.out.println( 'Printing Integer Array' ); printArray( intArray ); System.out.println( 'Printing Character Array' ); printArray( charArray ); } } 

תְפוּקָה

 Printing Integer Array 10 20 30 40 50 Printing Character Array J A V A T P O I N T 

תו כללי ב-Java Generics

ה ? סמל (סימן שאלה) מייצג את רכיב התו הכללי. זה אומר כל סוג. אם נכתוב , הכוונה היא לכל כיתת צאצא של מספר, למשל, מספר שלם, צף וכפול. כעת אנו יכולים לקרוא למתודה של מחלקת Number דרך כל אובייקט מחלקה ילד.

אנחנו יכולים להשתמש בתו כללי בתור א סוג של פרמטר, שדה, סוג החזרה או משתנה מקומי. עם זאת, אסור להשתמש בתווים כלליים כארגומנט סוג עבור הפעלת שיטה גנרית, יצירת מופע מחלקה גנרית או טיפוס על .

בואו נבין את זה לפי הדוגמה המובאת להלן:

 import java.util.*; abstract class Shape{ abstract void draw(); } class Rectangle extends Shape{ void draw(){System.out.println('drawing rectangle');} } class Circle extends Shape{ void draw(){System.out.println('drawing circle');} } class GenericTest{ //creating a method that accepts only child class of Shape public static void drawShapes(List lists){ for(Shape s:lists){ s.draw();//calling method of Shape class by child class instance } } public static void main(String args[]){ List list1=new ArrayList(); list1.add(new Rectangle()); List list2=new ArrayList(); list2.add(new Circle()); list2.add(new Circle()); drawShapes(list1); drawShapes(list2); }} 

תְפוּקָה

 drawing rectangle drawing circle drawing circle 

תווים כלליים בעלי גבול עליון

המטרה של תווים כלליים בגבולות העליונים היא להקטין את ההגבלות על משתנה. זה מגביל את הסוג הלא ידוע להיות סוג מסוים או תת-סוג מסוג זה. הוא משמש על ידי הצהרת תו כללי ('?') ואחריו מילת המפתח מרחיב (במקרה של, מחלקה) או מיישם (במקרה של ממשק), ואחריו הגבול העליון שלה.

תחביר

 List 

כאן,

? הוא תו כללי.

משתרע , היא מילת מפתח.

מספר , הוא מחלקה הקיימת בחבילת java.lang

נניח שאנו רוצים לכתוב את השיטה עבור רשימת המספר ותתי-הסוגים שלו (כמו מספר שלם, כפול). באמצעות רשימה מתאים לרשימה מסוג Number או כל תת-מחלקות שלו ואילו רשימה עובד עם רשימת הסוג מספר בלבד. כך, רשימה הוא פחות מגביל מאשר רשימה .

מיון מהיר

דוגמה לתווים כלליים לתחום הגבול העליון

בדוגמה זו, אנו משתמשים בתווים כלליים של הגבול העליון כדי לכתוב את השיטה עבור רשימה ורשימה.

 import java.util.ArrayList; public class UpperBoundWildcard { private static Double add(ArrayList num) { double sum=0.0; for(Number n:num) { sum = sum+n.doubleValue(); } return sum; } public static void main(String[] args) { ArrayList l1=new ArrayList(); l1.add(10); l1.add(20); System.out.println('displaying the sum= '+add(l1)); ArrayList l2=new ArrayList(); l2.add(30.0); l2.add(40.0); System.out.println('displaying the sum= '+add(l2)); } } 

תְפוּקָה

 displaying the sum= 30.0 displaying the sum= 70.0 

תווים כלליים ללא גבולות

סוג התווים הכלליים הלא מוגבלים מייצג את הרשימה של סוג לא ידוע כגון רשימה. גישה זו יכולה להיות שימושית בתרחישים הבאים: -

• כאשר השיטה הנתונה מיושמת על ידי שימוש בפונקציונליות הניתנת במחלקה Object.
• כאשר המחלקה הגנרית מכילה את השיטות שאינן תלויות בפרמטר הסוג.

דוגמה לתווים כלליים ללא גבולות

 import java.util.Arrays; import java.util.List; public class UnboundedWildcard { public static void display(List list) { for(Object o:list) { System.out.println(o); } } public static void main(String[] args) { List l1=Arrays.asList(1,2,3); System.out.println('displaying the Integer values'); display(l1); List l2=Arrays.asList('One','Two','Three'); System.out.println('displaying the String values'); display(l2); } } 

תְפוּקָה

 displaying the Integer values 1 2 3 displaying the String values One Two Three 

תווים כלליים בעלי גבול נמוך יותר

המטרה של תווים כלליים בעלי גבולות תחתונים היא להגביל את הסוג הלא ידוע להיות סוג ספציפי או טיפוס על מסוג זה. הוא משמש על ידי הצהרת תו כללי ('?') ואחריו מילת המפתח העל, ואחריו הגבול התחתון שלו.

תחביר

 List 

כאן,

? הוא תו כללי.

סוּפֶּר , היא מילת מפתח.

מספר שלם , הוא שיעור עטיפה.

מילת מפתח סטטית ב-java

נניח, ברצוננו לכתוב את השיטה עבור הרשימה של מספר שלם וסוג העל שלו (כמו מספר, אובייקט). באמצעות רשימה מתאים לרשימה מסוג Integer או כל אחת ממחלקות העל שלו ואילו רשימה עובד עם הרשימה מסוג מספר שלם בלבד. כך, רשימה הוא פחות מגביל מאשר רשימה .

דוגמה לתווים כלליים של סף תחתון

בדוגמה זו, אנו משתמשים בתווים כלליים של הגבול התחתון כדי לכתוב את השיטה עבור רשימה ורשימה.

 import java.util.Arrays; import java.util.List; public class LowerBoundWildcard { public static void addNumbers(List list) { for(Object n:list) { System.out.println(n); } } public static void main(String[] args) { List l1=Arrays.asList(1,2,3); System.out.println('displaying the Integer values'); addNumbers(l1); List l2=Arrays.asList(1.0,2.0,3.0); System.out.println('displaying the Number values'); addNumbers(l2); } } 

תְפוּקָה

 displaying the Integer values 1 2 3 displaying the Number values 1.0 2.0 3.0