Java und das leidige Thema "wording"

[Kotelettklopfer]

Hi,

ich hoffe der Post ist in Ordnung und stößt nicht auf allzu große Kritik.
Mir ist heute wieder einmal aufgefallen, dass ich als Anfänger wirklich große Probleme mit dem Wording habe.

Jemand will helfen und wirft mit eigentlich einfachen standard Begriffen um sich und ich stehe auf dem Schlauch
"Was war jetzt nochmal eine Instanzvariable ?"
"Methode , was ?"

Ich habe ein paar meiner Codepassagen kommentiert.. stimmt meine Beschriftung?

package dbUtil;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

//Klasse DBConnection
public class DBConnection {
//Klassenrumpf
 
    //Instanzvariablen
    public static final String DB_NAME = "Haushaltsbuch.db";
    public static final String DB_PATH = "F:\\Projekte\\Kosten\\src\\";
    public static final String CONNECTION_STRING = "jdbc:sqlite:" + DB_PATH + DB_NAME;

    //Methode getConnection
    public Connection getConnection()throws SQLException {

        Connection connection = null;
        connection = DriverManager.getConnection(CONNECTION_STRING);
       
        return connection;

    }


}

Wenn das ok ist, würde ich den Thread dann weiter für sowas nutzen. Vielleicht kann der eine oder andere User das Wissen auch gebrauchen.

 

[mihe7]

Wären die "Variablen" in den Zeilen 12 bis 14 weder static noch final, wären es Instanzvariablen. Sind die Variablen static, spricht man von Klassenvariablen. Instanz- und Klassenvariablen können final deklariert werden, dann spricht man gewöhnlich von Konstanten. Den Rest kann man so lassen.

 

[Kotelettklopfer]

Instanzvariablen können nicht static sein, weil sie dann nicht in anderen Klassen nutzbar wären.

Klassenvariablen sind static und sind daher nur in dieser einen Klasse nutzbar.

So korrekt wiedergegeben ?

 

[JensXF]

Instanzvariable: Sind an das erzeugt Objekt einer Klasse gebunden.

Klassenvariable: Zugriff ohne erzeugen einen Objekts möglich. KlassenName.variablenName Gilt für alle Objekte der Klasse.

Konstante: Muss initialisiert werden, kann nicht mehr verändert werden.

 

[mihe7]

Ergänzend kann man noch erwähnen, dass Klassenvariablen ausschließlich als Konstanten sinnvoll sind. Ausnahme: man möchte die Zahl der erzeugten Objekte mitzählen. Das wäre ein veränderliches Attribut, das sich eben nicht auf das einzelne Objekte sondern auf die Klasse als Ganzes bezieht.

 

[kneitzel]

Die Begriffe muss man leider mit der Zeit lernen. (Einige direkt am Anfang).

Viele Begriffe ergeben sich etwas aus dem Zusammenhang - sie hängen also zusammen:

- Klasse: Das ist das Konstrukt, das Du mit "class" schreibst (public class Test { ... }).

