Permalänk
Medlem

[Java]Konstruktorer...

Jo det är såhär att som novis på programmering (Java) så har jag väldigt svårt för att komma in i det ganska användbara "objektorienterade" tänket man behöver. Med massa metoder och konstruktorer.

Så jag undrar ifall någon har något tips eller guide så man kan besegra konstruktorerna och komma in i tänket. För vad jag har förstått så är det inte så svårt därifrån...

Permalänk
Medlem

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!

Permalänk
Citat:

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

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

}

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

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.

Permalänk
Medlem

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!

Permalänk
Medlem

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;
}

?

Permalänk
Medlem
Citat:

Ursprungligen inskrivet av Myris
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

Permalänk
Medlem
Citat:

Ursprungligen inskrivet av Myris
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 "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;

Permalänk
Medlem
Citat:

Ursprungligen inskrivet av Myris
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 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.

Permalänk
Medlem
Citat:

Ursprungligen inskrivet av Garnet
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!

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.

Permalänk
Medlem
Citat:

Ursprungligen inskrivet av Yarrick
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.

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!

Permalänk
Medlem
Citat:

Ursprungligen inskrivet av Yarrick
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.

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?

Permalänk
Medlem
Citat:

Ursprungligen inskrivet av Turbo_tail
Btw: Finns det inget String.Empty i Java? [/B]

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

Permalänk
Medlem
Citat:

Ursprungligen inskrivet av Turbo_tail

Btw: Finns det inget String.Empty i Java?

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

Permalänk
Medlem
Citat:

Ursprungligen inskrivet av Turbo_tail
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...

Btw: Finns det inget String.Empty i Java?

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.

Permalänk
Medlem
Citat:

Ursprungligen inskrivet av conio
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

Ok, ska kanske ha förklarat mig lite.

I .NET finns:

http://windowssdk.msdn.microsoft.com/en-us/library/system.str...

Alltså istället för:

string s = "";

kan man använda sig av

string s = string.Emtpy;

Lite snyggare, men ingen större praktiskt betydelse.