Speichern

[Trabbelmaker]

Guten Tag,
ich habe ein Problem mit den Speichern.
Erstmal will ich den Code zeigen:
Die Klasse Vorname:

package personen.Informations.system;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Scanner;

class Vorname {
	private String vorname1;
	
	BufferedReader breader = new BufferedReader(new InputStreamReader(System.in));
	
	public void eingabeVorname() {
		Scanner scan = new Scanner(System.in);
		Speichern speichern = new Speichern();
		System.out.println(">>>>Wie lautet dein Vorname?<<<<");
		System.out.println("Schreib bitte dein Name in der Chatleiste.");
		String temp = scan.nextLine();
		speichern.setVorname(temp);
		
	}
}

Und die Klasse Speichern:

package personen.Informations.system;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

class Speichern {
	private String vorname;
	/*private String[] e = { String vorname };*/
	
	FileWriter writer;
	File file;
	
	public void setVorname(String vornamexyz) {
		vorname = vornamexyz;
	}
	
	public String getVorname() {
		return vorname;
	}

	public void schreiben() {
		file = new File("Personeninformationen.txt");
		try {
			writer = new FileWriter(file ,true);
		    writer.write("Name: " + vorname + " "); 
		    writer.write(System.getProperty("line.separator"));    
		    writer.flush();
		    writer.close();
		    System.out.println("Die Datei wurde gespeichert!");
		} catch (IOException e) {
		     e.printStackTrace();
		}
	}
}

Mein Problem:
Ich will, dass die Angaben, die ich in der Klasse Vorname schreibe, nach der Klasse Speichern übergeben werden und dort in die txt Datei Personeninformationen.txt gespeichert wird. Nur ich weiß nicht, wie ich
das machen soll. Ich habe schon Google gefragt, aber nichts passendes gefunden :/.
Besser wär es noch, wenn man erst alle Angaben machen könnte und ganz zum Schluss erst alles gespeichert wird. Ein Beispiel: Ich gebe mein Vorname ein, dann wird er irgendwo zwischengespeichert und dann gebe ich mein Alter ein und das wird auch zwischengespeichert. Wenn alle Angaben vorhanden sind, wird alles in der Personeninformation.txt gespeichert.


Mit freundlichen Grüßen,
Trabbelmaker

 

[kaoZ]

Du könntest / solltest ein VO erstellen , also ein ValueObjekt, welches die Daten enthält, und dieses dann deiner klasse die das speichern übernimmt übergeben.

z.B sowas in der art, wobei hier Daten natürlich nicht der Optimale Name wäre

public class Daten{

	private String vorname;
	private String name;
	
	public Daten(String vorname, String name){
		this.vorname = vorname;
		this.name = name;
	}
	
	public String getVorname()				{return vorname;}
	public String getName()					{return name;}
}

ein wirklich ziemlich einfach und uninnovativer Datenhandler könnte dann so aussehen.

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;


public class DataHandler{

	public static void save(Daten daten, String path){

		BufferedWriter writer;
		
		try {
			writer = new BufferedWriter(new FileWriter(new File(path)));
			writer.write(daten.getVorname());
			writer.write(daten.getName());
			writer.close();
		}
		catch (Exception ex) {
			ex.printStackTrace();
		}
	}
}

Der aufruf wäre dann wie folgt :

public static void main(String[] args){
		Daten d = new Daten("Michael","Musterman");
		
		DataHandler.save(d, "H:/Apps/Test.txt");
	}

aber das ist wie gesagt nur schnell mal zusammengewürfelt, und auch nicht wiederverwertbar, außer für deinen speziellen Fall .

BTW : in deinem Code , die Klasse Speichern sollte keine kenntniss von irgendwelchen namen oder anderen Feldern bzw. Attributen haben , sondern lediglich die Aufgabe des speicherns übernehmen.

Ausserdem würde ich in deinem Fall dazu übergehen und Serialisieren ( also das Objekt Speichern), anstelle einfach den plain Text in eine Datei zu schreiben.

 

[Trabbelmaker]

Ich habe das jetzt so übernommen und bearbeitet, aber er zeigt noch mehrere Fehler an.
In der Speicherklasse:

package personen.Informations.system;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileWriter;
import java.io.InputStreamReader;

class Speichern {
	
