[Java]Konstruktorer...

Med risk för att skämma ut mig själv skall jag jag försöka förklara detta (obs, ingen HAJP erfarenhet av Java)

Ponera att du har en klass som heter "Person". Nu finns det ju en massa personer så då måste vi kunna skapa massa "Person"-objekt. Jag antar att du vet vad en vektor är. Vi kallar vektorn "massaPersoner[]".

Nu vill vi lägga in några personer i våran vektor. Men för att vi skall kunna GÖRA en person (i java är det enklare än det riktiga livet) så måste vi aropa klassen "Person"s konstruktor, vilket vi gör genom ex.

massaPersoner[0] = new Person("Nils", 14)
massaPersoner[1] = new Person("Kalle", 15)
massaPersoner[2] = new Person("Olle", 43)

Vad händer nu då?

Jo när vi skriver "New Person(argument, argument)" så anropas klassen "Person"s konstruktor. Nu kastade jag in ex en "String" och en "int" som representerar namnet och åldern.

För att jag skall göra det ännu mer tydlig kan jag visa hur den tänkta konstuktorn då ser ut.

class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}

}

Det som står i fet stil är nu konstruktorn som tar emot två argument och sparar ner dem i attributen för att man senare skall kunna använda dem.

EDIT: OJ!

Med viss risk för att skämma ut dig ja
I en konstruktör anger man aldrig returtyp, men bortsett från det så är koden i princip korrekt, tänk även på att deklarera variabler som privata om inga synnerliga skäl för att göra dem publika föreligger.

class Person
{
      private String name;
      private int age;

      public Person(String name, int age)
      {
            this.name = name;
            this.age = age;
      }
}

Principen med en konstruktör är att den ska användas för att instantiera nya objekt av den önskade klassen. Genom att i det här fallet skriva följande:

Person tmpPers = new Person("Sture", 55);

Så instantieras ett objekt av typen Person och referensvariabeln tmpPers pekar på detta objekt.

I konstruktören så sätter man som regel alla parametrar för en given klass, antingen genom att skicka dem som argument när man instantierar objektet, eller så är klassens parametrar fasta.

Ett annat lättfattligt exempel är att skapa en sträng genom att anropa dess konstruktör (något man egentligen inte behöver göra i de flesta fall då just strängar är ett specialfall):

String tmpString = new String("Skapar en sträng via dess konstruktör");

Nu har jag säkert jiddrat en massa utan att komma fram till särskilt mycket men jag hoppas att det är till någon nytta.

och ytterligare en rolig sak med konstruktorer, och alla andra metoder för den delen, är att man kan överlagra (är det rätt ord?) dem. Du kan alltså ha flera konstuktorer i samma klass, men med olika attribut.

Så säg att du i din person klass har som soft0 skrev, en kostruktor som tar parametrarna name och age, men du skulle tex även vilja ange vad personen jobbar med, om den har ett jobb dvs...

så, bygg ut din klass till detta

class Person {
String name;
int age;
String job;

public Person(String name, int age) {
this.name = name;
this.age = age;
}

public Person(String name, int age, String job) {
this.name = name;
this.age = age;
this.job = job;
}
}

Sedär, nu kan vi alltså skapa upp lite personer genom att använda olika konstruktorer tex:

Person kalle = new Person("Kalle", 15) //kalle har inget jobb
Person sven = new Person("Sven, 34, "murare") //sven har ett jobb

Sådär, mycket kul med kontruuktorer. Men som antyddes i början, en konstuktor är som en vanlig metod, bara att den körs automatiskt vid en instansiering av dess klass. Om du vill kan du göra om koden ovan att ha en tom konstruktor och sätta egenskaperna via publika metoder:

class Person {
String name;
in age;
public Person() {
//detta är vår tomma konstrukor, gör inget alls
}

public void setProperties(String name, int age) {
this.name = name;
this.age = age;
}

public void setProperties(String name, int age, String job) {
this.name = name;
this.age = age;
this.job = job;
}
}

Det blir lite omständigare vid instansiering på detta sättet, jag ville bara påpeka att det går, att man inte måste använda konstruktorerna

Person kalle = new Person(); //inga parametrar här inte...
kalle.setProperties("Kalle", 15);
Person sven = new Person();
sven.setProperties("Sven", 34, "murare");

Detta är inte så smidigt men det funkar. Dock så är det väl vanligast att man sätter en massa egenskaper via kontruktorn och sedan modifierar egenskap efter egenskap efter behov i egna publika metoder, typ setName(String name), setAge(int age), setJob(String job) osv osv. Men detta kanske du redan var bekant med, jag skrev bara för att det är så kul att skriva såhär på natten. Godnatt och lycka till!

bara jag som föredrar

public void setProperties(String name, int age) {
m_name = name;
m_age = age;
}

framför

public void setProperties(String name, int age) {
this.name = name;
this.age = age;
}

?

Jag föredrar pepsi framför cola

Jag föredrar "m_" också, om det var det du menade. Överlag är det bra att särskilja på member-variabler och temporära variabler, speciallt då man har längre metoder så ser man direkt vilka variabler som hör till klassen.

Detta kan se väldigt mystiskt ut för en nybörjare :

    this.name = name;

jag själv brukar köra denna teknik...

private String name;
private int age;

public void setProperties(String in_name, in_age) {
name = in_name;
age = in_age;
}

...då har jag koll på vad som är medlemsvariabler och vilka som är inkommande. Jag tog dock efter soft0's ovan för att få enhetlighet, och inte en massa olika kodstilar i tråden.

Ett enklare sätt att ha flera konstruktorer med olika antal argument är att de anropar varandra.
Exempel:

class Person
{
      private String name;
      private Integer age;
      private String job;

      public Persion(String name) {
            this(name, null, null);
      }

      public Person(String name, Integer age) {
            this(name, age, null);
      }

      public Person(String name, Integer age, String job)
      {
            this.name = name;
            this.age = age;
            this.job = job;
      }
}

och så vidare. När man får mycket kod i sin konstruktor så vill man absolut inte ha den på flera ställen. Notera att jag bytt age till Integer så man kan sätta den till null.

class Person
{
      private String name;
      private Integer age;
      private String job;

      public Persion(String name) {
            this(name, null, null);
      }

      public Person(String name, Integer age) {
            this(name, age, null);
      }

      public Person(String name, Integer age, String job)
      {
            this.name = name;
            this.age = age;
            this.job = job;
      }
}

Men se där! Smidigt, hehe det där har jag inte tänkt på. Underlättar ju enormt om man måste ha flera kontruktorer. Behöver man inte sakna optional arguments lika mycket i java längre. Tack för tipset!

class Person
{
      private String name;
      private Integer age;
      private String job;

      public Persion(String name) {
            this(name, null, null);
      }

      public Person(String name, Integer age) {
            this(name, age, null);
      }

      public Person(String name, Integer age, String job)
      {
            this.name = name;
            this.age = age;
            this.job = job;
      }
}

Hmm. Är det en bra idé att sätta värden till null? Om man använder klassen frekvent och i många olika situationer, t.ex. bindar mot UIn, så kommer det nog att resultera i många NullReferenceExceptions! Jag föredrar att explicit sätta (vettiga) värden på variablerna. Att binda en null Integer mot UIt är inget lyckat drag...

Jag skulle dessutom fördra "andra vägen" med konstruktors, men det är bara en smaksak:

class Person
{
      private String name = "";
      private int age = 0;
      private String job = "";

      public Persion(String name) 
      {
            this.name = name;
            
           // Do stuff here 
      }

      public Person(String name, int age) 
      {
            this(name);
            this.age = age;
      }

      public Person(String name, int age)
      {
            this(name, age);
            this.job = job;
      }
}

Btw: Finns det inget String.Empty i Java?

Jag är inte helt säker på vad du menar med String.Empty, men jag gissar. Nej det finns ingen funktion för att tömma innehållet i en sträng. Faktum är att du inte ens kan ändra innehållet i Sträng-klasserna.

Sedan kan man diskutera om man tycker det är en bra eller dålig sak (men jag tycker att det troligtvis är en mycket bra sak).

//C

http://download.java.net/jdk6/docs/api/java/lang/String.html#...()
om du menar så.

Jag brukar använda null för att visa att ett värde inte är satt. Men visst så passar det i många fall med ett speciellt defaultvärde istället, när dessa är "vettiga". Nu hade vi tex egenskapen ålder som inte har något bra defaultvärde. Man kan sätta tex -1 eller sånt om man vill, men då tycker jag null är elegantare.