Byte-Welt Wiki - Benutzerbeiträge [de]

Dokument mit Standardanwendung öffnen (Java)

2013-08-22T19:15:19Z

Theuserbl: /* Linux */

In diesem Kurz-Tutorial wird beschrieben, wie man in Java Dokumente und Dateien mit der dafür bestimmten (im System registrierten) Standardanwendung öffnen kann.
Im Beispiel ist '''MyFile.pdf''' der Dateiname.

=Bis Java 1.5=
==Windows==
<pre>Runtime.getRuntime().exec("rundll32 SHELL32.DLL,ShellExec_RunDLL MyFile.pdf");</pre>

oder

<pre>Runtime.getRuntime().exec("cmd /c start MyFile.pdf");</pre>

==MacOS X==
<pre>Runtime.getRuntime().exec("open MyFile.pdf");</pre>

==Linux==
<pre>Runtime.getRuntime().exec("xdg-open MyFile.pdf");</pre>

=Ab Java 1.6=
Mit Java 1.6 wurde die Klasse Desktop eingeführt, die nun unter allen Betriebssystemen gleichen Code einsetzt, um Dateien mit der Standardanwendung zu öffnen.

Beispiel fehlt noch...

[[Kategorie:Java]]

Dokument mit Standardanwendung öffnen (Java)

2013-08-22T19:05:20Z

Theuserbl: Angeblich ist "Mein-Dokument.pdf" der Dateiname. Daher korrigiert.

In diesem Kurz-Tutorial wird beschrieben, wie man in Java Dokumente und Dateien mit der dafür bestimmten (im System registrierten) Standardanwendung öffnen kann.
Im Beispiel ist '''Mein-Dokument.pdf''' der Dateiname.

=Bis Java 1.5=
==Windows==
<pre>Runtime.getRuntime().exec("rundll32 SHELL32.DLL,ShellExec_RunDLL Mein-Dokument.pdf");</pre>

oder

<pre>Runtime.getRuntime().exec("cmd /c start Mein-Dokument.pdf");</pre>

==MacOS X==
<pre>Runtime.getRuntime().exec("open Mein-Dokument.pdf");</pre>

==Linux==
Fehlt noch...

=Ab Java 1.6=
Mit Java 1.6 wurde die Klasse Desktop eingeführt, die nun unter allen Betriebssystemen gleichen Code einsetzt, um Dateien mit der Standardanwendung zu öffnen.

Beispiel fehlt noch...

[[Kategorie:Java]]

Dokument mit Standardanwendung öffnen (Java)

2013-08-22T19:00:40Z

Theuserbl: /* Windows */

In diesem Kurz-Tutorial wird beschrieben, wie man in Java Dokumente und Dateien mit der dafür bestimmten (im System registrierten) Standardanwendung öffnen kann.
Im Beispiel ist '''Mein-Dokument.pdf''' der Dateiname.

=Bis Java 1.5=
==Windows==
<pre>Runtime.getRuntime().exec("rundll32 SHELL32.DLL,ShellExec_RunDLL pdf_datei.pdf");</pre>

oder

<pre>Runtime.getRuntime().exec("cmd /c start pdf_datei.pdf");</pre>

==MacOS X==
<pre>Runtime.getRuntime().exec("open pdf_datei.pdf");</pre>

==Linux==
Fehlt noch...

=Ab Java 1.6=
Mit Java 1.6 wurde die Klasse Desktop eingeführt, die nun unter allen Betriebssystemen gleichen Code einsetzt, um Dateien mit der Standardanwendung zu öffnen.

Beispiel fehlt noch...

[[Kategorie:Java]]

Vererbung (CSharp)

2013-08-21T22:50:32Z

Theuserbl:

Im folgenden wird in anschaulicher Weise die Vererbung in C#, welches ein Teilbereich der Objektorientierung ist, beschrieben.
Alle Programme sehen, wenn man sie ausführt, genau gleich aus und bedienen sich auch gleich. Auch wenn der Quellcode immer wieder etwas anders ist.

Fangen wir mit einem einfachen kleinen Programm an, das ein Fenster öffnet und drei Buttons erstellt. Zwei davon sind rot:

{|
|style="width:30em"|<code=csharp>






























    </code=csharp>
|style="width:1em"|
|style="width:30em"|<code=csharp>using System;
using System.Drawing;
using System.Windows.Forms;

public class MyProgram {

public static void Main(string[] args) {
Form f = new Form();
f.Font = SystemFonts.MessageBoxFont;
f.Text = "My Window";
FlowLayoutPanel p = new FlowLayoutPanel();
Button b1 = new Button();
Button b2 = new Button();
Button b3 = new Button();
b1.Text = "Button 1";
b2.Text = "Button 2";
b3.Text = "Button 3";
b1.BackColor = Color.FromArgb(255,0,0);
b3.BackColor = Color.FromArgb(255,0,0);
p.Controls.Add(b1);
p.Controls.Add(b2);
p.Controls.Add(b3);
f.Controls.Add(p);
p.Width = 300;
p.Height = 100;
f.Width = 350;
f.Height = 150;
Application.EnableVisualStyles();
Application.Run(f);
}

}</code=csharp>
|}

Durch "new" wird ein neues Objekt (eine Instanz) erstellt, das eine Kopie des Hauptobjekts ist.

Betrachten wir uns nun ''Form''. Man kann in C# eine neue Klasse erstellen (sofern die Klasse, von der sie sich ableitet, nicht "''private''" ist), die sämtliche Eigenschaften der Klasse, von der sie abgeleitet wurde, erbt.

In folgendem Programm habe ich nun eine Klasse ''MyForm'' erstellt, die mittels '':'' von der Klasse ''Form'' alle Eigenschaften erbt:
{|
|style="width:30em"|<code=csharp>using System.Windows.Forms;

public class MyForm : Form {
public MyForm() {
}
}

























    </code=csharp>
|style="width:1em"|
|style="width:30em"|<code=csharp>using System;
using System.Drawing;
using System.Windows.Forms;

public class MyProgram {

public static void Main(string[] args) {
MyForm f = new MyForm();
f.Font = SystemFonts.MessageBoxFont;
f.Text = "My Window";
FlowLayoutPanel p = new FlowLayoutPanel();
Button b1 = new Button();
Button b2 = new Button();
Button b3 = new Button();
b1.Text = "Button 1";
b2.Text = "Button 2";
b3.Text = "Button 3";
b1.BackColor = Color.FromArgb(255,0,0);
b3.BackColor = Color.FromArgb(255,0,0);
p.Controls.Add(b1);
p.Controls.Add(b2);
p.Controls.Add(b3);
f.Controls.Add(p);
p.Width = 300;
p.Height = 100;
f.Width = 350;
f.Height = 150;
Application.EnableVisualStyles();
Application.Run(f);
}

}</code=csharp>
|}

Im Programm ''MyProgram'' wird nun ''MyForm'' auch genau so genutzt und behandelt wie zuvor ''Form''. Und das Ergebnis ist ebenfalls gleich.

(wird fortgesetzt...)

== Siehe auch ==

