🚀 go-pugleaf

P wrote:
> * Binnen een /static/ methode kan je enkel andere /static/ methoden e.d.
> oproepen.  Maar als je een progje wilt executen, dan moet je toch de
> /static/ methode /main/ gebruiken?  Hetgeen uiteindelijk toch betekent
> dat ALLE methoden die je schrijft /static/ moeten zijn?  Wat klopt er
> niet in mijn redenering?

Dat Java een (bijna volledige) objectgeori�nteerde programmeertaal is. Het
idee is dat U (zelf geschreven) klassen instanti�erd, waarvan de methoden
natuurlijk niet static hoeven te zijn.

Voor een erg klein programma waarbij U enkel een enkele (hoofd) klasse
definieert, volstaat het aanmaken van een object van die hoofdklasse, de
niet static methoden kunt U dan aanroepen.

Voorbeeld:

public class Test {
  private int fieldOne;
  ...
  private String fieldN;

  public void Test() {
    construeer hier iets.
  }
 
  public int methode() {
    doe iets.
  }

  public static void main( String[] args ) {
    Test t = new Test();
    t.methode();
    ... 
  }
}

 
> * Ik snap het gebruik van /this/ niet helemaal.

Dat is een verwijzing naar de klasse waarin dat `this' staat, leuk voor
variabelen scheiding (this.field vs field).

> public class Person
> {
>      private String name ;
>      private int age ;
> 
>      public Person(String naam, int lftd)
>      {
>          name = naam;
>          age = lftd;
>      }
> 
>      public Person(String naam)
>      {
>          this(naam,0); // ****
>      }
> }
> 
> 
> Op die regel met **** erachter: waarom kan ik hier niet " Person(naam,
> 0) " gebruiken?

Omdat de compiler van Java anders niet kan bepalen welke Person U bedoelt,
in de lokale context is de naam van de methode Person, daarnaast is er nog
in de context van de klasse een methode Person ( twee zelfs). Kortom, een
conflict dat U voor de compiler op moet lossen. In dit geval met this.

-- 
Djatha

Djatha schreef:
> P wrote:
> 
>>* Binnen een /static/ methode kan je enkel andere /static/ methoden e.d.
>>oproepen.  Maar als je een progje wilt executen, dan moet je toch de
>>/static/ methode /main/ gebruiken?  Hetgeen uiteindelijk toch betekent
>>dat ALLE methoden die je schrijft /static/ moeten zijn?  Wat klopt er
>>niet in mijn redenering?
> 
> 
> Dat Java een (bijna volledige) objectgeori�nteerde programmeertaal is. Het
> idee is dat U (zelf geschreven) klassen instanti�erd, waarvan de methoden
> natuurlijk niet static hoeven te zijn.
> 
> Voor een erg klein programma waarbij U enkel een enkele (hoofd) klasse
> definieert, volstaat het aanmaken van een object van die hoofdklasse, de
> niet static methoden kunt U dan aanroepen.

Begrijp ik het goed dat het dus volstaat binnen die statische 
main-methode een object aan te maken waarop ik dan vervolgens 
niet-statische methoden kan toepassen?


>>* Ik snap het gebruik van /this/ niet helemaal.
> 
> 
> Dat is een verwijzing naar de klasse waarin dat `this' staat, leuk voor
> variabelen scheiding (this.field vs field).

Dit gebruik van /this/ heb ik volledig door, ik snapte echter niet 
vanwaar het probleem hieronder komt...

> 
>>public class Person
>>{
>>     private String name ;
>>     private int age ;
>>
>>     public Person(String naam, int lftd)
>>     {
>>         name = naam;
>>         age = lftd;
>>     }
>>
>>     public Person(String naam)
>>     {
>>         this(naam,0); // ****
>>     }
>>}
>>
>>
>>Op die regel met **** erachter: waarom kan ik hier niet " Person(naam,
>>0) " gebruiken?
> 
> 
> Omdat de compiler van Java anders niet kan bepalen welke Person U bedoelt,
> in de lokale context is de naam van de methode Person, daarnaast is er nog
> in de context van de klasse een methode Person ( twee zelfs). Kortom, een
> conflict dat U voor de compiler op moet lossen. In dit geval met this.

