Parameteriserade typer i Java: Generics

1. Alla klasser ärverObject

Alla klasser i Java ärver implicit Objectklassen.

Vi kommer att analysera vad arv är och hur det fungerar i Java i Java Core-uppdraget. För nu ska vi överväga ett enkelt faktum som följer av detta:

Ett objekt av vilken klass som helst kan tilldelas en Objectvariabel. Exempel:

Object o = new Scanner(System.in);

Object o = new String();

Object o = new Integer(15);

Object o = "Hello";

Det är här de goda nyheterna slutar. Kompilatorn håller inte reda på den ursprungliga typen av objekt som sparats i en Objectvariabel, så du kommer inte att kunna anropa andra metoder på det sparade objektet än klassens metoder Object.

Om du behöver anropa metoderna som är associerade med objektets ursprungliga typ, måste du först spara en referens till den i en variabel av rätt typ och sedan anropa metoderna för den variabeln:

Object o = new Scanner(System.in);
int x = o.nextInt();

Object o = new Scanner(System.in);

Scanner console = (Scanner) o;

int x = console.nextInt();

Du kan inte bara gå och tilldela en Objectvariabel till en Scanner-variabel, även om Objectvariabeln lagrar en referens till ett Scannerobjekt. Men du kan göra detta om du använder typecast-operatorn , som du redan känner till. Detta är dess allmänna utseende:

Type name1 = (Type) name2;

Var name1är namnet på en Typevariabel, och name2är namnet på en Objectvariabel som lagrar en referens till ett Typeobjekt.

Typecasting

Om variabelns typ och objektets typ inte stämmer överens, kommer a ClassCastExceptionatt kastas. Exempel:

Object o = new Integer(5);
String s = (String) o;

Det finns ett sätt att undvika detta fel i Java: vi gör detta genom att kontrollera typen av objekt som lagras i en variabel :

name instanceof Type

Operatören instanceofkontrollerar om namevariabeln är ett Typeobjekt.

Som ett exempel, låt oss hitta en sträng i en rad olika objekt:

Object[] objects = {10, "Hello", 3.14};

for (int i = 0; i < objects.length; i++)
{
   if (objects[i] instanceof String)
   {
      String s = (String) objects[i];
      System.out.println(s);
   }
}

2. Varför generika dök upp - samlingar

Låt oss återgå till samlingarna.

Så fort Java-utvecklare skapade ArrayListklassen ville de göra den universell, så att den kunde lagra vilken typ av objekt som helst. Så de använde en array av Objects för att lagra elementen.

Styrkan med detta tillvägagångssätt är att du kan lägga till ett objekt av vilken typ som helst i samlingen.

Naturligtvis finns det flera svagheter.

Nackdel 1.

Det var alltid nödvändigt att skriva en typkonverteringsoperator när man hämtade element från en samling:

ArrayList numbers = new ArrayList();


for (int i = 0; i < 10; i++)
   numbers.add(i * 10);


int sum = 0;
for (int i = 0; i < 10; i++)
{
   sum = sum + (Integer) numbers.get(i);
}

Nackdel 2.

Det fanns ingen garanti för att en samling innehåller en specifik typ av element

ArrayList numbers = new ArrayList();


for (int i = 0; i < 10; i++)
   numbers.add(i * 2.5);


int sum = 0;
for (int i = 0; i < 10; i++)
{
   sum = sum + (Integer) numbers.get(i);
}

Data kan läggas in i samlingen var som helst:

• i en annan metod
• i ett annat program
• från en fil
• över nätverket

Nackdel 3.

Uppgifterna i samlingen kan ändras av misstag.

Du kan skicka en samling fylld med dina data till någon metod. Den metoden, skriven av en annan programmerare, lägger till sina data till din samling.

Namnet på samlingen anger inte tydligt vilka typer av data som kan lagras i den. Och även om du ger din variabel ett tydligt namn, kan en referens till den skickas till ett dussintal metoder, och de metoderna kommer definitivt inte att veta något om variabelns ursprungliga namn.

3. Generika

I Java elimineras alla dessa problem av denna coola sak som kallas generika.

I Java betyder generika möjligheten att lägga till typparametrar till typer. Resultatet är en komplex komposittyp. Den allmänna synen på en sådan sammansatt typ är denna:

