Shulou(Shulou.com)05/31 Report--

This article introduces the relevant knowledge of "how to understand generics in Java". In the operation of actual cases, many people will encounter such a dilemma, so let the editor lead you to learn how to deal with these situations. I hope you can read it carefully and be able to achieve something!

Generics: a feature introduced in JDK5 that constrains and checks the data types of operations at compile time.

Format of generics: note: generics can only support reference data types.

All interfaces and implementation classes of the collection architecture support the use of generics.

Advantages:

Uniform data type.

Advance the running problem to the compilation time, avoiding the possible problems of forced type conversion, because the compile-time type can be determined.

Public static void main (String [] args) {List list = new ArrayList (); list.add ("Ishihara Rimei"); list.add ("Kudo Shizuka"); list.add ("Zhu Yin"); for (String s: list) {System.out.println (s);}} output result: Ishihara Rimei Kudo Shizuka Zhu Yin

And generics can be defined in many places, such as generic classes after classes, generic methods on method declarations, and generic interfaces after interfaces. Let's learn how these generics are used:

Custom generic class concept

A class that defines generics as well as generics is a generic class.

Format of generic classes: modifier class class name {}

Public class MyArrayList {}

Function: data types can be specified during compilation, similar to the role of collections

Actual combat teaching

Now create a generic class to implement basic add and delete operations to specifically understand its usage:

/ / generic class MyArrayLIstpublic class MyArrayLIst {public void add (E) {} public void remove (E) {}} / / mainpublic static void main (String [] args) {MyArrayLIst list = new MyArrayLIst (); / / list.add ("Ishihara Rimei"); list.add ("Kudo Shizuka") List.remove (Shizuka Kudo);}

The principle of generic classes:

Replace all the places where generic variables appear with the real data types that are transmitted.

Through careful observation, it is not difficult to find that the biggest difference between generic classes and ordinary classes is that they can uniformly deal with the same kind of data when calling methods, and other data types are not involved. to a certain extent, it avoids the problems that may occur when forced type conversion.

Custom generic method concept

A method that defines a generic type while defining a generic method is a generic method.

Format of generic methods: modifier returns value type method name (formal parameter list) {}

Public void view (E e) {}

Function: generics can be used in the method to receive all the parameters of the actual type, and the method is more universal.

Note: generic methods need to be different from those defined in generic classes, although they also use generics, but the generics are not defined by them, but by generic classes.

Actual combat teaching

No matter what type of array is passed in, you can return its contents, that is, to achieve the function of Arrays.toString ()

Public static void main (String [] args) {String [] name = {"Rimei Ishihara", "Kudo Shizuka", "Zhu Yin"}; view (name); Integer [] age = {18pr 19 arr 20}; view (age);} public static void view (T [] arr) {StringBuilder list = new StringBuilder (); for (int I = 0; I < arr.length) ) {list.append (arr [I]) .append ("\ t");} System.out.println (list);}

Through the definition of generic methods, we can receive a variety of data types, and the scope of application is more extensive.

Custom generic interface concept

Interfaces defined using generics are generic interfaces.

Format of generic interface: public interface People {}

Public interface People {}

Function: the generic interface allows the implementing class to select the data types that the current function needs to operate on.

Actual combat teaching

Define a People interface to operate on teacher Teacher class, student Student class, etc.

/ / People interface public interface People {void run (E); void height (E e);} / / Student class public class Teacher {} / / implementation class Fantypepublic class Fantype implements People {@ Override public void run (Teacher teacher) {} @ Override public void height (Teacher teacher) {}}

Through the observation of the above code, we can see that what type is defined after People, then the implementation class can only operate on that data type, and other types cannot do so.

Wildcards and upper and lower limit wildcards

? Can represent all types when "using generics"

E T K V is used when defining generics

Suppose there is a competition for students and teachers that needs to compare who is faster, create a certain number of objects and pass them into the collection. However, when we pass these two sets into the method respectively, we will find that there is an error in the student object collection list2. Why? The reason is that because the data types are different, how can both types be passed in? Maybe at this point someone will say, "since both classes are subclasses of People, why not define its generics as People?" This is a good idea, but we need to make it clear that although there is a relationship between the subclass and the parent class, there is no relationship between the defined set, so it doesn't work here.

/ / main// teacher object collection ArrayList list1 = new ArrayList (); list1.add (new Teacher ()); list1.add (new Teacher ()); Competition (list1); / / Student object collection ArrayList list2 = new ArrayList (); list2.add (new student ()); list2.add (new student ()); Competition (list2) / / since the formal parameter of the contention method is a collection with generic Teacher, the parent class class People {} / / subclass class Teacher extends People {} class student extends People {} / / contention method: public static void contention (ArrayList people) {}

To deal with this problem, we can put the knowledge "wildcard" introduced in this article into practical application to solve the problem, through its short concept "? you can represent all types when you 'use generics' and you can understand their role, and here we can use"? " Together represent two types.

Public static void contention (ArrayList people) {/ / through wildcards? The problem can be solved} upper and lower limits.

However, there is another problem, defining a dog class, trying to create some objects and mixing games into the collection, which of course is not allowed to happen, however? Can represent any type and cannot be restricted. Therefore, the role of the upper and lower limits is reflected:

Upper limit:

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.