Kursinnehåll
Java Fördjupad
Java Fördjupad
Konstruktor
Hur förenklar man initiering av klasser?
Att initiera varje fält varje gång kan vara omständligt. För sådana ändamål har klasser konstruktorer. Syntaxen för en konstruktor är följande:
Main.java
modifier ClassName(ParameterType parameter1, ParameterType parameter2) { this.parameter1 = parameter1; this.parameter2 = parameter2; }
Låt oss gå igenom varje ord som används här:
modifier
: Detta avser åtkomstmodifieraren, som ofta ärpublic
för konstruktorer. Fall där en konstruktor kan ha en annan åtkomstmodifierare kommer att behandlas i en separat kurs;ClassName
: Detta är helt enkelt namnet på klassen där du skapar denna konstruktor;ParameterType
: Detta är typen av parameter som kommer att användas i konstruktorn. Det är viktigt att vara uppmärksam här eftersom denna parameter ska vara av samma typ som fältet i klassen; Till exempel: Om klassen har två parametrar,String name
ochint age
, ska konstruktorn ha samma parametrar (om vi vill initiera alla fält via konstruktorn). Om vi vill initiera endast ett specifikt klassfält via konstruktorn, till exempelname
, ska vi använda endast en parameter med samma typ och namn som fältet i klassen;- Därefter, inuti konstruktorns kropp, tilldelar vi värden till klassens fält med hjälp av de värden som skickas in som parameter.
"this"-nyckelordet
Med hjälp av this
-nyckelordet kan vi referera till klassfältet i vilket vi skriver värdet för detta nyckelord. Till exempel, när vi har en klass med två fält: name
och age
, kan vi skriva this.name
inuti konstruktorn eller metoden, och det kommer specifikt att referera till klassfältet, inte den lokala variabeln som skickas som parameter till konstruktorn eller metoden. På detta sätt kan vi initiera klassfält genom konstruktorn med syntaxen: this.name = name;
.
Exempel
Vi tittar på ett exempel på en konstruktor i en klass som hjälper oss att initiera alla fält för att göra det tydligare:
Person.java
class Person { String name; int age; String gender; public Person(String name, int age, String gender) { this.name = name; this.age = age; this.gender = gender; } }
Vi har en klass som heter Person
med tre fält. Var och en av dessa fält har lagts till i konstruktorn med hjälp av nyckelordet this
. Därför initierar konstruktorn fälten med värdena från parametrarna. Vi använder denna konstruktor i main
-metoden så att du kan se att fälten initieras med det vi skickar som parametrar:
Main.java
package com.example; class Person { String name; int age; String gender; public Person(String name, int age, String gender) { this.name = name; this.age = age; this.gender = gender; } } public class Main { public static void main(String[] args) { Person bob = new Person("Bob", 20, "Male"); System.out.println("Bob's name: " + bob.name + ", Bob's age: " + bob.age + ", Bob's gender: " + bob.gender); } }
Vi initierade Person
-objektet bob
med hjälp av konstruktorn genom att skicka name
, age
och gender
som parametrar. Därefter skrev vi ut dess parametrar på skärmen och ser att objektet har fältvärden enligt de värden som angavs i konstruktorns parametrar.
Konstruktoröverladdning
Konstruktorn kan också överladdas och behöver inte täcka initiering av alla klassfält. Till exempel, om vi inte vill ange Alices kön, kan vi överladda konstruktorn så att den endast accepterar 2 parametrar och initierar fälten med dessa:
Main.java
package com.example; class Person { String name; int age; String gender; public Person(String name, int age, String gender) { this.name = name; this.age = age; this.gender = gender; } public Person(String name, int age) { this.name = name; this.age = age; } } public class Main { public static void main(String[] args) { Person bob = new Person("Bob", 20, "Male"); System.out.println("Bob's name: " + bob.name + ", Bob's age: " + bob.age + ", Bob's gender: " + bob.gender); Person alice = new Person("Alice", 17); System.out.println("Alice's name: " + alice.name + ", Alice's age: " + alice.age); } }
Det kan konstateras att en konstruktor, likt en metod, kan överlagras och acceptera olika antal och typer av parametrar.
Standardkonstruktor
En standardkonstruktor är en konstruktor som inte tar några parametrar och initierar inga fält. Den finns i alla klasser som standard om de inte har någon annan typ av konstruktor, vilket är anledningen till att den kallas standardkonstruktor. Varje gång vi skapar ett objekt av en klass använder vi en konstruktor. För att kunna använda standardkonstruktorn när vi redan har en konstruktor som accepterar parametrar, måste vi även skriva en tom konstruktor:
Main.java
package com.example; class Person { String name; int age; String gender; public Person(String name, int age, String gender) { this.name = name; this.age = age; this.gender = gender; } public Person(String name, int age) { this.name = name; this.age = age; } public Person() { } } public class Main { public static void main(String[] args) { Person bob = new Person("Bob", 20, "Male"); System.out.println("Bob's name: " + bob.name + ", Bob's age: " + bob.age + ", Bob's gender: " + bob.gender); Person alice = new Person("Alice", 17); System.out.println("Alice's name: " + alice.name + ", Alice's age: " + alice.age); Person john = new Person(); System.out.println("John's name: " + john.name + ", John's age: " + john.age); } }
Vi använder tre olika konstruktorer för att initiera var och en av Person
-objekten. Som vi kan se i det sista exemplet har John
varken namn eller ålder eftersom dessa fält inte är initierade för objektet. Därmed kan vi överlasta konstruktorn så många gånger vi behöver och skapa objekt genom den.
1. Vilket av följande påståenden om konstruktorer är sant?
2. Vad är syftet med en konstruktor i Java?
3. Vilket av följande kodexempel visar det korrekta sättet att skapa en parameteriserad konstruktor?
Tack för dina kommentarer!