ClassName<TypeParameter>

Detta är en generisk klass. Och den kan användas överallt där du normalt använder klasser.

ArrayList<Integer> list;

list = new ArrayList<Integer> ();

ArrayList<Integer>[] array;

Endast Integervariabler kan lagras i en sådan samling:

ArrayList<Integer> list = new ArrayList<Integer>();
list.add(new Integer(1));
list.add(2);
list.add("Hello");

Du kommer att lära dig hur du skapar dina egna klasser med typparametrar i Java Collections-uppdraget. För nu ska vi titta på hur man använder dem och hur de fungerar.

4. Hur generika fungerar

Egentligen är generika fruktansvärt primitiva.

Kompilatorn ersätter helt enkelt generiska typer med vanliga typer. Men när metoder av en generisk typ används, lägger kompilatorn till en typecast-operator för att casta parametrar till typparametrarna:

ArrayList<Integer> list = new ArrayList<Integer>();

ArrayList list = new ArrayList();

list.add(1);

list.add( (Integer) 1 );

int x = list.get(0);

int x = (Integer) list.get(0);

list.set(0, 10);

list.set(0, (Integer) 10);

Anta att vi har en metod som summerar talen i en samling heltal:

public int sum(ArrayList<Integer> numbers)
{
   int result = 0;

   for (int i = 0; i < numbers.size(); i++)
      result = result + numbers.get(i);

   return result;
}

public int sum(ArrayList numbers)
{
   int result = 0;

   for (int i = 0; i < numbers.size(); i++)
      result = result + (Integer) numbers.get(i);

   return result;
}

Generika är med andra ord ett slags syntaktisk socker, precis som autoboxning, men lite mer. Med autoboxning lägger kompilatorn till metoder för att konvertera en inttill en Integeroch vice versa, och för generika lägger den till typecast-operatorer.

Efter att kompilatorn har kompilerat dina generiska klasser med typparametrar, konverteras de helt enkelt till vanliga klasser och typecast-operatorer. Information om typargumenten som skickas till variabler av generiska typer går förlorad. Denna effekt kallas även typradering .

Ibland behöver programmerare som skriver generiska klasser (klasser med typparametrar) verkligen informationen om de typer som skickas som argument. I Java Collections-uppdraget får du lära dig hur du hanterar detta och vad det innebär.

5. Lite fakta om generika

Här är några mer intressanta fakta om generika.

Klasser kan ha flera typparametrar. Det ser ut ungefär så här:

ClassName<TypeParameter1, TypeParameter2, TypeParameter3>

Egentligen är detta inte riktigt förvånande. Överallt där kompilatorn kan lägga till en operatör för att casta till en typ, kan den lägga till flera typecast-operatorer.

Exempel:

HashMap<Integer, String> map = new HashMap<Integer, String>();
map.put(7, "Hello");
map.put(-15, "Hello");

Generiska typer kan också användas som parametrar . Det ser ut ungefär så här:

ClassName<TypeParameter<TypeParameterParameter>>

Anta att vi vill skapa en lista som lagrar listor med strängar. I det här fallet kommer vi att få något i stil med detta:

// List of greetings
ArrayList<String> listHello = new ArrayList<String>();
listHello.add ("Hello");
listHello.add ("Hi");

// List of goodbyes
ArrayList<String> listBye = new ArrayList<String>();
listBye.add("Bye");
listBye.add ("Goodbye");

// List of lists
ArrayList<ArrayList<String>> lists = new ArrayList<ArrayList<String>>();
lists.add(listHello);
lists.add(listBye);

Generiska typer (typer med typparametrar) kan också användas som arraytyper. Det ser ut ungefär så här:

ClassName<TypeParameter>[] array = new ClassName<TypeParameter>[size];

Det är inget magiskt som händer här: vinkelparenteserna indikerar bara typnamnet:

ArrayList<String>[] list = new ArrayList<String>[10];

StringArrayList[] list = new StringArrayList[10];

ArrayList<Integer>[] list = new ArrayList<Integer>[10];

IntegerArrayList[] list = new IntegerArrayList[10];

ArrayList<Scanner>[] list = new ArrayList<Scanner>[10];

ScannerArrayList[] list = new ScannerArrayList[10];