Klasser och objekt •Klasser, objekt och instansvariabler•Definiera metoder•Konstruktorer•Skapa objekt och anropa metoder•Parametrar•Klassen String•Åtkomst i objekt•Klassvariabler och klassmetoder•Syntax

Klasser, objekt och instansvariabler

• En klass beskriver något. Orden mall, förlaga eller ritning skulle kanske kunna användas i stället.

• Ett objekt är något som skapas utifrån en klass. Objekten kan ses som "avtryck" av klassen.

Ett (ofta använt) exempel: Pepparkaksformen är en klass. Den är en mall för hur pepparkakorna ska se ut.Pepparkakorna är objekt som skapats utifrån mallen.

Klasser, objekt och instansvariabler

När man skapar objekt utifrån en klass säger man ibland att man instansierar objekt.

Egenskaper

En klass beskriver vilka egenskaper objekten kan ha, och vad objekten kan göra.

Vi börjar med egenskaperna.(Vad objekten kan göra definieras i metoder.)

Exempel:

Tänk dig en beskrivning av en boll. Den har en viss storlek, är gjord av ett visst material och har en viss färg.Bollbeskrivningen är klassen, medan bollarna (som tillverkats utifrån denna beskrivning) är objekten.

• Vi ger klassen ett namn – Boll passar väl bra. • Låt oss instansiera två objekt av klassen Boll. Vi kallar

objekten för a respektive b.• Ofta säger vi att vi refererar till objekten med a respektive b

Klassen BollVariabler:

diametermaterialfärg

5GummiRöd

10 PlastBlå

Objekt a instansierasfrån klassen Boll

• Egenskaperna hos ett objekt definieras av variabler.

• Variabler anger hur objekter är, exempelvis hur det ser ut – objektets status säger man ibland.I klassen Boll ovan beskrivs egenskaperna av variablerna diameter, material och farg.

