ಜಾವಾ ಜೆನೆರಿಕ್ಸ್ ಟ್ಯುಟೋರಿಯಲ್ - ಜೆನೆರಿಕ್ಸ್ ಎಂದರೇನು ಮತ್ತು ಅವುಗಳನ್ನು ಹೇಗೆ ಬಳಸುವುದು?

ಜಾವಾ ಜೆನೆರಿಕ್ಸ್ ಜಾವಾ ಭಾಷೆಯ ಪ್ರಮುಖ ಲಕ್ಷಣಗಳಲ್ಲಿ ಒಂದಾಗಿದೆ. ಜೆನೆರಿಕ್ಸ್‌ನ ಹಿಂದಿನ ಕಲ್ಪನೆಯು ತುಂಬಾ ಸರಳವಾಗಿದೆ, ಆದಾಗ್ಯೂ, ಅದರೊಂದಿಗೆ ಸಂಬಂಧಿಸಿದ ಸಾಮಾನ್ಯ ಸಿಂಟ್ಯಾಕ್ಸ್‌ನಿಂದ ಸ್ಥಳಾಂತರಗೊಂಡ ಕಾರಣ ಇದು ಕೆಲವೊಮ್ಮೆ ಸಂಕೀರ್ಣವಾಗಿದೆ.

ಈ ಟ್ಯುಟೋರಿಯಲ್ ನ ಉದ್ದೇಶವು ಜೆನೆರಿಕ್ಸ್ನ ಈ ಉಪಯುಕ್ತ ಪರಿಕಲ್ಪನೆಯನ್ನು ಸುಲಭವಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ರೀತಿಯಲ್ಲಿ ನಿಮಗೆ ಪರಿಚಯಿಸುವುದು.

ಆದರೆ ಜೆನೆರಿಕ್ಸ್‌ಗೆ ಧುಮುಕುವ ಮೊದಲು, ಜಾವಾ ಜೆನೆರಿಕ್ಸ್ ಮೊದಲ ಸ್ಥಾನದಲ್ಲಿ ಏಕೆ ಬೇಕು ಎಂದು ಕಂಡುಹಿಡಿಯೋಣ.

ಜಾವಾ ಜೆನೆರಿಕ್ಸ್ ಉದ್ದೇಶ

ಜಾವಾ 5 ರಲ್ಲಿ ಜೆನೆರಿಕ್ಸ್ ಅನ್ನು ಪರಿಚಯಿಸುವ ಮೊದಲು, ದೋಷ ಅಥವಾ ಎಚ್ಚರಿಕೆಯನ್ನು ಎಸೆಯದೆ ನೀವು ಈ ರೀತಿಯ ಕೋಡ್ ತುಣುಕನ್ನು ಬರೆಯಬಹುದು ಮತ್ತು ಕಂಪೈಲ್ ಮಾಡಬಹುದು:

List list = new ArrayList(); list.add('hey'); list.add(new Object());

ಯಾವುದೇ ರೀತಿಯ ಡೇಟಾವನ್ನು ಅದು ಸಂಗ್ರಹಿಸುತ್ತದೆ ಎಂದು ಘೋಷಿಸದೆ ನೀವು ಯಾವುದೇ ಪ್ರಕಾರದ ಮೌಲ್ಯಗಳನ್ನು ಪಟ್ಟಿಗೆ ಅಥವಾ ಇನ್ನೊಂದು ಜಾವಾ ಸಂಗ್ರಹಕ್ಕೆ ಸೇರಿಸಬಹುದು. ಆದರೆ ನೀವು ಪಟ್ಟಿಯಿಂದ ಮೌಲ್ಯಗಳನ್ನು ಹಿಂಪಡೆಯುವಾಗ, ನೀವು ಅದನ್ನು ನಿರ್ದಿಷ್ಟ ಪ್ರಕಾರಕ್ಕೆ ಸ್ಪಷ್ಟವಾಗಿ ಬಿತ್ತರಿಸಬೇಕು.

