programmeringsspråket Java använder klasser och objekt för att tillåta programmerare att arbeta med data . Som C + + , Java även tillåter användare att definiera klasser som kan använda flera datatyper , så att öka flexibiliteten och användbarheten av sina skapade objekt . Genom att ta detta begreppet flexibel datatyp användning , kallad " generika ", och tillämpar en rekursiv inslag , kan programmerare säkerställa att användarna av objekt använder bara vissa typer av data så att det generiska objektet fungerar som avsett och samtidigt tillåta användare att förlänga användningen av alstret. Klasser och typer
Java-funktioner , främst som ett objektorienterat programmeringsspråk . Detta innebär att programmerare använder "klasser" för att definiera särskilda "typer" av data. Klasser använder även andra typer av data i deras definition . I följande kod , till exempel , använder klass Box tre heltal som en del av sin definition : för att klassen att fungera för andra programmerare , de måste följa denna definition genom att leverera tre heltal . Detta upprätthåller effektiviteten av klassen Box :
class Box {
int längd , int bredd , int höjd ,
offentlig Box ( int l , int w , int h ) { //Box måste använda integersint längd = l ; int width = w , int höjd = h ; } }
generiska typer
Vissa programmerare , kan dock inte gillar denna begränsning . Vissa kanske utveckla datastrukturer , till exempel, som kräver att användaren av datastrukturen tillåtas att använda alla datatyper i strukturen. I detta fall , kan programmeraren skapa en " generisk " klass som tar en viss datatyp. Så , som i följande kod t.ex. får klass Box tar nu någon typ " T " för att representera sina sidor . Detta kan vara mycket användbart om användaren kanske vill använda antingen heltal eller decimaltal för att representera sidor :
klass Box {
T längd , T bredd , T höjd ;
offentliga Box ( T l , T w , T h ) { //Box använder nu typ Tint längd = l ; int width = w , int höjd = h ; } } Addera
generiska Rekursiva typer
att komplicera generiska typer , kanske några programmerare spela med reglerna för vad som är tillåtet som en generisk typ för en klass . Till exempel , istället för att ha en allmän datatyp " T , " programmeraren kan skapa en klass som tar samma typ som den klass den fungerar som generisk typ av . Följande exempel illustrerar detta : I stället för typ T , används klassen den generiska typen T som representerar en version , eller " ärver " från , class Box :
klass Box < T utökar Box > {
Box längd , Box bredd , Box höjd ,
allmänheten (fält l , Box w , Box h ) { //Box använder nu typ Box int längd = l ; int width = w , int höjd = h ; } } Addera Nyttan av Rekursiv Typer
I praktiken tycks det förvirrande och krånglig . Men , faktiskt den representerar ett smart sätt för skaparen av klassen att genomdriva viss typ användning . I detta fall använder användaren av klasstyp "Box" med generisk typ "T" som en generisk typ för sig själv. Detta innebär i huvudsak att en användare som skapar ett objekt av typen " Box " tvingas använda samma typ ( Box ) som den generiska typen snarare än ett heltal , decimaltal , eller något annat . Detta gör det möjligt för programmerare att garantera att ett visst beteende uppstår när användare interagerar med klasser som de skapar .