- Instanz: So bezeichnet man Objekte, die aus einer Klasse erzeugt werden (i.d.R. über den new Operator: Test test = new Test(); Dies deklariert eine neue Variable test vom Typ Test und in dieser wird eine Referenz auf die neu erstellte Instanz gespeichert.

Bei den Variablen gibt es dann zwei Arten von Variablen:
- Klassenvariable - Diese sind über die Klasse ansprechbar und gelten für die ganze Klasse. (Also die Variable gibt es nur ein mal in der Klasse)
- Instanzvariable - Diese sind über die Instanz ansprechbar und die Variable ist in jeder Instanz zu finden. Jede Instanz hat das also eigenständig für sich.

Aber die von Dir angesprochene Problematik wird hier auch direkt deutlich, denn "Was zum Teufel ist jetzt eine Referenz?"

Am Anfang ist es mit den Begriffen auf jeden Fall schwer, denn es sind ja nicht nur die Begriffe. Die ganzen Internas sind noch unbekannt. Und die muss man ja mit lernen.

Da kann ich Dich aber auch nur ermuntern: Frag! Ich bin sicher, dass wir gerne Auskunft geben werden und versuchen werden, die Zusammenhänge zu erklären.

 

[Kotelettklopfer]

Hier mein erster eigener Versuch (ohne Tutorial) die DB zu erreichen.
Wäre das so sauber umgesetzt ?

[CODE lang="java" title="Main.java"]package haushaltsbuch;

import java.sql.Connection;
import java.sql.SQLException;

public class Main {
public static void main(String[] args) {

/*
erstellen einer neuen Instanz aus der Klasse DBConnection
*/
DBConnection connect = new DBConnection();

}
}
[/CODE]


[CODE lang="java" title="DBConnection.java"]package haushaltsbuch;


import java.sql.*;

//Klasse DBConnection
public class DBConnection {

//Instanzvariablen
public static final String DB_NAME = "Haushaltsbuch.db";
public static final String DB_PATH = "F:\\Projekte\\Kosten\\src\\";
public static final String CONNECTION_STRING = "jdbc:sqlite:" + DB_PATH + DB_NAME;

//Methode getConnection
public Connection getConnection()throws SQLException {

Connection connection = null;
connection = DriverManager.getConnection(CONNECTION_STRING);

return connection;


}


}[/CODE]

In meinem Lernkurs wurde hier noch eine Klasse DBStatement genutzt, die habe ich auf Ratschlag weggelassen.

 

[Barista]

Kann man so machen.

Die konstanten Werte könnten zum Problem werden, wenn das Programm mal auf einem anderen Rechner (Path) laufen soll.

Dafür nutzt man in Java üblicherweise properties-Dateien, ist aber fürs erste egal.

Die Klasse DBConnection mit der Methode getConnection kann allerdings fast nichts, also mach weiter!

 

[Kotelettklopfer]

Kann man so machen.

Die konstanten Werte könnten zum Problem werden, wenn das Programm mal auf einem anderen Rechner (Path) laufen soll.

Dafür nutzt man in Java üblicherweise properties-Dateien, ist aber fürs erste egal.

Die Klasse DBConnection mit der Methode getConnection kann allerdings fast nichts, also mach weiter!

Ein kleiner Schritt für die Menschheit, ein großer Schritt für mich
Ein einzige Methode in der DBConnection, aber mein ganzer Stolz da die DB connectet ohne Fehler xPPP


Das mit dem konstanten Pfad hatte ich garnicht auf dem Schirm, stimmt. Werde ich, wenn mal alles passt in einem "Update" ändern.

 

[Jw456]

Hallo
Connection connection = null;
Könntest du weglassen denn du weißt es ja gleich in der nechsten Anweisung zu.

Das mit der Null würde ich bei einer Instanzvariablen machen.
Nicht bei einer localen.
Schadet aber auch nicht.

Connection connection = DriverManager.getConnection(CONNECTION_STRING);

 

[Kotelettklopfer]

Hallo
Connection connection = null;
Könntest du weglassen denn du weißt es ja gleich in der nechsten Anweisung zu.

Das mit der Null würde ich bei einer Instanzvariablen machen.
Nicht bei einer localen.
Schadet aber auch nicht.

Connection connection = DriverManager.getConnection(CONNECTION_STRING);

Wieso sagt er mir nun, dass die variable connection redundant sei?
Funktionieren tut es trotzdem !!

 

[Jw456]

Wenn du das mit der Null stehen lassen hast wird die variable versucht zweimal zu erstellen.
Lösche die Zeile mit der Null. Dachte das wäre klar gewesen.

 

[Kotelettklopfer]

Wenn du das mit der Null stehen lassen hast wird die variable versucht zweimal zu erstellen.
Lösche die Zeile mit der Null. Dachte das wäre klar gewesen.

Natürlich war das klar.. Es steht trotzdem da
Bei doppelter Nutzung stände da auch "....is allready defiened in Scope

 

[kneitzel]

@Kotelettklopfer
Also die Variable ist redundant, weil Du mit der nichts anderes machst, als diese zu erstellen und dann sofort zurück zu geben.

Diese Meldung soll also nur sagen, dass der Code vereinfacht / verkürzt werden kann.

    public Connection getConnection()throws SQLException {
        return DriverManager.getConnection(CONNECTION_STRING);
    }

Und lass Dich bitte nicht von den Aussagen von Jw456 verwirren - da ist einiges nicht wirklich korrekt!

@Jw456
Und nein: Eine Variable kann in einem Scope nicht zwei Mal erstellt werden. Daher ist klar, dass er das eben nicht gemacht hat. Der Versuch, eine Variable zwei Mal zu erstellen würde einen Fehler bringen wie "Variable 'xxx' is already defined in the scope" und der Code wäre nicht übersetzbar.

Und nein - Instanz und Klassenvariablen explizit auf null setzen ist unnötig, denn diese Variablen haben schon eine entsprechende Initialisierung.
Bei einer lokalen Variable kann es Sinn machen, denn diese hat keinen initialen Wert und kann erst gelesen werden, nachdem eine Initialisierung stattgefunden hat ...

 

[kneitzel]

@Kotelettklopfer
Da Du so schön ein Bildschirmfoto gebracht hast: Schau Dir das doch einmal im Detail an:
Da wird Dir eine Möglichkeit angeboten. Bei sowas einfach mal ausprobieren! Also hier: Click mal einfach "inline Variable" an. Meine Erwartungshaltung ist, dass die IDE das dann ändert.

Wenn die die Änderung zusagt: Behalte es bei. Ansonsten einfach Rückgängig machen

 

[Kotelettklopfer]

@Kotelettklopfer
Da Du so schön ein Bildschirmfoto gebracht hast: Schau Dir das doch einmal im Detail an:
Da wird Dir eine Möglichkeit angeboten. Bei sowas einfach mal ausprobieren! Also hier: Click mal einfach "inline Variable" an. Meine Erwartungshaltung ist, dass die IDE das dann ändert.

Wenn die die Änderung zusagt: Behalte es bei. Ansonsten einfach Rückgängig machen

Im Eifer des Gefechts nicht gesehen, dass die IDE Hilfe anbietet xD Danke

 

[Kotelettklopfer]

DBConnection ist nun um einen SQL INSERT Befehl erweitert, welchen ich dann in der Main aufrufe.
Das hat mich ganz schön Nerven gekostet xD

[CODE lang="java" title="Main.java" highlight="14-21"]package haushaltsbuch;

import java.sql.Connection;
import java.sql.SQLException;

public class Main {
public static void main(String[] args) {

/*
erstellen einer neuen Instanz aus der Klasse DBConnection
*/
DBConnection connect = new DBConnection();

/*
ausführen des INSERT SQL Befehls
Ausführung durch die Methode insertData aus dem Objekt connect
*/
try {
connect.insertData();
} catch (Exception e) {
e.printStackTrace();
}

}


}
[/CODE]

[CODE lang="java" title="DBConnection.java" highlight="19-43"]package haushaltsbuch;

import java.sql.*;

//Klasse DBConnection
public class DBConnection {

//Instanzvariablen
public static final String DB_NAME = "Haushaltsbuch.db";
public static final String DB_PATH = "F:\\Projekte\\Kosten\\src\\";
public static final String CONNECTION_STRING = "jdbc:sqlite:" + DB_PATH + DB_NAME;

//Methode getConnection
public Connection getConnection() throws SQLException {
return DriverManager.getConnection(CONNECTION_STRING);

}

//Methode insertData
private DBConnection dbconnection = new DBConnection();

private Connection connection = null;
private Statement statement = null;

public void insertData() throws SQLException {
String insertData = "INSERT INTO ";

executeQuery(insertData);
}

//Methode executeQuery
private void executeQuery(String sqlQuery) throws SQLException {

try {
connection = dbconnection.getConnection();
statement = connection.createStatement();
if (statement != null) {
statement.execute(sqlQuery); // execute = ausführen
}
} finally {
statement.close();
connection.close();
}


}
}
[/CODE]

Handelt es sich bei insertData & executeQuery überhaupt um Methoden?

 

[Kotelettklopfer]

Verdammt, bekomme einen StackOverflow

 

[fhoffmann]

private DBConnection dbconnection = new DBConnection();

In der Klasse DBConnection erzeugst du eine Instanz von DBConnection,
diese erzeugt eine weitere Instanz von DBConnection,
diese erzeugt eine weitere Instanz von DBConnection,
diese erzeugt eine weitere Instanz von DBConnection,
diese erzeugt eine weitere Instanz von DBConnection,
....

 

[kneitzel]

In DBConnection hast Du folgende Instanzvariable:

private DBConnection dbconnection = new DBConnection();

Immer wenn eine Instanz erzeugt wird, erzeugt diese direkt wieder eine Instanz. Das führt dann leider zu diesem Effekt.

Du kannst diese Zeile komplett löschen!

Das sollte dann soweit diesen Fehler beheben.

Dein Code macht aber noch nicht wirklich etwas. Die SQL Anweisung, die Du absetzt, ist so noch nicht wirklich vollständig.

Ansonsten sieht das schon gut aus. Was da noch auffällt:
Die close() Aufrufe im finally sind gold richtig, aber diese könnten auch eine Exception werfen. Die würde man ignorieren wollen.
Und da dies viel Code ist für wenig Inhalt, wurde das Optimiert. Schau Dir einmal "try with resources" an, wenn Du Zeit und Lust hast.

Java - Try with Resources | Baeldung

A quick and practical guide to how we can use the try-with-resources functionality introduced in Java 7 to auto-close resources and simplify our syntax.

www.baeldung.com

(Und bei Fragen oder wenn etwas nicht verstanden wurde, dann einfach erneut fragen!)

 

[Kotelettklopfer]

In der Klasse DBConnection erzeugst du eine Instanz von DBConnection,
diese erzeugt eine weitere Instanz von DBConnection,
diese erzeugt eine weitere Instanz von DBConnection,
diese erzeugt eine weitere Instanz von DBConnection,
diese erzeugt eine weitere Instanz von DBConnection,
....

Ja , just in diesem Moment fiel es mir auch auf. Habe das anders gelöst. Hoffe es passt jetzt.
Bin gerade dabei testweise einen SQL String zu schreiben um die Ausführung zu testen.

    //Methode getConnection
    public static Connection getConnection() throws SQLException {
        return DriverManager.getConnection(CONNECTION_STRING);

    }

    //Methode insertData
//    DBConnection dbconnection = new DBConnection();

    private Connection connection = null;
    private Statement statement = null;

    public void insertData() throws SQLException {
        String insertData = "INSERT INTO " + TABLE_AUSGABEN + " VALUES "

        executeQuery(insertData);
    }

    //Methode executeQuery
    private void executeQuery(String sqlQuery) throws SQLException {

        try {
            connection = DBConnection.getConnection();
            statement = connection.createStatement();
            if (statement != null) {
                statement.execute(sqlQuery); // execute = ausführen
            }
        } finally {
            statement.close();
            connection.close();
        }

 

[Kotelettklopfer]

In DBConnection hast Du folgende Instanzvariable:

private DBConnection dbconnection = new DBConnection();

Immer wenn eine Instanz erzeugt wird, erzeugt diese direkt wieder eine Instanz. Das führt dann leider zu diesem Effekt.

Du kannst diese Zeile komplett löschen!

Das sollte dann soweit diesen Fehler beheben.

Dein Code macht aber noch nicht wirklich etwas. Die SQL Anweisung, die Du absetzt, ist so noch nicht wirklich vollständig.

Ansonsten sieht das schon gut aus. Was da noch auffällt:
Die close() Aufrufe im finally sind gold richtig, aber diese könnten auch eine Exception werfen. Die würde man ignorieren wollen.
Und da dies viel Code ist für wenig Inhalt, wurde das Optimiert. Schau Dir einmal "try with resources" an, wenn Du Zeit und Lust hast.

Java - Try with Resources | Baeldung

A quick and practical guide to how we can use the try-with-resources functionality introduced in Java 7 to auto-close resources and simplify our syntax.

www.baeldung.com

(Und bei Fragen oder wenn etwas nicht verstanden wurde, dann einfach erneut fragen!)

Schau mal bitte in meinen Post davor.
Ich habe den StackOverflow Fehler selbst schon gelöst gehabt, allerdings musste ich dafür die Methode getconnection auf static setzen .....
Nicht schön oder?

Zum SQL Code, das war erstmal nur ein %. Den String baue ich gerade.

 

[kneitzel]

llerdings musste ich dafür die Methode getconnection auf static setzen .....

Wieso denn das? Du nutzt die Methode doch innerhalb einer nicht statischen Methode.

Also sollte ein einfaches:

connection = getConnection();

funktionieren ohne dass getConnection statisch ist.

 

[Kotelettklopfer]

Ok da lag mein Fehler...
Ich hatte dort noch dbconnection.getconnection stehen.
Habe es jetzt geändert und der Fehler ist weg, allerdings habe ich ein anderes Problem.
Die Tabelle ist aufjedenfall Richtig und der SQL String funktioniert auch (habe ihn im DBBrowser mal ausgeführt)

Mich wundert an der Stelle dieses .DBConnection.





[CODE lang="java" highlight="9-17"]package haushaltsbuch;

import java.sql.*;

//Klasse DBConnection
public class DBConnection {

//Instanzvariablen
public static final String DB_NAME = "Haushaltsbuch.db";
public static final String DB_PATH = "F:\\Projekte\\Kosten\\src\\";
public static final String CONNECTION_STRING = "jdbc:sqlite:" + DB_PATH + DB_NAME;

//Methode getConnection
public Connection getConnection() throws SQLException {
return DriverManager.getConnection(CONNECTION_STRING);

}

//Methode insertData
private DBConnection dbconnection = new DBConnection();

private Connection connection = null;
private Statement statement = null;

public void insertData() throws SQLException {
String insertData = "INSERT INTO ";

executeQuery(insertData);
}

//Methode executeQuery
private void executeQuery(String sqlQuery) throws SQLException {

try {
connection = dbconnection.getConnection();
statement = connection.createStatement();
if (statement != null) {
statement.execute(sqlQuery); // execute = ausführen
}
} finally {
statement.close();
connection.close();
}


}
}[/CODE]



Ich würde sagen er findet die DB nicht und SQLite generiert dann eine neue. Ich habe nämlich nach jedem ausführen eine neue DB im Ordner -.-
Kann es sein, das die DB nicht im src Ordner liegen darf?

 

[Kotelettklopfer]

Ok, habe es gelöst.
Ihm fehlte scheinbar beim Datenbanknamen das .db
Jetzt ging es !!!

Meine Datenbank hat die ersten Datensätze empfangen.
Nach dem gestrigen Tag könnt ihr euch nicht vorstellen wie stolz ich gerade bin xD

 

[Jw456]

Ok da lag mein Fehler...
Ich hatte dort noch dbconnection.getconnection stehen.
Habe es jetzt geändert und der Fehler ist weg, allerdings habe ich ein anderes Problem.
Die Tabelle ist aufjedenfall Richtig und der SQL String funktioniert auch (habe ihn im DBBrowser mal ausgeführt)

Mich wundert an der Stelle dieses .DBConnection.

Anhang anzeigen 15886



[CODE lang="java" highlight="9-17"]package haushaltsbuch;

import java.sql.*;

//Klasse DBConnection
public class DBConnection {

//Instanzvariablen
public static final String DB_NAME = "Haushaltsbuch.db";
public static final String DB_PATH = "F:\\Projekte\\Kosten\\src\\";
public static final String CONNECTION_STRING = "jdbc:sqlite:" + DB_PATH + DB_NAME;

//Methode getConnection
public Connection getConnection() throws SQLException {
return DriverManager.getConnection(CONNECTION_STRING);

}

//Methode insertData
private DBConnection dbconnection = new DBConnection();

private Connection connection = null;
private Statement statement = null;

public void insertData() throws SQLException {
String insertData = "INSERT INTO ";

executeQuery(insertData);
}

//Methode executeQuery
private void executeQuery(String sqlQuery) throws SQLException {

try {
connection = dbconnection.getConnection();
statement = connection.createStatement();
if (statement != null) {
statement.execute(sqlQuery); // execute = ausführen
}
} finally {
statement.close();
connection.close();
}


}
}[/CODE]



Ich würde sagen er findet die DB nicht und SQLite generiert dann eine neue. Ich habe nämlich nach jedem ausführen eine neue DB im Ordner -.-
Kann es sein, das die DB nicht im src Ordner liegen darf?

hier wundert mich etwas .
wieso erstellt du hier eine Instanz von der Klasse in der du selber bist.
private DBConnection dbconnection = new DBConnection();

Die Instanz hast du doch in deiner Main Methode schon erstellt.
Könnstest jetzt gar nicht in der Klasse sein zur laufzeit wenn es keine Intanz der Klasse gäbe.

@kneitzel sagte dir doch schon das du in der Klasse direkt auf deine Methoden in der eigen Klasse zugreifen kannst.

connection = getConnection();

in "insertData()" rufst du doch auch eine Methode aus deiner Klasse "executeQuery(insertData)" auf , ist doch hier das selbe bei "getConnection()"

 

[Kotelettklopfer]

Das sind / waren zwei paar Schuhe.

 

[Barista]

@Kotelettklopfer
Im Gegensatz zu vielen anderen Leuten hier im Forum finde ich es ok, wenn Deine DBConnection statische Methoden hat.

Schliesslich hast Du nur eine Datenbank, bzw. sprichst im Programm nur mit einer Datenbank.

Nichtstatisch wäre ansonsten für das automatisierte Testen interessant, ich glaube aber, davon bist Du noch weit entfernt.

 

[Kotelettklopfer]

Ich bräuchte nochmal einen Denkanstoß, vielleicht auch zwei.
Ich möchte nun weg von festen SQL Statements und will das ganze dynamisch halten.
Sprich User Eingabe über sie Kommandozeile.

Mein grobes Vorgehen: Ich habe eine UserEntry.java dort soll alles rein was die User eingabe betrifft. In meiner Vorstellung bilde ich das über Sysout ab.
Die gespeicherten Werte müssen als Variable dann in der DBConnection.java landen um dort im Statement abgebildet zu werden.
In der Main.java bleibt alles wie es ist, weil der ist es egal ob das Statement welches aus der DBConnection kommt dynamisch oder fest definiert ist.


Passt das so von meiner Idee?


Ich weiß gerade nur nicht wie ich in diese Methode :

[CODE lang="java" title="DBConnection.java"]//Methode insertData
private Connection connection = null;
private Statement statement = null;

// Hier müssen dann die Variablen aus der Ausgabe.java rein
public void insertData() throws SQLException {
String insertData = "INSERT INTO " + TABLE_AUSGABEN + " VALUES " + "(Null, 'Juli', 'Nahrung', 'Rewe', 56.69), "
+ "(Null, 'Juli', 'Nahrung', 'Aldi', 14.34), "
+ "(Null, 'Juli', 'Haushalt', 'DM', 23.84) ";

System.out.println(insertData);

executeQuery(insertData);[/CODE]

die Variablen aus der Ausgabe.java einbinde.

Methoden verschachteln?

 

[kneitzel]

Hier sind jetzt mehrere Dinge wichtig, die aber alle verstanden sein sollten.

a) Du solltest die Daten in entsprechenden Objekten halten. Also statt einfach nur mit den Basis Typen zu arbeiten, erstellst Du Dir entsprechende Klassen. Hier wäre dann z.B. eine Klasse "Ausgabe" denkbar, die dann diverse Werte vorhält, u.a. die id:

private Long id;

public Long getId() { return id; }

public void setId(final Long id) {
    this.id = id;
}

b) Dann kannst Du eine Methode schreiben, die eine Instanz von Ausgabe entgegen nimmt. Also sowas wie:

public void save(final Ausgabe ausgabe) { ...}

Da musst Du dann schauen: Hat ausgabe bereits eine id? Wenn ja, dann kommt ein UPDATE statemt, ansonsten ein INSERT statement.

c) Jetzt müssen wir aber - um das richtig zu lösen - eine neue Sache betrachten: PreparedStatements. Du willst Inhalte übergeben, die nicht zwingend Text sind. Typische Beispiele sind Dinge wie Datum, ein Bild, .... Generell sollte man immer bei den eigentlichen Typen bleiben.
Strings übergibst Du in ' - was passiert, wenn das Quote Zeichen nun in dem String selbst vor kommt? Ganz blöd!