	public static void save(Vorname daten) {
		
		BufferedWriter writer; //Fehler: BufferedWriter cannot be resolved to a type
		
		try {
			writer = new BufferedWriter(new FileWriter(new File(path))); //Fehler: Genau das gleiche
			writer.write(daten.eingabeVorname());
			//writer.write(daten.getName());
			writer.close();
		}
		catch (Exception ex) {
			ex.printStackTrace();
		}
	}
}

Und in der Klasse Vorname:

package personen.Informations.system;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Scanner;

class Vorname {
	private String vorname1;
	BufferedReader breader = new BufferedReader(new InputStreamReader(System.in));
	
	public void eingabeVorname() {
		System.out.println(">>>>Wie lautet dein Vorname?<<<<");
		System.out.println("Schreib bitte dein Name in der Chatleiste.");
		
		try {
			vorname1 = breader.readLine();
		} catch (IOException e) {
			System.out.println("Es ist ein Fehler aufgetreten: " + e);
		}
		
		Speichern d = new Speichern(vorname1);
		Speichern.save(d, "H:/Apps/Test.txt");
	}
}

Das spuckt mein Editor aus:

Exception in thread "main" java.lang.Error: Unresolved compilation problems: 
	The constructor Speichern(String, String) is undefined
	The method save(Vorname, String) in the type Speichern is not applicable for the arguments (Speichern, String)

	at personen.Informations.system.Vorname.eingabeVorname(Vorname.java:15)
	at personen.Informations.system.Hauptklasse.vornamensetzen(Hauptklasse.java:8)
	at personen.Informations.system.HauptklasseStarter.main(HauptklasseStarter.java:7)

 

[kaoZ]

Da steht dein Fehler

The constructor Speichern(String, String) is undefined
The method save(Vorname, String) in the type Speichern is not applicable for the arguments (Speichern, String)

du musst hier ein DatenObjekt erzeugen , kein speicherObjekt^^ und dies dann der statischen hilfsmethode der Klasse Speichern übergeben.

Das hier ist nicht korrekt

peichern d = new Speichern(vorname1);
Speichern.save(d, "H:/Apps/Test.txt");

Der richtige weg wäre du erstellst eine Klasse welche die eingaben auf der Konsole erhält , daraus ein DatenObjekt erzeugt, und dieses dann an die Klasse speichern übergibt.

 

[Trabbelmaker]

Wie kann ich das den machen.

 

[kaoZ]

Du erstellt dir eine Klasse welche für das erfassen deiner Eingaben zuständig ist, diese hält z.B eine Referenz auf dein Objekt und füllt dieses Mit Daten , fragt ab ob gespeichert werden soll oder nicht und nutzt dann die Statische hilfsmethodeder Klasse dataHandler um das Objekt / dessen inhalt zu speichern.

 

[Bug Fisher]

EIN Vorschlag wäre folgendes Gerüst:

class Main {
  public static void main(String[] args) {
    final Data data = readFromConsole();
    
    //so...
    data.save();

    //oder so...
    Data.save(data);
  }

  private static Data readFromConsole() {
    final String[] msgs = "Vorname angeben,Nachname angeben,foo bar".split(",");
    String[] fields = new String[n];

    //elided

    assert(msgs.length == fields.length); //kannst du auch weglassen, ist aber sehr nützlich 
    
    for(int i = 0; i < fields.length; ++i) {
      System.out.println(msgs[i]);
      fields[i] = breader.readLine();
    }

    return new Data(fields);
  }
}

public class Data {
  private final String[] fields;

  public Data(final String... fields) {
    this.fields = fields;
  }

  //so...
  public void save() {

  }

  //oder so...
  public static void save(final Data instance) {

  }
}

 

[Trabbelmaker]

Da ich hier gerade nicht mehr mitkomme (Bin immer noch Java Anfänger)
wollte ich mal fragen ob das so auch geht.
Nachdem ich den Namen eingegeben habe, wird der String in eine andere
Klasse namens "Speichern" übergeben und dort erstmal gelagert.
Nach dem ich die anderen Angaben gegeben habe (z.B: Alter, Wohnort)
werden alle Angaben Automatisch gespeichert.
(Wichtig ist, dass alles zum Schluss gespeichert, weil ich irgendwo gelesen habe,
dass man nicht zu oft auf die Festplatte zugreifen soll. Irgendwie soll das erstmal
auf den Arbeitsspeicher gespeichert werden und dann zum Schluss in die .txt Datei.)
Ich will auch noch kein Fortschrittliches Java haben, nur das, was man so am Anfang hat,
weil ich im Buch auch noch nicht soweit bin

