Att hantera objektens tillstånd i Java är en grundläggande aspekt av objektorienterad programmering. Det handlar om att kontrollera och upprätthålla de data som lagras i ett objekt och hur dessa data ändras över tid. Här är en uppdelning av processen och viktiga överväganden:
1. Förstå objekttillstånd:
* State definierat: Tillståndet för ett objekt representeras av värdena lagrade i dess fält (instansvariabler). Dessa värden definierar objektets tillstånd vid en given tidpunkt.
* State Changes: Staten ändras när metoder kallas på objektet som modifierar värdena på dess fält.
* Objektidentitet kontra tillstånd: Det är avgörande att skilja mellan ett objekts identitet (dess unika läge i minnet) och dess tillstånd (de data den innehåller). Två objekt kan ha samma tillstånd men ändå vara olika objekt.
2. Viktiga principer och tekniker:
* inkapsling (data som gömmer sig):
* Princip: Begränsa direkt åtkomst till objektets fält. Gör fält "privat".
* Syfte: Skyddar det interna tillståndet från oavsiktlig modifiering. Låter dig kontrollera hur staten nås och ändras.
* Implementering: Använd `privata 'åtkomstmodifierare för fält. Ge offentliga "getter" (tillbehör) och "setter" (mutator) metoder för att interagera med staten på ett kontrollerat sätt.
* Exempel:
`` `Java
Public Class Person {
privat strängnamn;
privat int ålder;
offentlig person (strängnamn, int ålder) {
this.name =name;
detta.age =ålder;
}
public String getName () {
returnamn;
}
public void setName (String Name) {
this.name =name;
}
public int getage () {
Återlämnande ålder;
}
public void setage (int ålder) {
if (ålder> =0) {// validering
detta.age =ålder;
} annat {
System.out.println ("Ålder kan inte vara negativ.");
}
}
}
`` `
* kontrollerad åtkomst med getters och setters:
* getters (accessorer): "Allmänna" metoder som returnerar värdet på ett fält. De ger skrivskyddad åtkomst till objektets tillstånd.
* Setters (mutatorer): "Allmänna" metoder som tillåter modifiering av ett fälts värde. avgörande bör bosättare inkludera validering och logik för att säkerställa att staten förblir konsekvent och giltig.
* Immutability: Om du vill förhindra tillståndsförändringar efter skapandet av objekt ska du inte ge bosättare. Skapa objektet med all nödvändig tillståndsinformation i konstruktören.
* Validering:
* Syfte: Säkerställer att objektets tillstånd förblir giltigt enligt reglerna för din applikation.
* Implementering: Inkludera valideringslogik i bosättare och konstruktörer. Kontrollera om det är ogiltiga värden, såsom negativa åldrar, tomma strängar eller nummer utanför området.
* Exempel: (Se metoden "Setage" i klassen "Person" ovan.)
* Immutability:
* Princip: Ett oföränderligt objektstillstånd kan inte ändras efter att det har skapats.
* Fördelar:
* trådsäkerhet: Immutable föremål är i sig trådsäkra eftersom deras tillstånd inte kan modifieras samtidigt.
* enkelhet: Lättare att resonera om och felsöka eftersom staten är förutsägbar.
* caching: Kan säkert cachas utan att oroa sig för förändringar.
* Implementering:
* Gör alla fält "Final" och "privat".
* Ge inga bosättare.
* Om ett fält är ett muterbart objekt (som en "List" eller "Map"), returnera en defensiv kopia i Getter för att förhindra extern modifiering.
* Exempel:
`` `Java
offentlig slutklass ImmutablePoint {
privat slutlig int x;
privat slutlig int y;
offentlig immutablePoint (int x, int y) {
this.x =x;
this.y =y;
}
public int getX () {
returnera x;
}
public int gety () {
returnera y;
}
}
`` `
* observatörsmönster (för beroende objekt):
* När man ska använda: När tillståndet för ett objekt (ämnet) påverkar tillståndet för andra objekt (observatörer).
* Mekanism: Ämnet upprätthåller en lista över observatörer och meddelar dem när dess tillstånd ändras. Observatörer uppdaterar sig sedan i enlighet därmed.
* Exempel: En aktiekursspårare kanske meddelar alla registrerade investerare när priset på en aktie ändras.
* memento -mönster (för tillståndskonservering):
* När man ska använda: När du behöver spara och återställa ett objekts tillstånd vid olika tidpunkter (t.ex. för att ångra/göra om funktionalitet).
* Mekanism: Objektet skapar ett "memento" -objekt som innehåller en ögonblicksbild av dess nuvarande tillstånd. Memento kan lagras och senare användas för att återställa objektet mot det sparade tillståndet.
* tillståndsmönster (för beteende baserat på tillstånd):
* När man ska använda: När ett objekts beteende förändras beroende på dess interna tillstånd.
* Mekanism: Representera varje möjlig tillstånd som en separat klass. Kontextobjektet (objektet vars beteende förändras) har en hänvisning till ett tillståndsobjekt. När en metod kallas i sammanhanget delegerar det samtalet till det aktuella tillståndsobjektet.
* Exempel: En automat kan ha tillstånd som "inaktiv", "att välja produkt", "dispensering" och "utflyttning", var och en med olika beteenden.
* trådsäkerhet (samtidighet):
* Betydelse: Om flera trådar kan komma åt och ändra tillståndet för ett objekt samtidigt måste du säkerställa trådsäkerhet.
* Tekniker:
* Synkronisering: Använd "synkroniserade" block eller metoder för att skydda kritiska kodavsnitt där tillstånd är modifierade.
* Locks: Använd `java.util.concurrent.locks` för mer finkornig kontroll över låsning.
* atomvariabler: Använd `java.util.concurrent.atomic` klasser (t.ex.` atomicinteger`, 'atomicbooolean') för atomoperationer på primitiva typer.
* oföränderliga föremål: Som nämnts tidigare är oföränderliga föremål i sig trådsäkra.
* Exempel:
`` `Java
offentlig klassräknare {
privat int count =0;
offentlig synkroniserad tomrumsökning () {
Räkna ++;
}
public int getCount () {
returantal;
}
}
`` `
* Serialisering:
* Syfte: Konvertera ett objekts tillstånd till en ström av byte för lagring eller transmission.
* Implementering: Implementera gränssnittet `java.io.serializable`. JVM hanterar serialiseringsprocessen automatiskt. Du kan anpassa serialisering med hjälp av "Transient" -nyckelordet (för att utesluta fält) och genom att implementera "writeObject ()" och "readObject ()" -metoder.
* Överväganden: Var medveten om kompatibiliteten hos serialiserade objekt när du uppdaterar klassdefinitionen.
3. Bästa metoder:
* princip för minst privilegium: Bevilja endast åtkomst till objektets tillstånd som är absolut nödvändigt.
* Rensa namngivning: Använd beskrivande namn för fält, getters och bosättare för att göra koden lätt att förstå.
* Dokumentera din kod: Förklara syftet med varje fält och det förväntade beteendet hos getters och setters i Javadoc -kommentarer.
* Testa noggrant: Skriv enhetstester för att verifiera att objektets tillstånd hanteras korrekt och att valideringsreglerna verkställs.
* Tänk på användningsfallet: Det bästa tillvägagångssättet för statlig ledning beror på de specifika kraven i din ansökan. Välj de tekniker som ger rätt balans mellan flexibilitet, säkerhet och prestanda.
* Undvik offentliga fält: Att direkt exponera fält som "allmän" är i allmänhet dålig praxis. Det kringgår kapsling och gör det svårt att kontrollera och underhålla staten.
* defensiv kopiering: När du returnerar muterbara objekt från Getters, överväg att returnera en * defensiv kopia * för att förhindra att den som ringer från att ändra objektets interna tillstånd direkt. Detta är särskilt viktigt i oföränderliga klasser.
* Överväg att använda poster (Java 14+): Uppgifter är ett kortfattat sätt att skapa oföränderliga dataklasser. De genererar automatiskt konstruktörer, getters, `lika ()`, `hashcode ()` och `toString ()` metoder. De är väl lämpade för att representera dataöverföringsobjekt (DTO) eller enkla datastrukturer.
Sammanfattningsvis:
Att hantera objekttillstånd i Java är en kritisk aspekt av objektorienterad design. Genom att följa principer som inkapsling, immutabilitet, validering och trådsäkerhet kan du skapa robusta, underhållbara och pålitliga applikationer. De specifika teknikerna du väljer beror på komplexiteten i dina objekt och kraven i din applikation.