[http://de.wikipedia.org/wiki/Vererbung_%28Programmierung%29 ''Wikipedia: Vererbung in der Programmierung.'']

[[Kategorie:CSharp]]

Vererbung (CSharp)

2013-08-21T22:49:18Z

Theuserbl: Die Seite wurde neu angelegt: „Im folgenden wird in anschaulicher Weise die Vererbung in C#, welches ein Teilbereich der Objektorientierung ist, beschrieben. Alle Programme sehen, wenn man sie …“

Im folgenden wird in anschaulicher Weise die Vererbung in C#, welches ein Teilbereich der Objektorientierung ist, beschrieben.
Alle Programme sehen, wenn man sie ausführt, genau gleich aus und bedienen sich auch gleich. Auch wenn der Quellcode immer wieder etwas anders ist.

Fangen wir mit einem einfachen kleinen Programm an, das ein Fenster öffnet und drei Buttons erstellt. Zwei davon sind rot:

{|
|style="width:30em"|<code=csharp>






























    </code=csharp>
|style="width:1em"|
|style="width:30em"|<code=java>using System;
using System.Drawing;
using System.Windows.Forms;

public class MyProgram {

public static void Main(string[] args) {
Form f = new Form();
f.Font = SystemFonts.MessageBoxFont;
f.Text = "My Window";
FlowLayoutPanel p = new FlowLayoutPanel();
Button b1 = new Button();
Button b2 = new Button();
Button b3 = new Button();
b1.Text = "Button 1";
b2.Text = "Button 2";
b3.Text = "Button 3";
b1.BackColor = Color.FromArgb(255,0,0);
b3.BackColor = Color.FromArgb(255,0,0);
p.Controls.Add(b1);
p.Controls.Add(b2);
p.Controls.Add(b3);
f.Controls.Add(p);
p.Width = 300;
p.Height = 100;
f.Width = 350;
f.Height = 150;
Application.EnableVisualStyles();
Application.Run(f);
}

}</code=java>
|}

Durch "new" wird ein neues Objekt (eine Instanz) erstellt, das eine Kopie des Hauptobjekts ist.

Betrachten wir uns nun ''Form''. Man kann in C# eine neue Klasse erstellen (sofern die Klasse, von der sie sich ableitet, nicht "''private''" ist), die sämtliche Eigenschaften der Klasse, von der sie abgeleitet wurde, erbt.

In folgendem Programm habe ich nun eine Klasse ''MyForm'' erstellt, die mittels '':'' von der Klasse ''Form'' alle Eigenschaften erbt:
{|
|style="width:30em"|<code=csharp>using System.Windows.Forms;

public class MyForm : Form {
public MyForm() {
}
}

























    </code=csharp>
|style="width:1em"|
|style="width:30em"|<code=csharp>using System;
using System.Drawing;
using System.Windows.Forms;

public class MyProgram {

public static void Main(string[] args) {
MyForm f = new MyForm();
f.Font = SystemFonts.MessageBoxFont;
f.Text = "My Window";
FlowLayoutPanel p = new FlowLayoutPanel();
Button b1 = new Button();
Button b2 = new Button();
Button b3 = new Button();
b1.Text = "Button 1";
b2.Text = "Button 2";
b3.Text = "Button 3";
b1.BackColor = Color.FromArgb(255,0,0);
b3.BackColor = Color.FromArgb(255,0,0);
p.Controls.Add(b1);
p.Controls.Add(b2);
p.Controls.Add(b3);
f.Controls.Add(p);
p.Width = 300;
p.Height = 100;
f.Width = 350;
f.Height = 150;
Application.EnableVisualStyles();
Application.Run(f);
}

}</code=csharp>
|}

Im Programm ''MyProgram'' wird nun ''MyForm'' auch genau so genutzt und behandelt wie zuvor ''Form''. Und das Ergebnis ist ebenfalls gleich.

(wird fortgesetzt...)

== Siehe auch ==

[http://de.wikipedia.org/wiki/Vererbung_%28Programmierung%29 ''Wikipedia: Vererbung in der Programmierung.'']

[[Kategorie:CSharp]]

Static / non-static (Java)

2013-08-19T10:08:58Z

Theuserbl: /* Besonderheiten von statischen Methoden */

== Der Unterschied zwischen statischen und nicht-statischen Methoden und Variablen ==

Das kleine Wort ''static'' macht einen großen Unterschied.

== Statische Methoden ==

Wer nicht-objektorientierte Sprachen wie C kennt, dem dürften statische Methoden vertraut sein. In nicht-objektorientiersten Sprachen heißen Methoden "Funktionen". Und im Grunde genommen sind statische Methoden genau das: Funktionen wie in C.

Wenn man von einer anderen Klasse auf statische Methoden oder Variablen zugreifen möchte, dann ruft man sie zusammen mit dem Klassennamen auf:

{|
|style="width:30em"|<code=java>public class ExternalClass {

public static int number=5;
private static String text="Anfangstext";

public static void myStaticMethod() {
System.out.println("statische Methode aufgerufen");
}

public static double add(double a, double b) {
return a + b;
}

public static void printText() {
System.out.println(text);
}

public static void changeText() {
text = "geaenderter Text";
}

}</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>public class MyProgram {

public static void main(String[] args) {
ExternalClass.myStaticMethod();
System.out.println( ExternalClass.add(17.65, 9.23) );
System.out.println( ExternalClass.number );
ExternalClass.number = 13;
System.out.println( ExternalClass.number );
ExternalClass.printText();
ExternalClass.changeText();
ExternalClass.printText();
}

}








</code=java>
|}

Befinden sich die Methoden und Variablen in der eigenen Klasse, dann sieht es genauso aus:
{|
|style="width:61em"|<code=java>public class MyProgram {

public static int number=5;
private static String text="Anfangstext";

public static void myStaticMethod() {
System.out.println("statische Methode aufgerufen");
}

public static double add(double a, double b) {
return a + b;
}

public static void printText() {
System.out.println(text);
}

public static void changeText() {
text = "geaenderter Text";
}

public static void main(String[] args) {
MyProgram.myStaticMethod();
System.out.println( MyProgram.add(17.65, 9.23) );
System.out.println( MyProgram.number );
MyProgram.number = 13;
System.out.println( MyProgram.number );
MyProgram.printText();
MyProgram.changeText();
MyProgram.printText();
}

}
</code=java>
|}

Der Einsatzzweck für statische Methoden ist somit ähnlich wie bei Funktionen von nicht-objketorientierten Sprachen.
Statische Variablen sind ein zentraler Ort an dem etwas gespeichert wird.

Beispiele für die Verwendung von statische Methoden im JRE:

{|
|style="width:61em"|<code=java>public class MyProgram {

public static void main(String[] args) {
System.out.println( Math.PI ); // PI ist eine statische Variable in der Klasse Math
System.out.println( Math.E ); // E ist eine statische Variable in der Klasse Math
System.out.println( Math.sin(2) ); // sin() ist eine statische Methode in der Klasse Math
System.out.println( Math.log(7) ); // log() ist eine statische Methode in der Klasse Math
}

}
</code=java>
|}

PI ist halt überall immer 3.141..., sin(2) ist überall 0.909..., etc.

== Nicht-Statische Methoden ==

Nicht-Statische Methoden und Variablen kommen vor allem in objektorientierten Sprachen vor.
Um diese aufrufen zu können, muß erst mit ''new'' eine Instanz von der Klasse erstellt werden. Und an dieser kann man dann die Methoden aufrufen. Die Methoden gehören dann zur Instanz:

{|
|style="width:30em"|<code=java>public class ExternalClass {

public int number=5;
private String text="Anfangstext";

public ExternalClass() {
}

public void myNonStaticMethod() {
System.out.println("nicht-statische Methode aufgerufen");
}

public double add(double a, double b) {
return a + b;
}

public void printText() {
System.out.println(text);
}

public void changeText() {
text = "geaenderter Text";
}

}</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>public class MyProgram {

public static void main(String[] args) {
ExternalClass ec1 = new ExternalClass();
ec1.myNonStaticMethod();
System.out.println( ec1.add(17.65, 9.23) );
System.out.println( ec1.number );
ec1.number = 13;
System.out.println( ec1.number );
ec1.printText();
ec1.changeText();
ec1.printText();

ExternalClass ec2 = new ExternalClass();
ec2.printText();
ec1.printText();

ec2.number = 29;
System.out.println( ec1.number );
System.out.println( ec2.number );
}

}


</code=java>
|}

Zwar existieren nun genau die gleichen Methoden und Variablen wie bei dem Beispiel mit den statischen Methoden, jedoch existieren sie für jede Instanz unabhängig voneinander.

Befinden sich die Methoden und Variablen in der eigenen Klasse, dann sieht es ähnlich aus. In der eigenen Klasse wird jedoch statt einem Instanznamen das Schlüsselwort ''this'' verwendet:

{|
|style="width:61em"|<code=java>public class MyProgram {

public int number=5;
private String text="Anfangstext";

public MyProgram() {
this.myNonStaticMethod();
System.out.println( this.add(17.65, 9.23) );
System.out.println( this.number );
this.number = 13;
System.out.println( this.number );
this.printText();
this.changeText();
this.printText();
}

public void myNonStaticMethod() {
System.out.println("nicht-statische Methode aufgerufen");
}

public double add(double a, double b) {
return a + b;
}

public void printText() {
System.out.println(text);
}

public void changeText() {
text = "geaenderter Text";
}

public static void main(String[] args) {
MyProgram p = new MyProgram();
}

}
</code=java>
|}

Für mehr Informationen zur vorgenommenen Umformung bitte auf [[Vererbung_(Java)]] nachlesen.

Beispiele für die Verwendung von nicht-statische Methoden im JRE:
{|
|style="width:61em"|<code=java>import javax.swing.*;
import javax.swing.border.*;
import java.awt.*;

public class MyProgram {

public static void main(String[] args) {
JFrame f = new JFrame("MyProgram");
JPanel p = new JPanel();
JButton b1 = new JButton("Button 1");
JButton b2 = new JButton("Button 2");
JButton b3 = new JButton("Button 3");
JLabel l1 = new JLabel("Label 1");
JTextArea ta = new JTextArea();

p.add(b1);
p.add(b2);
p.add(b3);
p.add(l1);
p.add(ta);

ta.setPreferredSize(new Dimension(100,50)); // setPreferredSize ist eine nicht-statische
// Methode der Klasse JTextArea, von dem ta eine
// Instanz ist
ta.setBorder(new LineBorder(Color.blue));
ta.setText( b2.getText() ); // Hier wird die Methode getText() von der
// Instanz b2 verwendet und ta mit setText()
// zugewiesen

b1.setPreferredSize(new Dimension(180, 70)); // Die Groesse des Buttons von b1 wird mit
// der Methode setPreferredSize(), die in JButton
// definiert wurde, veraendert
b3.setPreferredSize(new Dimension(160, 90)); // Andere Instanzen von Buttons bleiben davon
// unberührt und koennen ebenfalls mit der gleichen
// Methode eine andere Groesse erhaltem

b1.setBackground(Color.red); // Auch hier wieder:
b3.setBackground(Color.green); // zwei verschiedene Buttons, die mit Hilfe der
// gleichen Methode setBackground() eine andere
// Hintergrundfarbe erhalten.

f.add(p);
f.pack();
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.setVisible(true);
}

}</code=java>
|}

== Verwirrungen um static / non-static ==

So unterschiedlich statische und nicht-statische Methoden sind, so kommt es doch bei Anfängern zu Verwirrungen, da es manchmal so aussieht, als täten beide genau das Selbe:

{|
|style="width:61em"|<code=java>import javax.swing.*;
import javax.swing.border.*;
import java.awt.*;

public class MyProgram {

public static int myStaticVar=0;

public int myNonStaticVar=0;

public static void myStaticMethod() {
myStaticVar *= 7; // ist das gleiche wie
// myStaticVar = myStaticVar * 7;
}

public void myNonStaticMethod() {
myNonStaticVar *= 13; // ist das gleiche wie
// myNonStaticVar = myNonStaticVar * 13;
}

public MyProgram() {
myStaticVar = 6;
myNonStaticVar = 5;

System.out.println(myStaticVar);
System.out.println(myNonStaticVar);

myStaticMethod();
myNonStaticMethod();

System.out.println(myStaticVar);
System.out.println(myNonStaticVar);

myStaticMethod();
myNonStaticMethod();

System.out.println(myStaticVar);
System.out.println(myNonStaticVar);
}

public static void main(String[] args) {
new MyProgram(); // aehnlich wie
// MyProgram mp = new MyProgram();
// bloß, dass in diesem Fall nur der Konstruktor aufgerufen
// wird. Jedoch nicht eine Instanz zur weiteren verwendung in
// main() erhalten bleibt.
}

}</code=java>

Augenscheinlich gibt es zwischen der statischen Methode und Variable und der nicht-statischen Methode und Variable keinen Unterschied.

Das liegt aber daran, weil man bei statischen Methoden den Klassennamen der Einfachheit halber weglassen kann und bei nicht-statischen Methoden das ''this''.
Ausgeschrieben sieht das Programm folgendermaßen aus:

{|
|style="width:61em"|<code=java>import javax.swing.*;
import javax.swing.border.*;
import java.awt.*;

public class MyProgram {

public static int myStaticVar=0;

public int myNonStaticVar=0;

public static void myStaticMethod() {
myStaticVar *= 7;
}

public void myNonStaticMethod() {
myNonStaticVar *= 13;
}

public MyProgram() {
MyProgram.myStaticVar = 6;
this.myNonStaticVar = 5;

System.out.println(MyProgram.myStaticVar);
System.out.println(this.myNonStaticVar);

MyProgram.myStaticMethod();
this.myNonStaticMethod();

System.out.println(MyProgram.myStaticVar);
System.out.println(this.myNonStaticVar);

MyProgram.myStaticMethod();
this.myNonStaticMethod();

System.out.println(MyProgram.myStaticVar);
System.out.println(this.myNonStaticVar);
}

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

}
</code=java>

Noch deutlicher wird der Unterschied, wenn man von außen auf die Instanz zugreift:

{|
|style="width:61em"|<code=java>import javax.swing.*;
import javax.swing.border.*;
import java.awt.*;

public class MyProgram {

public static int myStaticVar=0;

public int myNonStaticVar=0;

public static void myStaticMethod() {
myStaticVar *= 7;
}

public void myNonStaticMethod() {
myNonStaticVar *= 13;
}

public MyProgram() {
}

public static void main(String[] args) {
MyProgram mp1 = new MyProgram();
MyProgram mp2 = new MyProgram();

MyProgram.myStaticVar = 6;
mp1.myNonStaticVar = 5;
mp2.myNonStaticVar = 8;

System.out.println( MyProgram.myStaticVar );
System.out.println( mp1.myNonStaticVar );
System.out.println( mp2.myNonStaticVar );

MyProgram.myStaticMethod();
mp1.myNonStaticMethod();

System.out.println( MyProgram.myStaticVar );
System.out.println( mp1.myNonStaticVar );
System.out.println( mp2.myNonStaticVar );

mp2.myNonStaticMethod();
mp2.myNonStaticMethod();
mp2.myNonStaticMethod();
mp2.myNonStaticMethod();

System.out.println( MyProgram.myStaticVar );
System.out.println( mp1.myNonStaticVar );
System.out.println( mp2.myNonStaticVar );
}

}</code=java>

Hier sieht man noch mal, daß statische Methoden und Variablen für alle Instanzen und auch statische Methoden wie main() gelten, während nicht-statische Methoden nur für eine bestimmte Instanz ihre Gültigkeit haben.

== Besonderheiten von statischen Methoden ==

Am Anfang haben wir statische Methoden als äquivalent zu Funktionen in C und anderen nicht-objektorientierten Sprachen kennengelernt.
Um den Unterschied zwischen statischen und nicht-statischen Methoden zu verstehen, ist es auch für den Anfang ganz sinnvoll es so zu erklären.
Aber in der objektorientierten Sprache Java, gibt es dann doch einige Zusätze, die es in C z.B. nicht gibt.

Statische Methoden lassen sich genauso wie nicht-statische Methoden ableiten:

{|
|style="width:30em"|<code=java>public class BaseClass {

public static void printFirstText() {
System.out.println("Dieses ist ein Text in BaseClass");
}

public static void printSecondText() {
System.out.println("Und noch ein Text in BaseClass");
}

}</code=java>

<code=java>public class ExternalClass extends BaseClass{

public static void printSecondText() {
System.out.println("Ein Text in ExternalClass");
}

}</code=java>

|style="width:1em"|
|style="width:30em"|<code=java>public class MyProgram {

public static void main(String[] args) {
BaseClass.printFirstText(); // normaler Aufruf
BaseClass.printSecondText(); // normaler Aufruf
ExternalClass.printFirstText(); // Methode ist von BaseClass abgeleitet
ExternalClass.printSecondText(); // Methode, die die von BaseClass
// ueberschrieben hat
}

}









    </code=java>
|}

Es gibt etwas ähnliches wie einen Konstruktor für statische Methoden:

{|
|style="width:30em"|<code=java>public class ExternalClass {

public static void myStaticMethod() {
System.out.println("die statische Methode wurde aufgerufen.");
}

public static void myOtherStaticMethod() {
System.out.println("eine weitere Methode wurde aufgerufen.");
}

static {
System.out.println("Es wurde zum erstem Mal statisch auf diese Klasse zugegriffen.");
}

}</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>public class MyProgram {

public static void main(String[] args) {
System.out.println(
"Noch ist kein Zugriff auf ExternalCLass erfolgt.");
ExternalClass.myStaticMethod();
ExternalClass.myOtherStaticMethod();
ExternalClass.myStaticMethod();
}

}



    </code=java>
|}

Diese Möglichkeit wird insbesondere eingesetzt, wenn man statischen Variablen direkt am Anfang bestimmte Werte zuweisen möchte.
So kann es sein, daß der Anfangswert der Variablen erst berechnet werden muß. Oder es handelt sich um eine Liste, die sich nur mit Hilfe einer [[Schleife]] befüllen lässt.

[[Kategorie:Java]]
[[Kategorie:Java Grundlagen]]

Static / non-static (Java)

2013-08-19T09:58:20Z

Theuserbl: /* Besonderheiten von statischen Methoden */

== Der Unterschied zwischen statischen und nicht-statischen Methoden und Variablen ==

Das kleine Wort ''static'' macht einen großen Unterschied.

== Statische Methoden ==

Wer nicht-objektorientierte Sprachen wie C kennt, dem dürften statische Methoden vertraut sein. In nicht-objektorientiersten Sprachen heißen Methoden "Funktionen". Und im Grunde genommen sind statische Methoden genau das: Funktionen wie in C.

Wenn man von einer anderen Klasse auf statische Methoden oder Variablen zugreifen möchte, dann ruft man sie zusammen mit dem Klassennamen auf:

{|
|style="width:30em"|<code=java>public class ExternalClass {

public static int number=5;
private static String text="Anfangstext";

public static void myStaticMethod() {
System.out.println("statische Methode aufgerufen");
}

public static double add(double a, double b) {
return a + b;
}

public static void printText() {
System.out.println(text);
}

public static void changeText() {
text = "geaenderter Text";
}

}</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>public class MyProgram {

public static void main(String[] args) {
ExternalClass.myStaticMethod();
System.out.println( ExternalClass.add(17.65, 9.23) );
System.out.println( ExternalClass.number );
ExternalClass.number = 13;
System.out.println( ExternalClass.number );
ExternalClass.printText();
ExternalClass.changeText();
ExternalClass.printText();
}

}








</code=java>
|}

Befinden sich die Methoden und Variablen in der eigenen Klasse, dann sieht es genauso aus:
{|
|style="width:61em"|<code=java>public class MyProgram {

public static int number=5;
private static String text="Anfangstext";

public static void myStaticMethod() {
System.out.println("statische Methode aufgerufen");
}

public static double add(double a, double b) {
return a + b;
}

public static void printText() {
System.out.println(text);
}

public static void changeText() {
text = "geaenderter Text";
}

public static void main(String[] args) {
MyProgram.myStaticMethod();
System.out.println( MyProgram.add(17.65, 9.23) );
System.out.println( MyProgram.number );
MyProgram.number = 13;
System.out.println( MyProgram.number );
MyProgram.printText();
MyProgram.changeText();
MyProgram.printText();
}

}
</code=java>
|}

Der Einsatzzweck für statische Methoden ist somit ähnlich wie bei Funktionen von nicht-objketorientierten Sprachen.
Statische Variablen sind ein zentraler Ort an dem etwas gespeichert wird.

Beispiele für die Verwendung von statische Methoden im JRE:

{|
|style="width:61em"|<code=java>public class MyProgram {

public static void main(String[] args) {
System.out.println( Math.PI ); // PI ist eine statische Variable in der Klasse Math
System.out.println( Math.E ); // E ist eine statische Variable in der Klasse Math
System.out.println( Math.sin(2) ); // sin() ist eine statische Methode in der Klasse Math
System.out.println( Math.log(7) ); // log() ist eine statische Methode in der Klasse Math
}

}
</code=java>
|}

PI ist halt überall immer 3.141..., sin(2) ist überall 0.909..., etc.

== Nicht-Statische Methoden ==

Nicht-Statische Methoden und Variablen kommen vor allem in objektorientierten Sprachen vor.
Um diese aufrufen zu können, muß erst mit ''new'' eine Instanz von der Klasse erstellt werden. Und an dieser kann man dann die Methoden aufrufen. Die Methoden gehören dann zur Instanz:

{|
|style="width:30em"|<code=java>public class ExternalClass {

public int number=5;
private String text="Anfangstext";

public ExternalClass() {
}

public void myNonStaticMethod() {
System.out.println("nicht-statische Methode aufgerufen");
}

public double add(double a, double b) {
return a + b;
}

public void printText() {
System.out.println(text);
}

public void changeText() {
text = "geaenderter Text";
}

}</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>public class MyProgram {

public static void main(String[] args) {
ExternalClass ec1 = new ExternalClass();
ec1.myNonStaticMethod();
System.out.println( ec1.add(17.65, 9.23) );
System.out.println( ec1.number );
ec1.number = 13;
System.out.println( ec1.number );
ec1.printText();
ec1.changeText();
ec1.printText();

ExternalClass ec2 = new ExternalClass();
ec2.printText();
ec1.printText();

ec2.number = 29;
System.out.println( ec1.number );
System.out.println( ec2.number );
}

}


</code=java>
|}

Zwar existieren nun genau die gleichen Methoden und Variablen wie bei dem Beispiel mit den statischen Methoden, jedoch existieren sie für jede Instanz unabhängig voneinander.

Befinden sich die Methoden und Variablen in der eigenen Klasse, dann sieht es ähnlich aus. In der eigenen Klasse wird jedoch statt einem Instanznamen das Schlüsselwort ''this'' verwendet:

{|
|style="width:61em"|<code=java>public class MyProgram {

public int number=5;
private String text="Anfangstext";

public MyProgram() {
this.myNonStaticMethod();
System.out.println( this.add(17.65, 9.23) );
System.out.println( this.number );
this.number = 13;
System.out.println( this.number );
this.printText();
this.changeText();
this.printText();
}

public void myNonStaticMethod() {
System.out.println("nicht-statische Methode aufgerufen");
}

public double add(double a, double b) {
return a + b;
}

public void printText() {
System.out.println(text);
}

public void changeText() {
text = "geaenderter Text";
}

public static void main(String[] args) {
MyProgram p = new MyProgram();
}

}
</code=java>
|}

Für mehr Informationen zur vorgenommenen Umformung bitte auf [[Vererbung_(Java)]] nachlesen.

Beispiele für die Verwendung von nicht-statische Methoden im JRE:
{|
|style="width:61em"|<code=java>import javax.swing.*;
import javax.swing.border.*;
import java.awt.*;

public class MyProgram {

public static void main(String[] args) {
JFrame f = new JFrame("MyProgram");
JPanel p = new JPanel();
JButton b1 = new JButton("Button 1");
JButton b2 = new JButton("Button 2");
JButton b3 = new JButton("Button 3");
JLabel l1 = new JLabel("Label 1");
JTextArea ta = new JTextArea();

p.add(b1);
p.add(b2);
p.add(b3);
p.add(l1);
p.add(ta);

ta.setPreferredSize(new Dimension(100,50)); // setPreferredSize ist eine nicht-statische
// Methode der Klasse JTextArea, von dem ta eine
// Instanz ist
ta.setBorder(new LineBorder(Color.blue));
ta.setText( b2.getText() ); // Hier wird die Methode getText() von der
// Instanz b2 verwendet und ta mit setText()
// zugewiesen

b1.setPreferredSize(new Dimension(180, 70)); // Die Groesse des Buttons von b1 wird mit
// der Methode setPreferredSize(), die in JButton
// definiert wurde, veraendert
b3.setPreferredSize(new Dimension(160, 90)); // Andere Instanzen von Buttons bleiben davon
// unberührt und koennen ebenfalls mit der gleichen
// Methode eine andere Groesse erhaltem

b1.setBackground(Color.red); // Auch hier wieder:
b3.setBackground(Color.green); // zwei verschiedene Buttons, die mit Hilfe der
// gleichen Methode setBackground() eine andere
// Hintergrundfarbe erhalten.

f.add(p);
f.pack();
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.setVisible(true);
}

}</code=java>
|}

== Verwirrungen um static / non-static ==

So unterschiedlich statische und nicht-statische Methoden sind, so kommt es doch bei Anfängern zu Verwirrungen, da es manchmal so aussieht, als täten beide genau das Selbe:

{|
|style="width:61em"|<code=java>import javax.swing.*;
import javax.swing.border.*;
import java.awt.*;

public class MyProgram {

public static int myStaticVar=0;

public int myNonStaticVar=0;

public static void myStaticMethod() {
myStaticVar *= 7; // ist das gleiche wie
// myStaticVar = myStaticVar * 7;
}

public void myNonStaticMethod() {
myNonStaticVar *= 13; // ist das gleiche wie
// myNonStaticVar = myNonStaticVar * 13;
}

public MyProgram() {
myStaticVar = 6;
myNonStaticVar = 5;

System.out.println(myStaticVar);
System.out.println(myNonStaticVar);

myStaticMethod();
myNonStaticMethod();

System.out.println(myStaticVar);
System.out.println(myNonStaticVar);

myStaticMethod();
myNonStaticMethod();

System.out.println(myStaticVar);
System.out.println(myNonStaticVar);
}

public static void main(String[] args) {
new MyProgram(); // aehnlich wie
// MyProgram mp = new MyProgram();
// bloß, dass in diesem Fall nur der Konstruktor aufgerufen
// wird. Jedoch nicht eine Instanz zur weiteren verwendung in
// main() erhalten bleibt.
}

}</code=java>

Augenscheinlich gibt es zwischen der statischen Methode und Variable und der nicht-statischen Methode und Variable keinen Unterschied.

Das liegt aber daran, weil man bei statischen Methoden den Klassennamen der Einfachheit halber weglassen kann und bei nicht-statischen Methoden das ''this''.
Ausgeschrieben sieht das Programm folgendermaßen aus:

{|
|style="width:61em"|<code=java>import javax.swing.*;
import javax.swing.border.*;
import java.awt.*;

public class MyProgram {

public static int myStaticVar=0;

public int myNonStaticVar=0;

public static void myStaticMethod() {
myStaticVar *= 7;
}

public void myNonStaticMethod() {
myNonStaticVar *= 13;
}

public MyProgram() {
MyProgram.myStaticVar = 6;
this.myNonStaticVar = 5;

System.out.println(MyProgram.myStaticVar);
System.out.println(this.myNonStaticVar);

MyProgram.myStaticMethod();
this.myNonStaticMethod();

System.out.println(MyProgram.myStaticVar);
System.out.println(this.myNonStaticVar);

MyProgram.myStaticMethod();
this.myNonStaticMethod();

System.out.println(MyProgram.myStaticVar);
System.out.println(this.myNonStaticVar);
}

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

}
</code=java>

Noch deutlicher wird der Unterschied, wenn man von außen auf die Instanz zugreift:

{|
|style="width:61em"|<code=java>import javax.swing.*;
import javax.swing.border.*;
import java.awt.*;

public class MyProgram {

public static int myStaticVar=0;

public int myNonStaticVar=0;

public static void myStaticMethod() {
myStaticVar *= 7;
}

public void myNonStaticMethod() {
myNonStaticVar *= 13;
}

public MyProgram() {
}

public static void main(String[] args) {
MyProgram mp1 = new MyProgram();
MyProgram mp2 = new MyProgram();

MyProgram.myStaticVar = 6;
mp1.myNonStaticVar = 5;
mp2.myNonStaticVar = 8;

System.out.println( MyProgram.myStaticVar );
System.out.println( mp1.myNonStaticVar );
System.out.println( mp2.myNonStaticVar );

MyProgram.myStaticMethod();
mp1.myNonStaticMethod();

System.out.println( MyProgram.myStaticVar );
System.out.println( mp1.myNonStaticVar );
System.out.println( mp2.myNonStaticVar );

mp2.myNonStaticMethod();
mp2.myNonStaticMethod();
mp2.myNonStaticMethod();
mp2.myNonStaticMethod();

System.out.println( MyProgram.myStaticVar );
System.out.println( mp1.myNonStaticVar );
System.out.println( mp2.myNonStaticVar );
}

}</code=java>

Hier sieht man noch mal, daß statische Methoden und Variablen für alle Instanzen und auch statische Methoden wie main() gelten, während nicht-statische Methoden nur für eine bestimmte Instanz ihre Gültigkeit haben.

== Besonderheiten von statischen Methoden ==

Am Anfang haben wir statische Methoden als äquivalent zu Funktionen in C und anderen nicht-objektorientierten Sprachen kennengelernt.
Um den Unterschied zwischen statischen und nicht-statischen Methoden zu verstehen, ist es auch für den Anfang ganz sinnvoll es so zu erklären.
Aber in der objektorientierten Sprache Java, gibt es dann doch einige Zusätze, die es in C z.B. nicht gibt.

Statische Methoden lassen sich genauso wie nicht-statische Methoden ableiten:

{|
|style="width:30em"|<code=java>public class BaseClass {

public static void printFirstText() {
System.out.println("Dieses ist ein Text in BaseClass");
}

public static void printSecondText() {
System.out.println("Und noch ein Text in BaseClass");
}

}</code=java>

<code=java>public class ExternalClass extends BaseClass{

public static void printSecondText() {
System.out.println("Ein Text in ExternalClass");
}

}</code=java>

|style="width:1em"|
|style="width:30em"|<code=java>public class MyProgram {

public static void main(String[] args) {
BaseClass.printFirstText(); // normaler Aufruf
BaseClass.printSecondText(); // normaler Aufruf
ExternalClass.printFirstText(); // Methode ist von BaseClass abgeleitet
ExternalClass.printSecondText(); // Methode, die die von BaseClass
// ueberschrieben hat
}

}









    </code=java>
|}

Es gibt etwas ähnliches wie einen Konstruktor für statische Methoden:

{|
|style="width:30em"|<code=java>public class ExternalClass {

public static void myStaticMethod() {
System.out.println("die statische Methode wurde aufgerufen.");
}

public static void myOtherStaticMethod() {
System.out.println("eine weitere Methode wurde aufgerufen.");
}

static {
System.out.println("Es wurde zum erstem Mal statisch auf diese Klasse zugegriffen.");
}

}</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>public class MyProgram {

public static void main(String[] args) {
ExternalClass.myStaticMethod();
ExternalClass.myOtherStaticMethod();
ExternalClass.myStaticMethod();
}

}





    </code=java>
|}

Diese Möglichkeit wird insbesondere eingesetzt, wenn man statischen Variablen direkt am Anfang bestimmte Werte zuweisen möchte.
So kann es sein, daß der Anfangswert der Variablen erst berechnet werden muß. Oder es handelt sich um eine Liste, die sich nur mit Hilfe einer [[Schleife]] befüllen lässt.

[[Kategorie:Java]]
[[Kategorie:Java Grundlagen]]

Static / non-static (Java)

2013-08-19T09:51:20Z

Theuserbl:

== Der Unterschied zwischen statischen und nicht-statischen Methoden und Variablen ==

Das kleine Wort ''static'' macht einen großen Unterschied.

== Statische Methoden ==

Wer nicht-objektorientierte Sprachen wie C kennt, dem dürften statische Methoden vertraut sein. In nicht-objektorientiersten Sprachen heißen Methoden "Funktionen". Und im Grunde genommen sind statische Methoden genau das: Funktionen wie in C.

Wenn man von einer anderen Klasse auf statische Methoden oder Variablen zugreifen möchte, dann ruft man sie zusammen mit dem Klassennamen auf:

{|
|style="width:30em"|<code=java>public class ExternalClass {

public static int number=5;
private static String text="Anfangstext";

public static void myStaticMethod() {
System.out.println("statische Methode aufgerufen");
}

public static double add(double a, double b) {
return a + b;
}

public static void printText() {
System.out.println(text);
}

public static void changeText() {
text = "geaenderter Text";
}

}</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>public class MyProgram {

public static void main(String[] args) {
ExternalClass.myStaticMethod();
System.out.println( ExternalClass.add(17.65, 9.23) );
System.out.println( ExternalClass.number );
ExternalClass.number = 13;
System.out.println( ExternalClass.number );
ExternalClass.printText();
ExternalClass.changeText();
ExternalClass.printText();
}

}








</code=java>
|}

Befinden sich die Methoden und Variablen in der eigenen Klasse, dann sieht es genauso aus:
{|
|style="width:61em"|<code=java>public class MyProgram {

public static int number=5;
private static String text="Anfangstext";

public static void myStaticMethod() {
System.out.println("statische Methode aufgerufen");
}

public static double add(double a, double b) {
return a + b;
}

public static void printText() {
System.out.println(text);
}

public static void changeText() {
text = "geaenderter Text";
}

public static void main(String[] args) {
MyProgram.myStaticMethod();
System.out.println( MyProgram.add(17.65, 9.23) );
System.out.println( MyProgram.number );
MyProgram.number = 13;
System.out.println( MyProgram.number );
MyProgram.printText();
MyProgram.changeText();
MyProgram.printText();
}

}
</code=java>
|}

Der Einsatzzweck für statische Methoden ist somit ähnlich wie bei Funktionen von nicht-objketorientierten Sprachen.
Statische Variablen sind ein zentraler Ort an dem etwas gespeichert wird.

Beispiele für die Verwendung von statische Methoden im JRE:

{|
|style="width:61em"|<code=java>public class MyProgram {

public static void main(String[] args) {
System.out.println( Math.PI ); // PI ist eine statische Variable in der Klasse Math
System.out.println( Math.E ); // E ist eine statische Variable in der Klasse Math
System.out.println( Math.sin(2) ); // sin() ist eine statische Methode in der Klasse Math
System.out.println( Math.log(7) ); // log() ist eine statische Methode in der Klasse Math
}

}
</code=java>
|}

PI ist halt überall immer 3.141..., sin(2) ist überall 0.909..., etc.

== Nicht-Statische Methoden ==

Nicht-Statische Methoden und Variablen kommen vor allem in objektorientierten Sprachen vor.
Um diese aufrufen zu können, muß erst mit ''new'' eine Instanz von der Klasse erstellt werden. Und an dieser kann man dann die Methoden aufrufen. Die Methoden gehören dann zur Instanz:

{|
|style="width:30em"|<code=java>public class ExternalClass {

public int number=5;
private String text="Anfangstext";

public ExternalClass() {
}

public void myNonStaticMethod() {
System.out.println("nicht-statische Methode aufgerufen");
}

public double add(double a, double b) {
return a + b;
}

public void printText() {
System.out.println(text);
}

public void changeText() {
text = "geaenderter Text";
}

}</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>public class MyProgram {

public static void main(String[] args) {
ExternalClass ec1 = new ExternalClass();
ec1.myNonStaticMethod();
System.out.println( ec1.add(17.65, 9.23) );
System.out.println( ec1.number );
ec1.number = 13;
System.out.println( ec1.number );
ec1.printText();
ec1.changeText();
ec1.printText();

ExternalClass ec2 = new ExternalClass();
ec2.printText();
ec1.printText();

ec2.number = 29;
System.out.println( ec1.number );
System.out.println( ec2.number );
}

}


</code=java>
|}

Zwar existieren nun genau die gleichen Methoden und Variablen wie bei dem Beispiel mit den statischen Methoden, jedoch existieren sie für jede Instanz unabhängig voneinander.

Befinden sich die Methoden und Variablen in der eigenen Klasse, dann sieht es ähnlich aus. In der eigenen Klasse wird jedoch statt einem Instanznamen das Schlüsselwort ''this'' verwendet:

{|
|style="width:61em"|<code=java>public class MyProgram {

public int number=5;
private String text="Anfangstext";

public MyProgram() {
this.myNonStaticMethod();
System.out.println( this.add(17.65, 9.23) );
System.out.println( this.number );
this.number = 13;
System.out.println( this.number );
this.printText();
this.changeText();
this.printText();
}

public void myNonStaticMethod() {
System.out.println("nicht-statische Methode aufgerufen");
}

public double add(double a, double b) {
return a + b;
}

public void printText() {
System.out.println(text);
}

public void changeText() {
text = "geaenderter Text";
}

public static void main(String[] args) {
MyProgram p = new MyProgram();
}

}
</code=java>
|}

Für mehr Informationen zur vorgenommenen Umformung bitte auf [[Vererbung_(Java)]] nachlesen.

Beispiele für die Verwendung von nicht-statische Methoden im JRE:
{|
|style="width:61em"|<code=java>import javax.swing.*;
import javax.swing.border.*;
import java.awt.*;

public class MyProgram {

public static void main(String[] args) {
JFrame f = new JFrame("MyProgram");
JPanel p = new JPanel();
JButton b1 = new JButton("Button 1");
JButton b2 = new JButton("Button 2");
JButton b3 = new JButton("Button 3");
JLabel l1 = new JLabel("Label 1");
JTextArea ta = new JTextArea();

p.add(b1);
p.add(b2);
p.add(b3);
p.add(l1);
p.add(ta);

ta.setPreferredSize(new Dimension(100,50)); // setPreferredSize ist eine nicht-statische
// Methode der Klasse JTextArea, von dem ta eine
// Instanz ist
ta.setBorder(new LineBorder(Color.blue));
ta.setText( b2.getText() ); // Hier wird die Methode getText() von der
// Instanz b2 verwendet und ta mit setText()
// zugewiesen

b1.setPreferredSize(new Dimension(180, 70)); // Die Groesse des Buttons von b1 wird mit
// der Methode setPreferredSize(), die in JButton
// definiert wurde, veraendert
b3.setPreferredSize(new Dimension(160, 90)); // Andere Instanzen von Buttons bleiben davon
// unberührt und koennen ebenfalls mit der gleichen
// Methode eine andere Groesse erhaltem

b1.setBackground(Color.red); // Auch hier wieder:
b3.setBackground(Color.green); // zwei verschiedene Buttons, die mit Hilfe der
// gleichen Methode setBackground() eine andere
// Hintergrundfarbe erhalten.

f.add(p);
f.pack();
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.setVisible(true);
}

}</code=java>
|}

== Verwirrungen um static / non-static ==

So unterschiedlich statische und nicht-statische Methoden sind, so kommt es doch bei Anfängern zu Verwirrungen, da es manchmal so aussieht, als täten beide genau das Selbe:

{|
|style="width:61em"|<code=java>import javax.swing.*;
import javax.swing.border.*;
import java.awt.*;

public class MyProgram {

public static int myStaticVar=0;

public int myNonStaticVar=0;

public static void myStaticMethod() {
myStaticVar *= 7; // ist das gleiche wie
// myStaticVar = myStaticVar * 7;
}

public void myNonStaticMethod() {
myNonStaticVar *= 13; // ist das gleiche wie
// myNonStaticVar = myNonStaticVar * 13;
}

public MyProgram() {
myStaticVar = 6;
myNonStaticVar = 5;

System.out.println(myStaticVar);
System.out.println(myNonStaticVar);

myStaticMethod();
myNonStaticMethod();

System.out.println(myStaticVar);
System.out.println(myNonStaticVar);

myStaticMethod();
myNonStaticMethod();

System.out.println(myStaticVar);
System.out.println(myNonStaticVar);
}

public static void main(String[] args) {
new MyProgram(); // aehnlich wie
// MyProgram mp = new MyProgram();
// bloß, dass in diesem Fall nur der Konstruktor aufgerufen
// wird. Jedoch nicht eine Instanz zur weiteren verwendung in
// main() erhalten bleibt.
}

}</code=java>

Augenscheinlich gibt es zwischen der statischen Methode und Variable und der nicht-statischen Methode und Variable keinen Unterschied.

Das liegt aber daran, weil man bei statischen Methoden den Klassennamen der Einfachheit halber weglassen kann und bei nicht-statischen Methoden das ''this''.
Ausgeschrieben sieht das Programm folgendermaßen aus:

{|
|style="width:61em"|<code=java>import javax.swing.*;
import javax.swing.border.*;
import java.awt.*;

public class MyProgram {

public static int myStaticVar=0;

public int myNonStaticVar=0;

public static void myStaticMethod() {
myStaticVar *= 7;
}

public void myNonStaticMethod() {
myNonStaticVar *= 13;
}

public MyProgram() {
MyProgram.myStaticVar = 6;
this.myNonStaticVar = 5;

System.out.println(MyProgram.myStaticVar);
System.out.println(this.myNonStaticVar);

MyProgram.myStaticMethod();
this.myNonStaticMethod();

System.out.println(MyProgram.myStaticVar);
System.out.println(this.myNonStaticVar);

MyProgram.myStaticMethod();
this.myNonStaticMethod();

System.out.println(MyProgram.myStaticVar);
System.out.println(this.myNonStaticVar);
}

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

}
</code=java>

Noch deutlicher wird der Unterschied, wenn man von außen auf die Instanz zugreift:

{|
|style="width:61em"|<code=java>import javax.swing.*;
import javax.swing.border.*;
import java.awt.*;

public class MyProgram {

public static int myStaticVar=0;

public int myNonStaticVar=0;

public static void myStaticMethod() {
myStaticVar *= 7;
}

public void myNonStaticMethod() {
myNonStaticVar *= 13;
}

public MyProgram() {
}

public static void main(String[] args) {
MyProgram mp1 = new MyProgram();
MyProgram mp2 = new MyProgram();

MyProgram.myStaticVar = 6;
mp1.myNonStaticVar = 5;
mp2.myNonStaticVar = 8;

System.out.println( MyProgram.myStaticVar );
System.out.println( mp1.myNonStaticVar );
System.out.println( mp2.myNonStaticVar );

MyProgram.myStaticMethod();
mp1.myNonStaticMethod();

System.out.println( MyProgram.myStaticVar );
System.out.println( mp1.myNonStaticVar );
System.out.println( mp2.myNonStaticVar );

mp2.myNonStaticMethod();
mp2.myNonStaticMethod();
mp2.myNonStaticMethod();
mp2.myNonStaticMethod();

System.out.println( MyProgram.myStaticVar );
System.out.println( mp1.myNonStaticVar );
System.out.println( mp2.myNonStaticVar );
}

}</code=java>

Hier sieht man noch mal, daß statische Methoden und Variablen für alle Instanzen und auch statische Methoden wie main() gelten, während nicht-statische Methoden nur für eine bestimmte Instanz ihre Gültigkeit haben.

== Besonderheiten von statischen Methoden ==

Am Anfang haben wir statische Methoden als äquivalent zu Funktionen in C und anderen nicht-objektorientierten Sprachen kennengelernt.
Um den Unterschied zwischen statischen und nicht-statischen Methoden zu verstehen, ist es auch für den Anfang ganz sinnvoll es so zu erklären.
Aber in der objektorientierten Sprache Java, gibt es dann doch einige Zusätze, die es in C z.B. nicht gibt.

Statische Methoden lassen sich genauso wie nicht-statische Methoden ableiten:

{|
|style="width:30em"|<code=java>public class BaseClass {

public static void printFirstText() {
System.out.println("Dieses ist ein Text in BaseClass");
}

public static void printSecondText() {
System.out.println("Und noch ein Text in BaseClass");
}

}</code=java>

<code=java>public class ExternalClass extends BaseClass{

public static void printSecondText() {
System.out.println("Ein Text in ExternalClass");
}

}</code=java>

|style="width:1em"|
|style="width:30em"|<code=java>public class MyProgram {

public static void main(String[] args) {
BaseClass.printFirstText(); // normaler Aufruf
BaseClass.printSecondText(); // normaler Aufruf
ExternalClass.printFirstText(); // Methode ist von BaseClass abgeleitet
ExternalClass.printSecondText(); // Methode, die die von BaseClass
// ueberschrieben hat
}

}









    </code=java>
|}

Es gibt etwas ähnliches wie einen Konstruktor für statische Methoden:

{|
|style="width:30em"|<code=java>public class ExternalClass {

public static void myStaticMethod() {
System.out.println("die statische Methode wurde aufgerufen.");
}

public static void myOtherStaticMethod() {
System.out.println("eine weitere Methode wurde aufgerufen.");
}

static {
System.out.println("Es wurde zum erstem Mal statisch auf diese Klasse zugegriffen.");
}

}</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>public class MyProgram {

public static void main(String[] args) {
ExternalClass.myStaticMethod();
ExternalClass.myOtherStaticMethod();
ExternalClass.myStaticMethod();
}

}





    </code=java>
|}

Diese Möglichkeit wird insbesondere eingesetzt, wenn man statischen Variablen direkt am Anfang bestimmte Werte zuweisen möchte.
So kann es sein, daß Anfangswert der Variablen erst berechnet werden muß. Oder es handelt sich um eine Liste, die sich nur mit Hilfe einer [[Schleife]] befüllen lässt.

[[Kategorie:Java]]
[[Kategorie:Java Grundlagen]]

Schleife

2013-08-19T09:33:06Z

Theuserbl: Die Seite wurde neu angelegt: „Eine Schleife bewirkt, daß sich ein Programmabschnitt mehrmals wiederholt. Bei den meisten Schleifen, werden dabei für jeden Vorgang ein anderer Wert einer Vari…“

Eine Schleife bewirkt, daß sich ein Programmabschnitt mehrmals wiederholt.
Bei den meisten Schleifen, werden dabei für jeden Vorgang ein anderer Wert einer Variablen benutzt.

Bei Java gibt es folgende Schleifen:
* [[For-Schleife]]
* [[For_each-Schleife]]
* [[While-Schleife]]

[[Kategorie:Java]]

Static / non-static (Java)

2013-08-19T09:26:13Z

Theuserbl:

== Der Unterschied zwischen statischen und nicht-statischen Methoden und Variablen ==

Das kleine Wort ''static'' macht einen großen Unterschied.

== Statische Methoden ==

Wer nicht-objektorientierte Sprachen wie C kennt, dem dürften statische Methoden vertraut sein. In nicht-objektorientiersten Sprachen heißen Methoden "Funktionen". Und im Grunde genommen sind statische Methoden genau das: Funktionen wie in C.

Wenn man von einer anderen Klasse auf statische Methoden oder Variablen zugreifen möchte, dann ruft man sie zusammen mit dem Klassennamen auf:

{|
|style="width:30em"|<code=java>public class ExternalClass {

public static int number=5;
private static String text="Anfangstext";

public static void myStaticMethod() {
System.out.println("statische Methode aufgerufen");
}

public static double add(double a, double b) {
return a + b;
}

public static void printText() {
System.out.println(text);
}

public static void changeText() {
text = "geaenderter Text";
}

}</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>public class MyProgram {

public static void main(String[] args) {
ExternalClass.myStaticMethod();
System.out.println( ExternalClass.add(17.65, 9.23) );
System.out.println( ExternalClass.number );
ExternalClass.number = 13;
System.out.println( ExternalClass.number );
ExternalClass.printText();
ExternalClass.changeText();
ExternalClass.printText();
}

}








</code=java>
|}

Befinden sich die Methoden und Variablen in der eigenen Klasse, dann sieht es genauso aus:
{|
|style="width:61em"|<code=java>public class MyProgram {

public static int number=5;
private static String text="Anfangstext";

public static void myStaticMethod() {
System.out.println("statische Methode aufgerufen");
}

public static double add(double a, double b) {
return a + b;
}

public static void printText() {
System.out.println(text);
}

public static void changeText() {
text = "geaenderter Text";
}

public static void main(String[] args) {
MyProgram.myStaticMethod();
System.out.println( MyProgram.add(17.65, 9.23) );
System.out.println( MyProgram.number );
MyProgram.number = 13;
System.out.println( MyProgram.number );
MyProgram.printText();
MyProgram.changeText();
MyProgram.printText();
}

}
</code=java>
|}

Der Einsatzzweck für statische Methoden ist somit ähnlich wie bei Funktionen von nicht-objketorientierten Sprachen.
Statische Variablen sind ein zentraler Ort an dem etwas gespeichert wird.

Beispiele für die Verwendung von statische Methoden im JRE:

{|
|style="width:61em"|<code=java>public class MyProgram {

public static void main(String[] args) {
System.out.println( Math.PI ); // PI ist eine statische Variable in der Klasse Math
System.out.println( Math.E ); // E ist eine statische Variable in der Klasse Math
System.out.println( Math.sin(2) ); // sin() ist eine statische Methode in der Klasse Math
System.out.println( Math.log(7) ); // log() ist eine statische Methode in der Klasse Math
}

}
</code=java>
|}

PI ist halt überall immer 3.141..., sin(2) ist überall 0.909..., etc.

== Nicht-Statische Methoden ==

Nicht-Statische Methoden und Variablen kommen vor allem in objektorientierten Sprachen vor.
Um diese aufrufen zu können, muß erst mit ''new'' eine Instanz von der Klasse erstellt werden. Und an dieser kann man dann die Methoden aufrufen. Die Methoden gehören dann zur Instanz:

{|
|style="width:30em"|<code=java>public class ExternalClass {

public int number=5;
private String text="Anfangstext";

public ExternalClass() {
}

public void myNonStaticMethod() {
System.out.println("nicht-statische Methode aufgerufen");
}

public double add(double a, double b) {
return a + b;
}

public void printText() {
System.out.println(text);
}

public void changeText() {
text = "geaenderter Text";
}

}</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>public class MyProgram {

public static void main(String[] args) {
ExternalClass ec1 = new ExternalClass();
ec1.myNonStaticMethod();
System.out.println( ec1.add(17.65, 9.23) );
System.out.println( ec1.number );
ec1.number = 13;
System.out.println( ec1.number );
ec1.printText();
ec1.changeText();
ec1.printText();

ExternalClass ec2 = new ExternalClass();
ec2.printText();
ec1.printText();

ec2.number = 29;
System.out.println( ec1.number );
System.out.println( ec2.number );
}

}


</code=java>
|}

Zwar existieren nun genau die gleichen Methoden und Variablen wie bei dem Beispiel mit den statischen Methoden, jedoch existieren sie für jede Instanz unabhängig voneinander.

Befinden sich die Methoden und Variablen in der eigenen Klasse, dann sieht es ähnlich aus. In der eigenen Klasse wird jedoch statt einem Instanznamen das Schlüsselwort ''this'' verwendet:

{|
|style="width:61em"|<code=java>public class MyProgram {

public int number=5;
private String text="Anfangstext";

public MyProgram() {
this.myNonStaticMethod();
System.out.println( this.add(17.65, 9.23) );
System.out.println( this.number );
this.number = 13;
System.out.println( this.number );
this.printText();
this.changeText();
this.printText();
}

public void myNonStaticMethod() {
System.out.println("nicht-statische Methode aufgerufen");
}

public double add(double a, double b) {
return a + b;
}

public void printText() {
System.out.println(text);
}

public void changeText() {
text = "geaenderter Text";
}

public static void main(String[] args) {
MyProgram p = new MyProgram();
}

}
</code=java>
|}

Für mehr Informationen zur vorgenommenen Umformung bitte auf [[Vererbung_(Java)]] nachlesen.

Beispiele für die Verwendung von nicht-statische Methoden im JRE:
{|
|style="width:61em"|<code=java>import javax.swing.*;
import javax.swing.border.*;
import java.awt.*;

public class MyProgram {

public static void main(String[] args) {
JFrame f = new JFrame("MyProgram");
JPanel p = new JPanel();
JButton b1 = new JButton("Button 1");
JButton b2 = new JButton("Button 2");
JButton b3 = new JButton("Button 3");
JLabel l1 = new JLabel("Label 1");
JTextArea ta = new JTextArea();

p.add(b1);
p.add(b2);
p.add(b3);
p.add(l1);
p.add(ta);

ta.setPreferredSize(new Dimension(100,50)); // setPreferredSize ist eine nicht-statische
// Methode der Klasse JTextArea, von dem ta eine
// Instanz ist
ta.setBorder(new LineBorder(Color.blue));
ta.setText( b2.getText() ); // Hier wird die Methode getText() von der
// Instanz b2 verwendet und ta mit setText()
// zugewiesen

b1.setPreferredSize(new Dimension(180, 70)); // Die Groesse des Buttons von b1 wird mit
// der Methode setPreferredSize(), die in JButton
// definiert wurde, veraendert
b3.setPreferredSize(new Dimension(160, 90)); // Andere Instanzen von Buttons bleiben davon
// unberührt und koennen ebenfalls mit der gleichen
// Methode eine andere Groesse erhaltem

b1.setBackground(Color.red); // Auch hier wieder:
b3.setBackground(Color.green); // zwei verschiedene Buttons, die mit Hilfe der
// gleichen Methode setBackground() eine andere
// Hintergrundfarbe erhalten.

f.add(p);
f.pack();
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.setVisible(true);
}

}</code=java>
|}

== Verwirrungen um static / non-static ==

So unterschiedlich statische und nicht-statische Methoden sind, so kommt es doch bei Anfängern zu Verwirrungen, da es manchmal so aussieht, als täten beide genau das Selbe:

{|
|style="width:61em"|<code=java>import javax.swing.*;
import javax.swing.border.*;
import java.awt.*;

public class MyProgram {

public static int myStaticVar=0;

public int myNonStaticVar=0;

public static void myStaticMethod() {
myStaticVar *= 7; // ist das gleiche wie
// myStaticVar = myStaticVar * 7;
}

public void myNonStaticMethod() {
myNonStaticVar *= 13; // ist das gleiche wie
// myNonStaticVar = myNonStaticVar * 13;
}

public MyProgram() {
myStaticVar = 6;
myNonStaticVar = 5;

System.out.println(myStaticVar);
System.out.println(myNonStaticVar);

myStaticMethod();
myNonStaticMethod();

System.out.println(myStaticVar);
System.out.println(myNonStaticVar);

myStaticMethod();
myNonStaticMethod();

System.out.println(myStaticVar);
System.out.println(myNonStaticVar);
}

public static void main(String[] args) {
new MyProgram(); // aehnlich wie
// MyProgram mp = new MyProgram();
// bloß, dass in diesem Fall nur der Konstruktor aufgerufen
// wird. Jedoch nicht eine Instanz zur weiteren verwendung in
// main() erhalten bleibt.
}

}</code=java>

Augenscheinlich gibt es zwischen der statischen Methode und Variable und der nicht-statischen Methode und Variable keinen Unterschied.

Das liegt aber daran, weil man bei statischen Methoden den Klassennamen der Einfachheit halber weglassen kann und bei nicht-statischen Methoden das ''this''.
Ausgeschrieben sieht das Programm folgendermaßen aus:

{|
|style="width:61em"|<code=java>import javax.swing.*;
import javax.swing.border.*;
import java.awt.*;

public class MyProgram {

public static int myStaticVar=0;

public int myNonStaticVar=0;

public static void myStaticMethod() {
myStaticVar *= 7;
}

public void myNonStaticMethod() {
myNonStaticVar *= 13;
}

public MyProgram() {
MyProgram.myStaticVar = 6;
this.myNonStaticVar = 5;

System.out.println(MyProgram.myStaticVar);
System.out.println(this.myNonStaticVar);

MyProgram.myStaticMethod();
this.myNonStaticMethod();

System.out.println(MyProgram.myStaticVar);
System.out.println(this.myNonStaticVar);

MyProgram.myStaticMethod();
this.myNonStaticMethod();

System.out.println(MyProgram.myStaticVar);
System.out.println(this.myNonStaticVar);
}

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

}
</code=java>

Noch deutlicher wird der Unterschied, wenn man von außen auf die Instanz zugreift:

{|
|style="width:61em"|<code=java>import javax.swing.*;
import javax.swing.border.*;
import java.awt.*;

public class MyProgram {

public static int myStaticVar=0;

public int myNonStaticVar=0;

public static void myStaticMethod() {
myStaticVar *= 7;
}

public void myNonStaticMethod() {
myNonStaticVar *= 13;
}

public MyProgram() {
}

public static void main(String[] args) {
MyProgram mp1 = new MyProgram();
MyProgram mp2 = new MyProgram();

MyProgram.myStaticVar = 6;
mp1.myNonStaticVar = 5;
mp2.myNonStaticVar = 8;

System.out.println( MyProgram.myStaticVar );
System.out.println( mp1.myNonStaticVar );
System.out.println( mp2.myNonStaticVar );

MyProgram.myStaticMethod();
mp1.myNonStaticMethod();

System.out.println( MyProgram.myStaticVar );
System.out.println( mp1.myNonStaticVar );
System.out.println( mp2.myNonStaticVar );

mp2.myNonStaticMethod();
mp2.myNonStaticMethod();
mp2.myNonStaticMethod();
mp2.myNonStaticMethod();

System.out.println( MyProgram.myStaticVar );
System.out.println( mp1.myNonStaticVar );
System.out.println( mp2.myNonStaticVar );
}

}</code=java>

Hier sieht man noch mal, daß statische Methoden und Variablen für alle Instanzen und auch statische Methoden wie main() gelten, während nicht-statische Methoden nur für eine bestimmte Instanz ihre Gültigkeit haben.

== Besonderheiten von statischen Methoden ==

Am Anfang haben wir statische Methoden als äquivalent zu Funktionen in C und anderen nicht-objektorientierten Sprachen kennengelernt.
Um den Unterschied zwischen statischen und nicht-statischen Methoden zu verstehen, ist es auch für den Anfang ganz sinnvoll es so zu erklären.
Aber in der objektorientierten Sprache Java, gibt es dann doch einige Zusätze, die es in C z.B. nicht gibt.

Statische Methoden lassen sich ableiten:

(diese Beschreibung wird später noch fortgesetzt...)

Es gibt etwas ähnliches wie einen Konstruktor für statische Methoden:

{|
|style="width:30em"|<code=java>public class ExternalClass {

public static void myStaticMethod() {
System.out.println("die statische Methode wurde aufgerufen.");
}

public static void myOtherStaticMethod() {
System.out.println("eine weitere Methode wurde aufgerufen.");
}

static {
System.out.println("Es wurde zum erstem Mal statisch auf diese Klasse zugegriffen.");
}

}</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>public class MyProgram {

public static void main(String[] args) {
ExternalClass.myStaticMethod();
ExternalClass.myOtherStaticMethod();
ExternalClass.myStaticMethod();
}

}





    </code=java>
|}

Diese Möglichkeit wird insbesondere eingesetzt, wenn man statischen Variablen direkt am Anfang bestimmte Werte zuweisen möchte.
So kann es sein, daß Anfangswert der Variablen erst berechnet werden muß. Oder es handelt sich um eine Liste, die sich nur mit Hilfe einer [[Schleife]] befüllen lässt.

[[Kategorie:Java]]
[[Kategorie:Java Grundlagen]]

Vererbung (Java)

2013-08-14T17:02:12Z

Theuserbl:

Im folgenden wird in anschaulicher Weise die Vererbung in Java, welches ein Teilbereich der Objektorientierung ist, beschrieben.
Alle Programme sehen, wenn man sie ausführt, genau gleich aus und bedienen sich auch gleich. Auch wenn der Quellcode immer wieder etwas anders ist.

Fangen wir mit einem einfachen kleinen Programm an, das ein Fenster öffnet und drei Buttons erstellt. Zwei davon sind rot:

{|
|style="width:30em"|<code=java>





















</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>import javax.swing.*;
import java.awt.*;

public class MyProgram {

public static void main(String[] args) {
JFrame f = new JFrame("My Window");
JPanel p = new JPanel();
JButton b1 = new JButton("Button 1");
JButton b2 = new JButton("Button 2");
JButton b3 = new JButton("Button 3");
b1.setBackground(new Color(255,0,0));
b3.setBackground(new Color(255,0,0));
p.add(b1);
p.add(b2);
p.add(b3);
f.add(p);
f.pack();
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.setVisible(true);
}

}</code=java>
|}

Durch "new" wird ein neues Objekt (eine Instanz) erstellt, das eine Kopie des Hauptobjekts ist.

Betrachten wir uns nun ''JFrame''. Man kann in Java eine neue Klasse erstellen (sofern die Klasse, von der sie sich ableitet, nicht "''private''" ist), die sämtliche Eigenschaften der Klasse, von der sie abgeleitet wurde, erbt.

In folgendem Programm habe ich nun eine Klasse ''MyFrame'' erstellt, die mittels ''extends'' von der Klasse ''JFrame'' alle Eigenschaften erbt:
{|
|style="width:30em"|<code=java>import javax.swing.*;

public class MyFrame extends JFrame {
MyFrame(String name) {
super(name);
}
}
















</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>import javax.swing.*;
import java.awt.*;

public class MyProgram {

public static void main(String[] args) {
MyFrame f = new MyFrame("My Window");
JPanel p = new JPanel();
JButton b1 = new JButton("Button 1");
JButton b2 = new JButton("Button 2");
JButton b3 = new JButton("Button 3");
b1.setBackground(new Color(255,0,0));
b3.setBackground(new Color(255,0,0));
p.add(b1);
p.add(b2);
p.add(b3);
f.add(p);
f.pack();
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.setVisible(true);
}

}</code=java>
|}

Im Programm ''MyProgram'' wird nun ''MyFrame'' auch genau so genutzt und behandelt wie zuvor ''JFrame''. Und das Ergebnis ist ebenfalls gleich.
In ''MyProgram'' wird ''MyFrame'' genau ein Argument übergeben: Der String "''My Window''".
Die Anzahl und Art der Argumente muss im Konstruktor von der ''MyFrame''-Klasse auch vorkommen: ''MyFrame(String name)''.
Und damit dieses Argument wiederum auch an das eigentliche ''JFrame'' übergeben wird, steht dort ''super(name)''.

''MyFrame'' ist ein neues Objekt. Ich kann ihm sämtliche Eigenschaften meines Programms geben:
{|
|style="width:30em"|<code=java>import javax.swing.*;
import java.awt.*;

public class MyFrame extends JFrame {

MyFrame() {
super("My Window");
JPanel p = new JPanel();
JButton b1 = new JButton("Button 1");
JButton b2 = new JButton("Button 2");
JButton b3 = new JButton("Button 3");
b1.setBackground(new Color(255,0,0));
b3.setBackground(new Color(255,0,0));
p.add(b1);
p.add(b2);
p.add(b3);
this.add(p);
this.pack();
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setVisible(true);
}

}</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>public class MyProgram {

public static void main(String[] args) {
MyFrame f = new MyFrame();
}

}












</code=java>
|}

Somit wird nun nur ''MyFrame'' aufgerufen. In ''MyFrame'' ist alles drin enthalten.
Man muss es wie eine Komponente sehen. Das Programmm sieht zwar beim Ausführen wieder genau gleich aus, aber vom Programmaufbau ist es nun etwas anders. Ich kann z.B. nun ''MyFrame'' als Komponente in andere Programme integrieren. Befehle wie ''JButton'' brauche ich in dem anderen Programm dann nicht zu schreiben.

Die ''main()''-Methode in ''MyProgram'' kann man in jede beliebige Klasse schreiben. So kann man sie auch direkt in ''MyFrame'' schreiben:
{|
|style="width:30em"|<code=java>import javax.swing.*;
import java.awt.*;

public class MyFrame extends JFrame {

MyFrame() {
super("My Window");
JPanel p = new JPanel();
JButton b1 = new JButton("Button 1");
JButton b2 = new JButton("Button 2");
JButton b3 = new JButton("Button 3");
b1.setBackground(new Color(255,0,0));
b3.setBackground(new Color(255,0,0));
p.add(b1);
p.add(b2);
p.add(b3);
this.add(p);
this.pack();
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setVisible(true);
}

public static void main(String[] args) {
MyFrame f = new MyFrame();
}

}</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>

























     </code=java>
|}

Das hat den enormen Vorteil, dass man in Java in mehreren Klassen ''main()''-Methoden haben kann.
Man kann dann das Programm entweder von der eigentlichen Klasse aus starten oder aber auch einfach die ''main()''-Methode in einer der Komponenten. In letzterem Fall hat man dann z.B. ein Programm, das nur die eine Komponente ausführt. Somit muss man nicht immer das ganze Programm starten, wenn man nur mal kurz Veränderungen an einer Komponente testen will.

Genauso wie wir nun ''MyFrame'' erstellt haben, können wir auch eine Klasse namens ''RedButton'' erstellen, dessen Aufgabe es ist, einen roten Button zu erstellen:
{|
|style="width:30em"|<code=java>import javax.swing.*;
import java.awt.*;

public class RedButton extends JButton {

RedButton(String name) {
super(name);
this.setBackground(new Color(255,0,0));
}

}









</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>import javax.swing.*;

public class MyProgram {

public static void main(String[] args) {
MyFrame f = new MyFrame("My Window");
JPanel p = new JPanel();
RedButton b1 = new RedButton("Button 1");
JButton b2 = new JButton("Button 2");
RedButton b3 = new RedButton("Button 3");
p.add(b1);
p.add(b2);
p.add(b3);
f.add(p);
f.pack();
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.setVisible(true);
}

}</code=java>
|}

An dieser Stelle sieht man auch besser den Sinn der abgeleiteten Klassen. Nun wurden zwei ''JButton''s direkt zu ''RedButton''s. Wenn man bedenkt, dass sämtliche Swing-Komponenten wie ''JButton'' gezeichnet werden, so ist es eine erhebliche Arbeitserleichterung, dass das Programm dahinter nur einmal geschrieben wurde und dann immer wieder genutzt werden kann.

Zu guter Letzt nun auch noch mal die Klasse ''RedButton'' in Kombination mit der Klasse ''MyFrame'':
{|
|style="width:30em"|<code=java>import javax.swing.*;
import java.awt.*;

public class RedButton extends JButton {

RedButton(String name) {
super(name);
this.setBackground(new Color(255,0,0));
}

}













</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>import javax.swing.*;

public class MyFrame extends JFrame {

MyFrame() {
super("My Window");
JPanel p = new JPanel();
RedButton b1 = new RedButton("Button 1");
JButton b2 = new JButton("Button 2");
RedButton b3 = new RedButton("Button 3");
p.add(b1);
p.add(b2);
p.add(b3);
this.add(p);
this.pack();
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setVisible(true);
}

public static void main(String[] args) {
MyFrame f = new MyFrame();
}

}</code=java>
|}

[[Kategorie:Java]]
[[Kategorie:Java Grundlagen]]

Static / non-static (Java)

2013-08-14T16:56:43Z

Theuserbl: Die Seite wurde neu angelegt: „== Der Unterschied zwischen statischen und nicht-statischen Methoden und Variablen == Das kleine Wort ''static'' macht einen großen Unterschied. == Statische…“

Vererbung (Java)

2013-08-13T19:58:54Z

Theuserbl:

Im folgenden wird in anschaulicher Weise die Vererbung in Java, welches ein Teilbereich der Objektorientierung ist, beschrieben.
Alle Programme sehen, wenn man sie ausführt, genau gleich aus und bedienen sich auch gleich. Auch wenn der Quellcode immer wieder etwas anders ist.

Fangen wir mit einem einfachen kleinen Programm an, das ein Fenster öffnet und drei Buttons erstellt. Zwei davon sind rot:

{|
|style="width:30em"|<code=java>





















</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>import javax.swing.*;
import java.awt.*;

public class MyProgram {

public static void main(String[] args) {
JFrame f = new JFrame("My Window");
JPanel p = new JPanel();
JButton b1 = new JButton("Button 1");
JButton b2 = new JButton("Button 2");
JButton b3 = new JButton("Button 3");
b1.setBackground(new Color(255,0,0));
b3.setBackground(new Color(255,0,0));
p.add(b1);
p.add(b2);
p.add(b3);
f.add(p);
f.pack();
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.setVisible(true);
}

}</code=java>
|}

Durch "new" wird ein neues Objekt (eine Instanz) erstellt, das eine Kopie des Hauptobjekts ist.

Betrachten wir uns nun ''JFrame''. Man kann in Java eine neue Klasse erstellen (sofern die Klasse, von der sie sich ableitet, nicht "''private''" ist), die sämtliche Eigenschaften der Klasse, von der sie abgeleitet wurde, erbt.

In folgendem Programm habe ich nun eine Klasse ''MyFrame'' erstellt, die mittels ''extends'' von der Klasse ''JFrame'' alle Eigenschaften erbt:
{|
|style="width:30em"|<code=java>import javax.swing.*;

public class MyFrame extends JFrame{
MyFrame(String name) {
super(name);
}
}
















</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>import javax.swing.*;
import java.awt.*;

public class MyProgram {

public static void main(String[] args) {
MyFrame f = new MyFrame("My Window");
JPanel p = new JPanel();
JButton b1 = new JButton("Button 1");
JButton b2 = new JButton("Button 2");
JButton b3 = new JButton("Button 3");
b1.setBackground(new Color(255,0,0));
b3.setBackground(new Color(255,0,0));
p.add(b1);
p.add(b2);
p.add(b3);
f.add(p);
f.pack();
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.setVisible(true);
}

}</code=java>
|}

Im Programm ''MyProgram'' wird nun ''MyFrame'' auch genau so genutzt und behandelt wie zuvor ''JFrame''. Und das Ergebnis ist ebenfalls gleich.
In ''MyProgram'' wird ''MyFrame'' genau ein Argument übergeben: Der String "''My Window''".
Die Anzahl und Art der Argumente muss im Konstruktor von der ''MyFrame''-Klasse auch vorkommen: ''MyFrame(String name)''.
Und damit dieses Argument wiederum auch an das eigentliche ''JFrame'' übergeben wird, steht dort ''super(name)''.

''MyFrame'' ist ein neues Objekt. Ich kann ihm sämtliche Eigenschaften meines Programms geben:
{|
|style="width:30em"|<code=java>import javax.swing.*;
import java.awt.*;

public class MyFrame extends JFrame{

MyFrame() {
super("My Window");
JPanel p = new JPanel();
JButton b1 = new JButton("Button 1");
JButton b2 = new JButton("Button 2");
JButton b3 = new JButton("Button 3");
b1.setBackground(new Color(255,0,0));
b3.setBackground(new Color(255,0,0));
p.add(b1);
p.add(b2);
p.add(b3);
this.add(p);
this.pack();
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setVisible(true);
}

}</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>public class MyProgram {

public static void main(String[] args) {
MyFrame f = new MyFrame();
}

}












</code=java>
|}

Somit wird nun nur ''MyFrame'' aufgerufen. In ''MyFrame'' ist alles drin enthalten.
Man muss es wie eine Komponente sehen. Das Programmm sieht zwar beim Ausführen wieder genau gleich aus, aber vom Programmaufbau ist es nun etwas anders. Ich kann z.B. nun ''MyFrame'' als Komponente in andere Programme integrieren. Befehle wie ''JButton'' brauche ich in dem anderen Programm dann nicht zu schreiben.

Die ''main()''-Methode in ''MyProgram'' kann man in jede beliebige Klasse schreiben. So kann man sie auch direkt in ''MyFrame'' schreiben:
{|
|style="width:30em"|<code=java>import javax.swing.*;
import java.awt.*;

public class MyFrame extends JFrame{

MyFrame() {
super("My Window");
JPanel p = new JPanel();
JButton b1 = new JButton("Button 1");
JButton b2 = new JButton("Button 2");
JButton b3 = new JButton("Button 3");
b1.setBackground(new Color(255,0,0));
b3.setBackground(new Color(255,0,0));
p.add(b1);
p.add(b2);
p.add(b3);
this.add(p);
this.pack();
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setVisible(true);
}

public static void main(String[] args) {
MyFrame f = new MyFrame();
}

}</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>

























     </code=java>
|}

Das hat den enormen Vorteil, dass man in Java in mehreren Klassen ''main()''-Methoden haben kann.
Man kann dann das Programm entweder von der eigentlichen Klasse aus starten oder aber auch einfach die ''main()''-Methode in einer der Komponenten. In letzterem Fall hat man dann z.B. ein Programm, das nur die eine Komponente ausführt. Somit muss man nicht immer das ganze Programm starten, wenn man nur mal kurz Veränderungen an einer Komponente testen will.

Genauso wie wir nun ''MyFrame'' erstellt haben, können wir auch eine Klasse namens ''RedButton'' erstellen, dessen Aufgabe es ist, einen roten Button zu erstellen:
{|
|style="width:30em"|<code=java>import javax.swing.*;
import java.awt.*;

public class RedButton extends JButton {

RedButton(String name) {
super(name);
this.setBackground(new Color(255,0,0));
}

}









</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>import javax.swing.*;

public class MyProgram {

public static void main(String[] args) {
MyFrame f = new MyFrame("My Window");
JPanel p = new JPanel();
RedButton b1 = new RedButton("Button 1");
JButton b2 = new JButton("Button 2");
RedButton b3 = new RedButton("Button 3");
p.add(b1);
p.add(b2);
p.add(b3);
f.add(p);
f.pack();
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.setVisible(true);
}

}</code=java>
|}

An dieser Stelle sieht man auch besser den Sinn der abgeleiteten Klassen. Nun wurden zwei ''JButton''s direkt zu ''RedButton''s. Wenn man bedenkt, dass sämtliche Swing-Komponenten wie ''JButton'' gezeichnet werden, so ist es eine erhebliche Arbeitserleichterung, dass das Programm dahinter nur einmal geschrieben wurde und dann immer wieder genutzt werden kann.

Zu guter Letzt nun auch noch mal die Klasse ''RedButton'' in Kombination mit der Klasse ''MyFrame'':
{|
|style="width:30em"|<code=java>import javax.swing.*;
import java.awt.*;

public class RedButton extends JButton {

RedButton(String name) {
super(name);
this.setBackground(new Color(255,0,0));
}

}













</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>import javax.swing.*;

public class MyFrame extends JFrame{

MyFrame() {
super("My Window");
JPanel p = new JPanel();
RedButton b1 = new RedButton("Button 1");
JButton b2 = new JButton("Button 2");
RedButton b3 = new RedButton("Button 3");
p.add(b1);
p.add(b2);
p.add(b3);
this.add(p);
this.pack();
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setVisible(true);
}

public static void main(String[] args) {
MyFrame f = new MyFrame();
}

}</code=java>
|}

[[Kategorie:Java]]
[[Kategorie:Java Grundlagen]]

Vererbung (Java)

2013-08-13T18:53:37Z

Theuserbl:

Im folgenden wird in anschaulicher Weise die Vererbung in Java, welches ein Teilbereich der Objektorientierung ist, beschrieben.
Alle Programme sehen, wenn man sie ausführt, genau gleich aus und bedienen sich auch gleich. Auch wenn der Quellcode immer wieder etwas anders ist.

Fangen wir mit einem einfachen kleinen Programm an, das ein Fenster öffnet und drei Buttons erstellt. Zwei davon sind rot:

{|
|style="width:30em"|<code=java>





















</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>import javax.swing.*;
import java.awt.*;

public class MyProgram {

public static void main(String[] args) {
JFrame f = new JFrame("My Window");
JPanel p = new JPanel();
JButton b1 = new JButton("Button 1");
JButton b2 = new JButton("Button 2");
JButton b3 = new JButton("Button 3");
b1.setBackground(new Color(255,0,0));
b3.setBackground(new Color(255,0,0));
p.add(b1);
p.add(b2);
p.add(b3);
f.add(p);
f.pack();
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.setVisible(true);
}

}</code=java>
|}

Durch "new" wird ein neues Objekt (eine Instanz) erstellt, das eine Kopie des Hauptobjekts ist.

Betrachten wir uns nun ''JFrame''. Man kann in Java eine neue Klasse erstellen (sofern die Klasse, von der sie sich ableitet, nicht "''private''" ist), die sämtliche Eigenschaften der Klasse, von der sie abgeleitet wurde, erbt.

In folgendem Programm habe ich nun eine Klasse ''MyFrame'' erstellt, die mittels ''extends'' von der Klasse ''JFrame'' alle Eigenschaften erbt:
{|
|style="width:30em"|<code=java>import javax.swing.*;

public class MyFrame extends JFrame{
MyFrame(String name) {
super(name);
}
}
















</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>import javax.swing.*;
import java.awt.*;

public class MyProgram {

public static void main(String[] args) {
MyFrame f = new MyFrame("My Window");
JPanel p = new JPanel();
JButton b1 = new JButton("Button 1");
JButton b2 = new JButton("Button 2");
JButton b3 = new JButton("Button 3");
b1.setBackground(new Color(255,0,0));
b3.setBackground(new Color(255,0,0));
p.add(b1);
p.add(b2);
p.add(b3);
f.add(p);
f.pack();
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.setVisible(true);
}

}</code=java>
|}

Im Programm ''MyProgram'' wird nun ''MyFrame'' auch genau so genutzt und behandelt wie zuvor ''JFrame''. Und das Ergebnis ist ebenfalls gleich.
In ''MyProgram'' wird ''MyFrame'' genau ein Argument übergeben: Der String "''My Window''".
Die Anzahl und Art der Argumente muss im Konstruktor von der ''MyFrame''-Klasse auch vorkommen: ''MyFrame(String name)''.
Und damit dieses Argument wiederum auch an das eigentliche ''JFrame'' übergeben wird, steht dort ''super(name)''.

''MyFrame'' ist ein neues Objekt. Ich kann ihm sämtliche Eigenschaften meines Programms geben:
{|
|style="width:30em"|<code=java>import javax.swing.*;
import java.awt.*;

public class MyFrame extends JFrame{

MyFrame() {
super("My Window");
JPanel p = new JPanel();
JButton b1 = new JButton("Button 1");
JButton b2 = new JButton("Button 2");
JButton b3 = new JButton("Button 3");
b1.setBackground(new Color(255,0,0));
b3.setBackground(new Color(255,0,0));
p.add(b1);
p.add(b2);
p.add(b3);
this.add(p);
this.pack();
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setVisible(true);
}

}</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>public class MyProgram {

public static void main(String[] args) {
MyFrame f = new MyFrame();
}

}












</code=java>
|}

Somit wird nun nur ''MyFrame'' aufgerufen. In ''MyFrame'' ist alles drin enthalten.
Man muss es wie eine Komponente sehen. Das Programmm sieht zwar beim Ausführen wieder genau gleich aus, aber vom Programmaufbau ist es nun etwas anders. Ich kann z.B. nun ''MyFrame'' als Komponente in andere Programme integrieren. Befehle wie ''JButton'' brauche ich in dem anderen Programm dann nicht zu schreiben.

Die ''main()''-Methode in ''MyProgram'' kann man in jede beliebige Klasse schreiben. So kann man sie auch direkt in ''MyFrame'' schreiben:
{|
|style="width:30em"|<code=java>import javax.swing.*;
import java.awt.*;

public class MyFrame extends JFrame{

MyFrame() {
super("My Window");
JPanel p = new JPanel();
JButton b1 = new JButton("Button 1");
JButton b2 = new JButton("Button 2");
JButton b3 = new JButton("Button 3");
b1.setBackground(new Color(255,0,0));
b3.setBackground(new Color(255,0,0));
p.add(b1);
p.add(b2);
p.add(b3);
this.add(p);
this.pack();
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setVisible(true);
}

public static void main(String[] args) {
MyFrame f = new MyFrame();
}

}</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>

























     </code=java>
|}

Das hat den enormen Vorteil, dass man in Java in mehreren Klassen ''main()''-Methoden haben kann.
Man kann dann das Programm entweder von der eigentlichen Klasse aus starten oder aber auch einfach die ''main()''-Methode in einer der Komponenten. In letzterem Fall hat man dann z.B. ein Programm, das nur die eine Komponente ausführt. Somit muss man nicht immer das ganze Programm starten, wenn man nur mal kurz Veränderungen an einer Komponente testen will.

Genauso wie wir nun ''MyFrame'' erstellt haben, können wir auch eine Klasse namens ''RedButton'' erstellen, dessen Aufgabe es ist, einen roten Button zu erstellen:
{|
|style="width:30em"|<code=java>import javax.swing.*;
import java.awt.*;

public class RedButton extends JButton {

RedButton(String name) {
super(name);
this.setBackground(new Color(255,0,0));
}

}









</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>import javax.swing.*;

public class MyProgram {

public static void main(String[] args) {
MyFrame f = new MyFrame("My Window");
JPanel p = new JPanel();
RedButton b1 = new RedButton("Button 1");
JButton b2 = new JButton("Button 2");
RedButton b3 = new RedButton("Button 3");
p.add(b1);
p.add(b2);
p.add(b3);
f.add(p);
f.pack();
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.setVisible(true);
}

}</code=java>
|}

An dieser Stelle sieht man auch besser den Sinn der abgeleiteten Klassen. Nun wurden zwei ''JButton''s direkt zu ''RedButton''s. Wenn man bedenkt, dass sämtliche Swing-Komponenten wie ''JButton'' gezeichnet werden, so ist es eine erhebliche Arbeitserleichterung, dass das Programm dahinter nur einmal geschrieben wurde und dann immer wieder genutzt werden kann.

Zu guter Letzt nun auch noch mal die Klasse ''RedButton'' in Kombination mit der Klasse ''MyFrame'':
{|
|style="width:30em"|<code=java>import javax.swing.*;
import java.awt.*;

public class RedButton extends JButton {

RedButton(String name) {
super(name);
this.setBackground(new Color(255,0,0));
}

}














</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>import javax.swing.*;
import java.awt.*;

public class MyFrame extends JFrame{

MyFrame() {
super("My Window");
JPanel p = new JPanel();
RedButton b1 = new RedButton("Button 1");
JButton b2 = new JButton("Button 2");
RedButton b3 = new RedButton("Button 3");
p.add(b1);
p.add(b2);
p.add(b3);
this.add(p);
this.pack();
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setVisible(true);
}

public static void main(String[] args) {
MyFrame f = new MyFrame();
}

}</code=java>
|}

[[Kategorie:Java]]
[[Kategorie:Java Grundlagen]]

Vererbung (Java)

2013-08-13T18:51:12Z

Theuserbl:

Im folgenden wird in anschaulicher Weise die Vererbung in Java, welches ein Teilbereich der Objektorientierung ist, beschrieben.
Alle Programme sehen, wenn man sie ausführt, genau gleich aus und bedienen sich auch gleich. Auch wenn der Quellcode immer wieder etwas anders ist.

Fangen wir mit einem einfachen kleinen Programm an, das ein Fenster öffnet und drei Buttons erstellt. Zwei davon sind rot:

{|
|style="width:30em"|<code=java>





















</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>import javax.swing.*;
import java.awt.*;

public class myProgram {

public static void main(String[] args) {
JFrame f = new JFrame("My Window");
JPanel p = new JPanel();
JButton b1 = new JButton("Button 1");
JButton b2 = new JButton("Button 2");
JButton b3 = new JButton("Button 3");
b1.setBackground(new Color(255,0,0));
b3.setBackground(new Color(255,0,0));
p.add(b1);
p.add(b2);
p.add(b3);
f.add(p);
f.pack();
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.setVisible(true);
}

}</code=java>
|}

Durch "new" wird ein neues Objekt (eine Instanz) erstellt, das eine Kopie des Hauptobjekts ist.

Betrachten wir uns nun ''JFrame''. Man kann in Java eine neue Klasse erstellen (sofern die Klasse, von der sie sich ableitet, nicht "''private''" ist), die sämtliche Eigenschaften der Klasse, von der sie abgeleitet wurde, erbt.

In folgendem Programm habe ich nun eine Klasse ''MyFrame'' erstellt, die mittels ''extends'' von der Klasse ''JFrame'' alle Eigenschaften erbt:
{|
|style="width:30em"|<code=java>import javax.swing.*;

public class MyFrame extends JFrame{
MyFrame(String name) {
super(name);
}
}
















</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>import javax.swing.*;
import java.awt.*;

public class myProgram {

public static void main(String[] args) {
MyFrame f = new MyFrame("My Window");
JPanel p = new JPanel();
JButton b1 = new JButton("Button 1");
JButton b2 = new JButton("Button 2");
JButton b3 = new JButton("Button 3");
b1.setBackground(new Color(255,0,0));
b3.setBackground(new Color(255,0,0));
p.add(b1);
p.add(b2);
p.add(b3);
f.add(p);
f.pack();
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.setVisible(true);
}

}</code=java>
|}

Im Programm ''myProgram'' wird nun ''MyFrame'' auch genau so genutzt und behandelt wie zuvor ''JFrame''. Und das Ergebnis ist ebenfalls gleich.
In ''myProgram'' wird ''MyFrame'' genau ein Argument übergeben: Der String "''My Window''".
Die Anzahl und Art der Argumente muss im Konstruktor von der ''MyFrame''-Klasse auch vorkommen: ''MyFrame(String name)''.
Und damit dieses Argument wiederum auch an das eigentliche ''JFrame'' übergeben wird, steht dort ''super(name)''.

''MyFrame'' ist ein neues Objekt. Ich kann ihm sämtliche Eigenschaften meines Programms geben:
{|
|style="width:30em"|<code=java>import javax.swing.*;
import java.awt.*;

public class MyFrame extends JFrame{

MyFrame() {
super("My Window");
JPanel p = new JPanel();
JButton b1 = new JButton("Button 1");
JButton b2 = new JButton("Button 2");
JButton b3 = new JButton("Button 3");
b1.setBackground(new Color(255,0,0));
b3.setBackground(new Color(255,0,0));
p.add(b1);
p.add(b2);
p.add(b3);
this.add(p);
this.pack();
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setVisible(true);
}

}</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>public class myProgram {

public static void main(String[] args) {
MyFrame f = new MyFrame();
}

}












</code=java>
|}

Somit wird nun nur ''MyFrame'' aufgerufen. In ''MyFrame'' ist alles drin enthalten.
Man muss es wie eine Komponente sehen. Das Programmm sieht zwar beim Ausführen wieder genau gleich aus, aber vom Programmaufbau ist es nun etwas anders. Ich kann z.B. nun ''MyFrame'' als Komponente in andere Programme integrieren. Befehle wie ''JButton'' brauche ich in dem anderen Programm dann nicht zu schreiben.

Die ''main()''-Methode in ''myProgram'' kann man in jede beliebige Klasse schreiben. So kann man sie auch direkt in ''MyFrame'' schreiben:
{|
|style="width:30em"|<code=java>import javax.swing.*;
import java.awt.*;

public class MyFrame extends JFrame{

MyFrame() {
super("My Window");
JPanel p = new JPanel();
JButton b1 = new JButton("Button 1");
JButton b2 = new JButton("Button 2");
JButton b3 = new JButton("Button 3");
b1.setBackground(new Color(255,0,0));
b3.setBackground(new Color(255,0,0));
p.add(b1);
p.add(b2);
p.add(b3);
this.add(p);
this.pack();
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setVisible(true);
}

public static void main(String[] args) {
MyFrame f = new MyFrame();
}

}</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>

























     </code=java>
|}

Das hat den enormen Vorteil, dass man in Java in mehreren Klassen ''main()''-Methoden haben kann.
Man kann dann das Programm entweder von der eigentlichen Klasse aus starten oder aber auch einfach die ''main()''-Methode in einer der Komponenten. In letzterem Fall hat man dann z.B. ein Programm, das nur die eine Komponente ausführt. Somit muss man nicht immer das ganze Programm starten, wenn man nur mal kurz Veränderungen an einer Komponente testen will.

Genauso wie wir nun ''MyFrame'' erstellt haben, können wir auch eine Klasse namens ''RedButton'' erstellen, dessen Aufgabe es ist, einen roten Button zu erstellen:
{|
|style="width:30em"|<code=java>import javax.swing.*;
import java.awt.*;

public class RedButton extends JButton {

RedButton(String name) {
super(name);
this.setBackground(new Color(255,0,0));
}

}









</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>import javax.swing.*;

public class myProgram {

public static void main(String[] args) {
MyFrame f = new MyFrame("My Window");
JPanel p = new JPanel();
RedButton b1 = new RedButton("Button 1");
JButton b2 = new JButton("Button 2");
RedButton b3 = new RedButton("Button 3");
p.add(b1);
p.add(b2);
p.add(b3);
f.add(p);
f.pack();
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.setVisible(true);
}

}</code=java>
|}

An dieser Stelle sieht man auch besser den Sinn der abgeleiteten Klassen. Nun wurden zwei ''JButton''s direkt zu ''RedButton''s. Wenn man bedenkt, dass sämtliche Swing-Komponenten wie ''JButton'' gezeichnet werden, so ist es eine erhebliche Arbeitserleichterung, dass das Programm dahinter nur einmal geschrieben wurde und dann immer wieder genutzt werden kann.

Zu guter Letzt nun auch noch mal die Klasse ''RedButton'' in Kombination mit der Klasse ''MyFrame'':
{|
|style="width:30em"|<code=java>import javax.swing.*;
import java.awt.*;

public class RedButton extends JButton {

RedButton(String name) {
super(name);
this.setBackground(new Color(255,0,0));
}

}














</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>import javax.swing.*;
import java.awt.*;

public class MyFrame extends JFrame{

MyFrame() {
super("My Window");
JPanel p = new JPanel();
RedButton b1 = new RedButton("Button 1");
JButton b2 = new JButton("Button 2");
RedButton b3 = new RedButton("Button 3");
p.add(b1);
p.add(b2);
p.add(b3);
this.add(p);
this.pack();
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setVisible(true);
}

public static void main(String[] args) {
MyFrame f = new MyFrame();
}

}</code=java>
|}

[[Kategorie:Java]]
[[Kategorie:Java Grundlagen]]

Vererbung (Java)

2013-08-13T18:47:10Z

Theuserbl:

Im folgenden wird in anschaulicher Weise die Vererbung in Java, welches ein Teilbereich der Objektorientierung ist, beschrieben.
Alle Programme sehen, wenn man sie ausführt, genau gleich aus und bedienen sich auch gleich. Auch wenn der Quellcode immer wieder etwas anders ist.

Fangen wir mit einem einfachen kleinen Programm an, das ein Fenster öffnet und drei Buttons erstellt. Zwei davon sind rot:

{|
|style="width:30em"|<code=java>





















</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>import javax.swing.*;
import java.awt.*;

public class myProgram {

public static void main(String[] args) {
JFrame f = new JFrame("My Window");
JPanel p = new JPanel();
JButton b1 = new JButton("Button 1");
JButton b2 = new JButton("Button 2");
JButton b3 = new JButton("Button 3");
b1.setBackground(new Color(255,0,0));
b3.setBackground(new Color(255,0,0));
p.add(b1);
p.add(b2);
p.add(b3);
f.add(p);
f.pack();
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.setVisible(true);
}

}</code=java>
|}

Durch "new" wird ein neues Objekt (eine Instanz) erstellt, das eine Kopie des Hauptobjekts ist.

Betrachten wir uns nun ''JFrame''. Man kann in Java eine neue Klasse erstellen (sofern die Klasse, von der sie sich ableitet, nicht "''private''" ist), die sämtliche Eigenschaften der Klasse, von der sie abgeleitet wurde, erbt.

In folgendem Programm habe ich nun eine Klasse ''MyFrame'' erstellt, die mittels ''extends'' von der Klasse ''JFrame'' alle Eigenschaften erbt:
{|
|style="width:30em"|<code=java>import javax.swing.*;

public class MyFrame extends JFrame{
MyFrame(String name) {
super(name);
}
}
















</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>import javax.swing.*;
import java.awt.*;

public class myProgram {

public static void main(String[] args) {
MyFrame f = new MyFrame("My Window");
JPanel p = new JPanel();
JButton b1 = new JButton("Button 1");
JButton b2 = new JButton("Button 2");
JButton b3 = new JButton("Button 3");
b1.setBackground(new Color(255,0,0));
b3.setBackground(new Color(255,0,0));
p.add(b1);
p.add(b2);
p.add(b3);
f.add(p);
f.pack();
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.setVisible(true);
}

}</code=java>
|}

Im Programm ''myProgram'' wird nun ''MyFrame'' auch genau so genutzt und behandelt wie zuvor ''JFrame''. Und das Ergebnis ist ebenfalls gleich.
In ''myProgram'' wird ''MyFrame'' genau ein Argument übergeben: Der String "''My Window''".
Die Anzahl und Art der Argumente muss im Konstruktor von der ''MyFrame''-Klasse auch vorkommen: ''MyFrame(String name)''.
Und damit dieses Argument wiederum auch an das eigentliche ''JFrame'' übergeben wird, steht dort ''super(name)''.

''MyFrame'' ist ein neues Objekt. Ich kann ihm sämtliche Eigenschaften meines Programms geben:
{|
|style="width:30em"|<code=java>import javax.swing.*;
import java.awt.*;

public class MyFrame extends JFrame{

MyFrame() {
super("My Window");
JPanel p = new JPanel();
JButton b1 = new JButton("Button 1");
JButton b2 = new JButton("Button 2");
JButton b3 = new JButton("Button 3");
b1.setBackground(new Color(255,0,0));
b3.setBackground(new Color(255,0,0));
p.add(b1);
p.add(b2);
p.add(b3);
this.add(p);
this.pack();
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setVisible(true);
}

}</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>public class myProgram {

public static void main(String[] args) {
MyFrame f = new MyFrame();
}

}












</code=java>
|}

Somit wird nun nur ''MyFrame'' aufgerufen. In ''MyFrame'' ist alles drin enthalten.
Man muss es wie eine Komponente sehen. Das Programmm sieht zwar beim Ausführen wieder genau gleich aus, aber vom Programmaufbau ist es nun etwas anders. Ich kann z.B. nun ''MyFrame'' als Komponente in andere Programme integrieren. Befehle wie ''JButton'' brauche ich in dem anderen Programm dann nicht zu schreiben.

Die ''main()''-Methode in ''myProgram'' kann man in jede beliebige Klasse schreiben. So kann man sie auch direkt in ''MyFrame'' schreiben:
{|
|style="width:30em"|<code=java>import javax.swing.*;
import java.awt.*;

public class MyFrame extends JFrame{

MyFrame() {
super("My Window");
JPanel p = new JPanel();
JButton b1 = new JButton("Button 1");
JButton b2 = new JButton("Button 2");
JButton b3 = new JButton("Button 3");
b1.setBackground(new Color(255,0,0));
b3.setBackground(new Color(255,0,0));
p.add(b1);
p.add(b2);
p.add(b3);
this.add(p);
this.pack();
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setVisible(true);
}

public static void main(String[] args) {
MyFrame f = new MyFrame();
}

}</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>

























     </code=java>
|}

Das hat den enormen Vorteil, dass man in Java in mehreren Klassen ''main()''-Methoden haben kann.
Man kann dann das Programm entweder von der eigentlichen Klasse aus starten oder aber auch einfach die ''main()''-Methode in einer der Komponenten. In letzterem Fall hat man dann z.B. ein Programm, das nur die eine Komponente ausführt. Somit muss man nicht immer das ganze Programm starten, wenn man nur mal kurz Veränderungen an einer Komponente testen will.

Genauso wie wir nun ''MyFrame'' erstellt haben, können wir auch eine Klasse namens ''RedButton'' erstellen, dessen Aufgabe es ist, einen roten Button zu erstellen:
{|
|style="width:30em"|<code=java>import javax.swing.*;
import java.awt.*;

public class RedButton extends JButton {

RedButton(String name) {
super(name);
this.setBackground(new Color(255,0,0));
}

}









</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>import javax.swing.*;

public class myProgram {

public static void main(String[] args) {
MyFrame f = new MyFrame("My Window");
JPanel p = new JPanel();
RedButton b1 = new RedButton("Button 1");
JButton b2 = new JButton("Button 2");
RedButton b3 = new RedButton("Button 3");
p.add(b1);
p.add(b2);
p.add(b3);
f.add(p);
f.pack();
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.setVisible(true);
}

}</code=java>
|}

An dieser Stelle sieht man auch besser den Sinn der abgeleiteten Klassen. Nun wurden zwei ''JButton''s direkt zu ''RedButton''s. Wenn man bedenkt, dass sämtliche Swing-Komponenten wie ''JButton'' gezeichnet werden, so ist es eine erhebliche Arbeitserleichterung, dass das Programm dahinter nur einmal geschrieben wurde und dann immer wieder genutzt werden kann.

Zu guter Letzt nun auch noch mal die Klasse ''RedButton'' in Kombination mit der Klasse ''MyFrame'':
{|
|style="width:30em"|<code=java>import javax.swing.*;
import java.awt.*;

public class RedButton extends JButton {

RedButton(String name) {
super(name);
this.setBackground(new Color(255,0,0));
}

}













</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>import javax.swing.*;
import java.awt.*;

public class MyFrame extends JFrame{

MyFrame() {
super("My Window");
JPanel p = new JPanel();
RedButton b1 = new RedButton("Button 1");
JButton b2 = new JButton("Button 2");
RedButton b3 = new RedButton("Button 3");
p.add(b1);
p.add(b2);
p.add(b3);
this.add(p);
this.pack();
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setVisible(true);
}

public static void main(String[] args) {
MyFrame f = new MyFrame();
}

}</code=java>
|}

[[Kategorie:Java]]
[[Kategorie:Java Grundlagen]]

Vererbung (Java)

2013-08-13T18:41:53Z

Theuserbl:

Im folgenden wird in anschaulicher Weise die Vererbung in Java, welches ein Teilbereich der Objektorientierung ist, beschrieben.
Alle Programme sehen, wenn man sie ausführt, genau gleich aus und bedienen sich auch gleich. Auch wenn der Quellcode immer wieder etwas anders ist.

Fangen wir mit einem einfachen kleinen Programm an, das ein Fenster öffnet und drei Buttons erstellt. Zwei davon sind rot:

{|
|style="width:30em"|<code=java>





















</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>import javax.swing.*;
import java.awt.*;

public class myProgram {

public static void main(String[] args) {
JFrame f = new JFrame("My Window");
JPanel p = new JPanel();
JButton b1 = new JButton("Button 1");
JButton b2 = new JButton("Button 2");
JButton b3 = new JButton("Button 3");
b1.setBackground(new Color(255,0,0));
b3.setBackground(new Color(255,0,0));
p.add(b1);
p.add(b2);
p.add(b3);
f.add(p);
f.pack();
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.setVisible(true);
}

}</code=java>
|}

Durch "new" wird ein neues Objekt (eine Instanz) erstellt, das eine Kopie des Hauptobjekts ist.

Betrachten wir uns nun ''JFrame''. Man kann in Java eine neue Klasse erstellen (sofern die Klasse, von der sie sich ableitet, nicht "''private''" ist), die sämtliche Eigenschaften der Klasse, von der sie abgeleitet wurde, erbt.

In folgendem Programm habe ich nun eine Klasse ''myFrame'' erstellt, die mittels ''extends'' von der Klasse ''JFrame'' alle Eigenschaften erbt:
{|
|style="width:30em"|<code=java>import javax.swing.*;

public class myFrame extends JFrame{
myFrame(String name) {
super(name);
}
}
















</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>import javax.swing.*;
import java.awt.*;

public class myProgram {

public static void main(String[] args) {
myFrame f = new myFrame("My Window");
JPanel p = new JPanel();
JButton b1 = new JButton("Button 1");
JButton b2 = new JButton("Button 2");
JButton b3 = new JButton("Button 3");
b1.setBackground(new Color(255,0,0));
b3.setBackground(new Color(255,0,0));
p.add(b1);
p.add(b2);
p.add(b3);
f.add(p);
f.pack();
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.setVisible(true);
}

}</code=java>
|}

Im Programm ''myProgram'' wird nun ''myFrame'' auch genau so genutzt und behandelt wie zuvor ''JFrame''. Und das Ergebnis ist ebenfalls gleich.
In ''myProgram'' wird ''myFrame'' genau ein Argument übergeben: Der String "''My Window''".
Die Anzahl und Art der Argumente muss im Konstruktor von der ''myFrame''-Klasse auch vorkommen: ''myFrame(String name)''.
Und damit dieses Argument wiederum auch an das eigentliche ''JFrame'' übergeben wird, steht dort ''super(name)''.

''myFrame'' ist ein neues Objekt. Ich kann ihm sämtliche Eigenschaften meines Programms geben:
{|
|style="width:30em"|<code=java>import javax.swing.*;
import java.awt.*;

public class myFrame extends JFrame{

myFrame() {
super("My Window");
JPanel p = new JPanel();
JButton b1 = new JButton("Button 1");
JButton b2 = new JButton("Button 2");
JButton b3 = new JButton("Button 3");
b1.setBackground(new Color(255,0,0));
b3.setBackground(new Color(255,0,0));
p.add(b1);
p.add(b2);
p.add(b3);
this.add(p);
this.pack();
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setVisible(true);
}

}</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>public class myProgram {

public static void main(String[] args) {
myFrame f = new myFrame();
}

}












</code=java>
|}

Somit wird nun nur ''myFrame'' aufgerufen. In ''myFrame'' ist alles drin enthalten.
Man muss es wie eine Komponente sehen. Das Programmm sieht zwar beim Ausführen wieder genau gleich aus, aber vom Programmaufbau ist es nun etwas anders. Ich kann z.B. nun ''myFrame'' als Komponente in andere Programme integrieren. Befehle wie ''JButton'' brauche ich in dem anderen Programm dann nicht zu schreiben.

Die ''main()''-Methode in ''myProgram'' kann man in jede beliebige Klasse schreiben. So kann man sie auch direkt in ''myFrame'' schreiben:
{|
|style="width:30em"|<code=java>import javax.swing.*;
import java.awt.*;

public class myFrame extends JFrame{

myFrame() {
super("My Window");
JPanel p = new JPanel();
JButton b1 = new JButton("Button 1");
JButton b2 = new JButton("Button 2");
JButton b3 = new JButton("Button 3");
b1.setBackground(new Color(255,0,0));
b3.setBackground(new Color(255,0,0));
p.add(b1);
p.add(b2);
p.add(b3);
this.add(p);
this.pack();
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setVisible(true);
}

public static void main(String[] args) {
myFrame f = new myFrame();
}

}</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>

























     </code=java>
|}

Das hat den enormen Vorteil, dass man in Java in mehreren Klassen ''main()''-Methoden haben kann.
Man kann dann das Programm entweder von der eigentlichen Klasse aus starten oder aber auch einfach die ''main()''-Methode in einer der Komponenten. In letzterem Fall hat man dann z.B. ein Programm, das nur die eine Komponente ausführt. Somit muss man nicht immer das ganze Programm starten, wenn man nur mal kurz Veränderungen an einer Komponente testen will.

Genauso wie wir nun ''myFrame'' erstellt haben, können wir auch eine Klasse namens ''RedButton'' erstellen, dessen Aufgabe es ist, einen roten Button zu erstellen:
{|
|style="width:30em"|<code=java>import javax.swing.*;
import java.awt.*;

public class RedButton extends JButton {

RedButton(String name) {
super(name);
this.setBackground(new Color(255,0,0));
}

}









</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>import javax.swing.*;

public class myProgram {

public static void main(String[] args) {
myFrame f = new myFrame("My Window");
JPanel p = new JPanel();
RedButton b1 = new RedButton("Button 1");
JButton b2 = new JButton("Button 2");
RedButton b3 = new RedButton("Button 3");
p.add(b1);
p.add(b2);
p.add(b3);
f.add(p);
f.pack();
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.setVisible(true);
}

}</code=java>
|}

An dieser Stelle sieht man auch besser den Sinn der abgeleiteten Klassen. Nun wurden zwei ''JButton''s direkt zu ''RedButton''s. Wenn man bedenkt, dass sämtliche Swing-Komponenten wie ''JButton'' gezeichnet werden, so ist es eine erhebliche Arbeitserleichterung, dass das Programm dahinter nur einmal geschrieben wurde und dann immer wieder genutzt werden kann.

Zu guter Letzt nun auch noch mal die Klasse ''RedButton'' in Kombination mit der Klasse ''myFrame'':
{|
|style="width:30em"|<code=java>import javax.swing.*;
import java.awt.*;

public class RedButton extends JButton {

RedButton(String name) {
super(name);
this.setBackground(new Color(255,0,0));
}

}













</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>import javax.swing.*;
import java.awt.*;

public class myFrame extends JFrame{

myFrame() {
super("My Window");
JPanel p = new JPanel();
RedButton b1 = new RedButton("Button 1");
JButton b2 = new JButton("Button 2");
RedButton b3 = new RedButton("Button 3");
p.add(b1);
p.add(b2);
p.add(b3);
this.add(p);
this.pack();
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setVisible(true);
}

public static void main(String[] args) {
myFrame f = new myFrame();
}

}</code=java>
|}

[[Kategorie:Java]]
[[Kategorie:Java Grundlagen]]

Vererbung (Java)

2013-08-13T18:29:52Z

Theuserbl:

Im folgenden wird in anschaulicher Weise die Vererbung in Java, welches ein Teilbereich der Objektorientierung ist, beschrieben.
Alle Programme sehen, wenn man sie ausführt, genau gleich aus und bedienen sich auch gleich. Auch wenn der Quellcode immer wieder etwas anders ist.

Fangen wir mit einem einfachen kleinen Programm an, das ein Fenster öffnet und drei Buttons erstellt. Zwei davon sind rot:

{|
|style="width:30em"|<code=java>




















</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>import javax.swing.*;
import java.awt.*;

public class myProgram {

public static void main(String[] args) {
JFrame f = new JFrame("My Window");
JPanel p = new JPanel();
JButton b1 = new JButton("Button 1");
JButton b2 = new JButton("Button 2");
JButton b3 = new JButton("Button 3");
b1.setBackground(new Color(255,0,0));
b3.setBackground(new Color(255,0,0));
p.add(b1);
p.add(b2);
p.add(b3);
f.add(p);
f.pack();
f.setVisible(true);
}

}</code=java>
|}

Durch "new" wird ein neues Objekt (eine Instanz) erstellt, das eine Kopie des Hauptobjekts ist.

Betrachten wir uns nun ''JFrame''. Man kann in Java eine neue Klasse erstellen (sofern die Klasse, von der sie sich ableitet, nicht "''private''" ist), die sämtliche Eigenschaften der Klasse, von der sie abgeleitet wurde, erbt.

In folgendem Programm habe ich nun eine Klasse ''myFrame'' erstellt, die mittels ''extends'' von der Klasse ''JFrame'' alle Eigenschaften erbt:
{|
|style="width:30em"|<code=java>import javax.swing.*;

public class myFrame extends JFrame{
myFrame(String name) {
super(name);
}
}















</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>import javax.swing.*;
import java.awt.*;

public class myProgram {

public static void main(String[] args) {
myFrame f = new myFrame("My Window");
JPanel p = new JPanel();
JButton b1 = new JButton("Button 1");
JButton b2 = new JButton("Button 2");
JButton b3 = new JButton("Button 3");
b1.setBackground(new Color(255,0,0));
b3.setBackground(new Color(255,0,0));
p.add(b1);
p.add(b2);
p.add(b3);
f.add(p);
f.pack();
f.setVisible(true);
}

}</code=java>
|}

Im Programm ''myProgram'' wird nun ''myFrame'' auch genau so genutzt und behandelt wie zuvor ''JFrame''. Und das Ergebnis ist ebenfalls gleich.
In ''myProgram'' wird ''myFrame'' genau ein Argument übergeben: Der String "''My Window''".
Die Anzahl und Art der Argumente muss im Konstruktor von der ''myFrame''-Klasse auch vorkommen: ''myFrame(String name)''.
Und damit dieses Argument wiederum auch an das eigentliche ''JFrame'' übergeben wird, steht dort ''super(name)''.

''myFrame'' ist ein neues Objekt. Ich kann ihm sämtliche Eigenschaften meines Programms geben:
{|
|style="width:30em"|<code=java>import javax.swing.*;
import java.awt.*;

public class myFrame extends JFrame{

myFrame() {
super("My Window");
JPanel p = new JPanel();
JButton b1 = new JButton("Button 1");
JButton b2 = new JButton("Button 2");
JButton b3 = new JButton("Button 3");
b1.setBackground(new Color(255,0,0));
b3.setBackground(new Color(255,0,0));
p.add(b1);
p.add(b2);
p.add(b3);
this.add(p);
this.pack();
this.setVisible(true);
}

}</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>public class myProgram {

public static void main(String[] args) {
myFrame f = new myFrame();
}

}












</code=java>
|}

Somit wird nun nur ''myFrame'' aufgerufen. In ''myFrame'' ist alles drin enthalten.
Man muss es wie eine Komponente sehen. Das Programmm sieht zwar beim Ausführen wieder genau gleich aus, aber vom Programmaufbau ist es nun etwas anders. Ich kann z.B. nun ''myFrame'' als Komponente in andere Programme integrieren. Befehle wie ''JButton'' brauche ich in dem anderen Programm dann nicht zu schreiben.

Die ''main()''-Methode in ''myProgram'' kann man in jede beliebige Klasse schreiben. So kann man sie auch direkt in ''myFrame'' schreiben:
{|
|style="width:30em"|<code=java>import javax.swing.*;
import java.awt.*;

public class myFrame extends JFrame{

myFrame() {
super("My Window");
JPanel p = new JPanel();
JButton b1 = new JButton("Button 1");
JButton b2 = new JButton("Button 2");
JButton b3 = new JButton("Button 3");
b1.setBackground(new Color(255,0,0));
b3.setBackground(new Color(255,0,0));
p.add(b1);
p.add(b2);
p.add(b3);
this.add(p);
this.pack();
this.setVisible(true);
}

public static void main(String[] args) {
myFrame f = new myFrame();
}

}</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>
























     </code=java>
|}

Das hat den enormen Vorteil, dass man in Java in mehreren Klassen ''main()''-Methoden haben kann.
Man kann dann das Programm entweder von der eigentlichen Klasse aus starten oder aber auch einfach die ''main()''-Methode in einer der Komponenten. In letzterem Fall hat man dann z.B. ein Programm, das nur die eine Komponente ausführt. Somit muss man nicht immer das ganze Programm starten, wenn man nur mal kurz Veränderungen an einer Komponente testen will.

Genauso wie wir nun ''myFrame'' erstellt haben, können wir auch eine Klasse namens ''RedButton'' erstellen, dessen Aufgabe es ist, einen roten Button zu erstellen:
{|
|style="width:30em"|<code=java>import javax.swing.*;
import java.awt.*;

public class RedButton extends JButton {

RedButton(String name) {
super(name);
this.setBackground(new Color(255,0,0));
}

}








</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>import javax.swing.*;

public class myProgram {

public static void main(String[] args) {
myFrame f = new myFrame("My Window");
JPanel p = new JPanel();
RedButton b1 = new RedButton("Button 1");
JButton b2 = new JButton("Button 2");
RedButton b3 = new RedButton("Button 3");
p.add(b1);
p.add(b2);
p.add(b3);
f.add(p);
f.pack();
f.setVisible(true);
}

}</code=java>
|}

An dieser Stelle sieht man auch besser den Sinn der abgeleiteten Klassen. Nun wurden zwei ''JButton''s direkt zu ''RedButton''s. Wenn man bedenkt, dass sämtliche Swing-Komponenten wie ''JButton'' gezeichnet werden, so ist es eine erhebliche Arbeitserleichterung, dass das Programm dahinter nur einmal geschrieben wurde und dann immer wieder genutzt werden kann.

Zu guter Letzt nun auch noch mal die Klasse ''RedButton'' in Kombination mit der Klasse ''myFrame'':
{|
|style="width:30em"|<code=java>import javax.swing.*;
import java.awt.*;

public class RedButton extends JButton {

RedButton(String name) {
super(name);
this.setBackground(new Color(255,0,0));
}

}













</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>import javax.swing.*;
import java.awt.*;

public class myFrame extends JFrame{

myFrame() {
super("My Window");
JPanel p = new JPanel();
RedButton b1 = new RedButton("Button 1");
JButton b2 = new JButton("Button 2");
RedButton b3 = new RedButton("Button 3");
p.add(b1);
p.add(b2);
p.add(b3);
this.add(p);
this.pack();
this.setVisible(true);
}

public static void main(String[] args) {
myFrame f = new myFrame();
}

}</code=java>
|}

[[Kategorie:Java]]
[[Kategorie:Java Grundlagen]]

Vererbung (Java)

2013-08-13T18:18:28Z

Theuserbl:

Im folgenden wird in anschaulicher Weise die Vererbung in Java, welches ein Teilbereich der Objektorientierung ist, beschrieben.
Alle Programme sehen, wenn man sie ausführt, genau gleich aus und bedienen sich auch gleich. Auch wenn der Quellcode immer wieder etwas anders ist.

Fangen wir mit einem einfachen kleinen Programm an, das ein Fenster öffnet und drei Buttons erstellt. Zwei davon sind rot:

{|
|style="width:30em"|<code=java>




















</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>import javax.swing.*;
import java.awt.*;

public class myProgram {

public static void main(String[] args) {
JFrame f = new JFrame("My Window");
JPanel p = new JPanel();
JButton b1 = new JButton("Button 1");
JButton b2 = new JButton("Button 2");
JButton b3 = new JButton("Button 3");
b1.setBackground(new Color(255,0,0));
b3.setBackground(new Color(255,0,0));
p.add(b1);
p.add(b2);
p.add(b3);
f.add(p);
f.pack();
f.setVisible(true);
}

}</code=java>
|}

Durch "new" wird ein neues Objekt (eine Instanz) erstellt, das eine Kopie des Hauptobjekts ist.

Betrachten wir uns nun ''JFrame''. Man kann in Java eine neue Klasse erstellen (sofern die Klasse, von der sie sich ableitet, nicht "''private''" ist), die sämtliche Eigenschaften der Klasse, von der sie abgeleitet wurde, erbt.

In folgendem Programm habe ich nun eine Klasse ''myFrame'' erstellt, die mittels ''extends'' von der Klasse ''JFrame'' alle Eigenschaften erbt:
{|
|style="width:30em"|<code=java>import javax.swing.*;

public class myFrame extends JFrame{
myFrame(String name) {
super(name);
}
}















</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>import javax.swing.*;
import java.awt.*;

public class myProgram {

public static void main(String[] args) {
myFrame f = new myFrame("My Window");
JPanel p = new JPanel();
JButton b1 = new JButton("Button 1");
JButton b2 = new JButton("Button 2");
JButton b3 = new JButton("Button 3");
b1.setBackground(new Color(255,0,0));
b3.setBackground(new Color(255,0,0));
p.add(b1);
p.add(b2);
p.add(b3);
f.add(p);
f.pack();
f.setVisible(true);
}

}</code=java>
|}

Im Programm ''myProgram'' wird nun ''myFrame'' auch genau so genutzt und behandelt wie zuvor ''JFrame''. Und das Ergebnis ist ebenfalls gleich.
In ''myProgram'' wird ''myFrame'' genau ein Argument übergeben: Der String "''My Window''".
Die Anzahl und Art der Argumente muss im Konstruktor von der ''myFrame''-Klasse auch vorkommen: ''myFrame(String name)''.
Und damit dieses Argument wiederum auch an das eigentliche ''JFrame'' übergeben wird, steht dort ''super(name)''.

''myFrame'' ist ein neues Objekt. Ich kann ihm sämtliche Eigenschaften meines Programms geben:
{|
|style="width:30em"|<code=java>import javax.swing.*;
import java.awt.*;

public class myFrame extends JFrame{

myFrame() {
super("My Window");
JPanel p = new JPanel();
JButton b1 = new JButton("Button 1");
JButton b2 = new JButton("Button 2");
JButton b3 = new JButton("Button 3");
b1.setBackground(new Color(255,0,0));
b3.setBackground(new Color(255,0,0));
p.add(b1);
p.add(b2);
p.add(b3);
this.add(p);
this.pack();
this.setVisible(true);
}

}</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>public class myProgram {

public static void main(String[] args) {
myFrame f = new myFrame();
}

}












</code=java>
|}

Somit wird nun nur ''myFrame'' aufgerufen. In ''myFrame'' ist alles drin enthalten.
Man muss es wie eine Komponente sehen. Das Programmm sieht zwar beim Ausführen wieder genau gleich aus, aber vom Programmaufbau ist es nun etwas anders. Ich kann z.B. nun ''myFrame'' als Komponente in andere Programme integrieren. Befehle wie ''JButton'' brauche ich in dem anderen Programm dann nicht zu schreiben.

Die ''main()''-Methode in ''myProgram'' kann man in jede beliebige Klasse schreiben. So kann man sie auch direkt in ''myFrame'' schreiben:
{|
|style="width:30em"|<code=java>import javax.swing.*;
import java.awt.*;

public class myFrame extends JFrame{

myFrame() {
super("My Window");
JPanel p = new JPanel();
JButton b1 = new JButton("Button 1");
JButton b2 = new JButton("Button 2");
JButton b3 = new JButton("Button 3");
b1.setBackground(new Color(255,0,0));
b3.setBackground(new Color(255,0,0));
p.add(b1);
p.add(b2);
p.add(b3);
this.add(p);
this.pack();
this.setVisible(true);
}

public static void main(String[] args) {
myFrame f = new myFrame();
}

}</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>
























     </code=java>
|}

Das hat den enormen Vorteil, dass man in Java in mehreren Klassen ''main()''-Methoden haben kann.
Man kann dann das Programm entweder von der eigentlichen Klasse aus starten oder aber auch einfach die ''main()''-Methode in einer der Komponenten. In letzterem Fall hat man dann z.B. ein Programm, das nur die eine Komponente ausführt. Somit muss man nicht immer das ganze Programm starten, wenn man nur mal kurz Veränderungen an einer Komponente testen will.

Genauso wie wir nun ''myFrame'' erstellt haben, können wir auch eine Klasse namens ''RedButton'' erstellen, dessen Aufgabe es ist, einen roten Button zu erstellen:
{|
|style="width:30em"|<code=java>import javax.swing.*;
import java.awt.*;

public class RedButton extends JButton {

RedButton(String name) {
super(name);
this.setBackground(new Color(255,0,0));
}

}








</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>import javax.swing.*;

public class myProgram {

public static void main(String[] args) {
myFrame f = new myFrame("My Window");
JPanel p = new JPanel();
RedButton b1 = new RedButton("Button 1");
JButton b2 = new JButton("Button 2");
RedButton b3 = new RedButton("Button 3");
p.add(b1);
p.add(b2);
p.add(b3);
f.add(p);
f.pack();
f.setVisible(true);
}

}</code=java>
|}

An dieser Stelle sieht man auch besser den Sinn der abgeleiteten Klassen. Nun wurden zwei ''JButton''s direkt zu ''RedButton''s. Wenn man bedenkt, dass sämtliche Swing-Komponenten wie ''JButton'' gezeichnet werden, so ist es eine erhebliche Arbeitserleichterung, dass das Programm dahinter nur einmal geschrieben wurde und dann immer wieder genutzt werden kann.

Zu guter Letzt nun auch noch mal die Klasse ''RedButton'' in Kombination mit der Klasse ''myFrame'':
{|
|style="width:30em"|<code=java>import javax.swing.*;
import java.awt.*;

public class RedButton extends JButton {

RedButton(String name) {
super(name);
this.setBackground(new Color(255,0,0));
}

}













</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>import javax.swing.*;
import java.awt.*;

public class myFrame extends JFrame{

myFrame() {
super("My Window");
JPanel p = new JPanel();
RedButton b1 = new RedButton("Button 1");
JButton b2 = new JButton("Button 2");
RedButton b3 = new RedButton("Button 3");
p.add(b1);
p.add(b2);
p.add(b3);
this.add(p);
this.pack();
this.setVisible(true);
}

public static void main(String[] args) {
myFrame f = new myFrame();
}

}</code=java>
|}

Vererbung (Java)

2013-08-13T17:35:27Z

Theuserbl:

Programm 1

{|
|style="width:30em"|<code=java>




















</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>import javax.swing.*;
import java.awt.*;

public class myProgram {

public static void main(String[] args) {
JFrame f = new JFrame("My Window");
JPanel p = new JPanel();
JButton b1 = new JButton("Button 1");
JButton b2 = new JButton("Button 2");
JButton b3 = new JButton("Button 3");
b1.setBackground(new Color(255,0,0));
b3.setBackground(new Color(255,0,0));
p.add(b1);
p.add(b2);
p.add(b3);
f.add(p);
f.pack();
f.setVisible(true);
}

}</code=java>
|}

Programm 2

{|
|style="width:30em"|<code=java>import javax.swing.*;

public class myFrame extends JFrame{
myFrame(String name) {
super(name);
}
}















</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>import javax.swing.*;
import java.awt.*;

public class myProgram {

public static void main(String[] args) {
myFrame f = new myFrame("My Window");
JPanel p = new JPanel();
JButton b1 = new JButton("Button 1");
JButton b2 = new JButton("Button 2");
JButton b3 = new JButton("Button 3");
b1.setBackground(new Color(255,0,0));
b3.setBackground(new Color(255,0,0));
p.add(b1);
p.add(b2);
p.add(b3);
f.add(p);
f.pack();
f.setVisible(true);
}

}</code=java>
|}

Programm 3

{|
|style="width:30em"|<code=java>import javax.swing.*;
import java.awt.*;

public class myFrame extends JFrame{

myFrame() {
super("My Window");
JPanel p = new JPanel();
JButton b1 = new JButton("Button 1");
JButton b2 = new JButton("Button 2");
JButton b3 = new JButton("Button 3");
b1.setBackground(new Color(255,0,0));
b3.setBackground(new Color(255,0,0));
p.add(b1);
p.add(b2);
p.add(b3);
this.add(p);
this.pack();
this.setVisible(true);
}

}</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>public class myProgram {

public static void main(String[] args) {
myFrame f = new myFrame();
}

}















</code=java>
|}

Programm 4

{|
|style="width:30em"|<code=java>import javax.swing.*;
import java.awt.*;

public class myFrame extends JFrame{

myFrame() {
super("My Window");
JPanel p = new JPanel();
JButton b1 = new JButton("Button 1");
JButton b2 = new JButton("Button 2");
JButton b3 = new JButton("Button 3");
b1.setBackground(new Color(255,0,0));
b3.setBackground(new Color(255,0,0));
p.add(b1);
p.add(b2);
p.add(b3);
this.add(p);
this.pack();
this.setVisible(true);
}

public static void main(String[] args) {
myFrame f = new myFrame();
}

}</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>
























     </code=java>
|}

Programm 5

{|
|style="width:30em"|<code=java>import javax.swing.*;
import java.awt.*;

public class RedButton extends JButton {

RedButton(String name) {
super(name);
this.setBackground(new Color(255,0,0));
}

}








</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>import javax.swing.*;

public class myProgram {

public static void main(String[] args) {
myFrame f = new myFrame("My Window");
JPanel p = new JPanel();
RedButton b1 = new RedButton("Button 1");
JButton b2 = new JButton("Button 2");
RedButton b3 = new RedButton("Button 3");
p.add(b1);
p.add(b2);
p.add(b3);
f.add(p);
f.pack();
f.setVisible(true);
}

}</code=java>
|}

Programm 6

{|
|style="width:30em"|<code=java>import javax.swing.*;
import java.awt.*;

public class RedButton extends JButton {

RedButton(String name) {
super(name);
this.setBackground(new Color(255,0,0));
}

}













</code=java>
|style="width:1em"|
|style="width:30em"|<code=java>import javax.swing.*;
import java.awt.*;

public class myFrame extends JFrame{

myFrame() {
super("My Window");
JPanel p = new JPanel();
RedButton b1 = new RedButton("Button 1");
JButton b2 = new JButton("Button 2");
RedButton b3 = new RedButton("Button 3");
p.add(b1);
p.add(b2);
p.add(b3);
this.add(p);
this.pack();
this.setVisible(true);
}

public static void main(String[] args) {
myFrame f = new myFrame();
}

}</code=java>
|}

Vererbung (Java)

2013-08-13T17:31:30Z

Theuserbl: Erst mal nur das Grundgerüst meiner alten Beschreibung vom Januar 2010. Nur die Programmcodes sind momentan enthalten.

Programm 1

{|
|style="width:25em"|<code=java>




















</code=java>
|style="width:1em"|
|style="width:25em"|<code=java>import javax.swing.*;
import java.awt.*;

public class myProgram {

public static void main(String[] args) {
JFrame f = new JFrame("My Window");
JPanel p = new JPanel();
JButton b1 = new JButton("Button 1");
JButton b2 = new JButton("Button 2");
JButton b3 = new JButton("Button 3");
b1.setBackground(new Color(255,0,0));
b3.setBackground(new Color(255,0,0));
p.add(b1);
p.add(b2);
p.add(b3);
f.add(p);
f.pack();
f.setVisible(true);
}

}</code=java>
|}

Programm 2

{|
|style="width:25em"|<code=java>import javax.swing.*;

public class myFrame extends JFrame{
myFrame(String name) {
super(name);
}
}















</code=java>
|style="width:1em"|
|style="width:25em"|<code=java>import javax.swing.*;
import java.awt.*;

public class myProgram {

public static void main(String[] args) {
myFrame f = new myFrame("My Window");
JPanel p = new JPanel();
JButton b1 = new JButton("Button 1");
JButton b2 = new JButton("Button 2");
JButton b3 = new JButton("Button 3");
b1.setBackground(new Color(255,0,0));
b3.setBackground(new Color(255,0,0));
p.add(b1);
p.add(b2);
p.add(b3);
f.add(p);
f.pack();
f.setVisible(true);
}

}</code=java>
|}

Programm 3

{|
|style="width:25em"|<code=java>import javax.swing.*;
import java.awt.*;

public class myFrame extends JFrame{

myFrame() {
super("My Window");
JPanel p = new JPanel();
JButton b1 = new JButton("Button 1");
JButton b2 = new JButton("Button 2");
JButton b3 = new JButton("Button 3");
b1.setBackground(new Color(255,0,0));
b3.setBackground(new Color(255,0,0));
p.add(b1);
p.add(b2);
p.add(b3);
this.add(p);
this.pack();
this.setVisible(true);
}

}</code=java>
|style="width:1em"|
|style="width:25em"|<code=java>public class myProgram {

public static void main(String[] args) {
myFrame f = new myFrame();
}

}















</code=java>
|}

Programm 4

{|
|style="width:25em"|<code=java>import javax.swing.*;
import java.awt.*;

public class myFrame extends JFrame{

myFrame() {
super("My Window");
JPanel p = new JPanel();
JButton b1 = new JButton("Button 1");
JButton b2 = new JButton("Button 2");
JButton b3 = new JButton("Button 3");
b1.setBackground(new Color(255,0,0));
b3.setBackground(new Color(255,0,0));
p.add(b1);
p.add(b2);
p.add(b3);
this.add(p);
this.pack();
this.setVisible(true);
}

public static void main(String[] args) {
myFrame f = new myFrame();
}

}</code=java>
|style="width:1em"|
|style="width:25em"|<code=java>
























     </code=java>
|}

Programm 5

{|
|style="width:25em"|<code=java>import javax.swing.*;
import java.awt.*;

public class RedButton extends JButton {

RedButton(String name) {
super(name);
this.setBackground(new Color(255,0,0));
}

}








</code=java>
|style="width:1em"|
|style="width:25em"|<code=java>import javax.swing.*;

public class myProgram {

public static void main(String[] args) {
myFrame f = new myFrame("My Window");
JPanel p = new JPanel();
RedButton b1 = new RedButton("Button 1");
JButton b2 = new JButton("Button 2");
RedButton b3 = new RedButton("Button 3");
p.add(b1);
p.add(b2);
p.add(b3);
f.add(p);
f.pack();
f.setVisible(true);
}

}</code=java>
|}

Programm 6

{|
|style="width:25em"|<code=java>import javax.swing.*;
import java.awt.*;

public class RedButton extends JButton {

RedButton(String name) {
super(name);
this.setBackground(new Color(255,0,0));
}

}













</code=java>
|style="width:1em"|
|style="width:25em"|<code=java>import javax.swing.*;
import java.awt.*;

public class myFrame extends JFrame{

myFrame() {
super("My Window");
JPanel p = new JPanel();
RedButton b1 = new RedButton("Button 1");
JButton b2 = new JButton("Button 2");
RedButton b3 = new RedButton("Button 3");
p.add(b1);
p.add(b2);
p.add(b3);
this.add(p);
this.pack();
this.setVisible(true);
}

public static void main(String[] args) {
myFrame f = new myFrame();
}

}</code=java>
|}