Wiki der 13ITO4 - Benutzerbeiträge [de]

Interfaces

2013-07-15T08:43:19Z

Jimmy:

== Allgemeines über Interfaces ==
* Interfaces beschreiben den reinen Entwurf einer Klasse
* In Interfaces wird keine Logik implementiert
* Es werden nur Variablen und Methoden deklariert (nur Konstanten werden initialisiert)
* Wenn ein Interface implementiert wird müssen die Methoden spezialisiert werden

== Mehrfachvererbung ==
* Eine Klasse kann nur von einer Klasse abgeleitet werden
* Eine Klasse kann jedoch mehrere Interfaces implementieren
* Schlüsselwort "implements"

== Beispiel: ==

interface myInterface {
public int getX();
public void setX(int x);
}

public class implX implements myInterface {
int x = 0;
public int getX(){return x;}
public void setX(int x){this.x = x}
}

== Aufgabe ==

Wir haben eine Heizung, die mit verschiedenen Stoffen angeheizt werden kann. Alle diese Stoffe haben einen bestimmten Heizwert der angibt für wie viele Stunden mit diesem Stoff Wärme erzeugt werden kann.
Als Stoffe haben wir Holz (Brennwert = 3), Öl (Brennwert = 2) und Gas (Brennwert = 1).

== Lösung ==
=== Heizanlage.java ===

public class Heizanlage {

private int waermeSpeicher = 0;

public void speicherAuffuellen(Verheizbar stoff) {
this.waermeSpeicher += stoff.verbrennen();
System.out.println(this.waermeSpeicher + " Stunden kann geheizt werden");
}

// gibt false zurück, falls der Speicher leer ist
public boolean wohnungHeizen(int zeit) {

if (this.waermeSpeicher - zeit < 0) {
System.out.println("Es kann nur noch für " + (this.waermeSpeicher) + " Stunden geheizt werden");
this.waermeSpeicher = 0;
}
else {
System.out.println("Habe geheizt...");
this.waermeSpeicher -= zeit;
}
if (this.waermeSpeicher == 0) {
System.out.println("Bitte Speicher auffüllen!");
return false;
}
return true;
}
}
=== Verheizbar.java ===

public interface Verheizbar {
// verbrennt den brennbaren Stoff und liefert die Stunden zurück,
// wie lange die Wohnung mit diesem Stoff geheizt werden kann
int verbrennen();
}

=== Gas.java ===

public class Gas implements Verheizbar
{
public int verbrennen() {
return 3;
}
}

=== Holz.java ===
public class Holz implements Verheizbar {

public int verbrennen() {
return 2;
}
}

=== Oel.java ===

public class Oel implements Verheizbar{
public int verbrennen() {
return 1;
}
}

=== app.java ===

public class app {

public static void main(String[] args) {

Heizanlage anlage = new Heizanlage();

// Heizanlage auffüllen

anlage.speicherAuffuellen(new Holz());

anlage.speicherAuffuellen(new Gas());

anlage.speicherAuffuellen(new Holz());

anlage.speicherAuffuellen(new Oel());

anlage.speicherAuffuellen(new Holz());

// Vorrat anlegen

Verheizbar[] vorrat = new Verheizbar[8];

vorrat[0] = new Holz();

vorrat[1] = new Oel();

vorrat[2] = new Holz();

vorrat[3] = new Gas();

vorrat[4] = new Gas();

vorrat[5] = new Holz();

vorrat[6] = new Oel();

vorrat[7] = new Holz();

// Tag mit 24 Stunden

for (int i = 0; i < 24; i++) {

if (!anlage.wohnungHeizen(1)) {

for (int j = 0; j < vorrat.length; j++) {

if (vorrat[j] != null) {

anlage.speicherAuffuellen(vorrat[j]);

vorrat[j] = null;

break;

}

}

}

}
}
}