• (Du vet redan att vi inte använder Å, Ä och Ö när vi skriver variabelnamn

• Variablerna har olika värden i de två objekten ovan.

• För objektet a gäller: a.diameter = 5;

a.material="Gummi";

a.farg = "Röd";

• För objektet b gäller: b.diameter = 10;

b.material="Plast";

b.farg = "Blå";

• Man sätter referenserna (i vårt fall a respektive b) (och en punkt) framför variabelnamnet på detta vis, så att man vet att det är just det objektet vi menar.

(Det här skrivsättet, en referens följt av en punkt och sedan variabelnamnet kallas punktnotation)

• Den här typen av variabler, som tillhör ett visst objekt, och som därmed beskriver ett visst objekt, kallas för instansvariabler

Datatyper

• Ni vet att variabler är av olika datatyp.

• Exempel: Variabeln diameter lagrar ett tal (t ex 10) medan exempelvis variabeln farg lagrar en rad bokstäver – en sträng (t ex ”Blå”)

Att skapa klasser i Java• Dags för lite javakod! Om vi vill skapa klassen Boll i

Java börjar vi med att skriva denna kod

class Boll

• Man skriver alltså ordet class följt av klassens namn. Man bruka ha stor bokstav (versal) i början på ett klassnamn.

• Därefter följer två ”klamrar”. Utrymmet mellan klamrarna kallas för ett block. Här skriver man in vilka instansvariabler som ska vara med (samt definierar eventuella metoder…)

{

}

• Jämför ett javaprogram som börjar med ordet class.

• Ett javaprogram är också en klass - men en klass som innehåller en main-metod!

• Klassen Boll är inte ett javaprogram: Det finns ingen main-metod !

• Klassen Boll, så som den beskrivits hittills , skulle se ut så här:

class Boll

• Sen sparas filen med namnet Boll.java • Filens namn ska exakt se ut som klassens namn

följt av tillägget .java Därefter kompileras filen varvid Boll.class skapas.(Koden översatt till datorns språk…)

{ int diameter; String material; String farg;

}

Definiera metoder • Förutom variabler kan en klass också innehålla

metoder.En metod gör något, t ex något skrivs ut, något beräknas, något rör på sig …

• I klassen finns beskrivningar av metoderna, vad de heter och hur de fungerar (metoddefinitioner)

• Instansvariablerna beskriver hur ett objekt är (status).

• Metoderna anger vad ett objekt gör (beteende)

Vi ska förse vår Boll-klass med några metoder.• en metod, volym, som beräknar bollens volym• en metod, rullar, som på skärmen visar hur bollen rullat

10 varv (Tecknet 'O' ska visas en gång för varje varv bollen rullat)

Klassen BollVariabler:

diametermaterialfärg

Metoder:volym ( ){ beräkna volym}

rullar ( ){ visa hur bollen rullat 10 varv}

• Namngivning av metoder följer samma regler som namngivning av variabler. Ett metodnamn brukar ha en gemen (liten bokstav) som första tecken.

• Vi börjar med att definiera metoden volym. Först skrivs stommen:

• Direkt efter metodnamnet, volym, ska det stå två vanliga parenteser.Sen kommer ett block, där man skriver den kod som beskriver vad metoden ska göra.

• volym(){}

Vi deklarerar en lokal double-variabel, v, inne i metoden och beräknar volymen:

Från matematiken minns du formeln för klotets volym

V= (PI* d*d*d)/6

volym()

{

double v;

v = 3.14159 * diameter * diameter * diameter / 6;

}

• Med en lokal variabel menas en variabel som deklareras inne i en metod.En sådan variabel är giltig (har räckvidd) endast i metodblocket.

Jämför instansvariabler. Dessa är ju inte deklarerade inne i en metod. Dessa har räckvidd inom hela klassen, även inne i metoderna alltså…

• Vår volym-metod ska beräkna ett värde,och lämna ifrån sig värdet (returnera värdet)

• Två saker måste då läggas till:

• Sist i blocket skriver vi satsen return v; Därmed anger vi att det är värdet på v som metoden ska leverera.

• Dessutom måste vi skriva datatypen på det returnerade värdet, i detta fall double , framför metodnamnet.

• Så här:

double volym(){

double v;v = 3.14159 * diameter * diameter * diameter / 6 ;return v;

}

• Så till rulla-metoden. Så här kan den se ut:void rulla(){ for(int i = 0 ; i < 10 ; i++) {

System.out.print('O'); } System.out.println();

}

• Den här metoden ska ju inte returnera något värde. Den ska bara skriva ut lite på skärmen.

• Därför står det inte return i slutet av blocket och det står inte någon datatyp framför metodnamnet.

• I stället står där ordet void som just betyder att det är en metod som inte returnerar något värde.

Konstruktorer Så här ser vår klass Boll ut med instansvariabler och metoder

class Boll{ int diameter; String material; String farg; double volym() {

double v; v = 3.14159 * diameter * diameter * diameter / 6; return v;

} void rulla() {

for(int i = 0 ; i < 10 ; i++) {

System.out.print('O'); } System.out.println();

}}

• Det är snart dags att börja använda klassen, det vill säga instansiera objekt från den.

• Först måste vi dock bekanta oss med ännu ett begrepp, nämligen konstruktorer.

• En konstruktor är en metod som aktiveras (anropas) då ett objekt ur klassen skapas.

• I konstruktorn sätter man initialvärden för det objekt som skapas.Så här kan en konstruktor för klassen Boll se ut:Boll(){ diameter = 10; material = "Plast"; farg = "Gul";}• Att skriva en konstruktor påminner mycket om att skriva en vanlig

metod, men:• En konstruktor ska alltid ha samma namn som klassen ( här Boll )• Konstruktornamnet föregås inte av ordet void eller av någon

datatyp

"kompletta" variant av klassen Boll med konstruktor och allt class Boll{ // Instansvariabler int diameter; String material; String farg; // Konstruktor Boll() { diameter = 10; material = "Plast"; farg = "Gul"; } // Metoder double volym() // denna metod returnerar bollens volym {

double v; v = 3.14159 * diameter * diameter * diameter / 6; return v;

} void rulla() // denna metod visar bollens "väg" {

for(int i = 0 ; i < 10 ; i++) {

System.out.print('O'); } System.out.println(); }}

• StandardkonstuktornAntag att vår konstruktor hade sett ut så här - med ett tomt

block, utan några satser:Boll() { }• Denna konstuktor skapar ett bollobjekt, men inga värden

sätts. (I vårt fall skulle t ex bollens diameter bli 0 ) En sådan ”tom” konstruktor behöver man inte skriva in i

koden (om man inte vill)• Varje klass blir nämligen automatiskt försedd med en

sådan här, "tom" standardkonstruktor, utan parametrar och utan några satser i blocket. Observera dock att så fort man skriver en egen konstruktor upphör standardkonstruktorn att gälla. Då gäller endast den eller de konstuktorer som man själv kodat in.

• När du i fortsättningen träffar på en klass som (till synes) saknar konstruktor, så ska du tänka dig att denna "tomma" konstruktor existerar