Daher: Prepared Statements!

Using Prepared Statements (The Java™ Tutorials > JDBC Database Access > JDBC Basics)

Da kommt dann in dem SQL Befehl nur noch jeweils ein ? für Parameter und die werden dann gefüllt.

d) Bitte angewöhnen, die Felder anzugeben. Wenn die Datenbank sich verändert kommst Du sonst hinterher in Probleme. Und das größte Problem ist immer, wenn Daten korrupt werden, denn das fällt oft nicht zeitnah auf und das Problem vergrößert sich immer mehr... Da muss man nicht nur das Programm reparieren sondern auch den Datenbestand!

e) Wenn die id von der Datenbank vergeben wird, dann wollen wir die id nach dem speichern natürlich setzen. Dazu muss man sich die generierten Ids holen ...

Damit haben wir dann etwas in der Art, was hier im Browser / Forum geschrieben wurde. Tippfehler und so können also vorkommen. Und evtl. ist irgendwas auch nicht 100% stimmig - JDBC von Hand habe ich schon lange nicht mehr benutzt :

public void save(final Ausgabe ausgabe) {
    if (ausgabe.getId() == null) {
        insertAusgabe(ausgabe);
    } else {
        updateAusgabe(ausgabe);
    }
}

protected void insertAusgabe(final Ausgabe ausgabe) {
    String sql = "INSERT INTO ausgaben (feld1, feld2) VALUES(?, ?)";
    try (Connection connection = getConnection();
        PreparedStatement statement = connection.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS)) {
        statement.setString(1, ausgabe.getFeld1());
        statement.setInt(2, ausgabe.getFeld2());
        statement.executeUpdate();
        ResultSet rs = statement.getGeneratedKeys();
        if (rs.next()) {
            ausgabe.setId(rs.getLong(1));
        }
    }
}
   
