Java Generic

-

 

                           

                                    Java Generic 

Basic Examples

 Generic Class Example: NEW

In this example, Box is a generic class that can hold a value of any type. The <T> in Box<T> is a type parameter, and it represents the type that will be specified when creating an instance of the Box class. Here's how you can use it:



 Generic Class Example with supper class: NEW

In this example:

We have a generic class called StorageBox<T>, which extends a non-generic superclass Box<T>. T is the type parameter that is inherited from the superclass.

The StorageBox class has an additional field called storageLocation to store information about the storage location of the item.

The constructor of StorageBox takes both the value and the storage location as parameters and calls the superclass constructor using super(value) to set the value.

Here's how you can use this StorageBox class:


As you can see, the StorageBox class can be parameterized with different types (Integer and String in this case), and it inherits the generic type parameter T from its superclass Box<T>.



Generic Method Example: NEW

In this example, Utils is a class with a generic method called getFirstElement. This method takes a List<T> as an argument and returns the first element of the list. Here's how you can use it:

The <T> in Utils.<T>getFirstElement(...) specifies the generic type for the method, and it's inferred based on the type of the list passed as an argument.

These examples demonstrate the use of generic classes and methods in Java, which allow you to create reusable and type-safe components that can work with different data types.



Small use case related example:


In this example, Storage is a generic class that has a type parameter T with an upper bound extends Product. This upper bound constraint specifies that T must be a subclass of (or the same class as) the Product class. Here's how you can use this Storage class:






Nice Must Read Examples

===========================================================================================

Type1:  class generic

       We can define class which can be vary like this <T>

    Eg1:


       when the extract implementation relevant class can be provided 


   Eg2
   




Type 2:  (V.V) sub class to super class generic

  VV => { Reason for mentioning the extended class like (BIR extends BaseIndexerRunner) is only for identifying the supper class, otherwise methods or variables inside the "BIR" can not be identified to write the logic inside generic class(BaseIndexer) since we do not know even super class ,So when compiler know the super class we can use its methods inside the generic class(BaseIndexer) like new BIR().method1()  (if we do not use then no need of mentioning the extended class) }
 

V.V. Example project Code with kafka consumer :  https://github.com/jpssasadara/java-Generic-pick-EX

Type 3 method generic




Comments

Post a Comment

Popular posts from this blog

Hibernate (Java) -- by jps sasadara

-
Image
HQL & JPAQuery for Springboot =>   https://drive.google.com/drive/u/1/folders/18KA0A0EKYmn6Z7auazNquPDaweqPQvHI               https://www.baeldung.com/jpa-join-types   (only if we want to write join query, but in HQL no need of using join  key word , if we can correctly implement the mapping classes ) Native SQL for Springboot => https://drive.google.com/drive/u/1/folders/17vdDhEXBKtbWpTkYUy5UcF_n_r2G-YDy      projects =>  https://drive.google.com/drive/folders/14x_9TeE5SZq6ECZqCmoBaGTgOUSssuqm?usp=sharing We can write plan SQL Query in hibernate using   session.createSQLQuery(sqlSearch); Eg-::  String sqlSearch = SQLVarList.MSSQL_DEVICEOPERATIONREPORT_SQL2 + where + orderBy;             Query querySearch = session.createSQLQuery(sqlSearch);             querySearch = setD...
Read more

Observer Design Pattern & RxJava & @Async

-
Image
  Observer Design Pattern According to GoF definition,  observer pattern  defines a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically. It is also referred to as the  publish-subscribe pattern . In observer pattern, there are many observers (subscriber objects) that are observing a particular subject (publisher object). Observers register themselves to a subject to get a notification when there is a change made inside that subject. A observer object can register or unregister from subject at any point of time. It helps is making the objects objects  loosely coupled . 1. When to use observer design pattern As described above, when you have a design a system where multiple entities are interested in any possible update to some particular second entity object, we can use the observer pattern The flow is very simple to understand. Application creates the concrete subject object. All...
Read more

JAVA uml Based cording <<< by jps sasadara >>>

-
                             COMPOSITION TUTORIAL The term  composition  is not unique to Java, composition is a concept of object-oriented programming. By now you should be familiar with the concept of  inheritance  - inheritance requires the use of the Java keywords  extends  or  implements . When your class inherits members from either a superclass or a superinterface, you can directly invoke or access those members. Consider the following code that demonstrates inheritance: class OperatingSystem {      void bootUp() { ... }      void shutDown() { ... } } class Computer extends OperatingSystem { } class TestMe {      public static void main(String args[]){          Computer c = new Computer();          c.bootUp();  ...
Read more