Skapa objekt och anropa metoder Nu har vi vår klass Boll.class

Antag att vi också har ett javaprogram, en klass med en main-metod. Vi kallar den klassen SkapaBoll

Ett Boll -objekt instansieras från javaprogrammet med satsen

new Boll();

// ett javaprogramclass SkapaBoll{

... main(){

new Boll(); ...

}}

class Boll{

... Boll(){ diameter = 10; material"Plast" farg = "Gul";

}...

}

diameter = 10;material ="Plast"farg = "Gul"volym()rulla()

new

• Vad som händer är att konstruktorn, Boll(), i klassen Boll anropas.• Då skapas ett Boll-objekt med de egenskaper som konstruktorn

beskriver ( diam = 10, Plast, Gul )

Den här instansieringen är dock inte så lyckad. Vi har ingen referens till vårt objekt! Då kan vi inte komma åt objektets metoder och variabler.

Så här gör vi i stället:

Boll a;

a = new Boll();

Först deklareras a som en referens till ett objekt av Boll-typ (helt i analogi med hur vi deklarerar variabler…) Sedan skapar vi objektet med a = new Boll();

// ett javaprogramclass SkapaBoll{

... main(){

new Boll(); ...

}}

class Boll{

... Boll(){ diameter = 10; material"Plast" farg = "Gul";

}...

}

diameter = 10;material ="Plast"farg = "Gul"volym()rulla()

new

a

Man kan även skriva ihop satserna, så här: Boll a = new Boll();Glöm inte parenteserna efter Boll()

Nu har vi en referens till objektet och kan "komma åt" dess

instansvariabler och metoder.

Skriv av koden nedan. Spara filen i mappen Boll med namnet SkapaBoll.java

Kompilera och kör!

class SkapaBoll

{

public static void main( String args[] )

{

Boll a;

a = new Boll();

a.rulla();

System.out.println( "Volymen: " + a.volym() );

}

}

•Först deklarerar vi a som en referens till ett Boll-objekt•Sedan skapar vi ett Boll-objekt med a som referens•Därefter anropas Boll-objektets rulla-metod varvid bollens väg visas som 10 stycken 'O' -tecken.•Slutligen skrivs det värde som Boll-objektets volym-metod returnerar

Så här blir resultatet vid exekvering:

OOOOOOOOOO

Volymen: 523.5983333333334

• Anrop av en void-metod sker alltså helt enkelt genom att man skriver

referensen till det aktuella objektet, en punkt och metodens namn följt av parenteser (punktnotation). a.rulla();

Om det är en metod som lämnar ett värde måste detta värde "tas om hand":

Värdet kan skrivas ut eller tilldelas en variabel eller ingå i en beräkning. Exempel:

System.out.println( a.volym() );

v = a.volym();

dubbelvolym = a.volym() * 2;

Att anropa metoder i egna klassen

Antag att man i en klass har en metod, internMetod, där något utförs.

Antag vidare att man i samma klass vill anropa internMetod.

Ett sådan anrop sker med

this.internMetod();

Objektet använder ju sin egen metod och därför skrivs ordet this i stället för objektreferensen.

Anmärkning:

Ordet this kan utelämnas.

(Kompilatorn uppfattar det som det i alla fall står this där)

Sammanfattning: Skapa objekt

Antag att klassen MinKlass.class existerar.

Ett javaprogram instansierar ett MinKlass -objekt med satsen

new MinKlass ();

Med satserna MinKlass a;

a = new MinKlass ();

skapas ett nytt objekt som vi kan referera till med a

Man kan även skriva ihop satserna, så här:

MinKlass a = new MinKlass ();

Om objektet a har metoden minMetod anropas metoden från en annan klass med

a.minMetod ();

Om man vill anropa en metod som är definierad i den egna klassen sker anropet så här:

this.internMetod ();

Eller internMetod

Parametrar Så här ser rulla-metoden i Boll-klassen

ut för närvarande void rulla() {

for(int i = 0 ; i < 10 ; i++) {

System.out.print('O'); } System.out.println();

}

Låt oss ändra den lite:

void rulla( int n ) {

for(int i = 0 ; i < n ; i++) {

System.out.print('O'); } System.out.println();

}

Parametern är deklarerad som heltal …

Vi har här försett metoden med en parameter, som vi har gett namnet n Med en parameter kan man styra vad metoden ska göra.

Anropet kan nu vara (t. ex.) a.rulla(12);