protected void updateAusgabe(final Ausgabe ausgabe) {
    String sql = "UPDATE ausgaben SET feld1 = ?, feld2 = ? WHERE id = ?";
    try (Connection connection = getConnection();
        PreparedStatement statement = connection.prepareStatement(sql) {
        statement.setString(1, ausgabe.getFeld1());
        statement.setInt(2, ausgabe.getFeld2());
        statement.setLong(3, ausgabe.getId());
        statement.executeUpdate();
    }
}

Edit: Da fehlte wohl ein } bei der insertAusgabe Methode. Die Einrückung vom Forum war nicht korrekt und ich habe das mal im nachhinein angepasst (In der Hoffnung, dass es vom Format her jetzt nicht schlimmer wird)

 

[White_Fox]

@Kotelettklopfer
Nur Mut...du machst das schon alles ganz richtig. Das Wichtigste, um bei dem Kram irgendwann durchzublicken, ist, sich damit zu beschäftigen. Und das tust du ja, wie man sehen kann.
Es ist auch nicht notwendig alles gleich sofort zu wissen, was in den Büchern steht. Und es ist völlig normal daß das seine Zeit dauert, bis man im Thema drin ist.

Zwei Bücher würde ich dir ans Herz legen: "Java von Kopf bis Fuß" und "Entwurfsmuster von Kopf bis Fuß". Danach ist (mindestens fast) jeder, der was mit Java machen will, auf einem recht guten Weg.

 