ಮೇಲಿನ ಪಟ್ಟಿಯ ಮೂಲಕ ಪುನರಾವರ್ತಿಸುವುದನ್ನು ಪರಿಗಣಿಸಿ.

for (int i=0; i< list.size(); i++) {
String value = (String) list.get(i); //CastClassException when i=1 }

ನಾವು ಮಾಡಿದಂತೆ, ಸಂಗ್ರಹಿಸಿದ ಡೇಟಾ ಪ್ರಕಾರವನ್ನು ಮೊದಲು ಘೋಷಿಸದೆ ಪಟ್ಟಿಯನ್ನು ರಚಿಸಲು ಅನುಮತಿಸುವುದರಿಂದ, ಪ್ರೋಗ್ರಾಮರ್ಗಳು ಮೇಲಿನಂತಹ ತಪ್ಪುಗಳನ್ನು ಮಾಡಬಹುದು ClassCastExceptions ಚಾಲನೆಯ ಸಮಯದಲ್ಲಿ.

ಪ್ರೋಗ್ರಾಮರ್ಗಳು ಇಂತಹ ತಪ್ಪುಗಳನ್ನು ಮಾಡದಂತೆ ತಡೆಯಲು ಜೆನೆರಿಕ್ಸ್ ಅನ್ನು ಪರಿಚಯಿಸಲಾಯಿತು.

ಜೆನೆರಿಕ್ಸ್ನೊಂದಿಗೆ, ಜಾವಾ ಸಂಗ್ರಹವನ್ನು ರಚಿಸುವಾಗ ಸಂಗ್ರಹಿಸಬೇಕಾದ ಡೇಟಾ ಪ್ರಕಾರವನ್ನು ನೀವು ಈ ಕೆಳಗಿನ ಉದಾಹರಣೆಯಲ್ಲಿ ತೋರಿಸಿದಂತೆ ಸ್ಪಷ್ಟವಾಗಿ ಘೋಷಿಸಬಹುದು.

ಸೂಚನೆ:ಸಂಗ್ರಹಿಸಿದ ಡೇಟಾ ಪ್ರಕಾರವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸದೆ ನೀವು ಇನ್ನೂ ಜಾವಾ ಸಂಗ್ರಹ ವಸ್ತುವನ್ನು ರಚಿಸಬಹುದು ಆದರೆ ಅದನ್ನು ಶಿಫಾರಸು ಮಾಡುವುದಿಲ್ಲ. List stringList = new ArrayList();

ಈಗ, ಕಂಪೈಲ್-ಸಮಯದ ದೋಷವನ್ನು ಎಸೆಯದೆ ನೀವು ಇಂಟಿಜರ್ ಅನ್ನು ಸ್ಟ್ರಿಂಗ್ ಪ್ರಕಾರದ ಪಟ್ಟಿಯಲ್ಲಿ ತಪ್ಪಾಗಿ ಸಂಗ್ರಹಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ. ನಿಮ್ಮ ಪ್ರೋಗ್ರಾಂ ರನ್ಟೈಮ್ ದೋಷಗಳಿಗೆ ಒಳಗಾಗುವುದಿಲ್ಲ ಎಂದು ಇದು ಖಚಿತಪಡಿಸುತ್ತದೆ.

stringList.add(new Integer(4)); //Compile time Error

ಜಾವಾಕ್ಕೆ ಜೆನೆರಿಕ್ಸ್ ಅನ್ನು ಪರಿಚಯಿಸುವ ಮುಖ್ಯ ಉದ್ದೇಶವೆಂದರೆ ClassCastExceptions ಚಾಲನೆಯ ಸಮಯದಲ್ಲಿ.

ಜಾವಾ ಜೆನೆರಿಕ್ಸ್ ರಚಿಸಲಾಗುತ್ತಿದೆ

ಜಾವಾ ತರಗತಿಗಳು ಮತ್ತು ವಿಧಾನಗಳನ್ನು ರಚಿಸಲು ನೀವು ಜೆನೆರಿಕ್ಸ್ ಅನ್ನು ಬಳಸಬಹುದು. ಪ್ರತಿಯೊಂದು ಪ್ರಕಾರದ ಜೆನೆರಿಕ್ಸ್ ಅನ್ನು ಹೇಗೆ ರಚಿಸುವುದು ಎಂಬುದರ ಉದಾಹರಣೆಗಳನ್ನು ನೋಡೋಣ.

ಜೆನೆರಿಕ್ ವರ್ಗ

ಜೆನೆರಿಕ್ ವರ್ಗವನ್ನು ರಚಿಸುವಾಗ, ವರ್ಗದ ಪ್ರಕಾರದ ನಿಯತಾಂಕವನ್ನು ವರ್ಗ ಹೆಸರಿನ ಕೊನೆಯಲ್ಲಿ ಕೋನದಲ್ಲಿ ಸೇರಿಸಲಾಗುತ್ತದೆ ಆವರಣಗಳು.

public class GenericClass {
private T item;
public void setItem(T item) {
this.item = item;
}
public T getItem() {
return this.item;
} }

ಇಲ್ಲಿ, T ಡೇಟಾ ಪ್ರಕಾರದ ನಿಯತಾಂಕವಾಗಿದೆ. T, N, ಮತ್ತು E ಜಾವಾ ಸಂಪ್ರದಾಯಗಳ ಪ್ರಕಾರ ಡೇಟಾ ಪ್ರಕಾರದ ನಿಯತಾಂಕಗಳಿಗಾಗಿ ಬಳಸುವ ಕೆಲವು ಅಕ್ಷರಗಳು.

ಮೇಲಿನ ಉದಾಹರಣೆಯಲ್ಲಿ, ಜೆನೆರಿಕ್ ಕ್ಲಾಸ್ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ರಚಿಸುವಾಗ ನೀವು ಅದನ್ನು ನಿರ್ದಿಷ್ಟ ಡೇಟಾ ಪ್ರಕಾರವನ್ನು ರವಾನಿಸಬಹುದು.

public static void main(String[] args) {
GenericClass gc1 = new GenericClass();
gc1.setItem('hello');
String item1 = gc1.getItem(); // 'hello'
gc1.setItem(new Object()); //Error
GenericClass gc2 = new GenericClass();
gc2.setItem(new Integer(1));
Integer item2 = gc2.getItem(); // 1
gc2.setItem('hello'); //Error }

ಜೆನೆರಿಕ್ ಕ್ಲಾಸ್ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ರಚಿಸುವಾಗ ನೀವು ಪ್ರಾಚೀನ ಡೇಟಾ ಪ್ರಕಾರವನ್ನು ಡೇಟಾ ಪ್ರಕಾರದ ನಿಯತಾಂಕಕ್ಕೆ ರವಾನಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ. ಆಬ್ಜೆಕ್ಟ್ ಪ್ರಕಾರವನ್ನು ವಿಸ್ತರಿಸುವ ಡೇಟಾ ಪ್ರಕಾರಗಳನ್ನು ಮಾತ್ರ ಟೈಪ್ ನಿಯತಾಂಕಗಳಾಗಿ ರವಾನಿಸಬಹುದು.

ಉದಾಹರಣೆಗೆ:

GenericClass gc3 = new GenericClass(); //Error

ಜೆನೆರಿಕ್ ವಿಧಾನಗಳು

ಜೆನೆರಿಕ್ ವಿಧಾನಗಳನ್ನು ರಚಿಸುವುದು ಜೆನೆರಿಕ್ ತರಗತಿಗಳನ್ನು ರಚಿಸಲು ಇದೇ ಮಾದರಿಯನ್ನು ಅನುಸರಿಸುತ್ತದೆ. ನೀವು ಜೆನೆರಿಕ್ ವರ್ಗದೊಳಗೆ ಜೆನೆರಿಕ್ ವಿಧಾನವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು ಮತ್ತು ಜೆನೆರಿಕ್ ಅಲ್ಲದ ಒಂದು ವಿಧಾನವನ್ನು ಸಹ ನೀವು ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು.

public class GenericMethodClass {
public static void printItems(T[] arr){
for (int i=0; i< arr.length; i++) {

System.out.println(arr[i]);
}
}
public static void main(String[] args) {
String[] arr1 = {'Cat', 'Dog', 'Mouse'};
Integer[] arr2 = {1, 2, 3};

GenericMethodClass.printItems(arr1); // 'Cat', 'Dog', 'Mouse'
GenericMethodClass.printItems(arr2); // 1, 2, 3
} }

ಇಲ್ಲಿ, ವಿಧಾನವನ್ನು ನಿಯತಾಂಕಗೊಳಿಸಲು ನೀವು ನಿರ್ದಿಷ್ಟ ಪ್ರಕಾರದ ಶ್ರೇಣಿಯನ್ನು ರವಾನಿಸಬಹುದು. ಸಾಮಾನ್ಯ ವಿಧಾನ PrintItems() ಹಾದುಹೋದ ರಚನೆಯ ಮೂಲಕ ಪುನರಾವರ್ತಿಸುತ್ತದೆ ಮತ್ತು ಸಂಗ್ರಹಿಸಲಾದ ವಸ್ತುಗಳನ್ನು ಸಾಮಾನ್ಯ ಜಾವಾ ವಿಧಾನದಂತೆ ಮುದ್ರಿಸುತ್ತದೆ.

ಬೌಂಡೆಡ್ ಪ್ರಕಾರದ ನಿಯತಾಂಕಗಳು

ಇಲ್ಲಿಯವರೆಗೆ, ನಾವು ಮೇಲೆ ರಚಿಸಿದ ಜೆನೆರಿಕ್ ತರಗತಿಗಳು ಮತ್ತು ವಿಧಾನಗಳನ್ನು ಪ್ರಾಚೀನ ಪ್ರಕಾರಗಳನ್ನು ಹೊರತುಪಡಿಸಿ ಯಾವುದೇ ಡೇಟಾ ಪ್ರಕಾರಕ್ಕೆ ನಿಯತಾಂಕಗೊಳಿಸಬಹುದು. ಆದರೆ ಜೆನೆರಿಕ್ಸ್‌ಗೆ ರವಾನಿಸಬಹುದಾದ ಡೇಟಾ ಪ್ರಕಾರಗಳನ್ನು ಮಿತಿಗೊಳಿಸಲು ನಾವು ಬಯಸಿದರೆ ಏನು? ಬೌಂಡೆಡ್ ಟೈಪ್ ನಿಯತಾಂಕಗಳು ಇಲ್ಲಿಗೆ ಬರುತ್ತವೆ.

ಜೆನೆರಿಕ್ ವರ್ಗ ಅಥವಾ ವಿಧಾನದಿಂದ ಅಂಗೀಕರಿಸಲ್ಪಟ್ಟ ಡೇಟಾ ಪ್ರಕಾರಗಳನ್ನು ಅದು ಮತ್ತೊಂದು ಡೇಟಾ ಪ್ರಕಾರದ ಉಪವರ್ಗವಾಗಿರಬೇಕು ಎಂದು ನಿರ್ದಿಷ್ಟಪಡಿಸುವ ಮೂಲಕ ನೀವು ಬಂಧಿಸಬಹುದು.

ಉದಾಹರಣೆಗೆ:

//accepts only subclasses of List public class UpperBoundedClass{
//accepts only subclasses of List
public void UpperBoundedMethod(T[] arr) {
} }

ಇಲ್ಲಿ, | _ + + | ಮತ್ತು UpperBoundedClass UpperBoundedMethod ನ ಉಪ ಪ್ರಕಾರಗಳನ್ನು ಬಳಸಿ ಮಾತ್ರ ನಿಯತಾಂಕಗೊಳಿಸಬಹುದು ಡೇಟಾ ಪ್ರಕಾರ.

List ಡೇಟಾ ಪ್ರಕಾರವು ಟೈಪ್ ಪ್ಯಾರಾಮೀಟರ್‌ಗೆ ಮೇಲ್ಭಾಗದಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. List ನ ಉಪವಿಭಾಗವಲ್ಲದ ಡೇಟಾ ಪ್ರಕಾರವನ್ನು ಬಳಸಲು ನೀವು ಪ್ರಯತ್ನಿಸಿದರೆ, ಅದು ಕಂಪೈಲ್-ಸಮಯದ ದೋಷವನ್ನು ಎಸೆಯುತ್ತದೆ.

ಮಿತಿಗಳು ಕೇವಲ ವರ್ಗಗಳಿಗೆ ಸೀಮಿತವಾಗಿಲ್ಲ. ನೀವು ಇಂಟರ್ಫೇಸ್ಗಳನ್ನು ಸಹ ರವಾನಿಸಬಹುದು. ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ವಿಸ್ತರಿಸುವುದು ಎಂದರೆ, ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದು.

ಈ ಉದಾಹರಣೆಯು ತೋರಿಸಿದಂತೆ ಒಂದು ನಿಯತಾಂಕವು ಅನೇಕ ಮಿತಿಗಳನ್ನು ಹೊಂದಬಹುದು.

List

ಸ್ವೀಕರಿಸುವ ಡೇಟಾ ಪ್ರಕಾರವು ಪ್ರಾಣಿ ಮತ್ತು ಸಸ್ತನಿ ವರ್ಗಗಳ ಉಪವರ್ಗವಾಗಿರಬೇಕು. ಈ ಮಿತಿಗಳಲ್ಲಿ ಒಂದು ವರ್ಗವಾಗಿದ್ದರೆ, ಅದು ಬೌಂಡ್ ಘೋಷಣೆಯಲ್ಲಿ ಮೊದಲು ಬರಬೇಕು.

ಮೇಲಿನ ಉದಾಹರಣೆಯಲ್ಲಿ, ಸಸ್ತನಿ ಒಂದು ವರ್ಗ ಮತ್ತು ಪ್ರಾಣಿ ಇಂಟರ್ಫೇಸ್ ಆಗಿದ್ದರೆ, ಮೇಲೆ ತೋರಿಸಿರುವಂತೆ ಸಸ್ತನಿ ಮೊದಲು ಬರಬೇಕು. ಇಲ್ಲದಿದ್ದರೆ, ಕೋಡ್ ಕಂಪೈಲ್-ಸಮಯದ ದೋಷವನ್ನು ಎಸೆಯುತ್ತದೆ.

ಜಾವಾ ಜೆನೆರಿಕ್ಸ್ ವೈಲ್ಡ್ಕಾರ್ಡ್ಗಳು

ವೈಲ್ಡ್ಕಾರ್ಡ್‌ಗಳನ್ನು ಜೆನೆರಿಕ್ ಪ್ರಕಾರಗಳ ನಿಯತಾಂಕಗಳನ್ನು ವಿಧಾನಗಳಿಗೆ ರವಾನಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ. ಜೆನೆರಿಕ್ ವಿಧಾನಕ್ಕಿಂತ ಭಿನ್ನವಾಗಿ, ಇಲ್ಲಿ, ಜೆನೆರಿಕ್ ಪ್ಯಾರಾಮೀಟರ್ ಅನ್ನು ವಿಧಾನದಿಂದ ಅಂಗೀಕರಿಸಲ್ಪಟ್ಟ ನಿಯತಾಂಕಗಳಿಗೆ ರವಾನಿಸಲಾಗುತ್ತದೆ, ಇದು ನಾವು ಮೇಲೆ ಚರ್ಚಿಸಿದ ಡೇಟಾ ಪ್ರಕಾರದ ನಿಯತಾಂಕಕ್ಕಿಂತ ಭಿನ್ನವಾಗಿರುತ್ತದೆ. ವೈಲ್ಡ್ಕಾರ್ಡ್ ಅನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ? ಚಿಹ್ನೆ.

//accepts only subclasses of both Mammal and Animal public class MultipleBoundedClass{
//accepts only subclasses of both Mammal and Animal
public void MultipleBoundedMethod(T[] arr){
} }

