I objektorienterad programmering är en konstruktor en speciell funktion som du anropar för att skapa ett objekt. Konstruktörer har flera unika funktioner som gör att de kan arbeta.
I Java döper du en konstruktor efter dess klass. En konstruktor är en metod, definierad i den klass den gäller. Java-konstruktörer kan använda överbelastning för att tillhandahålla alternativt beteende. Konstruktörer i Java kan också använda arv för att återanvända kod.
Varför behöver du konstruktörer?
Konstruktörer är en stöttepelare i objektorienterad programmering, och Java är inget undantag. Det här exemplet visar hur du kan definiera en grundläggande Circle-klass med en dataegenskap och en metod:
public class Circle {
public double radius;
public double area() { return 3.14159 * radius * radius; }
}
Du kan sedan skapa en instans av den här klassen och interagera med den:
Circle c = new Circle();
c.radius = 2;
System.out.println(c.area()); // 12.56636
Men det här är mindre bekvämt och robust än det skulle kunna vara. Det är god objektorienterad praxis att kapsla in data och skydda dem från obehörig åtkomst:
public class Circle {
private double radius;
public double area() { return 3.14159 * radius * radius; }
public void setRadius(double r) { radius = r; }
}
Nu kan samtalskoden använda setRadius metod och inte behöva oroa dig för dess implementeringsdetaljer:
Circle c = new Circle();
c.setRadius(2);
Konstruktörer erbjuder ett ännu bättre sätt att leverera data till ett objekt när du skapar det. De används mycket ofta för initiering av egenskaper, såsom radie här.
Exempel på enkla konstruktörer
Den mest grundläggande konstruktorn är en utan argument, som inte gör något:
public class Circle {
public Circle() {}
}
Om du inte definierar en konstruktor kommer Java att tillhandahålla en standard som beter sig på samma sätt.
Notera ett par saker:
- Namnet på konstruktören matchar klassnamnet. Denna konstruktör använder offentlig åtkomstmodifierare, så vilken annan kod som helst kan kalla den. En konstruktör inkluderar inte en returtyp. Till skillnad från andra metoder kan konstruktörer inte returnera ett värde.
Konstruktörer utför vanligtvis någon form av initiering. Observera att koden ovan inte initierar radievärdet. I det här fallet kommer språket automatiskt att nollställa det. Den här klassen förväntar sig att en användare ska använda setRadius(). För att använda en mer användbar standard än 0, kan du tilldela den i konstruktorn:
public class Circle {
public Circle() { radius = 1; }
}
Cirklar skapade med den här klassen kommer åtminstone nu att ha ett verkligt område! Den som ringer kan fortfarande använda setRadius() för att ge en annan radie än 1. Men konstruktören kan vara ännu vänligare:
public class Circle {
public Circle(double r) { radius = r; }
}
Nu kan du skapa cirklar med en specifik radie redan från födseln:
Circle c = new Circle(2);
System.out.println(c.area()); // 12.56636
Detta är en mycket vanlig användning för konstruktörer. Du kommer ofta att använda dem för att initiera variabler till parametervärden.
Konstruktör överbelastning
Du kan ange mer än en konstruktor i en klassdefinition:
public Circle() { radius = 1; }
public Circle(double r) { radius = r; }
Detta ger anropskoden ett val av hur man konstruerar objekt:
Circle c1 = new Circle(2);
Circle c2 = new Circle();
System.out.println(c1.area() + ", " + c2.area()); // 12.56636, 3.14159
Med en lite mer komplex cirkel kan du utforska mer intressanta konstruktörer. Denna version lagrar sin position:
public class Circle {
public double x, y, radius;
public Circle() { radius = r; }
public Circle(double r) { radius = r; }
public Circle(double x, double y, double r) {
this.x = x; this.y = y; radius = r;
}
public double area() { return 3.14159 * radius * radius; }
}
Du kan nu skapa en cirkel utan argument, en enda radie eller x- och y-koordinater längs radien. Detta är samma typ av överbelastning som Java stöder för alla metoder.
Konstruktörskedja
Vad sägs om att skapa en cirkel, baserad på en annan? Detta skulle ge oss möjligheten att enkelt kopiera cirklar. Observera följande block:
public Circle(Circle c) {
this.x = c.x;
this.y = c.y;
this.radius = c.radius;
}
Detta kommer att fungera, men det upprepar en del kod i onödan. Eftersom Circle-klassen redan har en konstruktor som hanterar de individuella egenskaperna kan du anropa det istället med hjälp av detta nyckelord:
public Circle(Circle c) {
this(c.x, c.y, c.radius);
}
Detta är en form av konstruktörskedja, som anropar en konstruktör från en annan. Den använder mindre kod och hjälper till att centralisera en operation snarare än att duplicera den.
Ringer föräldrakonstruktören
Den andra formen av konstruktorkedjning uppstår när en konstruktör anropar en konstruktör av sin överordnade klass. Detta kan vara antingen explicit eller implicit. För att uttryckligen anropa en överordnad konstruktor, använd super nyckelord:
super(x, y);
Föreställ dig en Shape-klass som fungerar som förälder till cirkeln:
public class Shape {
double x, y;
public Shape(double _x, double _y) { x = _x; y = _y; }
}
Den hanterar gemensam positionering för alla former eftersom detta är funktionalitet som de alla delar. Nu kan Circle-klassen delegera positionshantering till sin förälder:
public class Circle extends Shape {
double radius;
public Circle(double r) { super(0, 0); radius = r; }
public Circle(double x, double y, double r) {
super(x, y);
radius = r;
}
}
Superklasskonstruktion är en mycket viktig aspekt av arv i Java. Språket upprätthåller det som standard om du inte uttryckligen ringer super i dina konstruktörer.
Åtkomstmodifierare på konstruktörer
Konstruktörer kan inkludera en åtkomstmodifierare i sin signatur. Liksom andra metoder definierar detta vilka typer av anropare som kan komma åt konstruktorn:
public class Test {
private static Test uniqueInstance = new Test();
private Test() { }
public static Test getInstance() {
return uniqueInstance;
}
}
Det här är ett mer komplicerat exempel, så var noga med att förstå det:
Klassen är inte abstrakt, så det är möjligt att instansiera från den. Konstruktören är privat så endast den här klassen själv kan skapa en ny instans. Via en statisk egenskap och metod exponerar klassen en enda unik instans av sig själv för anropare.
Använd konstruktörer i Java för att skapa objekt
Konstruktörer är avgörande för objektorienterad programmering. De låter dig skapa objekt, vilket är viktigt!
I Java ser konstruktörer ut som andra metoder och fungerar ungefär på samma sätt. Du bör komma ihåg de speciella reglerna kring standardkonstruktörer, överbelastning och konstruktorkedja. Om konstruktörer är nya för dig kanske du vill läsa om de andra centrala Java-koncepten du bör lära dig när du börjar.
Om författaren
Bobby Jack (65 artiklar publicerade)
Bobby är en teknikentusiast som arbetat som mjukvaruutvecklare under de flesta av två decennier. Han brinner för spel, arbetar som chefredaktör på Switch Player Magazine och är fördjupad i alla aspekter av onlinepublicering och webbutveckling.
Mer från Bobby Jack
Prenumerera på vårt nyhetsbrev
Gå med i vårt nyhetsbrev för tekniska tips, recensioner, free e-böcker och exklusiva erbjudanden!
Klicka här för att prenumerera