[Kotelettklopfer]

Java von Kopf bis Fuss ist für Java 5. Ist das egal ?

 

[Kotelettklopfer]

Hier sind jetzt mehrere Dinge wichtig, die aber alle verstanden sein sollten.

a) Du solltest die Daten in entsprechenden Objekten halten. Also statt einfach nur mit den Basis Typen zu arbeiten, erstellst Du Dir entsprechende Klassen. Hier wäre dann z.B. eine Klasse "Ausgabe" denkbar, die dann diverse Werte vorhält, u.a. die id:

private Long id;

public Long getId() { return id; }

public void setId(final Long id) {
    this.id = id;
}

b) Dann kannst Du eine Methode schreiben, die eine Instanz von Ausgabe entgegen nimmt. Also sowas wie:

public void save(final Ausgabe ausgabe) { ...}

Da musst Du dann schauen: Hat ausgabe bereits eine id? Wenn ja, dann kommt ein UPDATE statemt, ansonsten ein INSERT statement.

c) Jetzt müssen wir aber - um das richtig zu lösen - eine neue Sache betrachten: PreparedStatements. Du willst Inhalte übergeben, die nicht zwingend Text sind. Typische Beispiele sind Dinge wie Datum, ein Bild, .... Generell sollte man immer bei den eigentlichen Typen bleiben.
Strings übergibst Du in ' - was passiert, wenn das Quote Zeichen nun in dem String selbst vor kommt? Ganz blöd!

