Създаване на локални копия

Създаване на локални копия

• 
  Автоматично се създават псевдоними при предаването на аргументите.
  
• 
  Няма локални обекти, а само локални манипулатори.
  
• 
  Манипулаторите имат обхвати, обектите нямат.
  
• 
  В Java не стои въпросът с времето на живот на обектите.
  
• 
  Няма поддръжка от езика (напр. като const) за предотвратяване моди­фи­ци­ра­нето на обект (за предпазване от отрицателните ефести на псев­до­ни­ми­те).
  

Предаване по стойност

1. 
   Java дава всичко по стойност. Когато давате примитиви на метод, имате различно копие на примитива. Когато давате манипулатор на метод, имате ко­пие на манипулатора. Ergo, всичко се предава по стойност. Разбира се, предположението е че винаги мислите (и правите) да се предават ма­ни­пу­ла­то­ри, но изглежда каточели дизайнът на Java е изминал голям път нанатък поз­волявайки ви (товечето време) да работите с манипулатор. Тоест, изглежда да мислите за манипулатора като за “обекта,” понеже всяко извикване на метод работи с обекта.
   
2. 
   Java подава примитивите по стойност (няма аргумент), но обектите се пре­да­ват с позоваване. Това е световната координатна система където ма­ни­пу­ла­торите са псевдоними на обектите, така че не мислите за подаване на ма­ни­пулатори, ами казвате “Аз предавам обект.” Доколкото не се работи с ло­кално копие на обекта като го давате за аргумент, обектите явно не се пре­дават по стойност. Види се има поддръжка за тази гледна точка от Sun, по­неже една от “резервираните но не реализирани” ключови думи е byvalue. (Никой не знае, обаче, дали тя ще види бялелия свят някой ден.)
   

Клониране на обекти

//: c12:Cloning.java

// The clone() operation works for only a few

// items in the standard Java library.

import java.util.*;
class Int {

private int i;

public Int(int ii) { i = ii; }

public void increment() { i++; }

public String toString() {

return Integer.toString(i);

}

}
public class Cloning {

ArrayList v = new ArrayList();

for(int i = 0; i < 10; i++ )

v.add(new Int(i));

System.out.println("v: " + v);

ArrayList v2 = (ArrayList)v.clone();

// Increment all v2's elements:

for(Iterator e = v2.iterator();

e.hasNext(); )

((Int)e.next()).increment();

// See if it changed v's elements:

System.out.println("v: " + v);

}

} ///:~

Може да видите ефекта от плиткото копиране в изхода, където операциите изпълнени над v2 засягат v:

v: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

v: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Да не се прилага clone( ) към обектите съдържани в ArrayList е вероятно добро пред­положение, понеже не е сигурно, че всички те са клонируеми.²

Правене на клас клонируем

Използване на трик с protected

Integer x = new Integer(1);

x = x.clone();

ще получите, по време на компилация, съобщение за грешка, казващо че clone( ) не е достъпенe (понеже Integer не го подтиска и се вика този по под­раз­би­ране - protected версията).

Ако, обаче, сте в клас извлечен от Object (както всички класове са), имате поз­во­лението да викате Object.clone( ) понеже той е protected и вие сте в на­след­ни­ка. Базовият клас clone( ) има полезна функционалност – прави фактическо по­би­тово копие на обекта на извлечения клас, съгласно с общия смисъл на опе­ра­цията клониране . Обаче тогава трябва да направите вашата клонираща опе­ра­ция public за да бъде достъпна. Така че двата ключови въпроса при кло­ни­ра­не­то са: практически винаги се вика super.clone( ) и се прави public.

Вероятно бихте искали да подтиснете clone( ) в по-нататък извлечени класове, ина­че вашият (сега public) clone( ) ще се използва, а това може да не е точното не­що (макар и, понеже Object.clone( ) прави копие на фактическия обект, боже и да бъде). Трикът с protected работи еднократно, първият път когато на­сле­ди­те от клас който не е клонируем и го направите клонируем. Във всички класове на­следени от вашия клас методът clone( ) е достъпен понеже е невъзможно в Java да се намали достъпът на метод при наследяване. Тоест, щом класът е кло­ни­руем, всичко извлечено от него е клонируемо, ако не използвате механизма (опи­сан по-късно) за “изключване” на клонирането.

Прилагане на интерфейса Cloneable

interface Cloneable {}

Причината за прилагане на този празен interface очевидно не е че въз­на­ме­ря­ва­те да правите ъпкаст към Cloneable и да викате някой от неговите методи. Из­полз­ването на interface тук е малко като “hack” понеже се използва не по пред­наз­начение. Прилагането на Cloneable interface работи като флаг, вграден в ти­па на класа.