Det som skrivs inom parenteserna vid anropet kallas argument. Här är alltså argumenet heltalet 12Vid anropet överförs argumentets värde till parametern. Då metoden körs ersätts n av talet 12. Vår metod kommer att rita 12 stycken 'O'-tecken.

• Övning: Parameter• I Boll-klassen, i metoden rulla : Lägg in en parameter, n, • I SkapaBoll-klassen: Ändra så att rulla anropas med (t ex)

a.rulla(18);• Spara och kompilera båda. Kör SkapaBoll

• En metod kan ha mer än en parametrar och dessa kan vara av olika typ

• Exempel: void minMetod( int x, int y, String s, char c ){...kod...}

• Naturligtvis kan en icke-void-metod (som returnerar ett värde) också anropas med en (eller flera) parametrar.

• Exempel: double triangelarea( double b, double h ) { return b * h / 2; }

• Vidare kan man i samma klass ha två eller fler metoder med samma namn men med olika antal och/eller olika typ av parametrar. Dessa är då att betrakta som helt olika metoder.

• Exempel: minMetod( int x ) { … }• Detta är två helt olika metoder minMetod(int x,

char c ) { … }•• Metoder med samma namn, men med olika antal/typ av parametrar

kallas för överlagrade metoder.

• Övning: Konstruktorer med parametrar

• Skriv in ytterligare en konstruktor i klassen Boll

class Boll{ ... Boll() // Konstruktor 1 { diameter = 10; material = "Plast"; farg = "Gul"; } Boll(int d, String m, String f) // Konstruktor 2 { diameter = d; material = m; farg = f; } . . . osv

Nu kan ett nytt Boll-objekt instansieras - denna gång med argument!

Lägg till satser i SkapaBoll som skapar ännu ett Boll-objekt, med referensen b. Så här:class SkapaBoll{

public static void main( String args[] ){ Boll a , b; a = new Boll(); b = new Boll(20, "Gummi", "Svart"); a.rulla(20); System.out.println( "Volymen: " + a.volym() ); b.rulla(5); System.out.println( "Volymen: " + b.volym() );

}}

Spara och kompilera båda. Kör SkapaBoll.

Två objekt skapas:a skapas med en konstruktor som alltid ger

instansvariablerna värdena 10, "Plast", "Gul" b skapas med vår nya konstruktor. Instansvariablerna får

de värden som getts som argument.Metoderna rulla och volym anropas för båda objekten.

Så här blir resultatet:OOOOOOOOOOOOOOOOOOOOVolymen: 523.5983333333334OOOOOVolymen: 4188.786666666667

Namn på parametrar

Låt oss se på vår konstruktor 2 igen:

Boll(int d, String m, String f) // Konstruktor 2{ diameter = d; material = m; farg = f;}

Du kanske tycker att det vore praktiskt att ha samma namn på parametrarna som instansvariablerna.Det kan man ha, men då måste du skriva så här

Boll(int diameter, String material, String farg) // Konstruktor 2{ this.diameter = diameter; this.material = material; this.farg = farg;}

Parametern farg

Instansvariabeln farg

En sats som farg = farg; är ju meningslös.Satsen this.farg = farg; betyder att instansvariabeln farg som tillhör denna (this) klass tilldelas det värde som parametern farg har.

Objekt som parametrar och returvärdenParametrarnas datatyp, int, double, char, String . . . (det finns fler) anges vid

definitionen.

Då metoden anropas måste förstås argumenten vara av motsvarande datatyp.

Vi kommer längre fram att träffa på metoder där parametern deklarerats som en referens till ett objekt tillhörande viss klass. Så här t ex:

void minMetod( Boll b ) { ... }

Vid anrop av en sådan metod är argumentet förstås en referens till ett objekt ur en sådan klass.

Om a är en referens till Boll kan vi göra anropet:

minMetod( a );

Det värde som returneras från en icke-void-metod är av en viss datatyp (int, double, char, String . . .)

Det finns också metoder som returnerar objekt av en viss klass…

private Variabel eller metod endast åtkomlig inom objektet (räckvidd inom objektet)

public Variabel, metod eller klass åtkomlig från andra klasser

<ingen modifierare> Variabel, metod eller klass åtkomlig från andra klasser i samma mapp

Varje objekt ska vara "slutet" med avseende på instansvariabler och interna metoder (inkapsling)

Dessa deklareras som private

All kommunikation med ett objekt sker via metoder som är åtkomliga för andra klasser, det vill säga deklarerade med modifieraren public eller utan modifierare (om klasserna ligger i samma mapp)

public-metoder

privateinstans-variabler ochmetoder