ಮೇಲಿನ public void printItems(List list) {
for (int i=0; i< list.size(); i++) {
System.out.println(list.get(i));
} } ವಿಧಾನವು ಯಾವುದೇ ಡೇಟಾ ಪ್ರಕಾರದ ಪಟ್ಟಿಗಳನ್ನು ನಿಯತಾಂಕವಾಗಿ ಸ್ವೀಕರಿಸುತ್ತದೆ. ಪ್ರೋಗ್ರಾಮರ್ಗಳು ವಿಭಿನ್ನ ಡೇಟಾ ಪ್ರಕಾರಗಳ ಪಟ್ಟಿಗಳಿಗಾಗಿ ಸಂಕೇತಗಳನ್ನು ಪುನರಾವರ್ತಿಸುವುದನ್ನು ಇದು ತಡೆಯುತ್ತದೆ, ಇದು ಜೆನೆರಿಕ್ಸ್ ಇಲ್ಲದೆ ಇರುತ್ತದೆ.

ಮೇಲಿನ ಬೌಂಡ್ ವೈಲ್ಡ್ಕಾರ್ಡ್ಗಳು

ವಿಧಾನದಿಂದ ಅಂಗೀಕರಿಸಲ್ಪಟ್ಟ ಪಟ್ಟಿಯಲ್ಲಿ ಸಂಗ್ರಹವಾಗಿರುವ ಡೇಟಾ ಪ್ರಕಾರಗಳನ್ನು ಮಿತಿಗೊಳಿಸಲು ನಾವು ಬಯಸಿದರೆ, ನಾವು ಬೌಂಡೆಡ್ ವೈಲ್ಡ್ಕಾರ್ಡ್‌ಗಳನ್ನು ಬಳಸಬಹುದು.