Има две причини за съществуването на Cloneable interface. Първо, бихте могли да имате ъпкастнат манипулатор към базовия клас и да не може да определите обек­тът клонируем ли е или не. В този случай може да използвате ключовата ду­ма instanceof (описана в глава 11) за да намерите дали манипулаторът сочи към обект който може да бъде клониран:

if(myHandle instanceof Cloneable) // ...

Втората причина е допускането, че вероятно не бихте искали всички обекти да бъ­дат клонируеми. Така Object.clone( ) потвърждава дали класът прилага Cloneable интерфейс. Ако не, той изхвърля CloneNotSupportedException из­клю­чение. Изобщо, принудени сте да implement Cloneable като част от под­дръж­ката на клониране (в езика).

Успешно клониране

//: c12:LocalCopy.java

// Creating local copies with clone()

import java.util.*;

int i;

public Object clone() {

Object o = null;

try {

} catch (CloneNotSupportedException e) {

System.out.println("MyObject can't clone");

}

return o;

public String toString() {

return Integer.toString(i);

}

}

static MyObject g(MyObject v) {

// Passing a handle, modifies outside object:

v.i++;

}

static MyObject f(MyObject v) {

v.i++;

}

public static void main(String[] args) {

MyObject b = g(a);

// Testing handle equivalence,

// not object equivalence:

if(a == b)

System.out.println("a == b");

else

System.out.println("a != b");

System.out.println("b = " + b);

MyObject c = new MyObject(47);

MyObject d = f(c);

if(c == d)

System.out.println("c == d");

else

System.out.println("c != d");

System.out.println("d = " + d);

}

} ///:~

В LocalCopy двата метода g( ) и f( ) демонстрират разликата между двата под­хо­да към подаването на аргументи. g( ) показва подаването по указател и мо­ди­фи­цирането на външния обект и връща указател към него, докато f( ) клонира ар­гумента, по този начин разделяйки го от оригиналния обект. После може да пра­ви каквото си иска, даже да върне манипулатор към този нов обект без да за­сегне външния изобщо. Забележете следния някакси любопитно изглеждащ опе­ратор:

v = (MyObject)v.clone();

Това е където е създадено локалното копие. За да се предотврати смущението от такъв оператор, напомняме че такъв странен програмен идиом е перфектен в Java понеже всичко което има име е фактически манипулатор. Така че ма­ни­пу­ла­торът v се използва за clone( ) на копие от това, към което е насочен, а се връ­ща манипулатор към базовия обект Object (понеже е дефинирано по този начин в Object.clone( )) което после трябва да се преобразува в правилния тип.

В main( ) се тества разликата между двата подхода в двата аргумента. Изходът е:

a == b

b = 12

c = 47

Важно е да се отбележи, че тестването за равенство в Java не гледа съ­дър­жа­ние­то на сравняваните обекти. Операторите == и != просто сравняват съ­дър­жа­ние­то на манипулаторите. Ако адресите в манипулаторите са едни и същи, ма­ни­пу­латорите сочат един и същ обект и затова са “равни.” Така че операциите фак­тически проверяват дали двата манипулатора са псевдоними на един и същи обект!

Ефектът от Object.clone( )

Каквото и да правите, първо ще се вика super.clone( ) в процеса на кло­ни­ра­не­то. Това дава основа на цялата операция чрез създаването на точен дубликат. След тази точка може да направите каквото трябва за да завърши клонирането (кое­то може и да не трябва да е точно копиране - б.пр.).

За да определите какви трябва да бъдат допълнителните операции, трябва да знае­те какво точно прави Object.clone( ). В частност, дали клонира на­зна­че­ние­то на всички манипулатори? Следния пример проверява това:

//: c12:Snake.java

// Tests cloning to see if destination of

// handles are also cloned.

private Snake next;

private char c;

// Value of i == number of segments

Snake(int i, char x) {

c = x;

next = new Snake(i, (char)(x + 1));

}

void increment() {

if(next != null)

next.increment();

}

public String toString() {

if(next != null)

s += next.toString();

return s;

}

public Object clone() {

try {

} catch (CloneNotSupportedException e) {}

return o;

}

public static void main(String[] args) {

System.out.println("s = " + s);

Snake s2 = (Snake)s.clone();

System.out.println("s2 = " + s2);

s.increment();

System.out.println(

"after s.increment, s2 = " + s2);

}

} ///:~

Методът increment( ) рекурсивно инкрементира всеки белег, така че може да ви­дите промените, а toString( ) рекурсивно извежда всеки белег. Изходът е:

s = :a:b:c:d:e

s2 = :a:b:c:d:e

after s.increment, s2 = :a:c:d:e:f

