Array

2016-10-12T13:08:21Z

Cronut: mal korrigiert, wie es mir in den Sinn kam

Ein Array ist ein Konstrukt in dem mehrere [[Objekt]]e eines [[Datentyp]]s hintereinander aufgereiht stehen. (Es wird hier immer von Objekten geredet egal ob es in der [[Programmiersprache]] Objekte gibt oder nicht)
Diese Konstrukte werden oft verwendet, wenn man eine große Ansammlung von gleichen Daten eines Objekts hat. Durch die Verwendung von Arrays muss man nicht viele Variablen anlegen und hat so alles übersichtlicher. In den meisten Sprachen haben Arrays jedoch den Nachteil, dass sie statisch sind, d.h. man legt einmal ihre Größe fest und danach kann man diese nicht mehr ändern. Will man mehr Objekte ablegen, muss man ein neues Array anlegen. Daher haben Arrays in diesen Sprachen aber auch einen Vorteil gegenüber den dynamischen Strukturen wie Listen: Da sie eine fest definierte Größe haben kann man sie über einen Index anlegen und darauf zugreifen. Dies ist meistens eine schnellere Möglichkeit, als es bei anderen Strukturen möglich ist.

Für die Erzeugung von Arrays gibt es unterschiedliche Wege, jedoch haben sie meistens gemeinsam, dass eckige Klammern([]) ein Array symbolisieren. So wird in [[C]] und [[C++]] ein Array mit <code>typ name[];</code> deklariert und die Initialisierung kann auf zwei unterschiedliche Wege erfolgen, <code> name = typ[anzahl]</code> oder <code>name = malloc(sizeof(typ)*anzahl)</code>, bzw. <code>name = new typ[anzahl]</code>. Der Unterschied zwischen den beiden Arten ist, dass bei der ersten Möglichkeit der Speicher vom Compiler festgelegt wird und so nicht mehr freigegeben werden muss und bei der zweiten Art zur Laufzeit angelegt wird, welchen man dann auch selbst freigeben muss. Will man in C# oder Java ein Array anlegen, geschieht dies mit <code>typ[] name;</code> und die Initialisierung erfolgt über <code>name = new typ[anzahl]()</code>. In Java ist es auch möglich die Arrays wie in C++ anzulegen.

Bei der Sprache [[C#]] wurde noch ein weiterer Arraytyp eingeführt. Hier sind in jeder Zeile immer gleich viele Objekte, diese werden mit <code>typ[,] name = new typ[anzahl,anzahl]();</code> angelegt. In allen anderen Sprachen lassen sich Arrays auch mit mehreren Dimensionen anlegen, hierzu muss nur ein weiteres Klammerpaar hinzugefügt werden. Diese neuen Arrays in dem bestehenden Array müssen auch nicht gleich initialisiert werden sondern können auch erst später angelegt werden um so besser auf die Gegebenheiten angepasst zu sein. Daher ist es möglich das eine Zeile mal 4 Objekte enhält und eine mal gar keine, dies muss dann im Programm alles gesondert behandelt werden.

Neben der Möglichkeit des Anlegens von leeren Arrays gibt es auch Möglichkeit Arrays gleich mit vorhandenen Daten anzulegen. In den meisten Sprachen ist dies einfach möglich indem man nach der normalen Syntax für die Initialisierung des Arrays gleich in geschweiften Klammern die Objekte durch Kommas getrennt einfügt, z.B. in [[Java]]:
<code=java>
String s = new String[]{"Hallo"," ","Hallo","!!!"};
</code=java>
In einigen Sprachen ist es auch möglich bei der Deklaration der Variablen gleich die Werte zuzuweisen ohne die übliche Initialisierungssyntax, z.B. in Java:
<code=java>
String[] s = {"Hallo"," ","Hallo","!!!"};
</code=java>

[[Kategorie:Programmierung]]
[[Kategorie:Programmierung Grundlagen]]

GPG-Fehler - öffentlicher Schlüssel nicht verfügbar

2016-10-12T12:47:29Z

Cronut: typo korrigiert

=Fehler bei der Installation von Owncloud=

Bei der Installation von Owncloud wurde nach der Aktualisierung der Paketlisten folgender Fehler ausgegeben:
W: GPG-Fehler: http://download.opensuse.org Release: Die folgenden Signaturen konnten nicht überprüft werden, weil ihr öffentlicher Schlüssel nicht verfügbar ist: NO_PUBKEY 977C43A8BA684223
Das heißt, der fehlende Schlüssel muss importiert werden, damit eine Installation gelingen kann:
sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 977C43A8BA684223
Jetzt müssen die Paketquellen aktualisiert werden:
sudo apt-get update
Danach kann nun der Owncloud-Client installiert werden:
sudo apt-get install owncloud-client

==Links==
*[https://software.opensuse.org/download/package?project=isv:ownCloud:desktop&package=owncloud-client Owncloud-Client Installation]
[[Kategorie:Linux]]

Static / non-static (Java)

2016-10-12T12:42:25Z

Cronut: Rechtschreibfehler und Typos korrigiert/entfernt

== 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-objektorientierten 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-objektorientierten 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, muss 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 dasselbe:

{|
|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, dass 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.

{{Fragen stellen}}

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

Byte-Welt Wiki - Benutzerbeiträge [de]

Array

GPG-Fehler - öffentlicher Schlüssel nicht verfügbar

Static / non-static (Java)