ಉದಾಹರಣೆ:

printItems()

public void printSubTypes(List list) {
for (int i=0; i< list.size(); i++) {
System.out.println(list.get(i));
} } ಬಣ್ಣವು ಉಪ ಪ್ರಕಾರಗಳನ್ನು ಸಂಗ್ರಹಿಸುವ ಪಟ್ಟಿಗಳನ್ನು ಮಾತ್ರ ಸ್ವೀಕರಿಸುತ್ತದೆ. ಇದು ರೆಡ್‌ಕಲರ್ ಅಥವಾ ಬ್ಲೂಕಲರ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳ ಪಟ್ಟಿಯನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ, ಆದರೆ ಪ್ರಾಣಿ ವಸ್ತುಗಳ ಪಟ್ಟಿಯನ್ನು ಸ್ವೀಕರಿಸುವುದಿಲ್ಲ. ಏಕೆಂದರೆ ಪ್ರಾಣಿ ಬಣ್ಣಗಳ ಉಪವಿಭಾಗವಲ್ಲ. ಇದು ಮೇಲಿನ-ಬೌಂಡ್ ವೈಲ್ಡ್ಕಾರ್ಡ್ನ ಉದಾಹರಣೆಯಾಗಿದೆ.

ಲೋವರ್ ಬೌಂಡೆಡ್ ವೈಲ್ಡ್ಕಾರ್ಡ್ಗಳು