Това значи, че само първият сегмент е дублициран от Object.clone( ), така че се пра­ви плитко копие. Ако искате да се дублицира цялата змия – дълбоко ко­пи­ра­не – трябва да извършите допълнителни операции във вашия подтиснат clone( ).

Типично ще викате super.clone( ) във всеки клас извлечен от клонируем клас за да се осигури че всички операции от базовия клас (включително Object.clone( )) ще се извършат. Това е последвано от явно извикване на clone( ) за всеки ма­ни­пу­латор във вашия обект; иначе те ще станат псевдоними на тези в оригиналния обект. Това е аналогично на начина на викане на конструктори – конструктора на базовия клас пърно, после следващият извлечен конструктори така нататък до крайния извлечен конструктор. Разликата е че clone( ) не е конструктор така че нищо не го кара да става автоматично. Трябва да го правите сами.

Клониране на композиран обект

Този пример показва какво ще трябва да направите та дълбоко да копирате ком­позиран обект:

//: c12:DeepCopy.java

// Cloning a composed object

private double depth;

public DepthReading(double depth) {

this.depth = depth;

}

public Object clone() {

try {

} catch (CloneNotSupportedException e) {

e.printStackTrace();

}

return o;

}
class TemperatureReading implements Cloneable {

private long time;

private double temperature;

public TemperatureReading(double temperature) {

time = System.currentTimeMillis();

this.temperature = temperature;

}

public Object clone() {

try {

} catch (CloneNotSupportedException e) {

e.printStackTrace();

}

return o;

}
class OceanReading implements Cloneable {

private DepthReading depth;

private TemperatureReading temperature;

public OceanReading(double tdata, double ddata){

temperature = new TemperatureReading(tdata);

depth = new DepthReading(ddata);

}

public Object clone() {

try {

} catch (CloneNotSupportedException e) {

e.printStackTrace();

}

// Must clone handles:

o.temperature =

(TemperatureReading)o.temperature.clone();

return o; // Upcasts back to Object

}

}
public class DeepCopy {

OceanReading reading =

new OceanReading(33.9, 100.5);

// Now clone it:

OceanReading r =

(OceanReading)reading.clone();

}

} ///:~

Дълбоко копиране на ArrayList

//: c12:AddingClone.java

// You must go through a few gyrations to

// add cloning to your own class.

