Erste Schritte Übergabe von Klassen

[cppvoid]

Ich programmiere schon eine Weile in C++ und versuche mir nun Java beizubringen. Im Moment lese ich das Buch Effective Java 2nd Edition. Um das was ich gelesen habe zu verstehen, habe ich ein kleines Programm geschrieben. Nun bin ich etwas verwirrt, denn ich habe gelernt, dass das übergeben von Kopien(defensive copying) seht teuer ist. Deswegen habe ich versucht, so viel wie möglich immutable zu machen. Ich würde gerne wissen, ob mein Code kritischen Anfängerfehler enthält. Eine andere Frage ist, wie ich am besten damit umgehe, wenn sich der Name einer Person doch einmal ändernt? Ich dachte mir die einzige Möglichkeit wäre ein neues Objekt zu erstellen und das alte Objekt mit dem neuen auszutauschen, oder sollte Person nicht immutable sein?

//PhoneNumber.class
package cppvoid.addressbook.data;

import java.io.Serializable;

public final class PhoneNumber implements Serializable {
    private final String number;

    public PhoneNumber(String number) {
        this.number = number;
    }

    public String getNumber() {
        return number;
    }

    @Override
    public String toString() {
        return number;
    }
}
//Person.class
package cppvoid.addressbook.data;

import java.io.Serializable;
import java.util.*;
import java.time.*;

public final class Person implements Serializable{
    private final String firstName;
    private final String lastName;
    private final LocalDate dateOfBirth;
    private LinkedList<PhoneNumber> phoneNumbers = new LinkedList<>();

    public Person(String firstName, String lastName, LocalDate dateOfBirth) {
        this.firstName = firstName;
        this.lastName = lastName;

        if(dateOfBirth.isAfter(LocalDate.now())) {
            throw new IllegalArgumentException("date is not in the past");
        }

        this.dateOfBirth = dateOfBirth;
    }

    public Person(Person p) {
        this.firstName = p.firstName;
        this.lastName = p.lastName;
        this.dateOfBirth = p.dateOfBirth;
        this.phoneNumbers = new LinkedList<>(p.phoneNumbers);
    }

    public String getFirstName() {
        return firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public LocalDate getDateOfBirth() {
        return dateOfBirth;
    }

    public int getAge() {
        Period p = Period.between(dateOfBirth, LocalDate.now());

        return p.getYears();
    }

    public void addPhoneNumber(PhoneNumber number) {
        if(number == null) {
            throw new NullPointerException("PhoneNumber is null");
        }
        phoneNumbers.add(number);
    }

    public LinkedList<PhoneNumber> getPhoneNumbers() {
        return new LinkedList<>(phoneNumbers);
    }
}
//PersonsFile.class
import cppvoid.addressbook.data.Person;

import java.util.*;
import java.io.*;

public final class PersonsFile {
    public static final boolean save(String filePath, final LinkedList<Person> persons) {
        try(FileOutputStream fileStream = new FileOutputStream(filePath);
            ObjectOutputStream objectStream = new ObjectOutputStream(fileStream)) {

            objectStream.writeObject(persons);
            return true;
        }
        catch(IOException ex) {
            ex.printStackTrace();
            return false;
        }
    }

    public static final LinkedList<Person> load(String filePath) {
        LinkedList<Person> persons = null;

        File file = new File(filePath);
        if(!file.exists()) {
            return new LinkedList<>();
        }

        try(FileInputStream fileStream = new FileInputStream(filePath);
            ObjectInputStream objectStream = new ObjectInputStream(fileStream)) {

            persons = (LinkedList<Person>) objectStream.readObject();
        }
        catch(IOException | ClassNotFoundException ex) {
            ex.printStackTrace();
        }

        if(persons == null) {
            persons = new LinkedList<>();
        }

        return persons;
    }
}
//AddressBook.class
package cppvoid.addressbook;

import cppvoid.addressbook.data.Person;
import cppvoid.addressbook.io.PersonsFile;

import java.util.*;

public final class AdressBook implements Iterable<Person> {
    private final String filePath;
    private LinkedList<Person> persons;

    public AdressBook(String filePath) {
        this.filePath = filePath;

        persons = PersonsFile.load(filePath);
    }

    public void addPerson(Person p) {
        if(p == null) {
            throw new NullPointerException("Person is null");
        }
        persons.add(new Person(p));
    }

    public boolean save() {
        return PersonsFile.save(filePath, persons);
    }

    @Override
    public Iterator<Person> iterator() {
        return persons.iterator();
    }
}

Danke für eure Zeit.

 

[InfectedBytes]

Wenn der Name veränderbar sein sollte, dann sollte er natürlich mutable sein. Immer neue Objekte erzeugen und sie überall zu ersetzen ist sehr umständlich und teuer, vor allem wenn man bedenkt dass man auch einfach das Feld mutable machen kann.

Außerdem wird in Java zwar jede Variable per Value übergeben, aber bei Objekten heißt das nur, dass die Referenz kopiert wird und nicht das ganze Objekte

 

[stg]

ich habe gelernt, dass das übergeben von Kopien(defensive copying) seht teuer ist. Deswegen habe ich versucht, so viel wie möglich immutable zu machen.

Den Zusammenhang verstehe ich nicht.

persons.add(new Person(p));

Gerade dann, wenn Person immutable ist, macht das für mich keinen Sinn. Füge doch direkt p der Liste hinzu!

oder sollte Person nicht immutable sein?

Ob etwas immutable sein sollte, oder nicht, hängt immer davon ab, wo und wie du die Instanzen später einmal verwenden willst. Das ist in erster Linie eine Design-Entscheidung, die getroffen wird. Man muss nur wissen, ob etwas immutable ist oder nicht und dann dementsprechend damit arbeiten. Bei Personen würde ich das wenigstens fragwürdig finden. Wie du selbst sagst ändert sich dann doch mal der Name. Wenn du zum Ändernd des Namens eine neue Person anlegen musst, dann musst du diese auch in allen Relationen, in denen die Person auftaucht, neu verdrahten.