[https://docs.google.com/presentation/d/1273DDSpMTjLdIBAnkC6maFoJ_jwRysKMNoZgbASU5pI/edit#slide=id.p Präsentation]

Interfaces

2013-07-15T08:27:29Z

Jimmy:

== Allgemeines über Interfaces ==
* Interfaces beschreiben den reinen Entwurf einer Klasse
* In Interfaces wird keine Logik implementiert
* Es werden nur Variablen und Methoden deklariert (nur Konstanten werden initialisiert)
* Wenn ein Interface implementiert wird müssen die Methoden spezialisiert werden

== Mehrfachvererbung ==
* Eine Klasse kann nur von einer Klasse abgeleitet werden
* Eine Klasse kann jedoch mehrere Interfaces implementieren
* Schlüsselwort "implements"

== Beispiel: ==

interface myInterface {
public int getX();
public void setX(int x);
}

public class implX implements myInterface {
int x = 0;
public int getX(){return x;}
public void setX(int x){this.x = x}
}

== Aufgabe ==

Wir haben eine Heizung, die mit verschiedenen Stoffen angeheizt werden kann. Alle diese Stoffe haben einen bestimmten Heizwert der angibt für wie viele Stunden mit diesem Stoff Wärme erzeugt werden kann.
Als Stoffe haben wir Holz (Brennwert = 3), Öl (Brennwert = 2) und Gas (Brennwert = 1).

== Lösung ==
=== Heizanlage.java ===

public class Heizanlage {

private int waermeSpeicher = 0;

public void speicherAuffuellen(Verheizbar stoff) {
this.waermeSpeicher += stoff.verbrennen();
System.out.println(this.waermeSpeicher + " Stunden kann geheizt werden");
}

// gibt false zurück, falls der Speicher leer ist
public boolean wohnungHeizen(int zeit) {

if (this.waermeSpeicher - zeit < 0) {
System.out.println("Es kann nur noch für " + (this.waermeSpeicher) + " Stunden geheizt werden");
this.waermeSpeicher = 0;
}
else {
System.out.println("Habe geheizt...");
this.waermeSpeicher -= zeit;
}
if (this.waermeSpeicher == 0) {
System.out.println("Bitte Speicher auffüllen!");
return false;
}
return true;
}
}
=== Verheizbar.java ===

public interface Verheizbar {
// verbrennt den brennbaren Stoff und liefert die Stunden zurück,
// wie lange die Wohnung mit diesem Stoff geheizt werden kann
int verbrennen();
}

=== Gas.java ===

public class Gas implements Verheizbar
{
public int verbrennen() {
return 3;
}
}

=== Holz.java ===
public class Holz implements Verheizbar {

public int verbrennen() {
return 2;
}
}

=== Oel.java ===

public class Oel implements Verheizbar{
public int verbrennen() {
return 1;
}
}

=== app.java ===

public class app {

public static void main(String[] args) {

Heizanlage anlage = new Heizanlage();

// Heizanlage auffüllen
anlage.speicherAuffuellen(new Holz());
anlage.speicherAuffuellen(new Gas());
anlage.speicherAuffuellen(new Holz());
anlage.speicherAuffuellen(new Oel());
anlage.speicherAuffuellen(new Holz());

// Vorrat anlegen
Verheizbar[] vorrat = new Verheizbar[8];
vorrat[0] = new Holz();
vorrat[1] = new Oel();
vorrat[2] = new Holz();
vorrat[3] = new Gas();
vorrat[4] = new Gas();
vorrat[5] = new Holz();
vorrat[6] = new Oel();
vorrat[7] = new Holz();

// Tag mit 24 Stunden
for (int i = 0; i < 24; i++) {
if (!anlage.wohnungHeizen(1)) {
for (int j = 0; j < vorrat.length; j++) {
if (vorrat[j] != null) {
anlage.speicherAuffuellen(vorrat[j]);
vorrat[j] = null;
break;
}
}
}
}
}
}

[https://docs.google.com/presentation/d/1273DDSpMTjLdIBAnkC6maFoJ_jwRysKMNoZgbASU5pI/edit#slide=id.p Präsentation]

Interfaces

2013-07-15T08:11:39Z

Jimmy:

== Allgemeines über Interfaces ==
* Interfaces beschreiben den reinen Entwurf einer Klasse
* In Interfaces wird keine Logik implementiert
* Es werden nur Variablen und Methoden deklariert (nur Konstanten werden initialisiert)
* Wenn ein Interface implementiert wird müssen die Methoden spezialisiert werden

== Mehrfachvererbung ==
* Eine Klasse kann nur von einer Klasse abgeleitet werden
* Eine Klasse kann jedoch mehrere Interfaces implementieren
* Schlüsselwort "implements"

== Beispiel: ==

interface myInterface {
public int getX();
public void setX(int x);
}

public class implX implements myInterface {
int x = 0;
public int getX(){return x;}
public void setX(int x){this.x = x}
}

== Aufgabe ==

Wir haben eine Heizung, die mit verschiedenen Stoffen angeheizt werden kann. Alle diese Stoffe haben einen bestimmten Heizwert der angibt für wie viele Stunden mit diesem Stoff Wärme erzeugt werden kann.
Als Stoffe haben wir Holz (Brennwert = 3), Öl (Brennwert = 2) und Gas (Brennwert = 1).

== Lösung ==
=== Heizanlage.java ===

public class Heizanlage {

private int waermeSpeicher = 0;

public void speicherAuffuellen(Verheizbar stoff) {
this.waermeSpeicher += stoff.verbrennen();
System.out.println(this.waermeSpeicher + " Stunden kann geheizt werden");
}

// gibt false zurück, falls der Speicher leer ist
public boolean wohnungHeizen(int zeit) {

if (this.waermeSpeicher - zeit < 0) {
System.out.println("Es kann nur noch für " + (this.waermeSpeicher) + " Stunden geheizt werden");
this.waermeSpeicher = 0;
}
else {
System.out.println("Habe geheizt...");
this.waermeSpeicher -= zeit;
}
if (this.waermeSpeicher == 0) {
System.out.println("Bitte Speicher auffüllen!");
return false;
}
return true;
}
}
=== Verheizbar.java ===

public interface Verheizbar {
// verbrennt den brennbaren Stoff und liefert die Stunden zurück,
// wie lange die Wohnung mit diesem Stoff geheizt werden kann
int verbrennen();
}

=== Gas.java ===

public class Gas implements Verheizbar{
public int verbrennen() {
return 3;
}
}

=== Holz.java ===
public class Holz implements Verheizbar {

public int verbrennen() {
return 2;
}
}

=== Oel.java ===

public class Oel implements Verheizbar{
public int verbrennen() {
return 1;
}
}

=== app.java ===

public class app {

public static void main(String[] args) {

Heizanlage anlage = new Heizanlage();

// Heizanlage auffüllen
anlage.speicherAuffuellen(new Holz());
anlage.speicherAuffuellen(new Gas());
anlage.speicherAuffuellen(new Holz());
anlage.speicherAuffuellen(new Oel());
anlage.speicherAuffuellen(new Holz());

// Vorrat anlegen
Verheizbar[] vorrat = new Verheizbar[8];
vorrat[0] = new Holz();
vorrat[1] = new Oel();
vorrat[2] = new Holz();
vorrat[3] = new Gas();
vorrat[4] = new Gas();
vorrat[5] = new Holz();
vorrat[6] = new Oel();
vorrat[7] = new Holz();

// Tag mit 24 Stunden
for (int i = 0; i < 24; i++) {
if (!anlage.wohnungHeizen(1)) {
for (int j = 0; j < vorrat.length; j++) {
if (vorrat[j] != null) {
anlage.speicherAuffuellen(vorrat[j]);
vorrat[j] = null;
break;
}
}
}
}
}
}

[https://docs.google.com/presentation/d/1273DDSpMTjLdIBAnkC6maFoJ_jwRysKMNoZgbASU5pI/edit#slide=id.p Präsentation]

Interfaces

2013-07-15T08:11:09Z

Jimmy:

== Allgemeines über Interfaces ==
* Interfaces beschreiben den reinen Entwurf einer Klasse
* In Interfaces wird keine Logik implementiert
* Es werden nur Variablen und Methoden deklariert (nur Konstanten werden initialisiert)
* Wenn ein Interface implementiert wird müssen die Methoden spezialisiert werden

== Mehrfachvererbung ==
* Eine Klasse kann nur von einer Klasse abgeleitet werden
* Eine Klasse kann jedoch mehrere Interfaces implementieren
* Schlüsselwort "implements"

== Beispiel: ==

interface myInterface
{
public int getX();
public void setX(int x);
}

public class implX implements myInterface
{
int x = 0;
public int getX(){return x;}
public void setX(int x){this.x = x}
}

== Aufgabe ==

Wir haben eine Heizung, die mit verschiedenen Stoffen angeheizt werden kann. Alle diese Stoffe haben einen bestimmten Heizwert der angibt für wie viele Stunden mit diesem Stoff Wärme erzeugt werden kann.
Als Stoffe haben wir Holz (Brennwert = 3), Öl (Brennwert = 2) und Gas (Brennwert = 1).

== Lösung ==
=== Heizanlage.java ===

public class Heizanlage {

private int waermeSpeicher = 0;

public void speicherAuffuellen(Verheizbar stoff) {
this.waermeSpeicher += stoff.verbrennen();
System.out.println(this.waermeSpeicher + " Stunden kann geheizt werden");
}

// gibt false zurück, falls der Speicher leer ist
public boolean wohnungHeizen(int zeit) {

if (this.waermeSpeicher - zeit < 0) {
System.out.println("Es kann nur noch für " + (this.waermeSpeicher) + " Stunden geheizt werden");
this.waermeSpeicher = 0;
}
else {
System.out.println("Habe geheizt...");
this.waermeSpeicher -= zeit;
}
if (this.waermeSpeicher == 0) {
System.out.println("Bitte Speicher auffüllen!");
return false;
}
return true;
}
}
=== Verheizbar.java ===

public interface Verheizbar {
// verbrennt den brennbaren Stoff und liefert die Stunden zurück,
// wie lange die Wohnung mit diesem Stoff geheizt werden kann
int verbrennen();
}

=== Gas.java ===

public class Gas implements Verheizbar{
public int verbrennen() {
return 3;
}
}

=== Holz.java ===
public class Holz implements Verheizbar {

public int verbrennen() {
return 2;
}
}

=== Oel.java ===

public class Oel implements Verheizbar{
public int verbrennen() {
return 1;
}
}

=== app.java ===

public class app {

public static void main(String[] args) {

Heizanlage anlage = new Heizanlage();

// Heizanlage auffüllen
anlage.speicherAuffuellen(new Holz());
anlage.speicherAuffuellen(new Gas());
anlage.speicherAuffuellen(new Holz());
anlage.speicherAuffuellen(new Oel());
anlage.speicherAuffuellen(new Holz());

// Vorrat anlegen
Verheizbar[] vorrat = new Verheizbar[8];
vorrat[0] = new Holz();
vorrat[1] = new Oel();
vorrat[2] = new Holz();
vorrat[3] = new Gas();
vorrat[4] = new Gas();
vorrat[5] = new Holz();
vorrat[6] = new Oel();
vorrat[7] = new Holz();

// Tag mit 24 Stunden
for (int i = 0; i < 24; i++) {
if (!anlage.wohnungHeizen(1)) {
for (int j = 0; j < vorrat.length; j++) {
if (vorrat[j] != null) {
anlage.speicherAuffuellen(vorrat[j]);
vorrat[j] = null;
break;
}
}
}
}
}
}

[https://docs.google.com/presentation/d/1273DDSpMTjLdIBAnkC6maFoJ_jwRysKMNoZgbASU5pI/edit#slide=id.p Präsentation]

Interfaces

2013-07-15T08:10:12Z

Jimmy: Aufgaben

== Allgemeines über Interfaces ==
* Interfaces beschreiben den reinen Entwurf einer Klasse
* In Interfaces wird keine Logik implementiert
* Es werden nur Variablen und Methoden deklariert (nur Konstanten werden initialisiert)
* Wenn ein Interface implementiert wird müssen die Methoden spezialisiert werden

== Mehrfachvererbung ==
* Eine Klasse kann nur von einer Klasse abgeleitet werden
* Eine Klasse kann jedoch mehrere Interfaces implementieren
* Schlüsselwort "implements"

== Beispiel: ==

interface myInterface
{
public int getX();
public void setX(int x);
}

public class implX implements myInterface
{
int x = 0;
public int getX(){return x;}
public void setX(int x){this.x = x}
}

== Aufgabe ==

Wir haben eine Heizung, die mit verschiedenen Stoffen angeheizt werden kann. Alle diese Stoffe haben einen bestimmten Heizwert der angibt für wie viele Stunden mit diesem Stoff Wärme erzeugt werden kann.
Als Stoffe haben wir Holz (Brennwert = 3), Öl (Brennwert = 2) und Gas (Brennwert = 1).

== Lösung ==
===
Heizanlage.java ===

public class Heizanlage {

private int waermeSpeicher = 0;

public void speicherAuffuellen(Verheizbar stoff) {
this.waermeSpeicher += stoff.verbrennen();
System.out.println(this.waermeSpeicher + " Stunden kann geheizt werden");
}

// gibt false zurück, falls der Speicher leer ist
public boolean wohnungHeizen(int zeit) {

if (this.waermeSpeicher - zeit < 0) {
System.out.println("Es kann nur noch für " + (this.waermeSpeicher) + " Stunden geheizt werden");
this.waermeSpeicher = 0;
}
else {
System.out.println("Habe geheizt...");
this.waermeSpeicher -= zeit;
}
if (this.waermeSpeicher == 0) {
System.out.println("Bitte Speicher auffüllen!");
return false;
}
return true;
}
}
===
Verheizbar.java ===

public interface Verheizbar {
// verbrennt den brennbaren Stoff und liefert die Stunden zurück,
// wie lange die Wohnung mit diesem Stoff geheizt werden kann
int verbrennen();
}

=== Gas.java ===

public class Gas implements Verheizbar{
public int verbrennen() {
return 3;
}
}

=== Holz.java
===
public class Holz implements Verheizbar {

public int verbrennen() {
return 2;
}
}

=== Oel.java ===

public class Oel implements Verheizbar{
public int verbrennen() {
return 1;
}
}

=== app.java ===

public class app {

public static void main(String[] args) {

Heizanlage anlage = new Heizanlage();

// Heizanlage auffüllen
anlage.speicherAuffuellen(new Holz());
anlage.speicherAuffuellen(new Gas());
anlage.speicherAuffuellen(new Holz());
anlage.speicherAuffuellen(new Oel());
anlage.speicherAuffuellen(new Holz());

// Vorrat anlegen
Verheizbar[] vorrat = new Verheizbar[8];
vorrat[0] = new Holz();
vorrat[1] = new Oel();
vorrat[2] = new Holz();
vorrat[3] = new Gas();
vorrat[4] = new Gas();
vorrat[5] = new Holz();
vorrat[6] = new Oel();
vorrat[7] = new Holz();

// Tag mit 24 Stunden
for (int i = 0; i < 24; i++) {
if (!anlage.wohnungHeizen(1)) {
for (int j = 0; j < vorrat.length; j++) {
if (vorrat[j] != null) {
anlage.speicherAuffuellen(vorrat[j]);
vorrat[j] = null;
break;
}
}
}
}
}
}

[https://docs.google.com/presentation/d/1273DDSpMTjLdIBAnkC6maFoJ_jwRysKMNoZgbASU5pI/edit#slide=id.p Präsentation]

Interfaces

2013-07-15T08:00:48Z

Jimmy:

Allgemeines über Interfaces

- Interfaces beschreiben den reinen Entwurf einer Klasse
- In Interfaces wird keine Logik implementiert
- Es werden nur Variablen und Methoden deklariert (nur Konstanten werden initialisiert)
- Wenn ein Interface implementiert wird müssen die Methoden spezialisiert werden

Mehrfachvererbung

- Eine Klasse kann nur von einer Klasse abgeleitet werden
- Eine Klasse kann jedoch mehrere Interfaces implementieren
- Schlüsselwort "implements"

[https://docs.google.com/presentation/d/1273DDSpMTjLdIBAnkC6maFoJ_jwRysKMNoZgbASU5pI/edit#slide=id.p Präsentation]

Interfaces

2013-07-15T08:00:34Z

Jimmy:

== Interfaces ==

Allgemeines über Interfaces

- Interfaces beschreiben den reinen Entwurf einer Klasse
- In Interfaces wird keine Logik implementiert
- Es werden nur Variablen und Methoden deklariert (nur Konstanten werden initialisiert)
- Wenn ein Interface implementiert wird müssen die Methoden spezialisiert werden

Mehrfachvererbung

- Eine Klasse kann nur von einer Klasse abgeleitet werden
- Eine Klasse kann jedoch mehrere Interfaces implementieren
- Schlüsselwort "implements"

[https://docs.google.com/presentation/d/1273DDSpMTjLdIBAnkC6maFoJ_jwRysKMNoZgbASU5pI/edit#slide=id.p Präsentation]

Interfaces

2013-07-15T08:00:11Z

Jimmy: Die Seite wurde neu angelegt: „Interfaces Allgemeines über Interfaces - Interfaces beschreiben den reinen Entwurf einer Klasse - In Interfaces wird keine Logik implementiert - Es…“

Interfaces

Allgemeines über Interfaces

- Interfaces beschreiben den reinen Entwurf einer Klasse
- In Interfaces wird keine Logik implementiert
- Es werden nur Variablen und Methoden deklariert (nur Konstanten werden initialisiert)
- Wenn ein Interface implementiert wird müssen die Methoden spezialisiert werden

Mehrfachvererbung

- Eine Klasse kann nur von einer Klasse abgeleitet werden
- Eine Klasse kann jedoch mehrere Interfaces implementieren
- Schlüsselwort "implements"

[https://docs.google.com/presentation/d/1273DDSpMTjLdIBAnkC6maFoJ_jwRysKMNoZgbASU5pI/edit#slide=id.p Präsentation]

NAT

2013-07-15T07:56:50Z

Jimmy:

'''Network Address Translation (NAT)'''

NAT sorgt dafür, dass die lokalen Netze auch mit dem Internet kommunizieren kann. Die lokalen IP-Adressen sind im Internet nicht gültig, daher muss die lokale IP-Adresse in die öffentliche umgewandelt werden. Weil sich meistens in einem lokalen Netz nicht nur Client befindet, müssen die Antwort Datenpakete irgendwie dem richtigen Client zugeordnet werden. Jetzt kommt NAT ins Spiel.

'''Source NAT (SNAT)'''

Schickt ein Client eine Anfrage über den Router ins Internet funktioniert das immer nur über einen bestimmten Port, der dem Client zugewiesen wird. Der Router speichert die lokale IP-Adresse und die zugewiesene Portnummer, weitergeleitet wird das Datenpaket dann mit der öffentlichen IP-Adresse. Bekommt der Router eine Antwort auf die Anfrage, weiß der Router anhand der Portnummer und den intern geführten Tabelle mit den dazugehörigen IP-Adressen an wen er die Datenpakete weiterleiten muss.

[https://docs.google.com/presentation/d/10AU5oAz99ULiJv-voqJWmiEzfqR-F-ddS7vdCUxhb-4/edit#slide=id.gea32bdba_10 Präsentation]

NAT

2013-06-10T08:54:17Z

Jimmy: hh