Mit freundlichen Grüßen,
Trabbelmaker

 

[kaoZ]

Ich werde dir mal ein einfaches beispiel zu dem vorgang den ich beschrieben habe posten , dieser ist , wie schon erwähnt leicht verständlich unterteilt und ( in diesem Fall ) auf dein konkretes Problem zugeschnitten.

Gib mir einen Moment

Also , es setzt sich wie folgt zusammen :

4 Klassen, jede klasse übernimmt dabei eine Aufgabe :

Name.java
Handler.java
Input.java
Test.java

Hier erstmal die Klassen, wie gesagt das ganze ist nicht sonderlich innovativ, da es nur für dein Konkretes Problem umgesetzt ist, aber vielleicht kannst du es ja so besser nachvollziehen:

Name.java

public class Name {

	private String name;
	private String lastName;
	
	
	public Name(final String name, final String lastName){
		this.name = name;
		this.lastName = lastName;
	}
	
	public String getName()		{return name;}
	public String getLastName()	{return lastName;}
	public String getFullName()	{return name + " " + lastName;}
}

Handler.java

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;


public class Handler{

	
	public Handler(){}
	
	public static boolean save(String path, Name name){
		BufferedWriter writer;
		
		try {
			writer = new BufferedWriter(new FileWriter(new File(path)));
			
			//write information from name
			writer.write(name.getName());
			writer.newLine();
			writer.write(name.getLastName());
			
			//close writer
			writer.close();
			return true;
		}
		catch (Exception ex) {
			ex.printStackTrace();
		}
		return false;
	}
}

Input.java

import java.util.Scanner;


public class Input{
	
	Name data;
	Scanner sc;
	String[] questions = 
		{
			"Wie lautet ihr Vorname ?",
			"Wie lautet ihr Nachname ?",
			"Wollen Sie Speichern, JA oder NEIN ?"
		};
	
	public Input(){
		sc = new Scanner(System.in);
		getData();
	}
	
	public void getData(){
	
		//vorname
		System.out.println(questions[0]);
		String name = sc.nextLine();
		
		//nachname
		System.out.println(questions[1]);
		String lastname = sc.nextLine();
		
		//name Objekt erzeugen 
		data = new Name(name, lastname);
		
		//speichern
		System.out.println(questions[2]);
		boolean val = sc.nextLine().equalsIgnoreCase(("ja")) ? true : false;
		
		if(val) {
			System.out.println("Bitte geben sie einen Dateipfad an");
			System.out.println(Handler.save(sc.nextLine(), data) ? "Erfolgreich gespeichert !" : "Speichern Fehlgeschlagen !");
		}
	}
}

Test.java

public class Test{

	public static void main(String[] args){
		new Input();
	}
}

ich habe alles möglichst einfach und übersichtlich gehalten , wie du sehen kannst dient Test.java nur als einstiegspunkt für deine Anwendung.

Wenn du fragen haben solltest immer raus damit, wenn du diese Anwendung ausführst sollte es zu solch einer Ausgabe in deiner Konsole führen :

Wie lautet ihr Vorname ?
Max
Wie lautet ihr Nachname ?
Mustermann
Wollen Sie Speichern, JA oder NEIN ?
ja
Bitte geben sie einen Dateipfad an
H:/Apps/Text.txt
Erfolgreich gespeichert !

Ich habe es so implementiert das beim versuch zu speichern ein boolscher Wert zurückgeliefert wird, den ich dazu nutze um zu prüfen ob gespeichert wurde oder ob etwas fehltgeschlagen ist, bei von Hand angegebenen Pfaden ist das immer so eine Sache ......


Ich habe mir aus gründen der Zeit mal geschenkt sämtliche Felder als private zu deklarieren, da es hier lediglich darum geht das du Verständnis dafür entwickelst wie die ganzen Klassen zusammenspielen, die Klasse Input hält hier z.B als Attribut eine Referenz auf ein Name Objekt, welches über die Eingaben initialisiert wird, und dann später gespeichert, die ist im NORMALFALL nicht nötig, sondern dient dazu das du sehen kannst wie man mit Objekten anderer Klassen Arbeiten kann.

