Diep kopiëren en ondiepe kopie
Overzicht: In dit artikel zullen we het proces van het kopiëren van objecten in java te bespreken. Doel van kopiëren kan verschillend zijn gebaseerd op de applicatievereiste. Maar er zijn in hoofdzaak twee soorten kopiëren beschikbaar, diepe en ondiepe kopie. Werkwijze kopiëren varieert deze twee benaderingen.
Introductie:
De actie van het kopiëren van de kenmerken van het ene object naar een ander van hetzelfde type data wordt genoemd exemplaar object. In java, we hebben de volgende benaderingen van het kopiëren ene object naar een ander
- ondiepe Copy: Hier als het veld dat moet worden gekopieerd is een primitief soort, wordt de waarde wordt gekopieerd anders als het gebied dat moet worden gekopieerd is een geheugenadres (of een object zelf) dan het adres wordt gekopieerd. Dus als het adres wordt veranderd door een object, de verandering wordt overal terug te vinden.
- Deep Copy: Hier de gegevens worden gekopieerd in beide situaties. Deze benadering is duurder en langzamer.
- Lazy Copy: Dit is een combinatie van die twee benaderingen. Aanvankelijk oppervlakkige kopie benadering wordt gebruikt en vervolgens gecontroleerd of de gegevens worden gedeeld door vele voorwerpen en het programma moet een object wijzigen, de diepe kopie aanpak wordt toegepast.
Dus we kunnen het type van het kopiëren op basis van de volgende twee voorwaarden te selecteren
- Gebruik ondiepe kopiëren wanneer er geen inkapseling is vereist.
- Gebruik diepe kopiëren wanneer inkapseling is vereist.
ondiepe Copy:
In ondiepe kopie, een nieuw object gecreëerd dat de exacte kopie van de waarden in het oorspronkelijke object bevat. Ondiepe kopie volgt de bit-wise copy aanpak. In ondiep exemplaar als het veld is een geheugen adres, dan het adres wordt gekopieerd. Dus als het adres wordt veranderd door een object, de verandering wordt overal terug te vinden.
ondiepe kopie
Figure 1: Het stroomschema beschrijft ondiepe kopie
In deze figuur, het object – mainObj1 heeft een veld genoemd als field1 van een primitief soort zeggen int, en een object van het type String Als we dat doen een ondiepe kopie van mainObj1, mainObj2 is gemaakt met field2 van het type int, die de gekopieerde waarde van field1 maar de string object in mainObj2 bevat – nog steeds wijst op zichzelf objStr. Aangezien field1 is een primitief datatype, de waarde ervan wordt gekopieerd naar field2. Maar aangezien objStr een object, mainObj2 wijst naar hetzelfde adres van objStr. Zodat eventuele wijzigingen in objStr via mainObj1 gereflecteerd in mainObj2.
Implementatie:
[code]
Listing 1: Klasse SubjectVO.java beschrijft waarde object voor onderwerpen
package com.home.objectCopy;
publiek klasse SubjectVO {
prive- String name;
/**
* @return de naam
*/
publiek String getName() {
return naam;
}
/**
* @param naam
* de naam om
*/
publiek vervallen setName(String name) {
deze.name = naam;
}
publiek SubjectVO(String name) {
deze.name = naam;
}
}
[/code]
Listing 2: Klasse PupilVO.java beschrijven waarde object voor leerling
[code]
package com.home.objectCopy;
publiek klasse PupilVO gereedschap Cloneable {
// bevatte object
prive- SubjectVO subj;
prive- String name;
/**
* @return the subj
*/
publiek SubjectVO getSubj() {
return subj;
}
/**
* @param subj
* the subj instellen
*/
publiek vervallen setSubj(SubjectVO subj) {
deze.subj = subj;
}
/**
* @return de naam
*/
publiek String getName() {
return naam;
}
/**
* @param naam
* de naam om
*/
publiek vervallen setName(String name) {
deze.name = naam;
}
publiek PupilVO(String name, String sub) {
deze.name = naam;
deze.subj = nieuw SubjectVO(sub);
}
publiek object kloon() {
// ondiepe kopie
proberen {
return super.kloon();
} vangen (CloneNotSupportedException e) {
return nul;
}
}
}
[/code]
Listing3: Klasse ShallowCopyTest.java beschrijven kopieerproces
[code]
package com.home.objectCopy;
publiek klasse ShallowCopyTest {
publiek statisch vervallen hoofd-(Snaar[] args) {
// Original Object
PupilVO stud = nieuw PupilVO(“Johnathan”, “Algebra”);
Systeem.uit.println(“Original Object: ” + stud.getName() + ” – ”
+ stud.getSubj().getName());
// Clone Object
PupilVO clonedStud = (PupilVO) stud.clone();
Systeem.uit.println(“gekloonde Object: ” + clonedStud.getName() + ” – ”
+ clonedStud.getSubj().getName());
stud.setName(“Daniel”);
stud.getSubj().setName(“Fysica”);
Systeem.uit.println(“Originele Object nadat het is bijgewerkt: ”
+ stud.getName() + ” – ” + stud.getSubj().getName());
Systeem.uit.println(“Gekloonde Object na het updaten originele object: ”
+ clonedStud.getName() + ” – ”
+ clonedStud.getSubj().getName());
}
}
[/code]
uitgang: De uitvoer van dit programma is als in
Original Object: Johnathan – Algebra
gekloonde Object: Johnathan – Algebra
Originele Object nadat het is bijgewerkt: Daniel – Fysica
Gekloonde Object na het updaten originele object: Johnathan – Fysica
Hier zien we dat de waarde van de naam van het veld wordt gewijzigd nadat het kopiëren, maar de waarde van het object subject blijft hetzelfde als het wijst naar hetzelfde geheugen adres. Vandaar dat het onderwerp voor Jonathan wordt 'Physics’ waar zoals het zou moeten zijn 'Algebra’ als het object SubjectVO in de gekloonde object blijft ongewijzigd.
Deep Copy:
In diepe kopie, niet alleen alle velden van een object gekopieerd, alle dynamisch toegewezen geheugen adres wordt opgemerkt dat materiaal gekopieerd.
Deep Copy
Figure 2: Het schema beschrijft diepe kopieerproces
In deze figuur, het object mainObj1 heeft velden field1 een primitief datatype zeggen int, en een object van het type String Als we dat doen een diepe kopie van mainObj1, mainObj2 is gemaakt met field2 met de gekopieerde waarde van field1 en objStr2 wordt gecreëerd die de gekopieerde waarde van objStr1 bevat dus alle wijzigingen aan objStr1 in mainObj1 zal niet overeen met in mainObj2.
Implementatie:
Listing4: Klasse beschrijven diepe kopie
[Code]
package com.home.DeepCopy;
publiek klasse PupilVO gereedschap Cloneable {
// bevatte object
prive- SubjectVO subj;
prive- String name;
/**
* @return the subj
*/
publiek SubjectVO getSubj() {
return subj;
}
/**
* @param subj
* the subj instellen
*/
publiek vervallen setSubj(SubjectVO subj) {
deze.subj = subj;
}
/**
* @return de naam
*/
publiek String getName() {
return naam;
}
/**
* @param naam
* de naam om
*/
publiek vervallen setName(String name) {
deze.name = naam;
}
publiek PupilVO(String name, String sub) {
deze.name = naam;
deze.subj = nieuw SubjectVO(sub);
}
publiek object kloon() {
// deep copy
PupilVO pupil = nieuw PupilVO(naam, subj.getName());
return leerling;
}
}
[/code]
Het enige verschil tussen deze benadering en de eerdere benadering is dat de kloon werkwijze de PupilVO een nieuw gecreëerde PupilVO object retourneert. Dit zorgt ervoor dat wanneer het kopie mechanisme gestart, het object SubjectVO wordt ook veranderd. Deep exemplaar heeft een alternatieve aanpak – serialisatie. in serialisatie, het gehele object grafiek is geschreven in een aanhoudende winkel en teruglezen wanneer dat nodig is. Dus wanneer we lezen het object uit de aanhoudende winkel, het oorspronkelijke object wordt verwezen.
Het gebruik van ondiepe kopiëren en deep copy:
Er is geen vaste regel gedefinieerd voor het kiezen tussen ondiep kopiëren en diepe kopie maar normaal gesproken moeten we in gedachten houden dat als een object heeft slechts primitieve velden, dan natuurlijk moeten we gaan voor ondiep exemplaar, maar als het object verwijzingen naar andere objecten, Vervolgens gebaseerd op de eis, ondiepe kopie of diep kopie moet worden gedaan. Als de referenties niet worden bijgewerkt, dan is er geen zin om een diepe kopie te starten.
Leg lui copy:
Een luie kopie kan worden gedefinieerd als een combinatie van beide ondiepe kopiëren en deep copy. Het mechanisme volgt een eenvoudige benadering – in de oorspronkelijke staat, ondiepe kopie aanpak wordt toegepast. Een teller wordt ook gebruikt om een spoor op hoeveel objecten delen gegevens bewaren. Wanneer het programma wil het oorspronkelijke object wijzigen, controleert of het object niet wordt gedeeld of. Als het object wordt gedeeld, dan is de diepe kopie mechanisme wordt geïnitieerd.
Summary:
In ondiepe kopie, Alleen de velden van de primitieve datatype worden gekopieerd, terwijl de objecten referenties niet worden gekopieerd. Deep kopie omvat de kopie van de primitieve datatype evenals objet referenties. Er is geen vaste regel te bepalen wanneer zij ondiepe kopie doen en wanneer een diepe kopie te doen. Lui exemplaar een combinatie van beide benaderingen.
