Ein Algorithmus ist eine eindeutige, endliche Beschreibung eines

Ein Algorithmus ist eine eindeutige, endliche Beschreibung eines allgemeinen Verfahrens zur Lösung eines Problems. Also ein Bauplan;
Lösungsplan, unabhängig von einer Sprache. (Linearer Algorithmus: Anweisungen sequentiell nacheinander ausführen.)
| Die ContinueAnweisung: ("continue;") Eine Schleife wird im Gegensatz zu "break;" nicht verlassen; der Rest des Anweisungsteils wird übersprungen und
ein neuer Schleifendurchgang gestartet. | Syntaxdiagramme sind grafische Hilfsmittel, welche die syntaktischen Regeln beschreiben, nach
denen eine Programmiersprache aufgebaut ist. | Struktogramme visualisieren elementare Grundstrukturen wie Sequenzen (Anweisungen) und
Kontrollstrukturen zur Lösung des Problems. Jede Methode wird durch ein eigenes Struktogramm modelliert. | Abstraktion ist eine höhere
Schicht, die das Unwesentliche verbirgt und das Wesentliche sichtbar macht. | Ein Abstrakter Datentyp ist ein Verbund von Daten zusammen
mit der Definition aller zulässigen Operationen, die auf sie zugreifen. Da der Zugriff nur über die festgelegten Operationen erfolgt, sind die Daten
nach außen gekapselt. | Datentypen stellen den Bauplan für Variablen dar. | Eine Variable ist ein abstrakter Behälter für eine Größe, welche im
Verlauf eines Rechenprozesses auftritt. Charakterisiert durch Name, Datentyp, Inhalt und Speicherklasse. Beginnen immer mit Buchstabe;
keine Leerzeichen, keine reservierten Wortsymbole. | Referenzen sind in Java Zeigervariablen, welche jedoch nur auf angelegte Objekte,
Felder und null (wenn diese auf nichts zeigen) zeigen können. | Eine Referenzvariable ist eine Variable, die als Speicherinhalt eine Adresse
(Referenz) auf ein Objekt dieser Klasse haben kann und wird als lokale Variable in Methoden nicht initialisiert. Ein Objekt ist nur über eine
Referenzvariable zugreifbar. | Primitive Datentypen: boolean, byte, char, short, int, long, float, double. | Strings sind in Java Objekte. Der
Inhalt kann nicht geändert werden. ( String s = new String(“Text“); ) Methode equals() statt ==-Operator. | Die Klasse StringBuffer dient zur
Manipulation von Strings. Inhalt und Länge eines StringBuffer-Objekts sind veränderbar. | Lebensdauer einer Variablen: Normale Variablen
werden bei Blockeintritt allokiert (=im Speicher eingerichtet) und bei Blockaustritt deallokiert (=i.S. vernichtet). | Gültigkeitsdauer einer
Variablen: Orte in einem Programm, an welchen man mit dem Variablennamen auf den Inhalt dieser zugreifen kann. | Lokale Variablen sind
nur in der Methode gültig, in der sie definiert sind & werden erst allokiert, wenn die Methode ausgeführt wird & können Instanzen- bzw.
Klassenvariablen verdecken. | Instanzenvariablen sind Attribute, die in der Klassendefinition nicht mit dem Modifier „static“ versehen wurden.
Jedes Objekt hat seine eigenen Kopien dieser Attribute. Sie werden bei der Erzeugung eines Objekts initialisiert. | Klassenvariablen: wie
Instanzenvariablen, aber mit Vorsatz „static“ & werden eingerichtet wenn Klasse geladen wird & sind nur einmal pro Klasse vorhanden, egal wie
viele Objektinstanzen existieren. Dementsprechend Klassenmethoden. | Ein L-Value (=left-value) ist ein Ausdruck, der eine Variable im
Speicher bezeichnet, also eine reale Speicheradresse. | Präzedenz und Assoziativität von Operatoren: Präzedenz = Priorität; Assoziativität =
von r.n.l., bzw. von l.n.r. | Der Modulo-Operator „%“ ist definiert für ganzzahlige Operanden und berechnet den ganzzahligen Rest, der bei der
ganzzahligen Division eines Operanden x durch einen Operanden y entsteht. | Der Cast-Operator berechnet den Wert des Ausdrucks und
wandelt diesen in den angegebenen Zieldatentyp („float x=2.5;“→“int y=(int)x;“) | Stream-Konzept: Ein Stream ist eine geordnete Folge von
Bytes von normalerweise unbekannter Länge. Bei einem Eingabestream kommen die Daten von einer Datenquelle (z.B. Tastatur). Bei einem
Ausgabestream gehen die Daten zu einer Datensenke (z.B. Bildschirm, Variable (RAM), …). Dazu werden in Java vordefinierte Objekte benutzt.
| Ein Block ist eine Folge von Anweisungen, die hintereinander (sequentiell) ausgeführt werden. Diese werden syntaktisch durch die
Blockbegrenzer { und } zusammengefasst. Ein Block gilt syntaktisch als eine einzige Anweisung.| Vorteile von Methoden:
Komplexitätsreduktion, Wiederverwendbarkeit von Code, Vermeidung der Redundanz von Code. | Formale Parameter: „Platzhalter“-Variablen,
die bei der Definition einer Methode angegeben werden. Die aktuellen Parameter werden beim Aufruf der Methode berechnet und an die
formalen Parameter zugewiesen. | Die einzige Parameterübergabeart in Java ist die Call-By-Value-Methode. Dabei werden für die formalen
Parameter beim Methodenaufruf immer eigene Speicherstellen angelegt. Die formalen Parameter sind also eine Kopie der aktuellen Parameter.
| Eine Klasse besteht aus Datenfeldern (Attributen) und Operationen (Methoden). Mit Elementen sind immer beide gemeint. Sie ist ein Muster
bzw. Bauplan, wie Objekte von diesem Datentyp aufgebaut sind. | Information Hiding: Verbergen der internen Datenstrukturen eines Objekts.
Nur über die öffentlich verfügbaren Methoden können die Attribute manipuliert werden. | Grundregel der OOP: Auf die Attribute darf nie direkt
zugegriffen werden (→“private“) | Objekte (o. Instanzen o. Exemplare) von Klassen werden mit dem new-Operator auf dem Heap erzeugt. New
liefert die Adresse des Objekts zurück, die mit Hilfe einer Zuweisung in einer Referenzvariable gespeichert wird. Objekt=Daten+zugehörige
Funktionen (Methoden)(im Sinne eines ADT). | this ist ein verborgener Parameter, der eine Referenz auf das Objekt der zugehörigen Methode,
von der this aufgerufen wird, darstellt. this darf im Methodenrumpf wie eine normale Referenzvariable benutzt werden. | Konstruktoren sind
„Methoden“, die sofort nach Anlegen des Objekts ausgeführt werden. Er darf keinen Rückgabewert, auch nicht void, besitzen. Nicht aufrufbar. |
Overloading: Mehrere Methoden/Konstruktoren gleichen Namens aber mit unterschiedlichen Parametern in einer Klasse. | Ein Array ist die
Zusammenfassung logischer Einheiten unter einem gemeinsamen Namen. In Java sind Arrays Objekte. | Mehrdimensionale Felder/Arrays
sind Arrays, dessen Elemente wieder Arrayvariablen (Referenzen auf Arrays) sind. | Collections sind vordefinierte Klassen, die beliebig viele
Objekte beliebigen Typs speichern können. Dazu gehören auch Vektoren. | Innerhalb eines Vektors können neue Objektreferenzen an
beliebiger Stelle eingefügt werden, ohne dass eine schon vorhandene Referenz überschrieben wird. Zu finden in java.util.*. Vektoren
verarbeiten nur Objektreferenzen und keine Basistypen; für diese werden Wrapperklassen benutzt ( Integer pi = new Integer(int) ). | Vererbung:
Gekennzeichnet durch „extends“ + Basisklasse. Nur Einfachvererbung. Reale Speicherobjekte einer abgeleiteten Klasse bestehen aus den
Attributen und Methoden der Basisklasse, sowie aus den eigenen Attributen und Methoden (Beispiel: Objekt kreis, Klasse Kreis, Basisklasse
Figur). Der Konstruktor der Basisklasse kann durch (die erste Anweisung!) „super(…);“ im Konstruktor der abgeleiteten Klasse aufgerufen
werden. | Polymorphie von Objekten bedeutet, dass sich ein abgeleitetes Objekt auch wie ein Objekt der Basisklasse verhält. | Vom
Verdecken von Datenfeldern (Overriding) spricht man, wenn in einer abgeleiteten Klasse Attribute existieren, deren Name identisch ist mit
den in einer Vaterklasse vorhandenen Attributen (Zugriff nur über "super"-Referenz). | Overriding von Methoden: wenn eine abgeleitete
Klasse die Methode einer Basisklasse überschreibt, also wenn Methodenname und Liste der formalen Parameter identisch sind. ("Figur f=new
Kreis();"→"f.show();"→show-Methode von Kreis wird ausgegeben. Man spricht hier von einer virtuellen Methode. Methoden mit Vorsatz
"static","final" und "private" sind nie virtuell.) | Late Binding: Erst zur Laufzeit wird ermittelt, welche Methode aufgerufen werden muss. Wurde
eine Methode überschrieben, dann wird immer die tiefste in der Objekthierarchie aufgerufen. | Abstrakte Klassen sind Basisklassen, in denen
nur Schnittstellen von Methoden festgelegt werden und die eigentliche Implementierung erst in den abgeleiteten Klassen geschieht. Von
abstrakten Klassen können keine Instanzen gebildet werden! (Abstrakte Klasse: „abstract public class…“. Abstrakte Methode: „public void
abstract name()…“) | Exceptions sind in Java normale Objekte, die von der Klasse Exception abgeleitet werden. Bei eigenen (Checked
Exceptions) Exception-Klassen: „extends Exception“. Alle Exceptions, die in einer Methode geworfen werden können, müssen durch „throws
NameException“ gekennzeichnet werden. Tritt in der (im tryblock aufgerufenen) Methode ein Fehler auf, muss durch „throw new
NameException(fehlervariable);“ die Exception geworfen werden. Folge: Methode wird beendet, kein Rückgabewert, JVM erhält Kontrolle (der
catchblock nach dem try wird ausgeführt). | Interfaces sind keine Klassen, werden aber wie welche behandelt. Anstatt „public class“ steht
„interface“. Interface=Schnittstelle. Alle Methoden eines Interfaces sind automatisch public und abstract (private und final sind verboten). Alle
Konstanten sind automatisch public, static und final, d.h. für diese ist immer ein Initialisierungsausdruck notwendig. Abgeleitete Klassen werden
mit „implements Interfacename“ nach dem Klassenkopf gekennzeichnet. Die abgeleitete Klasse verpflichtet sich, die Interfacemethoden zu
realisieren. Schnittstellen lassen Mehrfachvererbung zu. Interfacereferenzvariablen können überall verwendet werden, außer beim newOperator (Objektinstantiierung) und bei „extends“. | Vorteile von Interfaces: Interfacereferenzen garantieren Typsicherheit und können Objekte
von versch. Klassen und damit von untersch. Datentypen verarbeiten. Simulation von dynamischem Klassenwechsel, obwohl ein Objekt von
genau einem Klassentyp ist. | Jeder Thread besitzt eigenen: Befehlszähler, Registersatz, Stack. Alle Threads nutzen gemeinsam: den Heap,
Code und Klassenvariable in der Method-Area, IO-Kanäle. Probleme dabei: Synchronisation (Gewährleistung der Konsistenz der Daten) und
Deadlocks (Gegenseitiges Blockieren von Threads). Durch Methodenaufruf ist es nicht möglich, Threads in den Zustand "Running" zu bringen. |
Werden eine oder mehrere Objektmethoden mit dem Vorsatz synchronized versehen, so hat jedes einzelne Objekt einen eigenen Monitor, der
den Zugriff auf dieses Objekt steuert und überwacht. Für alle synchronisierten Klassenmethoden (static) wird nur ein einziger Monitor für die
ganze Klasse angelegt. Klassensperre und Objektsperre sind voneinander unabhängig. wait(), notify() und notifyAll() dürfen nur in
synchronisierten Abschnitten verwendet werden. Bei wait() immer while-Schleife! |
public class Selektion {
public static void main(String[] args) {
if(Ausdruck)
{}
else if(Ausdruck_n)
{}
else
{}
}
import java.util.Scanner;
import java.io.DataInputStream;;
public class Beispielklasse {
final static int EINGABEKONSTANTE=255;
static int scanner, datainputstream, swing;
public static void main(String[] args) {
System.out.println("Ausgabe"+EINGABEKONSTANTE);
eingabeDataInputStream();
eingabeSwing();
eingabeScanner();
}
switch(Ausdruck) {
case konstante_1:
Anweisung_1;
break;
case konstante_n:
Anweisung_n;
break;
default:
Anweisung_default;
}
}
public static void eingabeScanner() {
Scanner eingabe=new Scanner(System.in);
try{
System.out.println("Zahl eingeben:");
scanner=eingabe.nextInt();
System.out.println("Zahl: "+scanner);
}
finally{eingabe.close();}
}
public class Iteration {
public static void main(String[] args) {
while(Boolescher Ausdruck)
{
Anweisung }
for(Initialisierungsklausel;
Boolescher Ausdruck;
Reinitialisierung)
{
Anweisung
}
public static void eingabeDataInputStream() {
DataInputStream eingabe=new DataInputStream(System.in);
try{
System.out.println("Zahl eingeben:");
datainputstream=Integer.parseInt(eingabe.readLine());
}
catch (Exception e){}
System.out.println("Zahl: "+datainputstream);
}
}
}
import java.util.*;
public class VecBeispiel {
public static void main(String[] args) {
Vector vec=new Vector();
vec.add("eins");
vec.add("drei");
vec.add("zwei");
vec.add("vier");
->[eins, drei, zwei, vier]
vec.add(1, "zwei");
->[eins, zwei, drei, zwei, vier]
vec.insertElementAt("objekt", 2);
->[eins, zwei, objekt, drei, zwei, vier]
vec.remove(4);
->[eins, zwei, objekt, drei, vier]
vec.remove("vier");
->[eins, zwei, objekt, drei]
vec.size();
->4
vec.elementAt(0);
->eins
}
}
public class HauptR {
public static void main(String[] argd)
{
Thread t1 = new Thread(new UhrR("UhrR1", 1000));
t1.start();
Thread t2 = new Thread(new UhrR("UhrR2", 800));
t2.start();
}
}
public class UhrR implements Runnable {
String name;
long ms;
long gesamtzeit = 0;
public UhrR(String n, long m)
{
this.name = n;
this.ms = m;
}
public void run()
{
while (true)
{
try
{
}
Figur f;
Kreis k;
//Up-Cast:
f=k;
//Down-Cast:
if(f instanceof Kreis)
Kreis k1=(Kreis)f;
public static void eingabeSwing() {
String s=javax.swing.JOptionPane.showInputDialog("Zahl eingeben:");
swing=Integer.parseInt(s);
System.out.println("Zahl: "+swing);
}
}
do{
Anweisung }
while(Boolescher Ausdruck); }
public static void main(String[] args) {
int [] array;
array=new int[4];
System.out.println(array.length);
int [] array2={8,3,5,10,5,6};
array2[0]=array2[0]+2;
//Mehrdimensionale Arrays
int [][] feld;
feld = new int[3][];
for(int i=0; i<feld.length; i++)
feld[i]=new int[i+1];
StringBuffer b1=new StringBuffer("World");
StringBuffer b2=new StringBuffer("Java");
String s1=b1.toString();
String s2=b2.toString();
if(s1.equals(s2)){...}
b1.length();
b1.charAt(index); //returns char
b1.setCharAt(index, char);
b1.append(String); //returns StringBuffer
public void ersteMethode()
{
}
try
{
/*Anweisung*/ return;
}
catch(ExceptionKlassenname irgendein_exc_name)
{
/*Anweisung*/ irgendein_exc_name.message();
return;
}
public int aufgerufeneMethode() throws ExceptionKlassenname
{
if(/*richtig*/)
return wert;
else
throw new ExceptionKlassenname();
}
public class Haupt {
public static void main(String[] argd) {
Uhr u1 = new Uhr("Uhr1", 1000);
u1.start();
Uhr u2 = new Uhr("Uhr2", 800);
u2.start();
}
}
public class Uhr extends Thread {
String name;
long ms;
long gesamtzeit = 0;
public Uhr(String n, long m)
{
this.name = n;
this.ms = m;
}
public void run()
{
while (true)
{
Thread.sleep(ms);
gesamtzeit += ms;
}
catch (InterruptedException e) {}
System.out.println(name+" : "+gesamtzeit);
}
}
}
try
{
sleep(ms);
gesamtzeit += ms;
}
catch (InterruptedException e) {}
System.out.println(name+": "+gesamtzeit);
}
}
public static void yield()
//Thread gibt freiwillig den Prozessor frei und wartet erneut auf Zuteilung von Prozessorleistung durch den Scheduler. Damit haben andere T hreads eine Chance, den Prozessor zu erhalten.
public final void stop()
//Thread wird beendet
public final void suspend()
//Thread wird blockiert und kann erst wieder durch "resume()" reaktiviert werden.
public final void resume()
//Die Blockierung eines Threads durch suspend() wird aufgehoben.
public final void join()
//Ein Thread kann die join()-Methode eines anderen Threads aufrufen. Der aufgerufene Thread wird blockiert, bis der Thread, dessen join()-Methode aufgerufen wurde, beendet ist (->dead).