Gleich bei der Deklaration?

public class D extends Dialog {
    Button ok  = new Button("OK");
    ...
}

Oder im Konstruktor bzw einer Methode aufgerufen im Konstruktor?

public class D extends Dialog{
    Button ok;
    pulic D(){
       ok = new Button("OK");
    }
}

Hat das einen Einfluß auf die Perfomance? Oder nur eine Frage des Stills? Macht es einen Unterschied wenn der Werte der Variable ein Objekt oder ein Literal ist?

In .net gibt es keinen Unterschied denn der Compiler erstellt den Code so dass Felder mit Standardwert nur im Konstruktor initiert werden.

Dieser Code

class Foo
{
 private string _name = "gfoidl";
 private int _alter;

 public Foo()
 {
  _alter = 27;
 }
}

Der Reflektor zeigt den Konsturktor so an (es kann auch der IL mit MSIL angeschaut werden - gleiches Ergebnis):

public Foo()
{
    this._name = "gfoidl";
    this._alter = 0x1b;
}

Insofern ist es eine geschmacksache.

Ich denke, dass ist eher eine Frage der Verwendung der Variablen.
Wenn du sie, die Variable, nur intern benötigst klar bei der Deklaration.
Willst du die Variable zur Verfügung stellen must du entscheiden ob sie bei der Instanziierung belegt werden muss. Dann natürlich im Konstruktor oder einer Methode die im Konstruktor verarbeitet wird.

Macht es einen Unterschied wenn der Werte der Variable ein Objekt oder ein Literal ist?

Der Wert der Variablen ist ja Typ-gebunden :-)

gfoidl hat für c# schon das Wesentliche gesagt. Der Unterscheid entsteht dann, wenn es mehrere Konstruktoren gibt. Die Initialisierung bei der Deklaration gilt dann für alle Konstruktoren. So kann man, wenn man es mag, die Initialisierung die allen Konstruktoren gemeinsam ist herausziehen.

Wenn man die Membervariable direkt initialisiert, also die erste Schreibweise verwendet,
gilt dies für ALLE Konstruktoren.

Ich halte diesen Weg für sicherer, da auch weitere/neue Konstruktoren davon profitieren.
Und man muß weniger Code schreiben wenn mehrere Konstruktoren vorhanden sind.
Aber meines Wissens geht das nur für Java und C#, aber nicht für C++.

Ich benutze eine - eigentlich überflüssige - Definition
Button ok = null
um anzudeuten, dass im Konstruktur bzw. in den Konstrukturen etwas besonderes passiert.

in Java belege ich Membervariablen normalerweise im Klassenkontext mit null oder eben -1 bei ints/longs vor, um eben zu zeigen (die werden auf jeden Fall noch angefasst)
Die Initalisierung muss dann eben im Konstruktor beziehungsweise in dort aufgerufenen Klassen vorgenommen werden.
Was man natürlich beachten sollte ... wurde glaube ich noch nicht genannt.
"public static final" variablen sollten natürlich nicht erst im Konstruktor vorbelegt werden :)

In ganz seltenen Fällen, wo Werte von Variablen schon VOR dem super()-Aufruf für die Vaterklasse bekannt sein müssen, können diese im static Klassenkontext vorbelegt werden.

Nicht-initialisierte Variablen sind eine haeufige Fehlerquelle.

Die direkte Zuweisung von Attributen findet bereits vor einem Konstruktor-Aufruf statt und stellt somit eine Default-Belegung von Attributen dar. Prinzipiell kann man diese Arbeit auch von Konstruktoren erledigen lassen, dann aber muss sie in jedem Konstruktor erfolgen.

Die Belegung im Konstruktor ist natürlich flexibler, weil sie a) parametrisiert und b) auf checked Exceptions reagieren kann.

Performance spielt jedenfalls keine Rolle.

IMHO ist das Problem nur etwas Ausführlicher zu beantworten:
Ich finde die Initialisierung von Variablen sollte nach Möglichkeit immer an einer Stelle erfolgen und zwar einheitlich an der selben Stelle. Damit wird bereits gesagt, dass die Variablen nicht im sogenannten Konstruktor direkt initialisiert werden können (ich kann ja mehrere davon haben). Direkt bei der Deklaration macht aber unter Umständen Probleme. Zugriff auf Variablen untergeordneter Klassen...
Somit bleibt aus meiner Sicht nur eine einheitliche Methode, die die gesamte Initialisierung der Instanz vornimmt => eine 'protected void initialize ()'.

@sml-ki
> Die direkte Zuweisung von Attributen findet bereits vor einem Konstruktor-Aufruf statt
Ja aber nur die Variablen der eigenen Instanz; nicht jedoch der Abgeleiteten Klassen. Wird dann - zum Beispiel über einen abstrakten Accessor - auf derartige Variablen zugegriffen, dann knallt es...

In Code Commplete (unbeding lesenswert) wird vorgeschlagen vor der ersten Verwendung zu initalisiern. Ansonsten ist natürlich der Konstruktor der "richtige" Platz...

Grundsätzlich im Konstruktor. Bei Objekten, die teuer sind, eventuell lazy initialization über den entsprechenden Getter.