Kursusindhold
Java Udvidet
Java Udvidet
Konstruktør
Hvordan forenkles initialisering af klasser?
Det kan være besværligt at initialisere hvert felt hver gang. Til dette formål har klasser konstruktører. Syntaksen for en konstruktør er som følger:
Main.java
modifier ClassName(ParameterType parameter1, ParameterType parameter2) { this.parameter1 = parameter1; this.parameter2 = parameter2; }
Lad os gennemgå hvert ord, der er skrevet her:
modifier
: Dette henviser til adgangsmodifikatoren, som ofte erpublic
for konstruktører. Tilfælde hvor en konstruktør kan have en anden adgangsmodifikator, vil blive dækket i et andet kursus;ClassName
: Dette er blot navnet på den klasse, hvor du opretter denne konstruktør;ParameterType
: Dette er typen af parameter, der vil blive brugt i konstruktøren. Det er vigtigt at være opmærksom her, fordi denne parameter skal være samme type som feltet i klassen; For eksempel: Hvis klassen har to parametre,String name
ogint age
, så skal konstruktøren have de samme parametre (hvis vi ønsker at initialisere alle felter gennem konstruktøren). Hvis vi kun ønsker at initialisere et specifikt klassefelt gennem konstruktøren, for eksempelname
, så skal vi kun bruge én parameter med samme type og navn som feltet i klassen;- Dernæst, inde i konstruktørens krop, tildeles værdier til klassefelterne ved hjælp af de værdier, der sendes med som parameter.
"this"-nøgleordet
Ved hjælp af this
-nøgleordet kan vi referere til klassefeltet, hvor vi skriver værdien af dette nøgleord. For eksempel, når vi har en klasse med to felter: name
og age
, kan vi skrive this.name
inde i konstruktøren eller metoden, og det vil specifikt referere til klassefeltet, ikke den lokale variabel, der sendes som parameter til konstruktøren eller metoden. På denne måde kan vi initialisere klassefelter gennem konstruktøren ved at bruge syntaksen: this.name = name;
.
Eksempel
Lad os se på et eksempel på en konstruktør i en klasse, der hjælper os med at initialisere alle felterne for at gøre det tydeligere:
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 klasse kaldet Person
med tre felter. Hvert af disse felter er blevet tilføjet til konstruktøren ved hjælp af nøgleordet this
. Derfor initialiserer konstruktøren felterne med værdierne fra parametrene. Lad os bruge denne konstruktør i main
-metoden, så du kan se, at felterne initialiseres med det, vi sender som parametre:
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 initialiserede Person
-objektet bob
ved hjælp af konstruktøren ved at videregive name
, age
og gender
som parametre. Derefter udskrev vi dets parametre på skærmen og ser, at objektet har feltværdier som angivet i konstruktørens parametre.
Konstruktør-overbelastning
Konstruktøren kan også overbelastes og behøver ikke at dække initialisering af alle klassefelter. For eksempel, hvis vi ikke ønsker at angive Alices køn, kan vi overbelaste konstruktøren til kun at acceptere 2 parametre og initialisere felterne med dem:
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 konkluderes, at en konstruktør, ligesom en metode, kan overbelastes og acceptere forskellige antal og typer af parametre.
Standardkonstruktør
En standardkonstruktør er en konstruktør, der ikke tager nogen parametre og initialiserer ikke nogen felter. Den findes i alle klasser som standard, hvis de ikke har nogen anden type konstruktør, hvilket er grunden til, at den kaldes standardkonstruktøren. Hver gang vi opretter et objekt af en hvilken som helst klasse, bruger vi en konstruktør. For at kunne bruge standardkonstruktøren, når vi allerede har en konstruktør, der accepterer parametre, skal vi også skrive en tom konstruktør:
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 bruger 3 forskellige konstruktører til at initialisere hver af Person
-objekterne. Som vi kan se i det sidste eksempel, har John
hverken navn eller alder, fordi disse felter ikke er initialiseret for objektet. Dermed kan vi overbelaste konstruktøren så mange gange, som vi har brug for, og oprette objekter gennem den.
1. Hvilke af følgende udsagn om konstruktører er sande?
2. Hvad er formålet med en konstruktør i Java?
3. Hvilket af følgende kodeeksempler viser den korrekte måde at oprette en parameteriseret konstruktør på?
Tak for dine kommentarer!