ಅದೇ ರೀತಿ, ನಾವು ಹೊಂದಿದ್ದರೆ:

printSubTypes()

ನಂತರ, | _ + + | ಡಾಗ್ ವರ್ಗದ ಸೂಪರ್ ಪ್ರಕಾರಗಳನ್ನು ಸಂಗ್ರಹಿಸುವ ಪಟ್ಟಿಗಳನ್ನು ಮಾತ್ರ ವಿಧಾನವು ಸ್ವೀಕರಿಸುತ್ತದೆ. ಇದು ಸಸ್ತನಿ ಅಥವಾ ಪ್ರಾಣಿ ವಸ್ತುಗಳ ಪಟ್ಟಿಯನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ ಆದರೆ ಲ್ಯಾಬ್‌ಡಾಗ್ ವಸ್ತುಗಳ ಪಟ್ಟಿಯನ್ನು ಸ್ವೀಕರಿಸುವುದಿಲ್ಲ ಏಕೆಂದರೆ ಲ್ಯಾಬ್‌ಡಾಗ್ ನಾಯಿಯ ಸೂಪರ್‌ಕ್ಲಾಸ್ ಅಲ್ಲ, ಆದರೆ ಉಪವರ್ಗ. ಇದು ಕಡಿಮೆ-ಬೌಂಡ್ ವೈಲ್ಡ್ಕಾರ್ಡ್ನ ಉದಾಹರಣೆಯಾಗಿದೆ.

ತೀರ್ಮಾನ

ಜಾವಾ ಜೆನೆರಿಕ್ಸ್ ಒಂದು ವೈಶಿಷ್ಟ್ಯವಾಗಿ ಮಾರ್ಪಟ್ಟಿದೆ, ಅದರ ಪರಿಚಯದ ನಂತರ ಪ್ರೋಗ್ರಾಮರ್ಗಳು ಬದುಕಲು ಸಾಧ್ಯವಿಲ್ಲ.

ಈ ಜನಪ್ರಿಯತೆಯು ಪ್ರೋಗ್ರಾಮರ್ಗಳ ಜೀವನವನ್ನು ಸುಲಭಗೊಳಿಸುವಲ್ಲಿ ಅದರ ಪ್ರಭಾವದಿಂದಾಗಿ. ಕೋಡಿಂಗ್ ತಪ್ಪುಗಳನ್ನು ಮಾಡದಂತೆ ತಡೆಯುವುದರ ಹೊರತಾಗಿ, ಜೆನೆರಿಕ್ಸ್ ಬಳಕೆಯು ಕೋಡ್ ಅನ್ನು ಕಡಿಮೆ ಪುನರಾವರ್ತಿಸುವಂತೆ ಮಾಡುತ್ತದೆ. ವಿಭಿನ್ನ ಡೇಟಾ ಪ್ರಕಾರಗಳಿಗಾಗಿ ಕೋಡ್ ಅನ್ನು ಪುನರಾವರ್ತಿಸುವುದನ್ನು ತಪ್ಪಿಸಲು ಇದು ತರಗತಿಗಳು ಮತ್ತು ವಿಧಾನಗಳನ್ನು ಹೇಗೆ ಸಾಮಾನ್ಯಗೊಳಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ನೀವು ಗಮನಿಸಿದ್ದೀರಾ?

ಭಾಷೆಯಲ್ಲಿ ಪರಿಣತರಾಗಲು ಜೆನೆರಿಕ್ಸ್ ಬಗ್ಗೆ ಉತ್ತಮ ಗ್ರಹಿಕೆಯನ್ನು ಹೊಂದಿರುವುದು ಮುಖ್ಯ. ಆದ್ದರಿಂದ, ಈ ಟ್ಯುಟೋರಿಯಲ್ ನಲ್ಲಿ ನೀವು ಕಲಿತದ್ದನ್ನು ಪ್ರಾಯೋಗಿಕ ಕೋಡ್‌ನಲ್ಲಿ ಅನ್ವಯಿಸುವುದು ಈಗ ಮುಂದುವರಿಯುವ ಮಾರ್ಗವಾಗಿದೆ.