Wenn du später z.B einmal Reale Gegenstände abbilden möchtest , wie z.B Personen, so hat jede Person z.B unter anderem einen Namen, der wiederrum aus vor-nach und ggf. zweitnamen / spitznamen besteht.
Der Sinn der Objekt Orientierung ist diese einzelnen Eigenschaften / und oder z.B auch funktionen ( Methoden) zu Kapseln, und nicht Prozedural alles hintereinander weg zu schrieben.
Dies erleichtert es zum Beispiel Später änderungen nur Lokal durchführen zu müssen , hierbei geht es dann um Kopplung und Kohäsion, aber da wirst du sicher auch noch hinkommen

Man könnte hier natürlich noch ansetzen und das ganze Generisch aufbauen, wenn du z.B sagen wir mehr als nur den Namen erfassen möchtest müsstest du die eingaben dementsprechend anpassen, falls du Hilfe brauchst lass es uns wissen

Aber einfacher und der bessere Weg wäre hier die Serialisierung , da du hier das erzeugte Objekt direkt speichern könntest, und nicht nur die Felder des Objektes, wenn du ein Beispiel benötigst liefere ich dir gerne eins soviel muss man da gar nicht ändern.

 

[Trabbelmaker]

@kaoZ: Vielen dank für die Ausführliche Antwort und dass du dir die Zeit genommen hast,
mir zu helfen
Ich habe es soweit verstanden und werde den Code bearbeiten.

Mit freundlichen Grüßen,
Trabbelmaker

 

[kaoZ]

Kein Problem , wie gesagt zum Persistenten Speichern würde ich dir Sonst Serialisierung ans Herz legen , insofern du dich nicht mit Datenbanken rumschlagen möchtest ^^

dies könnte man einfach durch austauschen des Handlers, gegen eine Generische Implementierung erreichen :

(Nachteil ist du kannst dies nicht mehr auf Statischem Weg machen ! sondern musst den Handler extra (anonym) instanziieren. )

z.B so

import java.io.File;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;

public class GenericHandler<T>{

	public GenericHandler(){}
	
	public boolean save(String path, T t){
		
		ObjectOutputStream oos;
		
		try {
			oos = new ObjectOutputStream(new FileOutputStream(new File(path)));
			oos.writeObject(t);
			oos.close();
			
			return true;
		}
		catch (Exception ex) {
			ex.printStackTrace();
		}
		return false;
	}
}

dafür sorgen das die Klasse Name das Interface Serializable erfüllt :

public class Name implements Serializable {...}

und den Aufruf dieses Handlers in der Klasse Input einfach in folgende Zeile abändern :

System.out.println(new GenericHandler<Name>().save(sc.nextLine(), data) ? "Erfolgreich gespeichert !" : "Speichern Fehlgeschlagen !");

So könntest du die Daten ( hier dann da komplette Objekt ) auch unter einem eigenen Dateinamen mit einer beliebigen Dateiendung abspeichern, wie z.B MaxMustermann.dat

natürlich müsste man dann noch eine Methode zum deserialisieren anbieten die dein gespeichertes Objekt dann wiederherstellt, aber das müsstest du auch wenn du die Werte der Felder einfach in Plain Text irgendwo speicherst ^^

falls du Hilfe brauchst immer raus damit, dies ist schnell gemacht.

 

[Trabbelmaker]

Das persistenten Speichern, hat das was mit MySQL zutun, dass ich das auf einer MySQL Datenbank speicher
oder ist das Lokal.
Ich habe noch ein Problem, bei mein jetzigen Code. Ich möchte meinen Geburtstag eingeben "zb: 15.06.1995".
Aber wenn ich den Code den ausführe kommt diese Fehlermeldung:

Wann bist du geboren?// Das ist die Frage
19.04.1996 // Das ist meine Antwort auf die Frage. Nachdem ich die Information eingetippt habe, geht nichts mehr
Exception in thread "main" java.util.InputMismatchException
	at java.util.Scanner.throwFor(Scanner.java:909)
	at java.util.Scanner.next(Scanner.java:1530)
	at java.util.Scanner.nextInt(Scanner.java:2160)
	at java.util.Scanner.nextInt(Scanner.java:2119)
	at personenSystem.Input.getData(Input.java:35)
	at personenSystem.Input.<init>(Input.java:20)
	at personenSystem.Test.main(Test.java:6)