Daher: Prepared Statements!

Using Prepared Statements (The Java™ Tutorials > JDBC Database Access > JDBC Basics)

Da kommt dann in dem SQL Befehl nur noch jeweils ein ? für Parameter und die werden dann gefüllt.

d) Bitte angewöhnen, die Felder anzugeben. Wenn die Datenbank sich verändert kommst Du sonst hinterher in Probleme. Und das größte Problem ist immer, wenn Daten korrupt werden, denn das fällt oft nicht zeitnah auf und das Problem vergrößert sich immer mehr... Da muss man nicht nur das Programm reparieren sondern auch den Datenbestand!

e) Wenn die id von der Datenbank vergeben wird, dann wollen wir die id nach dem speichern natürlich setzen. Dazu muss man sich die generierten Ids holen ...

Damit haben wir dann etwas in der Art, was hier im Browser / Forum geschrieben wurde. Tippfehler und so können also vorkommen. Und evtl. ist irgendwas auch nicht 100% stimmig - JDBC von Hand habe ich schon lange nicht mehr benutzt :

public void save(final Ausgabe ausgabe) {
    if (ausgabe.getId() == null) {
        insertAusgabe(ausgabe);
    } else {
        updateAusgabe(ausgabe);
    }
}

protected void insertAusgabe(final Ausgabe ausgabe) {
    String sql = "INSERT INTO ausgaben (feld1, feld2) VALUES(?, ?)";
    try (Connection connection = getConnection();
        PreparedStatement statement = connection.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS)) {
        statement.setString(1, ausgabe.getFeld1());
        statement.setInt(2, ausgabe.getFeld2());
        statement.executeUpdate();
        ResultSet rs = statement.getGeneratedKeys();
        if (rs.next()) {
            ausgabe.setId(rs.getLong(1));
        }
    }
}
 