Door het systeem van 'overloading' en het gebruik van andere argumenten, 
zou ik toch denken dat de compiler daaraan uit zou moeten kunnen.  Ik 
heb niet helemaal door wat u hier bedoelt met het verschil tussen de 
lokale en de klasse-context.  wanneer ik op de regel met **** de methode 
Person(naam, 0) wil oproepen, gaat hij dan niet binnen de klasse zoeken 
naar waar die methode staat en hoe die werkt?  Indien ik hier 
bijvoorbeeld doThis(naam, 0) zou oproepen ipv Person(naam, 0) , dan 
heeft hij daar toch ook geen probleem mee?  Dan gaat hij toch binnen de 
klasse zoeken naar waar die methode doThis(String naam, int lftd) wordt 
beschreven en die op die manier toepassen?   Waar zit ik fout in mijn 
hele redenering?

Thx

> 

"P" <de_polle_KEEP_SPAM_AWAY@kotnet.org> wrote in message
news:1098887972.901356@seven.kulnet.kuleuven.ac.be...
> Djatha schreef:
> > P wrote:
> >
> >>* Binnen een /static/ methode kan je enkel andere /static/ methoden e.d.
> >>oproepen.  Maar als je een progje wilt executen, dan moet je toch de
> >>/static/ methode /main/ gebruiken?  Hetgeen uiteindelijk toch betekent
> >>dat ALLE methoden die je schrijft /static/ moeten zijn?  Wat klopt er
> >>niet in mijn redenering?
> >
<knip>

> Begrijp ik het goed dat het dus volstaat binnen die statische
> main-methode een object aan te maken waarop ik dan vervolgens
> niet-statische methoden kan toepassen?
>
Je kan geen methodes toepassen op een object. Je kan aan een object vragen
om methodes uit te voeren. Static methodes werken op het klasse niveau, je
hoeft dus geen object te hebben om een static methode op te roepen.  Als je
een object creert (via de static constructor) kan je op dat object niet
statische methodes oproepen. Dus:
static          ->    klasse niveau
niet static    ->    object niveau

je dient je er altijd  van bewust te zijn op welk niveau je werkt. En van
het ene niveau naar het andere ga je over door een object aan te maken en
daar methods op op te roepen (van klasse naar object) of door een klasse
naam te specifieren en daar methods op te roepen (van object naar klasse)


>
> >>* Ik snap het gebruik van /this/ niet helemaal.
> >
<knip>
> >
> >>public class Person
> >>{
> >>     private String name ;
> >>     private int age ;
> >>
> >>     public Person(String naam, int lftd)
> >>     {
> >>         name = naam;
> >>         age = lftd;
> >>     }
> >>
> >>     public Person(String naam)
> >>     {
> >>         this(naam,0); // ****
> >>     }
> >>}
> >>
> >>
<knip>

> Door het systeem van 'overloading' en het gebruik van andere argumenten,
> zou ik toch denken dat de compiler daaraan uit zou moeten kunnen.  Ik
> heb niet helemaal door wat u hier bedoelt met het verschil tussen de
> lokale en de klasse-context.  wanneer ik op de regel met **** de methode
> Person(naam, 0) wil oproepen, gaat hij dan niet binnen de klasse zoeken
> naar waar die methode staat en hoe die werkt?
je hebt 100 % gelijk.

   Indien ik hier
> bijvoorbeeld doThis(naam, 0) zou oproepen ipv Person(naam, 0) , dan
> heeft hij daar toch ook geen probleem mee?  Dan gaat hij toch binnen de
> klasse zoeken naar waar die methode doThis(String naam, int lftd) wordt
> beschreven en die op die manier toepassen?   Waar zit ik fout in mijn
> hele redenering?

constructoren zijn geen gewone static methods. je kan ze niet zomaar
oproepen, je gebruikt de speciale constructie new Person("iets") om je
object aan te maken en niet gewoon Person("iets"). Dat in tegenstelling tot
Person.doThis(naam,0) dat je wel degelijk kan oproepen maar dat nooit een
nieuw object zal aanmaken. Dus constructors zijn niet gelijk aan static
methods. Nu hadden de ontwerpers van Java indertijd vermoedelijk ook kunnen
kiezen voor jouw voorstel: Person(naam, 0) ipv this(naam,0).
maar ze hebben het andere gekozen.

gC