Ich habe eine Vermutung woran das liegen kann, aber weiß nicht wie ich das beheben kann.
Meine Vermutung ist, dass ich keine mit Punkt oder Komma getrennte Zahlen übergeben kann.

//edit: Ich will erstmal mit den normalen Speichern klar kommen, denn gehe ich einen Schritt weiter
Mit freundlichen Grüßen,
Trabbelmaker

 

[kaoZ]

Das hier ist der Grund

Exception in thread "main" java.util.InputMismatchException

Das liegt daran das du parst, der scanner erwartet einen Integer sprich eine einzelne Ganzzahl ( z.B 11 ) du übergibst aber ein komplettes
Datum , speicher das Datum doch einfach als String , dann hast du diese Probleme nicht.

Der wirklich einfachste Weg, klasse Name in Daten Umbenennen und ein zusätzliches Feld erstellen welches das Geburtsdatum enthält.

Hier mal in form eines Strings

import java.io.Serializable;


public class Daten implements Serializable {
	private static final long serialVersionUID = 1L;
	
	private String name;
	private String lastName;
	private String date;
	
	public Daten(final String name, final String lastName){
		this.name = name;
		this.lastName = lastName;
	}
	
	public void setDate(String date){
		this.date = date;
	}
	
	public String getDate()		{return date;}
	public String getName()		{return name;}
	public String getLastName()	{return lastName;}
	public String getFullName()	{return name + " " + lastName;}
}

ansonsten eine Eigene Klasse erstellen welche das datum enthält und sich um das parsen der informationen kümmert, alles andere wäre mehr als in effizient.

die Frage ist außerdem , in welchem Format willst du das Datum speichern, als String, als Date Objekt ?

und ja MySQL wäre auch ein art Daten persistent zu speichern.

//edit: Ich will erstmal mit den normalen Speichern klar kommen, denn gehe ich einen Schritt weiter

Wenn du noch normal in plain Text in die Datei schreibst, musst du natürlich auch das zusätzliche Feld extra in die Datei schreiben.

also im Handler dann :

public class Handler{

	
	public Handler(){}
	
	public static boolean save(String path, Daten name){
		BufferedWriter writer;
		
		try {
			writer = new BufferedWriter(new FileWriter(new File(path)));
			
			//write information from name
			writer.write(name.getName());
			writer.newLine();
			writer.write(name.getLastName());
			writer.newLine();
			writer.write(name.getDate());
			
			//close writer
			writer.close();
			return true;
		}
		catch (Exception ex) {
			ex.printStackTrace();
		}
		return false;
	}
}

Sowas passiert übrigens wenn man wild drauf los Programmiert ohne sich vorher über evtl. verwendete Datenstrukturen etc. gedanken zu machen

Meistens muss man im nach hinein immer sehr viel ändern .

Ich weiß nicht worauf du genau hinaus willst , aber ich hätte die ganze sachen ggf. etwas Atomarer und auch Abstrakter gestaltet z.B mit einer Superklasse Person , welche die verschiedenen benötigten Datenfelder besitzt

Hier z.B mal nicht Abstrakt :

public class Person{

	private Name name;
	private String birthday;
	
	public Person(String name, String lastName, String birthday){
		this(new Name(name, lastName), birthday);
	}
	
	public Person(Name name, String birthday){
		this.name = name;
		this.birthday = birthday;
	}
	
	public String getBirthday()			{return birthday;}
	public String getName()				{return name.getName();}
	public String getLastName()			{return name.getLastName();}
}

man könnte das alles in wenigen Zeilen Code realisieren inclusive des Speicherns

Du musst dabei immer bedenken das inkonsistente Objektzustände vermieden werden sollte, sprich , nur dort setter anbieten wo dies auch sinn macht, ansonsten hat z.B eine Person IMMER einen Namen, eine Addresse und ein Geburtsdatum , diese Informationen sollten auch IMMER im Konstruktor übergeben werden, in welcher form dies geschieht ist dann eine Frage der Implementierung.

 

[Trabbelmaker]

ok das wusste ich noch nicht, dass man mit in einen String Zahlen packen kann
Aber nun habe ich wieder ein Problem.
Ich will ein Integer übergeben mit den Code, aber es klappt irgendwie nicht.
Der Compiler gibt auch keine Fehler aus, aber der Code schmiert ab, nachdem ich meine
Größe eingeben habe. Die Größenangabe habe ich in cm gemacht. Also z.B 189