protected void updateAusgabe(final Ausgabe ausgabe) {
    String sql = "UPDATE ausgaben SET feld1 = ?, feld2 = ? WHERE id = ?";
    try (Connection connection = getConnection();
        PreparedStatement statement = connection.prepareStatement(sql) {
        statement.setString(1, ausgabe.getFeld1());
        statement.setInt(2, ausgabe.getFeld2());
        statement.setLong(3, ausgabe.getId());
        statement.executeUpdate();
    }
}

Edit: Da fehlte wohl ein } bei der insertAusgabe Methode. Die Einrückung vom Forum war nicht korrekt und ich habe das mal im nachhinein angepasst (In der Hoffnung, dass es vom Format her jetzt nicht schlimmer wird)

Das muss ich mal in Ruhe durchlesen und verstehen xD Aber danke schonmal.

Prepared Statements kenne ich nur aus der SQL Injection, da wurden sie behandelt.
Klingt aber ziemlich wild, Mal schauen ob ich das raffe xD

 

[White_Fox]

Java von Kopf bis Fuss ist für Java 5. Ist das egal ?

Ja...das ist wurscht. Bei Büchern wie dem ist meiner Meinung nach die didaktische Umsetzung am Wichtigsten, und in diesem Punkt ist das Buch richtig gut.
Und das Buch ist auch für Java5 nicht komplett, du wirst so oder so später auf Dinge stoßen die nicht aus dem Buch kennst. Aber du verstehst die Sprache hinterher gut genug daß es dir nicht schwerfallen dürfte, selber zu suchen.

 

[kneitzel]

Evtl. noch ein Hinweis: evtl. kommt da bald eine 2.te Edition. Zumindest die Englische Variante existiert als early release in der 3ten Edition und soll im Dezember heraus kommen und ich würde vermuten, dass die Übersetzung dann auch nicht lange auf sich warten lassen wird (Aber ich habe da keine wirklichen Informationen - ich vermute es nur.)

Edit: Musste ich editieren - derzeit ist das nur early access und die neue Englische Edition soll im Dezember erst heraus kommen.

 

[Kotelettklopfer]

Habe es gerade für 10€ bei eBay geschossen.. denke das geht klar xD

 

[Kotelettklopfer]

Nebenfrage:
Damit ich mir beim rumorobieren nichts zerschieße, wie bilde ich am besten eine Versionsverwaltung ab ?
GitHub für sowas brauchbar ?
Bitbucket wäre glaube die Softwarelösung?!

 

[kneitzel]

Du brauchst nicht zwingend ein zentrales Repository wie GitHub, GitLab, ... So ein zentrales Repository ist nur wichtig, wenn von mehreren Rechnern der Zugriff erfolgen können soll.

Das Tool git alleine reicht schon. Gibt auch zwei freie Bücher, die das sehr gut erklären.

Das deutsche Git-Buch

gitbu.ch

Git - Book

git-scm.com

 

[Kotelettklopfer]

Schau ich mir an... Danke

 

[Barista]

Wenn Du Eclipse benutzt:

Projektbaum rechte Maustaste -> Team -> Share Project

Dann würde ich lokales Repository wählen, sonst legt Eclipse unter Win unter Deinem User eine Verzeichnis git an, in welchem des Repositoy liegt, finde ich nicht so gut.

Nach Änderungen
Projektbaum rechte Maustaste -> Team -> Commit

Regelmäßiges Backup Deines Projektes/Repositiry auf einen USB-Stick oder so ist wichtig.

 

[kneitzel]

Wenn Du Eclipse benutzt:

Generell hat eigentlich jede IDE eine gute Einbindung von git. Daher ist es egal, was man nutzt.

Aber ich rate dazu, sich auf jeden Fall die Basics auf der Kommandozeile anzusehen und zu verstehen. Dann kommt man auch schnell mit der Integration in der IDE klar.

Mit der IDE sehe ich generell das Problem, dass man da leicht etwas klickt, was man nicht verstanden hat und das sind dann in der Regel die Fälle wo behauptet wird, dass "git Daten gelöscht hat" oder so

Und ein gewisses Verständnis von working area, staging und dann dem Repository ist von großem Vorteil (Dann versteht man auch die Unterschiede zwischen den einzelnen Befehlen und so).

Wobei am Anfang nur der erste Abschnitt von den Büchern wirklich wichtig ist. Branching und Merging wirst Du erst einmal nicht brauchen, so nur ein Rechner im Einsatz ist. Das kann man sich dann erarbeiten, wenn man es braucht.

 

[Kotelettklopfer]

