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 5 Gummi Röd Objekt a instansieras från klassen Boll Klassen Boll Variabler: diameter material färg 10 Plast Blå

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 Boll Variabler: diameter material fä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() { }

v = 3.14159 * diameter * diameter * diameter / 6; } 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 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:

v = 3.14159 * diameter * diameter * diameter / 6 ; return v; } 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();

Standardkonstuktorn Antag 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(); class Boll { ... Boll() { diameter = 10; material"Plast" farg = "Gul"; } // ett javaprogram class SkapaBoll { ... main() new Boll(); ... } new diameter = 10; material ="Plast" farg = "Gul" volym() rulla()

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();

Man kan även skriva ihop satserna, så här: Boll a = new Boll(); // ett javaprogram class SkapaBoll { ... main() new Boll(); ... } class Boll { ... Boll() { diameter = 10; material"Plast" farg = "Gul"; } new a diameter = 10; material ="Plast" farg = "Gul" volym() rulla() 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.

Först deklarerar vi a som en referens till ett Boll-objekt 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 Låt oss ändra den lite: Så här ser rulla-metoden i Boll-klassen ut för närvarande Låt oss ändra den lite: void rulla() { for(int i = 0 ; i < 10 ; i++) System.out.print('O'); } System.out.println(); void rulla( int n ) { for(int i = 0 ; i < n ; i++) System.out.print('O'); } System.out.println(); 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 12 Vid 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. Parametern är deklarerad som heltal …

Ö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.

Boll(int d, String m, String f) // Konstruktor 2 diameter = d; Ö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

Spara och kompilera båda. Kör SkapaBoll. 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: OOOOOOOOOOOOOOOOOOOO Volymen: 523.5983333333334 OOOOO Volymen: 4188.786666666667

Låt oss se på vår konstruktor 2 igen: 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; } 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. Instansvariabeln farg Parametern farg

Objekt som parametrar och returvärden Parametrarnas 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 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 private instans- variabler och metoder