Jump to content

Java? Java! How to alles... - Teil 1 - Basics


idk.cpp
 Share

Recommended Posts

Wie funktioniert Java? In Java gibt es Klassen, von diesen Klassen kann man sog. Instanzen erzeugen, die man speichern kann. Diese Instanzen können wiederum Klassen enthalten, oder Methoden. Siehe_auch("Das new Keyword") Was ist eine Variable? Eine Variable ist ein Speicherplatz, in dem verschiedene Daten gespeichert werden können. Alle Instanzen können als Variable verwendet werden.

(modifikator) VariablenTyp variablenName (= InitialisierungsWert);

Ergänzung("Was ist eine Variable") New("15.06.2013")

Siehe_auch("Das new Keyword") Was ist eine Referenz? Eine Referenz ist sozusagen ein Verweiß auf einen Speicherplatz. Sie sieht so aus:

(modifikator) Typ name;

Jetzt die Frage: Was ist der unterschied zwischen einer Variable und einer Referenz? Eine Referenz ist noch kein Speicher im RAM. Sondern nur ein Platzhalter, der einen Namen hat. Mit dem "new"-Keyword wird dann ein Speicher im RAM reserviert! Dann wurde eine Variable erzeugt die man über die Referenz benutzen kann. Die Speicheradresse hat sozusagen einen Namen. (Für Leute die C++ oä können: Es gibt keine Pointer!!!!!) Variablken werden immer "per reference" übergeben! Schauen wir uns per Beispiel was das bedeutet:

public class SomeClass {  public static String str;  // Eine Referenz    public static void main(String args[]) {    str = new String("Hello World");   // Ein neues Objekt wird erzeugt und in "str" gespeichert    other(str);   // Die Referenz wird übergeben  }  public static boolean other(String arg) {   // String arg  ==> eine Referenz    if (arg == str) return true;   // Wenn die Objekte der Referenzen die SELBEN sind wird true zurückgegeben, das ist jetzt der Fall    else return false;  // sonst false  }}public class SomeOtherClass {  public static String str;      public static void main(String args[]) {    str = "Hello World";   // ein neues String-Objekt kann auch so erzeugt werden    other("Hello World");  }  public static boolean other(String arg) {    if (arg == str) return true;   // Jetzt wird false zurückgegeben, die Inhalte der Strings sind zwar gleich aber es sind nicht die SELBEN    else return false;  }}

Was ist eine Methode? Eine Methode ist ein definierter Ablauf von verschiedenen Operationen. Solche wie Variablen anlegen, Variablen verarbeiten oder auch andere Methoden aufrufen. Man kann Methoden Parameter übergeben, diese werden zu Variablen die es nur in der Methode gibt. In C++ werden Methoden "Funktionen" genannt.

modifikator returnTyp methodenName(ParameterKlasse parameterName, ...) {  Aktionen  return returnValue;}

Der Rückgabewert (returnValue) ist eine Instanz einer Klasse die durch den Aufruf "ersetzt" wird.

public Integer getInt() {//     ^^^//     Return Klasse//      Return Value//       v  return 5;//^^^^ //Keyword}Integer i = getInt() + 2; // ergibt 7//          ^^^^// wird durch die Instanz die returned wird ersetzt

Soll eine Funktion keinen Rückgabewert haben, so setzt man "void" ein. Dann muss es auch kein "return"-Statement beinhalten. Was ist eine Klasse? Eine Klasse ist eine Ansammlung von Variablen und Methoden.

modifikator class KlassenName {  Variablen;  Methoden {}}

Edit("15.06.2013") Die Operatoren:

Operator     Funktion   +         Stringverkettung, Addition   -         Subtraktion   *         Multiplikation   /         Division   %         Modulo   +=        Setze den ersten Ausdruck auf selbigen + den zweiten   -=        Setze den ersten Ausdruck auf selbigen - den zweiten   *=        Setze den ersten Ausdruck auf selbigen * den zweiten   /=        Setze den ersten Ausdruck auf selbigen / den zweiten   ==        Prüfe auf Objektgleichheit (bei Strings wird nicht auf Inhalt geprüft)   =         Setze ersten Ausdruck auf zweiten   &&        UND-Verknüpfung (ist true wenn der erste und zweite Ausdruck true sind)   ||        ODER-Verknüpfung (ist true wenn ein Ausdruck true ist)   !         NICHT-Operator (ist true wenn nachgestellter Ausdruck false ist)

Was heißt public? Es gibt in Java 3 verschiedene Zugriffsmodifikatoren;

publicprotectedprivate

Diese geben an welche Klassen auf spezielle Sachen zugreifen können. public bedeutet jedeKlasse kann zugreifen, protected bedeutet nur Subklassen oder Klassen des selben Packages können zugreifen, private bedeutet nur die eigene Klasse kann zugreifen, kein Modifikator bedeutet nur Klassen des selben Packages können zugreifen. Zugreifbare Methoden und Variablen können mit dem "." benutzt werden. Superklassen, Subklassen... extends Eine Subklasse ist eine Klasse die Methoden und Variablen aus einer sog. Superklasse übernimmt.

public class SuperClass {  public String myStr = "Hallo";  public String toString() {    return "SuperClass";  }}public class SubClass extends SuperClass {  public String otherStr = " Welt";}public class MyClass {  public static void main(String args[]) {    SubClass sC = new SubClass();    String str = sC.myStr + sC.otherStr; // Ergibt "Hallo Welt"//               ^^^^//               Instanz       Variable  }    @Override  public String toString() {    return "SubClass";  }}

Alle Methoden und Variablen werden in die Subklasse übernommen. Sie können mit der @Override Annotation überschrieben werden. Der Constructor Ein Contructor ist eine Methode ohne Rückgabewert. Sie wird bei der "Instantiierung" einer Klasse aufgerufen. Um Laufzeit-spezifische Anfangswerte einzusetzten. Der Constructor heißt immer so wie die Klasse.

public class MyClass {  private String myName = null;  public MyClass(String str) {    myName = str;  }  public String toString() {    return myName;  }}public class MainClass {  public static void main(String[] args) {    MyClass mC = new MyClass("Hello");    mC.toString(); // ergibt "Hello"  }}

Das "new" Keyword Das "new"-Keyword erzeugt eine neue Instanz aus einer Klasse. Die Instanz kann gespeichert werden. Der Constructor wird aufgerufen, er gibt als Rückgabewert die neue Instanz. Der static Modifikator Eine Variable die "static" ist, ist im gesamten Java Environment gleich. Sie gehört der Klasse nicht der Instanz. Um auf static Variablen zuzugreifen muss keine neue Instanz erzeugt werden.

public class NClass {  public String str = "Hello";}public class SClass {  public static String str = "World";}public class MainClass {  public static void main(String args[]) {    NClass.str;       // geht nicht    new NClass().str; // geht    SClass.str;       // geht    new SClass().str; // geht nicht  }}

non-static Variablen kann man nicht in einem static-context benutzen:

public class MyClass {  public String str = "hello";  public static void main(String str[]) {    String myStr = str;    // geht nicht  }}

Ausnahmen und was man tun kann: Eine Ausnahme (oder auch Exception) ist ein Fehler der während der Laufzeit auftritt. Die bekannteste Ausnahme ist die NullPointerException oder auch die IOException. Eine Excpetion wird mit dem "throw"-Keyword zur Aufrufenden Instanz/Klasse "geworfen".

public void do(String param) throws Exception {  if (param == null) throw new NullPointerException();}

Dabei kann man nach dem "throws"-Keyword genauer spezifizieren welche Exceptions auftreten können. Alle Exceptions sind Subklassen von Exception. Man kann nach dem "throws" auch eine Superklasse der Exception angeben.

public void do() throws GeneralSecurityException {  throw new InvalidKeyException();}

Die "GeneralSecurityException" die eine Superklasse von "InvalidKeyException". Alle Klassen die "gethrowed" werden müssen eine Subklasse von "Throwable" sein. Um dafür zu sorgen, dass eine Exception nicht das Programm beendet (crasht) muss man "probieren" und wenn die Ausnahme auftritt muss man sie abfangen.

try {  eineMethodeMitThrows();} catch (Exception e) {  e.printStackTrace();}

Man kann mit einem "catch"-Block mehrere Exceptions mit dem oder-Operator abfangen. Man kann aber auch mit mehreren "catch"-Blöcken abfangen. "e" ist eine Variable, die die Instanz der Exception (siehe "new Excepetion") beinhaltet. New("15.06.2013") If-else-Clause Eine sog. If-Abfrage ist eine Einrichtung um einen boolschen Wert zu überprüfen.

if (true) {  // Code} else {  // Code der nicht aufgerufen wird}

Ein "else"-Block ist nicht unbedingt nötig! Er kann weg gelassen werden wenn kein Code da ist der im anderen Fall ausgeführ werden soll. Der == Operator gibt einen boolschen Wert zurück! Er ist true, wenn die Objekte gleich sind, und false, wenn nicht. Es gibt Fälle da wird das mit da braucht man ein "else if", das sieht dann so aus:

if (ersterBool && !zweiterBool) {  // Fall 1} else if (!ersterBool && zweiterBool) {  // Fall 2} else {  // Fall 3}

New("15.06.2013") Annotation Eine Annotation gibt zusätzliche Informationen über den nachgestellten Ausdruck. Sie kann in Klammern zusätzliche Informationen enthalten, die mit Beistrich getrennt werden. Ein sog. "Annotation-Compiler" kann verwendet werden um mit bestimmten Annotationen Fehler und Warnungen zu unterdrücken. Annotationen fangen mit einem @-Zeichen an und gehen bis zum Ende der Zeile. Zum Beispiel zeigt folgende Annotation, dass die betreffende Funktion veraltet ist. Es wird eine Warnung ausgegeben wenn sie benutzt wird.

@Deprecatedpublic void veralteteMethode() {  // ...}

New("15.06.2013") Kommentar Ein Kommentar wird vom Compiler ignoriert. Er dieht nur zur Beschreibung des Codes oder für den Entwickler als Randinformation. Ein Kommentar der mit "//" eingeletet wird geht bis zum Ende der Zeile. Ein Kommentar der mit "/*" eingeleitet wird geht bis zu einem "*/"

public void methode() {  komischeMethode();  // Kommentar bis zum Ende der Zeile  /*  Kommentar      der      über       viele      Zeilen      geht */   code();}

New("14.06.2013")

Edit("29.06.2013") Finale Daten

Der "final" Modifikator gibt an, dass Werte unveränderlich sind, also Konstanten.

Sie können nur einmal im Constructor zugewiesen werden.

Methoden die "final" sind können von Subklassen nicht verändert werden

New("15.06.2013") Häufigste Datentypen Boolean

Im Idealfall genau ein Bit. Kann einen Wert zwischen "true" (Bit gesetzt) und "false" (Bit nicht gesetzt) speichern. Wird als Flag/Schalter benutzt um mit Hilfe der If-Abfrage den Programmfluss zu verändern.

Beispiel:

boolean fehler = false;try {  etwasWasMoglicherweiseNichtGeht();} catch (Exception e) {  fehler = true;}if (fehler) {  // der Fehler ist aufgetreten} else {  // kein Fehler ist aufgetreten}

Integer

Eine ganze Zahl (kein Komma).

Genauere Infos über Größe? => Google

Größter Wert wird durch die final Variable Integer.MAX_VALUE dargestellt

Kleinster => Integer.MIN_VALUE

String

Um eine Zeichenkette zu speichern.

Nützliche Klassen --> Weiters folgt (wahrscheinlich) noch ... Falls ich Fehler gemacht habe bitte mir sagen! (Außer Rechtschreibung)

Edited by idk.cpp
Link to comment
Share on other sites

Sehr sehr nützlich, da sind sogar einige Sachen dabei die ich auch noch nicht gewusst habe :)

Danke dafür.

Nutze aber bitte beim nächsten mal die "Bearbeiten"-Funktion um Doppelposts zu vermeiden.

Link to comment
Share on other sites

Verfolgt das hier noch jemand? (soweit das halt geht wenn nichts neues erscheint...)

Wenn ja, interessiert diesen Jemand eine Liste von nützlichen Datentypen (resp. Klassen)?

--

@TuxGamer

Cool, jetzt habe ich noch jmd. den ich bei Fragen belästigen kann

Ich warte auf deine Fragen mit denen du mich belästigen willst.....

Link to comment
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now
 Share

×
×
  • Create New...
B
B