Generell hat eigentlich jede IDE eine gute Einbindung von git. Daher ist es egal, was man nutzt.

Aber ich rate dazu, sich auf jeden Fall die Basics auf der Kommandozeile anzusehen und zu verstehen. Dann kommt man auch schnell mit der Integration in der IDE klar.

Mit der IDE sehe ich generell das Problem, dass man da leicht etwas klickt, was man nicht verstanden hat und das sind dann in der Regel die Fälle wo behauptet wird, dass "git Daten gelöscht hat" oder so

Und ein gewisses Verständnis von working area, staging und dann dem Repository ist von großem Vorteil (Dann versteht man auch die Unterschiede zwischen den einzelnen Befehlen und so).

Wobei am Anfang nur der erste Abschnitt von den Büchern wirklich wichtig ist. Branching und Merging wirst Du erst einmal nicht brauchen, so nur ein Rechner im Einsatz ist. Das kann man sich dann erarbeiten, wenn man es braucht.

Muss ehrlich gestehen, ich habe noch nie irgendwas mit der Kommandozeile gemacht. Bin sofort in die IDE gesprungen :-/

 

[Kotelettklopfer]

Danke @kneitzel für den Tip mit Git und den Büchern. Habe nun zur Übung mein Projekt in ein Repository gepackt und auch mal testweise ne Änderrung per commit gespeichert...
Echt super !! Klappt

 

[mihe7]

Echt super !! Klappt

Und das ist nur der Anfang.

 

[Kotelettklopfer]

Ich schon wieder

Ich wollte jetzt mal testen in einen alten Stand zurückzuspringen.
git resest --hard b066 (ich habe bewusst nicht ausgecheckt sondern wollte nachfolgende commits löschen)
Head is now at b066 Database Path Fixed

Wie bekomme ich die aktuelle Ansicht jetzt in meiner IDE angezeigt?
Wie zieh ich mir den Stand jetzt aus dem Git Verzeichnis?

IDE ist Intelij

 

[kneitzel]

In IntelliJ kannst Du einen Rechtsklich auf Dein Projekt im Projekt Fenster machen. Dann im Context Menü git -> Show History auswählen.

Dann bekommst Du die History angezeigt und kannst dann ein Element der History anzeigen und Rechtsklick machen.
- Checkout Revision würde dir den Stand ins Arbeitsverzeichnis holen
- Reset Current Branch to here - das setzt den gewählten Branch entsprechend, so dass dies das aktuelle ist.


Ansonsten hast Du unten rechts so ein Symbol mit "master" - darüber kannst Du auch immer den aktuellen Stand holen (nach dem reset ist der aktuelle Stand ein anderer) ... da ist dann ein fetch und weitere Möglichkeiten.

Und in der Symbolleiste ist auch ein blauer Pfeil bei git - das aktualisiert dein Projekt auch.

Da Du das reset schon auf der Kommandozeile gemacht hast, kannst Du z.B. das Symbol in der Symbolleiste nutzen.

 

[mrBrown]

Ich wollte jetzt mal testen in einen alten Stand zurückzuspringen.
git resest --hard b066 (ich habe bewusst nicht ausgecheckt sondern wollte nachfolgende commits löschen)
Head is now at b066 Database Path Fixed

Wie bekomme ich die aktuelle Ansicht jetzt in meiner IDE angezeigt?
Wie zieh ich mir den Stand jetzt aus dem Git Verzeichnis?

Wenn du git resest --hard gemacht hast, ist dein Projektverzeichnis inklusive allen Dateien jetzt auf dem alten Stand.

Die IDE sollte das nahezu ohne Verzögerung merken, und aus dem "Git Verzeichnis" solltest du da auch nicht raus ziehen müssen – das ist jetzt ja schon auf dem Stand und damit arbeitest du

 

[Kotelettklopfer]

Bekomme folgende Meldung beim klick auf den blauen Pfeil.


Sieht aus als hätte ich bei der Anlage etwas vergessen !?

Die Daten sind doch nach dem commit automatish in einem Branch oder?

 

[Kotelettklopfer]

Wenn du git resest --hard gemacht hast, ist dein Projektverzeichnis inklusive allen Dateien jetzt auf dem alten Stand.

Die IDE sollte das nahezu ohne Verzögerung merken, und aus dem "Git Verzeichnis" solltest du da auch nicht raus ziehen müssen – das ist jetzt ja schon auf dem Stand und damit arbeitest du

Hard setzt zurück inkl. Arbeitsverzeichnis
Soft nur bis zum Index ne?

War es das?

 

[mrBrown]

Bekomme folgende Meldung beim klick auf den blauen Pfeil.
Anhang anzeigen 15923

Sieht aus als hätte ich bei der Anlage etwas vergessen !?

Die Daten sind doch nach dem commit automatish in einem Branch oder?

Du versuchst dort aus dem Remote-Repo zu Pullen, was natürlich nur klappt, wenn es eins gibt und es zu deinem aktuellem Branch einen "tracked Branch" gibt.

Du hast vermutlich einfach kein Remote-Repo

Hard setzt zurück inkl. Arbeitsverzeichnis
Soft nur bis zum Index ne?

Git - Reset entzaubert

git-scm.com