package personenSystem;

public class Name {
	 
	private String name;
	private String lastName;
	private String geburtstag;
	private String land;
	private String wohnort;
	private int groeße;
 
 
	public Name(final String name, final String lastName, final String geburtstag, final String land, final String wohnort, final int groeße){
		this.name = name;
		this.lastName = lastName;
		this.geburtstag = geburtstag;
		this.land = land;
		this.wohnort = wohnort;
		this.groeße = groeße;
	}
 
	public String getName()			{return name;}
	public String getLastName()		{return lastName;}
	public String getFullName()		{return name + " " + lastName;}
	public String getGeburtstag()	{return geburtstag;}
	public String getLand() 		{return land;}
	public String getWohnort()		{return wohnort;}
	public String getFullWohnort() 	{return land + " || " + wohnort;}
	public int getGroeße()			{return groeße;}
}

 

[kaoZ]

Ich will ein Integer übergeben mit den Code, aber es klappt irgendwie nicht.

dann musst du parsen, entweder du nutzt die funktion des Scanners direkt

int groeße = sc.nextInt();

oder du parst die informationen aus dem String den du Scannst selbst ,

int groeße = 0;

try{
   groeße = Integer.parseInt(sc.nextLine());
}
catch(NumberFormatException ex){
   ex.printStackTrace();
}

Da es hier , durch unerwartete Eingaben zum werfen einer Exeption kommen kann würde ich das ganze grundsätzlich in einem try/catch block machen.

Dazu sei gesagt das ein einfaches ausgeben des StackTrace zwar die Fehlerfindung ungemein erleichtert, aber keine angemessene Behandlung dieser Ausnahme darstellt.

Trotzdem lege ich dir nahe zur Serialisierung über zu gehen , damit kannst du ganz einfach folgendes machen um ein Name Objekt zu speichern / wiederherzustellen (mit der Standard Serialisierung) :

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class GenericHandler<T>{

	public GenericHandler(){}
	
	public boolean save(String path, T t){
		
		ObjectOutputStream oos;
		
		try {
			oos = new ObjectOutputStream(new FileOutputStream(new File(path)));
			oos.writeObject(t);
			oos.close();
			
			return true;
		}
		catch (Exception ex) {
			ex.printStackTrace();
		}
		return false;
	}
	
	@SuppressWarnings("unchecked")
	public T load(String path){
		
		ObjectInputStream ois;
		T data = null;
		try {
			ois = new ObjectInputStream(new FileInputStream(new File(path)));
			data = (T) ois.readObject();
			ois.close();
		}
		catch (Exception ex) {
			ex.printStackTrace();
		}
		return data;
	}
}

alles in allem würde man dann über folgenden aufruf ein Name Objekt speichern können (Serialisierung):

new GenericHandler<Name>().save("H:/Apps/Test.txt", data));

und über diesen Aufruf einfach wieder herstellen (deserialisierung) :

Name n = new GenericHandler<Name>().load("H:/Apps/Test.txt");

du musst dich also nicht darum kümmern sämtliche Felder des Objektes von Hand wieder herzustellen wie du es machen musst wenn du sie auch von Hand speicherst

Das Gute daran ist , du kannst den Handler Typisieren ( darum ja generisch )

Du kannst also wenn du z.B kein Name sondern ein String Objekt / oder ein Objekt einer anderern Klasse, Speichern willst einfach dazu übergehen und folgendes machen

		//Speichern
		new GenericHandler<String>().save("H:/Apps/Text.txt", "Ich bin ein Serialisierter String");

		//laden
		String s = new GenericHandler<String>().load("H:/Apps/Text.txt");
		
		System.out.println(s);
		
		//oder kürzer 
		
		System.out.println(new GenericHandler<String>().load("H:/Apps/Text.txt"));

und das Ganze ginge auch statisch , dies nutzt aber entweder einen Statischen Typ <T>, oder eben den Raw Type ( dank type erasure , zur Laufzeit liegen also keine Informationen über den typ des Objektes vor sondern nur der Typ Object sebst) und ist recht kryptisch ( in dem Handler selbst) wenn man noch nicht so die Erfahrung mit der Syntax hat.

Wenn du weißt was du speichern und laden willst erzeugst du einfach vorher schon ein handler Objekt und kannst dies dann beliebig oft einsetzen, ohne immer ein neues zu instantiieren.