import java.util.*;
class Int2 implements Cloneable {

private int i;

public Int2(int ii) { i = ii; }

public void increment() { i++; }

public String toString() {

return Integer.toString(i);

}

public Object clone() {

try {

} catch (CloneNotSupportedException e) {

System.out.println("Int2 can't clone");

}

return o;

}
// Once it's cloneable, inheritance

// doesn't remove cloneability:

class Int3 extends Int2 {

private int j; // Automatically duplicated

public Int3(int i) { super(i); }

}
public class AddingClone {

public static void main(String[] args) {

Int2 x = new Int2(10);

Int2 x2 = (Int2)x.clone();

x2.increment();

System.out.println(

"x = " + x + ", x2 = " + x2);

// Anything inherited is also cloneable:

Int3 x3 = new Int3(7);

x3 = (Int3)x3.clone();

for(int i = 0; i < 10; i++ )

v.add(new Int2(i));

System.out.println("v: " + v);

ArrayList v2 = (ArrayList)v.clone();

// Now clone each element:

for(int i = 0; i < v.size(); i++)

v2.set(i, ((Int2)v2.get(i)).clone());

// Increment all v2's elements:

for(Iterator e = v2.iterator();

e.hasNext(); )

((Int2)e.next()).increment();

// See if it changed v's elements:

System.out.println("v: " + v);

System.out.println("v2: " + v2);

}

} ///:~

Може да видите какво е необходимо за дълбоко копиране на ArrayList: След ка­то е клониран ArrayList трябва да преминете по всички сочени от ArrayList обек­ти и да ги клонирате. Нещо подобно трябва да направите за дълбоко ко­пи­ра­не на HashMap.

Останалата част от примера показва че е станало клонирането понеже, веднъж като е клониран обектът, може да го променяте и оригинарът да остане не­за­сег­нат.

Дълбоко копиране чрез сериализация

Така че защо да не се използва сериализацията за постигане на дълбоко ко­пи­ра­не? Ето пример който сравнява двата подхода чрез измерване на времето за из­пъл­нение:

//: c12:Compete.java

import java.io.*;

class Thing2 implements Serializable {

Thing1 o1 = new Thing1();

}
class Thing3 implements Cloneable {

public Object clone() {

Object o = null;

try {

o = super.clone();

System.out.println("Thing3 can't clone");

}

return o;

}
class Thing4 implements Cloneable {

Thing3 o3 = new Thing3();

public Object clone() {

Thing4 o = null;

try {

} catch (CloneNotSupportedException e) {

System.out.println("Thing4 can't clone");

}

// Clone the field, too:

return o;

}

}
public class Compete {

public static void main(String[] args) {

Thing2[] a = new Thing2[SIZE];

for(int i = 0; i < a.length; i++)

a[i] = new Thing2();

Thing4[] b = new Thing4[SIZE];

for(int i = 0; i < b.length; i++)

b[i] = new Thing4();

try {

long t1 = System.currentTimeMillis();

new ByteArrayOutputStream();

ObjectOutputStream o =

new ObjectOutputStream(buf);

for(int i = 0; i < a.length; i++)

o.writeObject(a[i]);

// Now get copies:

ObjectInputStream in =

new ObjectInputStream(

new ByteArrayInputStream(

buf.toByteArray()));

Thing2[] c = new Thing2[SIZE];

for(int i = 0; i < c.length; i++)

c[i] = (Thing2)in.readObject();

long t2 = System.currentTimeMillis();

System.out.println(

"Duplication via serialization: " +

(t2 - t1) + " Milliseconds");

// Now try cloning:

t1 = System.currentTimeMillis();

Thing4[] d = new Thing4[SIZE];

for(int i = 0; i < d.length; i++)

d[i] = (Thing4)b[i].clone();

t2 = System.currentTimeMillis();

System.out.println(

"Duplication via cloning: " +

(t2 - t1) + " Milliseconds");

} catch(Exception e) {

e.printStackTrace();

}

}

Duplication via serialization: 3400 Milliseconds

Duplication via cloning: 110 Milliseconds
Duplication via serialization: 3410 Milliseconds

Duplication via cloning: 110 Milliseconds

Duplication via cloning: 110 Milliseconds

Напук на обевидно огромната разлика във времето за сериализация и кло­ни­ра­не, също ще забележите и че сериализационната техника значително варира по про­дължителност, докато клонирането става за еднакво време всеки път.

Добавяне на клонируемост надолу по йерархията

//: c12:HorrorFlick.java

// You can insert Cloneability at any

// level of inheritance.

import java.util.*;
class Person {}

class Hero extends Person {}

class Scientist extends Person

implements Cloneable {

public Object clone() {

try {

} catch (CloneNotSupportedException e) {

// this should never happen:

// It's Cloneable already!

throw new InternalError();

}

}

class MadScientist extends Scientist {}

public static void main(String[] args) {

Person p = new Person();

Hero h = new Hero();

Scientist s = new Scientist();

MadScientist m = new MadScientist();

// h = (Hero)h.clone(); // Compile error

s = (Scientist)s.clone();

m = (MadScientist)m.clone();

}

} ///:~

Защо този странен дизайн?

Ако всичко това изглежда странна схема, така е, защото тя наистина е такава. Мо­же да се чудите защо е направено по този начин. Какво се крие зад този ди­зайн? Това което следва не е доказана прецизна история – може би защото тър­го­вията около Java го показва като перфектно проектиран език – но тя върви дъл­го по пътя към обасняването защо нещата са такива, каквито са се оказали.

Оригинално Java беше замислена като език за управление на хардуерни устрой­ства и определено не с Internet в замисъла. В език с общо предназначение като то­зи има смисъл да се даде възможност програмистът да клонира всеки обект. Та­ка clone( ) беше сложен в кореновия клас Object, но беше public метод така че всеки обект можеше да се клонира. Това изглеждаше като най-разумен под­ход и, най-после, как можеше да навреди?

Добре, когато Java се виждаше вече като чудесен език за програмиране в/за Inter­net, нещата се промениха. Внезапно изскочиха изискванията за сигурност и, разбира се, тяхната връзка с използването на обекти, и липсата на желание всич­ки обекти да могат да бъдат клонирани от когото и да е. Така че това което се вижда са множеството кръпки по първоначалната праволинейна и проста схе­ма: clone( ) е сега protected в Object. Трябва да го подтиснете и да implement Cloneable и да работите с изключенията.

Нищо не е че трябва да използвате Cloneable интерфейса самоако се каните да викате clone( ) на Object понеже той проверява по време на изпълнение дали обек­тът е Cloneable. Но за пълнота (и понеже Cloneable е празен така или ина­че) ще го прилагате.

Каталог: Java
Java -> Лекция Изключения. Уравнение на КортевегДеВриз
Java -> Създаване на прозорци и аплети
Java -> Лекция 2 Типове данни. Класове и обекти. Числено интегриране
Java -> Национална академия по разработка на софтуер
Java -> Java за цифрово подписване на документи в уеб
Java -> Запознаване с JavaScript. Запознаване с Java Script
Java -> Програма за изчисляване на средна стойност

Изтегляне 13.53 Mb.

Сподели с приятели: