Apakah Generik di Jawa?

Generik dalam Java ialah ciri lanjutan yang membolehkan kebolehgunaan semula kod dan keselamatan jenis. Fungsi kebolehgunaan semula kod dicapai dengan mentakrifkan kelas Generik, antara muka, pembina dan kaedah. Generik menggunakan pengisytiharan jenis data untuk memastikan keselamatan jenis, dengan itu menghapuskan kemungkinan ralat masa jalan. Simbol kurungan sudut '<>' digunakan untuk melaksanakan Generik dan parameter jenis ditakrifkan dalam kurungan. Parameter jenis ini termasuk 'T' untuk jenis, 'E' untuk elemen, 'N' untuk nombor, 'K' untuk kunci dan 'V' untuk nilai. Contoh kelas Generik dengan parameter Jenis T ialah 'kelas awam DemoGenericClass {…}’

 

Mulakan Kursus Pembangunan Perisian Percuma Anda

Pembangunan web, bahasa pengaturcaraan, ujian perisian & lain-lain

Bagaimanakah Generik Dilaksanakan dalam Java?

Generik dilaksanakan menggunakan kurungan sudut “<>” dan kurungan menyertakan parameter jenis "T" di dalamnya. Contohnya, dalam , parameter jenis “T” ialah pemegang tempat, menunjukkan bahawa jenis data akan diberikan pada masa jalankan.

Kelas Generik boleh ditakrifkan sebagai:

Kod:

public class MyGenericClass<T> {…}

Berikut ialah parameter jenis standard:

• T: Taip
• E: Elemen
• N: Nombor
• K: Kunci
• V: Nilai

Dalam kes berbilang parameter, S, U, V dan seterusnya digunakan untuk menentukan parameter kedua, ketiga dan keempat, masing-masing.

Memahami Generik dalam Java

Apakah jenis keselamatan dan bagaimana ia berfungsi? Bagaimanakah kelas, antara muka, pembina dan kaedah Generik berbeza daripada kelas dan kaedah biasa kami yang menjadikannya boleh digunakan semula?

Java, iaitu bahasa yang ditaip secara statik, memerlukan pengisytiharan jenis data pembolehubah sebelum menggunakannya.

Contoh:

Kod:

String myString ="eduCBA";

Dalam kod di atas, “String” ialah jenis data dan “myString” ialah pembolehubah yang akan memegang nilai yang jenisnya String.

Sekarang, jika seseorang cuba menghantar nilai Boolean sebagai ganti rentetan, seperti di bawah:

Kod:

String myBooleanStr = true;

Ia akan mengakibatkan ralat masa kompilasi serta-merta, menyatakan "Tipe tidak padan: tidak boleh menukar daripada boolean kepada String"

Output:

Bagaimana untuk Mencapai Kebolehgunaan Kod dengan Generik?

Sekarang, mari kita tentukan kaedah biasa:

Kod:

public static void welcome(String name){
System.out.println("welcome to " + name);
}

Kaedah ini boleh digunakan hanya dengan menghantar parameter rentetan.

Kod:

welcome("eduCBA");

Hasilnya ialah "selamat datang ke eduCBA"

Walau bagaimanapun, hanya String boleh menggunakan kaedah ini. Percubaan untuk menghantar sebarang jenis data lain, seperti integer atau boolean, akan mengakibatkan ralat masa kompilasi, menyatakan "Kaedah dialu-alukan(String) dalam jenis Runner tidak boleh digunakan untuk argumen (boolean)"

Output:

Jika seseorang ingin menggunakan kaedah yang serupa untuk jenis data yang berbeza, seseorang boleh membuat kaedah baharu yang menerima jenis data yang diperlukan sebagai parameter. Teknik menulis semula kaedah dengan parameter jenis data yang berbeza ini dipanggil "pembebanan kaedah". Walau bagaimanapun, satu kelemahan pendekatan ini ialah ia boleh membawa kepada saiz kod yang lebih besar.

Seseorang juga boleh menggunakan Generik untuk menulis semula kaedah di atas dan menggunakannya untuk sebarang jenis data yang kami perlukan.

Mentakrifkan kaedah Generik:

Kod:

public static <T> void welcome(T t){
System.out.println("it is " + t);
}

Nota: Di sini, “t” ialah objek jenis T. Jenis data sebenar yang digunakan untuk menggunakan kaedah akan diberikan kepada parameter jenis “T”.

Ini membolehkan kaedah digunakan semula dengan jenis data yang berbeza mengikut keperluan, termasuk rentetan, boolean, integer dan lain-lain.

Kod:

welcome("educba");
Integer myint = 1;
welcome(myint);
welcome(true);

Pernyataan di atas akan memberikan output di bawah:

Output:

it is educba
it is 1
it is true

Oleh itu, menggunakan Generik di sini, kami boleh menggunakan semula kaedah kami untuk jenis data yang berbeza.

Bagaimana untuk Mencapai Jenis Keselamatan menggunakan Generik?

Salah satu perbezaan utama antara Tatasusunan dan Koleksi ialah tatasusunan hanya boleh menyimpan data homogen, manakala koleksi boleh menyimpan data heterogen. Dalam erti kata lain, koleksi boleh menyimpan sebarang jenis objek, termasuk jenis data yang ditentukan pengguna.

Nota: Koleksi hanya boleh menyimpan objek, termasuk jenis data yang ditentukan pengguna dan bukan jenis data primitif. Untuk bekerja dengan jenis data primitif, koleksi menggunakan kelas pembalut.

Now, let’s consider an ArrayList.

Code:

ArrayList myList = new ArrayList();

One can add elements of various data types, such as strings, integers, and doubles, to an ArrayList object.

Code:

myList.add("eduCBA");
myList.add(1);
myList.add(5.2);

On printing the ArrayList object, one can see that it contains the following values: [eduCBA, 1, 5.2].

Output:

To retrieve these values into variables, one needs to typecast them.

Code:

String someStr = (String)myList.get(0);
Integer someInt = (Integer)myList.get(1);
Double someFlt = (Double)myList.get(2);

If one does not typecast, it will prompt a compile-time error stating, “Type mismatch: cannot convert from Object to String”

Output:

Thus, one must typecast them to their respective types while retrieving the objects from the ArrayList. However, in real-time scenarios, an ArrayList can contain thousands of records, and manually typecasting every object may not be feasible. There is the risk of mistakenly typecasting an object to an incorrect data type. In such cases, a runtime error will occur, stating “Exception in thread “main” java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String at com.serviceClasess.Runner.main(Runner.java:43)”.

As there is no guarantee with regard to the type of data present inside a collection (in this case, ArrayList), they are considered unsafe to use with respect to type. Here, Generics play a role in providing type safety.

Using ArrayList with Generics:

Code:

ArrayList<String> myList = new ArrayList<String>();

The String type is specified inside the angular brackets “>” which means that this particular implementation of ArrayList can only hold String type data. If one tries to add another data type, it will simply throw a compile-time error. Here, the ArrayList has been made type-safe by eliminating its chances of adding a data type other than “String.”

Output:

Now, since one has specified the data type that is allowed to be added to the collection with the help of Generics, there is no need to typecast it while retrieving the data. One can simply retrieve the data by writing.

Code:

String someStr = myList.get(0);

Output:

How do Generics in Java make Work Easier?

• It helps make the collections type safe and ensures the code does not fail at a later point due to any run time exception.
• It saves the coder from having to typecast each object in the collection, which simplifies and speeds up the code development process.
• Generics allow writing code in a way that can work with multiple data types.

What else to do with Generics in Java?

So far, we have seen how we can achieve type safety and code reusability with Generics.

In addition to type safety and code reusability, here are some other features that Generics can provide:

• Bounded & Multiple Bounded Types
• Type Wildcards

1. Bounded Type

In the case of a bounded type, the data type of a parameter is bounded to a particular range. The keyword “extends” helps achieve this.

For example, let’s consider a Generic class with a bounded type parameter that extends the ‘Runnable interface’:

Code:

class myGenericClass<T extends Runnable>{}

Now, while creating its object in another class:

Code:

myGenericClass<Thread> myGen = new myGenericClass<Thread>();

The above statement will execute perfectly without any errors. In the case of the bounded type, one can pass the same class type or its child class type. Also, one can bind the parameter type to an interface and pass its implementations when invoking it, as in the example above.

What happens if one uses any other type of parameter?

Code:

myGenericClass<Integer> myGen = new myGenericClass<Integer >();

In the above case, it will result in a compile-time error, stating “Bound mismatch: The type Integer is not a valid substitute for the typecast of the type myGenericClass”

Output:

• Multiple bounded types: In the case of multiple bounded types, one can bind the parameter data type to more than one type.

Example:

Code:

class myGeneric<T extends Number & Runnable>{}

In this case, one can pass any type that extends the Number class and implements the Runnable interface. However, when using multiple bounded types, a few things should be noted:

• One cannot extend more than one class at a time.
• One can extend any number of interfaces simultaneously, i.e., there is no limit for interfaces.
• The class name should always come first, followed by the interface name. If not, it will result in a compile-time error.

2. Type Wildcards

The “?” (question mark) symbol represents Type Wildcards. It makes use of two main keywords:

1. extends (to define upper bound)
2. super (to define lower bounds).

Example:

Code:

ArrayList<? extends T> al

The ArrayList object “al” will hold any data of type T and all its subclasses.

Code:

ArrayList<? super T> al

The ArrayList object “al” will hold any data of type T and all its superclasses.

Advantages of Generics in Java

• Flexibility: Generics allow the code to accommodate different data types with the help of Generic classes and methods.
• Code Maintenance and Reusability: Due to Generic classes and methods, one need not rewrite the code in case of a change in requirements later, making the code easier to maintain and reuse.
• Type Safety: Provides type safety to the collection framework by defining the data type the collection can hold beforehand; and eliminating any chances of failure at run time due to ClassCastException.
• Eliminating the Need to Typecast: Since the data types being held by the collections are already determined, one need not typecast it at the time of retrieval. This reduces the code’s length and a coder’s effort.

Generics in Java Skills

• To work with Generics, one should be proficient in the basics of Java.
• One should understand how type checking and typecasting work. Thorough knowledge of other concepts such as method overloading, the relationship between parent and child classes, interfaces, and their implementations is necessary.
• Also, it is crucial to understand the difference between primitive data types (system-defined data type) and objects (user-defined data type) when working with the collection framework.

Why use Generics in Java?

• Using Generics makes the code more maintainable as it reduces the need to rewrite data type-specific code every time there is a change in requirements.
• By using Generics bounded type, one can restrict the data type and, at the same time, provide flexibility to the code by defining its range.
• Generics provide type safety, making the code less error-prone and less likely to fail at a later point.

Scope for Generics in Java

Generics scope is limited to compile time, i.e., the Generics concept is applicable only at compile time but not at run time.

Example:

Code:

ArrayList myList = new ArrayList<Integer>();
ArrayList myList = new ArrayList<Float>();
ArrayList myList = new ArrayList<Double>();
ArrayList myList = new ArrayList<Boolean>();

Here all the above four statements are the same. They will allow adding any type of data to the list object.

Conclusion

Generics renders coding easy for a coder. It diminishes the chances of encountering ClassCastException at run time by providing strong type-checking. Also, it eliminates the need for typecasting, which means less code needs to be written. It allows the development of Generic algorithms independent of the data type they are working with.

Atas ialah kandungan terperinci Apakah Generik di Jawa?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!