wywoływanie konstruktorów z konstruktorów

[bielen2k]

Idąc dalej tropem Thinking in Java przerabiam przykład z działu
"wywoływanie konstruktorów z konstruktorów":

=================KOD===========================
public class Flower {
int petalCount = 0;
String s = new String("null");
// 1
Flower(int petals){
petalCount = petals;
System.out.println(
"1. Konstruktor tylko z arg int. petalCount= " +
petalCount);
}
// 2 ???????????
Flower(String ss){
System.out.println(
"2. Kontstruktor tylko z arg String, s= " + ss);
s = ss;
}
// 3
Flower(String s, int petals){
this(petals);
this.s = s;
System.out.println("3. Argumenty String i int");
}
// 4
Flower(){
this("hi", 45);
System.out.println(
"4. Konstruktor domyślny (bez argumentów)");
}
// 5
void print(){
System.out.println(
"5. petalCount = " + petalCount + ", s = " + s);
}
public static void main(String[] args){
Flower x = new Flower();
x.print();
}
}
===============================================

============WYNIK================
1. Konstruktor tylko z arg int. petalCount= 45
3. Argumenty String i int
4. Konstruktor domyślny (bez argumentów)
5. petalCount = 45, s = hi
==================================

Czy moglibyście wytłumaczyć mi dlaczego nie jest tutaj wywoływana
metoda nr. 2 ??

Jeżeli w metodzie 4. zmodyfikuję odwołanie na this("hi"); to metoda nr
2 jest wywoływana. Dlaczego obie (1 i 2) nie są wywoływane gdy mamy
this("hi", 45); ?

bielen2k

[Grzegorz Brzeczyszczykiewicz]

A co wywoluje linijka
this(petals)

w konstruktorze nr 3?
Widzisz gdzies analogiczne wywolanie dla konstruktora z par. String?

--
Grzegorz Brzeczyszczykiewicz

[bielen2k]

On 22 Maj, 19:42, Grzegorz Brzeczyszczykiewicz

w książce mam coś w tym stylu (chodzi mi o komentarze)

// 3
Flower(String s, int petals){
this(petals);

//! this(s); // nie mozna wywołać dwóch!
this.s = s; // Inne użycie "this"

System.out.println("3. Argumenty String i int");
}

zatem dwóch wywołać w jednej metodzie nie można, nie do końca rozumiem
zatem tego drugiego zapisu "this.s=s;"

Rafał Bieleniewicz

[Zbyszek Malec]

Dnia Thu, 22 May 2008 11:31:44 -0700 (PDT), bielen2k napisał(a):

> w książce mam coś w tym stylu (chodzi mi o komentarze)
>
> // 3
> Flower(String s, int petals){
> this(petals);
> //! this(s); // nie mozna wywołać dwóch!
> this.s = s; // Inne użycie "this"
> System.out.println("3. Argumenty String i int");
> }
>
>
> zatem dwóch wywołać w jednej metodzie nie można, nie do końca rozumiem
> zatem tego drugiego zapisu "this.s=s;"

Java mówi, że można wywołać jeden konstruktor w innym konstruktorze, ale
tylko jako pierwszą instrukcję tego konstruktora. Innymi słowy nie da się
wywołać dwóch konstruktorów w jednym konstruktorze.

this.s = s;
Tutaj s jest zarówno polem klasy, jak i argumentem przekazywanym do
konstruktora. W takiej sytuacji parametr przesłania pole, więc napis
s = s;
oznaczałby przypisanie parametru do siebie samego. Podobnie:
this.s = this.s;
oznacza przypisanie pola klasy do siebie samego, czyli również bez sensu.
this.s oznacza "pole s z obiektu".

Generalnie przykład przez ciebie podany jest nie za fajny. Lepiej jest jak
konstruktory bardziej konkretne wołają konstruktor bardziej ogólny:

class Flower
{
private int petals;
private String name;

public Flower(int petals, String name)
{
this.petals = petals;
this.name = name;
}

public Flower(int petals)
{
this(petals, "");
}

public Flower(String name)
{
this(0, name);
}
}

W ten sposób nie musisz powtarzać tego samego kodu w każdym konstruktorze z
osobna (taki jest właśnie cel umożliwienia wywołania konstruktora na
poczatku innego konstruktora).

--
Zbyszek Malec Ustronie 104
gg 2756100
jid: zbys...@jid.pl