Programmeringsstuga 2 2016-10-26

Innehåll: Arrays Arraylists For loops For-each loops Koppling mellan arrays & arraylists med for- & foreach-loop Klasser Åtkomst Konstruktorer Attribut Metoder Parametrar Returnvärde

Arrays Syntax: Bra: Typ[] variabelNamn = new Typ[int storlek]; Mindre bra: Typ variabelNamn[] = new Typ[int storlek]; Innebär samma sak, men första exemplet ger bättre läsbarhet samt branschstandard Exempel: String[] bracketsEfterTyp = new String[5]; String bracketsEfterNamn[] = new String[5]; Typade: String[] lista = new String[2]; lista[0] = “Test”; // OK lista[1] = true; // Fel Icke typade: Object[] lista = new Object[2]; lista[1] = true; // OK visa typade listor vs icke typade

Arrays Fördelar: Har index Bra ifall det handlar om ett bestämt antal element Nackdelar: Måste veta antalet element i förhand kan inte ändra storlek efter arrayen är initialiserad och ha kvar de värden som finns Visa exempel på String[5] = massa värden, sedan ändra till String[6], vilket tar bort all data som finns

Arrays - Integer public class ArrayDemo { public static void main(String[] args) { int[] array = new int[5]; array[0] = 141; array[1] = 551; array[2] = 61; array[3] = Integer.MIN_VALUE; array[4] = Integer.MAX_VALUE; // Kan också deklareras från början: String[] array2 = new String { 141, 551, 61, Integer.MIN_VALUE, Integer.MAX_VALUE }; System.out.println(array2[0]); // prints “141” } }

Arrays -boolean public class ArrayDemo { public static void main(String[] args) { boolean[] charArray = new boolean[3]; charArray[0] = true; charArray[1] = false; charArray[2] = (charArray[1] == true); //false }

Arrays -character public class ArrayDemo { public static void main(String[] args) { char[] charArray = new char[3]; charArray[0] = ‘a’; charArray[1] = ‘B’; charArray[2] = ‘!’; }

Arrays - Andra public class ArrayDemo { public static void main(String[] args) { double[] multiDimensional; float[] floatArray; long[] longArray; }

Arrays - Jämförelse med parkering public class ArrayDemo { public static void main(String[] args) { }

Arrays - Jämförelse med parkering public class ArrayDemo { public static void main(String[] args) { Bil[] bilarPåParkering = new Bil[10]; }

Arrays - Jämförelse med parkering public class ArrayDemo { public static void main(String[] args) { Bil[] bilarPåParkering = new Bil[10]; bilarPåParkering[0] = new Bil(“blå”); }

Arrays - Jämförelse med parkering public class ArrayDemo { public static void main(String[] args) { Bil[] bilarPåParkering = new Bil[10]; bilarPåParkering[0] = new Bil(“blå”); bilarPåParkering[1] = new Bil(“gul”); }

Arrays - Jämförelse med parkering public class ArrayDemo { public static void main(String[] args) { Bil[] bilarPåParkering = new Bil[10]; bilarPåParkering[0] = new Bil(“blå”); bilarPåParkering[1] = new Bil(“gul”); bilarPåParkering[2] = new Bil(“röd”); }

Arrays - Jämförelse med parkering public class ArrayDemo { public static void main(String[] args) { Bil[] bilarPåParkering = new Bil[10]; bilarPåParkering[0] = new Bil(“blå”); bilarPåParkering[1] = new Bil(“gul”); bilarPåParkering[2] = new Bil(“röd”); bilarPåParkering[4] = new Bil(“gul”); }

Arrays - Jämförelse med parkering public class ArrayDemo { public static void main(String[] args) { Bil[] bilarPåParkering = new Bil[10]; bilarPåParkering[0] = new Bil(“blå”); bilarPåParkering[1] = new Bil(“gul”); bilarPåParkering[2] = new Bil(“röd”); bilarPåParkering[4] = new Bil(“gul”); bilarPåParkering[5] = new Bil(“orange”); }

Arrays - Jämförelse med parkering public class ArrayDemo { public static void main(String[] args) { Bil[] bilarPåParkering = new Bil[10]; bilarPåParkering[0] = new Bil(“blå”); bilarPåParkering[1] = new Bil(“gul”); bilarPåParkering[2] = new Bil(“röd”); bilarPåParkering[4] = new Bil(“gul”); bilarPåParkering[5] = new Bil(“orange”); bilarPåParkering[7] = new Bil(“blå”); }

Arrays - Jämförelse med parkering public class ArrayDemo { public static void main(String[] args) { Bil[] bilarPåParkering = new Bil[10]; bilarPåParkering[0] = new Bil(“blå”); bilarPåParkering[1] = new Bil(“gul”); bilarPåParkering[2] = new Bil(“röd”); bilarPåParkering[4] = new Bil(“gul”); bilarPåParkering[5] = new Bil(“orange”); bilarPåParkering[7] = new Bil(“blå”); bilarPåParkering[8] = new Bil(“grön”); }

Arrays - Jämförelse med parkering public class ArrayDemo { public static void main(String[] args) { Bil[] bilarPåParkering = new Bil[10]; bilarPåParkering[0] = new Bil(“blå”); bilarPåParkering[1] = new Bil(“gul”); bilarPåParkering[2] = new Bil(“röd”); bilarPåParkering[4] = new Bil(“gul”); bilarPåParkering[5] = new Bil(“orange”); bilarPåParkering[7] = new Bil(“blå”); bilarPåParkering[8] = new Bil(“grön”); bilarPåParkering[9] = new Bil(“röd”); }

Arrays - Jämförelse med parkering public class ArrayDemo { public static void main(String[] args) { Bil[] bilarPåParkering = new Bil[10]; bilarPåParkering[0] = new Bil(“blå”); bilarPåParkering[1] = new Bil(“gul”); bilarPåParkering[2] = new Bil(“röd”); bilarPåParkering[4] = new Bil(“gul”); bilarPåParkering[5] = new Bil(“orange”); bilarPåParkering[7] = new Bil(“blå”); bilarPåParkering[8] = new Bil(“grön”); bilarPåParkering[9] = new Bil(“röd”); System.out.println(bilarPåParkering[3]); }

Arrays - Jämförelse med parkering public class ArrayDemo { public static void main(String[] args) { Bil[] bilarPåParkering = new Bil[10]; bilarPåParkering[0] = new Bil(“blå”); bilarPåParkering[1] = new Bil(“gul”); bilarPåParkering[2] = new Bil(“röd”); bilarPåParkering[4] = new Bil(“gul”); bilarPåParkering[5] = new Bil(“orange”); bilarPåParkering[7] = new Bil(“blå”); bilarPåParkering[8] = new Bil(“grön”); bilarPåParkering[9] = new Bil(“röd”); System.out.println(bilarPåParkering[3]); bilarPåParkering[3].toString(); } google stacktrace

Arrays - Multidimensional arrays public class ArrayDemo { public static void main(String[] args) { String[][] multiDimensional = new String[2][3]; // tänk [rader][kolumner] multiDimensional[0][0] = “rad 0, kolumn 0”; multiDimensional[0][1] = “rad 0, kolumn 1”; multiDimensional[0][2] = “rad 0, kolumn 2”; multiDimensional[1][0] = “rad 1, kolumn 0”; multiDimensional[1][1] = “rad 1, kolumn 1”; multiDimensional[1][2] = “rad 1, kolumn 2”; } multiDimensional[0] “rad 0, kolumn 0” “rad 0, kolumn 1” “rad 0, kolumn 2” “rad 1, kolumn 0” “rad 1, kolumn 1” “rad 1, kolumn 2” multiDimensional[1]

ArrayList Syntax: ArrayList<Typ> variabelNamn = new ArrayList<Typ>(); Exempel: ArrayList<String> listOfStrings = new ArrayList<String>(); För typade listor: ArrayList<Typ1> lista = new ArrayList<Typ1>(); lista.add(Typ1); // OK lista.add(Typ2); // Fel För icke typade listor: ArrayList lista = new ArrayList(); lista.add(Typ2); // OK visa typade listor vs icke typade

ArrayList Fördelar: Bra ifall det handlar om ett icke bestämt antal element Listan ökar i storlek automatiskt Uppbackad av Collection = Har många användbara metoder Nackdelar: Saknar förmågan att lägga in element på bestämda index Listan har index, men inte några som vi kan påverka

ArrayList - Metoder ArrayList<String> list = new ArrayList<String>(); Add list.add(“an entry”); Remove list.remove(“an entry”); ELLER String s = “an entry”; list.remove(s);

ArrayList - Metoder från Collection ArrayList<String> list = new ArrayList<String>(); // T.ex.: Collections.sort(list); Collections.frequency(list, “a”); //returnerar hur många gånger “a” finns i list Collections.max(list); //returnerar största värdet i listan (måste vara en lista med numeriska värden) ...och många fler

ArrayList - String import java.util.ArrayList; public class ArraylistDemo { public static void main(String[] args) { ArrayList<String> lista = new ArrayList<String>(); lista.add(“string one”); lista.add(“string two”); lista.add(“string three”); String externalString = “string four”; lista.add(externalString); lista.add(1); // fel, kan endast hålla strings lista.add(“1”); // OK lista.add(1 + “”); // OK } “sträng” och String s = “sträng” är samma sak

ArrayList - Andra import java.util.ArrayList; public class ArraylistDemo { public static void main(String[] args) { ArrayList<Integer> lista = new ArrayList<Integer>(); ArrayList<Double> lista = new ArrayList<Double>(); ArrayList<Float> lista = new ArrayList<Float>(); ArrayList<Character> lista = new ArrayList<Character>(); ArrayList<ArrayList<String>> lista = new ArrayList<ArrayList<String>>(); ArrayList<Object> lista = new ArrayList<Object>(); // kan hålla allt ArrayList lista1 = new ArrayList(); // kan också hålla allt // T.ex.: lista.add(new ArrayList<String>()); lista2.add(new ArrayList<String>()); lista.add(1); lista2.add(1); }

For- och foreach-loopar For-loop: for (nummer; villkor; utförande_vid_varje_iteration) { // Kod som exekveras varje iteration } Exempel: for (int i = 0; i < 11; i++) { System.out.println(i); } Foreach-loop: for (Typ variabelNamn : lista) { // Kod som exekveras varje iteration } Exempel: for (String namn : listaMedNamn) { System.out.println(namn); } For/Foreach går under samma namn “forloopa genom den listan”

For-loop Är detsamma som: int i = 0; int ANTAL_GÅNGER = 3; if (i < ANTAL_GÅNGER) { // Är 0 < 3? true System.out.println(i); i++; } if (i < ANTAL_GÅNGER) { // Är 1 < 3? true System.out.println(i); if (i < ANTAL_GÅNGER) { // Är 2 < 3? true System.out.println(i); if (i < ANTAL_GÅNGER) { // Är 3 < 3? false Skriv ut något X antal gånger: int ANTAL_GÅNGER = 3; for (int i = 0; i < ANTAL_GÅNGER; i++) { System.out.println(i); }

For-loop - Hur fungerar ++? Tankesätt i loopar: i++ använder först variabeln och ökar sedan värdet med ett ++i ökar först värdet med 1, och använder sedan variabeln Exempel: int i = 0; System.out.println(i++); // printar 0 System.out.println(i); // printar 1 System.out.println(++i); // printar 2 System.out.println(i); // printar 2

For-loop - Hur fungerar ++? 1a iterationen: for (int i = 0; i < 4; i++) { // i är nu 0 } // här blir i = 1 2a iterationen: // i är nu 1 } // här blir i = 2 3e iterationen: // i är nu 2 } // här blir i = 3 4e iterationen: // i är nu 4 } // här blir i = 4 5e iterationen: Är i < 4? (Dvs 4 < 4?) - false, loopen slutar Skriven som loop: for (int i = 0; i < 4; i++) { // kod }

For-loop for (int i = 0; i < 4; i++) { System.out.println(i); } Iteration for (int i = 0; i < 4; i++) { System.out.println(i); } // Villkoret i loopen är nu // false och koden fortsätter // på nästa rad System.out.println(“klar”); Output: “0” “1” “2” “3” “klar” 1a 2a 3e 4e For/Foreach går under samma namn “forloopa genom den listan”

Forloopar - Iterera genom en array String[] listaMedNamn = new String[] { “hans”, “peter”, “pelle”, “jöns”, “peter-niklas” }; int längdPåListan = listaMedNamn.length; // 5 For-loop: for (int i = 0; i < listaMedNamn.length; i++) { // detsamma som att skriva i < 5 System.out.println(listaMedNamn[i]); } Foreach: for (String name : listaMedNamn) { System.out.println(name); }

For-loopar - Fördelar/nackdelar Du kan ange hur många gånger du vill ska loopas Du har en variabel som håller reda på vilken iteration du är på Man kan iterera baklänges (reverse): T.ex: for (int i = list.length; i >= 0; i--) Nackdelar: Den tar inte hänsyn till eventuella tomma indexes T.ex. ifall array[5] = null, så loopar den ändå genom indexet

Foreach-loopar - Fördelar/nackdelar Enklare syntax Man slipper ha en extra variabel (int i = 0) Den struntar i tomma indexes - Fel, det gör den visst! Nackdelar: Det går inte att hålla reda på vilken iteration/index man är på Det går inte att iterera baklänges

Loopar - break och continue break avbryter hela loopen Exempel: for (int i = 0; i < 5; i++) { System.out.println(“test”); break; } //Printar endast ut “test” en gång

Loopar - break och continue continue börjar om från början på nästa iteration Exempel: for (int i = 0; i < 5; i++) { System.out.println(“test”); continue; System.out.println(“test2”); // Exception: unreachable statement }

Loopar - tankesätt Iteration: 1 temporärBilVariabel = public class ArrayDemo { public static void main(String[] args) { Bil[] bilarPåParkering = new Bil[10]; bilarPåParkering[0] = new Bil(“blå”); bilarPåParkering[1] = new Bil(“gul”); bilarPåParkering[2] = new Bil(“röd”); bilarPåParkering[4] = new Bil(“gul”); bilarPåParkering[5] = new Bil(“orange”); bilarPåParkering[7] = new Bil(“blå”); bilarPåParkering[8] = new Bil(“grön”); bilarPåParkering[9] = new Bil(“röd”); for (Bil temporärBilVariabel : bilarPåParkering) { System.out.println(temporärBilVariabel); } Iteration: 1 temporärBilVariabel =

Loopar - tankesätt Iteration: 2 temporärBilVariabel = public class ArrayDemo { public static void main(String[] args) { Bil[] bilarPåParkering = new Bil[10]; bilarPåParkering[0] = new Bil(“blå”); bilarPåParkering[1] = new Bil(“gul”); bilarPåParkering[2] = new Bil(“röd”); bilarPåParkering[4] = new Bil(“gul”); bilarPåParkering[5] = new Bil(“orange”); bilarPåParkering[7] = new Bil(“blå”); bilarPåParkering[8] = new Bil(“grön”); bilarPåParkering[9] = new Bil(“röd”); for (Bil temporärBilVariabel : bilarPåParkering) { System.out.println(temporärBilVariabel); } Iteration: 2 temporärBilVariabel =

Loopar - tankesätt Iteration: 3 temporärBilVariabel = public class ArrayDemo { public static void main(String[] args) { Bil[] bilarPåParkering = new Bil[10]; bilarPåParkering[0] = new Bil(“blå”); bilarPåParkering[1] = new Bil(“gul”); bilarPåParkering[2] = new Bil(“röd”); bilarPåParkering[4] = new Bil(“gul”); bilarPåParkering[5] = new Bil(“orange”); bilarPåParkering[7] = new Bil(“blå”); bilarPåParkering[8] = new Bil(“grön”); bilarPåParkering[9] = new Bil(“röd”); for (Bil temporärBilVariabel : bilarPåParkering) { System.out.println(temporärBilVariabel); } Iteration: 3 temporärBilVariabel =

Loopar - tankesätt Iteration: 4 temporärBilVariabel = NULL public class ArrayDemo { public static void main(String[] args) { Bil[] bilarPåParkering = new Bil[10]; bilarPåParkering[0] = new Bil(“blå”); bilarPåParkering[1] = new Bil(“gul”); bilarPåParkering[2] = new Bil(“röd”); bilarPåParkering[4] = new Bil(“gul”); bilarPåParkering[5] = new Bil(“orange”); bilarPåParkering[7] = new Bil(“blå”); bilarPåParkering[8] = new Bil(“grön”); bilarPåParkering[9] = new Bil(“röd”); for (Bil temporärBilVariabel : bilarPåParkering) { System.out.println(temporärBilVariabel); } Iteration: 4 temporärBilVariabel = NULL

Loopar - tankesätt Iteration: 5 temporärBilVariabel = public class ArrayDemo { public static void main(String[] args) { Bil[] bilarPåParkering = new Bil[10]; bilarPåParkering[0] = new Bil(“blå”); bilarPåParkering[1] = new Bil(“gul”); bilarPåParkering[2] = new Bil(“röd”); bilarPåParkering[4] = new Bil(“gul”); bilarPåParkering[5] = new Bil(“orange”); bilarPåParkering[7] = new Bil(“blå”); bilarPåParkering[8] = new Bil(“grön”); bilarPåParkering[9] = new Bil(“röd”); for (Bil temporärBilVariabel : bilarPåParkering) { System.out.println(temporärBilVariabel); } Iteration: 5 temporärBilVariabel =

Loopar - tankesätt Iteration: 6 temporärBilVariabel = public class ArrayDemo { public static void main(String[] args) { Bil[] bilarPåParkering = new Bil[10]; bilarPåParkering[0] = new Bil(“blå”); bilarPåParkering[1] = new Bil(“gul”); bilarPåParkering[2] = new Bil(“röd”); bilarPåParkering[4] = new Bil(“gul”); bilarPåParkering[5] = new Bil(“orange”); bilarPåParkering[7] = new Bil(“blå”); bilarPåParkering[8] = new Bil(“grön”); bilarPåParkering[9] = new Bil(“röd”); for (Bil temporärBilVariabel : bilarPåParkering) { System.out.println(temporärBilVariabel); } Iteration: 6 temporärBilVariabel =

Loopar - tankesätt Iteration: 7 temporärBilVariabel = NULL public class ArrayDemo { public static void main(String[] args) { Bil[] bilarPåParkering = new Bil[10]; bilarPåParkering[0] = new Bil(“blå”); bilarPåParkering[1] = new Bil(“gul”); bilarPåParkering[2] = new Bil(“röd”); bilarPåParkering[4] = new Bil(“gul”); bilarPåParkering[5] = new Bil(“orange”); bilarPåParkering[7] = new Bil(“blå”); bilarPåParkering[8] = new Bil(“grön”); bilarPåParkering[9] = new Bil(“röd”); for (Bil temporärBilVariabel : bilarPåParkering) { System.out.println(temporärBilVariabel); } Iteration: 7 temporärBilVariabel = NULL

Loopar - tankesätt Iteration: 8 temporärBilVariabel = public class ArrayDemo { public static void main(String[] args) { Bil[] bilarPåParkering = new Bil[10]; bilarPåParkering[0] = new Bil(“blå”); bilarPåParkering[1] = new Bil(“gul”); bilarPåParkering[2] = new Bil(“röd”); bilarPåParkering[4] = new Bil(“gul”); bilarPåParkering[5] = new Bil(“orange”); bilarPåParkering[7] = new Bil(“blå”); bilarPåParkering[8] = new Bil(“grön”); bilarPåParkering[9] = new Bil(“röd”); for (Bil temporärBilVariabel : bilarPåParkering) { System.out.println(temporärBilVariabel); } Iteration: 8 temporärBilVariabel =

Loopar - tankesätt Iteration: 9 temporärBilVariabel = public class ArrayDemo { public static void main(String[] args) { Bil[] bilarPåParkering = new Bil[10]; bilarPåParkering[0] = new Bil(“blå”); bilarPåParkering[1] = new Bil(“gul”); bilarPåParkering[2] = new Bil(“röd”); bilarPåParkering[4] = new Bil(“gul”); bilarPåParkering[5] = new Bil(“orange”); bilarPåParkering[7] = new Bil(“blå”); bilarPåParkering[8] = new Bil(“grön”); bilarPåParkering[9] = new Bil(“röd”); for (Bil temporärBilVariabel : bilarPåParkering) { System.out.println(temporärBilVariabel); } Iteration: 9 temporärBilVariabel =

Loopar - tankesätt Iteration: 10 temporärBilVariabel = public class ArrayDemo { public static void main(String[] args) { Bil[] bilarPåParkering = new Bil[10]; bilarPåParkering[0] = new Bil(“blå”); bilarPåParkering[1] = new Bil(“gul”); bilarPåParkering[2] = new Bil(“röd”); bilarPåParkering[4] = new Bil(“gul”); bilarPåParkering[5] = new Bil(“orange”); bilarPåParkering[7] = new Bil(“blå”); bilarPåParkering[8] = new Bil(“grön”); bilarPåParkering[9] = new Bil(“röd”); for (Bil temporärBilVariabel : bilarPåParkering) { System.out.println(temporärBilVariabel); } Iteration: 10 temporärBilVariabel =

Övning - for-loopar T.ex., input “3 5” ger output: “X X X X X Skriv ett program som läser in två tal. Det första talet anger hur många rader som ska skrivas ut. Det andra talet anger hur många kolumner som ska skrivas ut på varje rad. Vilken bokstav ni använder som utskrift bestämmer ni själva (i detta exempel används X). T.ex., input “3 5” ger output: “X X X X X X X X X X X X X X X” Input “1 10” ger output: “X X X X X X X X X X” Input “0 1231231233123” ger output: “” Tips på googlesökningar: “how to use for loop java” “for loop example java” “nested for loops java” T.ex: int rader = 3; int kolumner = 4; for (int i = 0; i < rader; i++) { for (int j = 0; j < kolumner; j++) { }

Lösning - for-loopar Scanner scan = new Scanner(System.in); int rows = scan.nextInt(); int cols = scan.nextInt(); for (int i = 0; i < rows; i++) { for (int j = 0; j < cols; j++) { System.out.print(“x “); } System.out.println();

Övning - array + forloop Skriv ett program som läser in ett tal. Talet anger hur många Strings ni kommer att skriva in härnäst (varje string är separerad från nästa string med ett mellanslag eller en ny rad) De X-antal Strings som ni skriver in ska lagras i en array. (Dvs String[]) Därefter ska listan loopas igenom med hjälp av en foreach-loop, där varje String i listan skrivs ut på en egen rad. Tips på google-sökningar: “string array java” “initialize array java” “scanner java” “for loop java” “foreach loop java” “nextline java skips input” (tips, scan.next() ) Exempel: Input: “3 Namn1 Namn2 Namn3” Output: “Namn1 Exempel: Input: “1 Namn1” Output: “Namn1” Exempel: Input: “0” Output: ingen output

Lösning - array + forloop Scanner scan = new Scanner(System.in); int numberOfEntries = scan.nextInt(); String[] listOfStrings = new String[numberOfEntries]; for (int i = 0; i < numberOfEntries; i++) { listOfStrings[i] = scan.next(); } for (String s : listOfStrings) { System.out.println(s);

Metoder & Klasser Gemensamt för båda är åtkomsten Åtkomsten bestäms av modifierare: De två vanligaste modifierarna (de ni behöver kunna): public = Alla kan komma åt den private = Endast den egna klassen kan komma åt den Andra modifierare: protected default _____________ Klassen, package, subklasser

Metoder Något som en klass kan utföra. Returnerar antingen ett värde som vi sedan kan stoppa in någon annanstans, T.ex.: int, double, String, float, egenskapade klasser Eller så returnerar den ingenting alls (void) Kan ta in parametrar, dvs input till det den ska utföra Kortfattat: returnvärde = output parametrar = input

Metoder Utför allt som finns inom dess måsvingar steg för steg: public int returnOnePlusOne() { int one = 1; // Steg 1 int result = one + one; // Steg 2 // (hoppar över denna rad) return result; // Steg 3 } Det värde som metoden returnerar måste vara av samma typ som typen i metodhuvudet public int returnOnePlusOne() { <-- Metodhuvud int one = 1; int result = one + one; return result;

Metoder Return avbryter metoden public int returnOnePlusOne() { int one = 1; int result = one + one; return result; System.out.println(result); // unreachable code } Metoder avbryts/slutar automatiskt när alla instruktioner är utförda public void calculateOnePlusOneButDontReturn() { int one = 1; // Steg 1 int result = one + one; // Steg 2, och sedan avslutas

Metoder - Skillnad på return och println() System.out.println() printar endast ut det till consolen: public void printStringLength(String inputString) { System.out.println(inputString.length()); } Medan return returnerar värdet så att den kan användas som ett värde: public int returnStringLength(String inputString) { return inputString.length();

Metoder - Använda return-värdet (int exempel) public static void main(String[] args) { printStringLength(“test string”); // Output: “11”; int length = returnStringLength(“test string”); // length-variabeln är nu “11” //length-variabeln kan användas som ett nummer System.out.println(length + 2); // Output: “13” } public void printStringLength(String inputString) { System.out.println(inputString.length()); } public int returnStringLength(String inputString) { return inputString.length(); Tänk att “returnStringLength(“test string”); → byts ut mot 11

Metoder - Använda return-värdet (char exempel) public static void main(String[] args) { printFirstCharacter(“test string”); // Output: “t”; char firstLetter = returnFirstCharacter(“test string”); // firstLetter-variabeln är nu ‘t’ //firstLetter-variabeln kan användas System.out.println(firstLetter); // Output: ‘t’ } public void printFirstCharacter(String inputString) { System.out.println(inputString.charAt(0)); } public char returnFirstCharacter(String inputString) { return inputString.charAt(0);

Metoder - Parametrar (input) Parametrar är input som metoden kan använda En metod kan ha en parameter: public void printFirstCharacter(String inputString) { System.out.println(inputString.charAt(0)); } En metod kan ha flera parametrar: public int addTwoNumbers(int numberOne, int numberTwo) { return numberOne + numberTwo; En metod kan ha noll parametrar: public long returnCurrentTime() { return System.currentTimeMillis();

Metoder - När ska parametrar finnas? Tankesätt: Behöver jag skicka med en input för att metoden ska kunna fungera? Ingen parameter behövs public String getName() { return “Stinky McFly”; } En parameter behövs, då vi ska sätta namnet till något public void setName(String newName) { String name = newName; varför är det String / void på dem?

Metoder - Returnvärde Varför returnerar getName() en String, men setName() returnerar void (dvs ingenting)? public String getName() { return “Stinky McFly”; } public void setName(String newName) { String name = newName; varför är det String / void på dem?

Metoder - Static Statiska metoder kallas för Klassmetoder public static int getTotalHoursPerDay() { return 24; } Icke-statiska metoder kallas för Instansmetoder (dvs metoder som finns i en instans av klassen) public int getAge() { return 23; varför är det String / void på dem?

Metoder - Exempel på static Metoderna ska ligga var för sig, dvs utanför en annan metods måsvingar, men innanför klassens måsvingar public class StaticDemo { public static void main(String[] args) { int totalHours = getTotalHoursPerDay(); System.out.println(totalHours); } public static int getTotalHoursPerDay() { return 24; varför är det String / void på dem?

Metoder - Exempel på static En metod körs inte ifall den inte blir kallad på public class StaticDemo { public static void main(String[] args) { System.out.println(“running main method”); } public static int getTotalHoursPerDay() { // This is never used return 24; varför är det String / void på dem?

Metoder - Exempel på static En metod körs inte ifall den inte blir kallad på public class StaticDemo { public static void main(String[] args) { System.out.println(“running main method”); int totalHours = getTotalHoursPerDay(); } public static int getTotalHoursPerDay() { // This is now used return 24; varför är det String / void på dem?

Klasser En klass är som en ritning/mall för objekt som ska instantieras En klass kan ha attribut, t.ex: int, String, ArrayList, double, char En klass kan ha metoder, t.ex: getName(), setName(String name) Vad innebär “instantieras”? När ett barn föds, så instantieras denne från dess DNA vilket agerar som en ritning för hur barnet ska “byggas” När en maträtt tillagas så instantieras denne från ett recept, ifall receptet har 4 tomater har även varje instans (lagad maträtt) 4 tomater.

Klasser - Attribut När ett barn föds/skapas får den olika attribut, dvs egenskaper, t.ex.: Fingrar Vikt Namn I java kan detta översättas till: public class Barn { private int antalFingrar; private double vikt; // Varför är vikt av typen double? private String namn; }

Klasser - Konstruktor Barnets defualtvärde på dess egenskaper är null , dess egenskaper är således inte initierade: public class Barn { private int antalFingrar; //null private double vikt; //null private String namn; //null } För att instantiera barnet, dvs skapa, används en konstruktor: private int antalFingrar; private double vikt; private String namn; public Barn() { vi har i princip sagt: “ett barn kommer att finnas med dessa egenskaper, men de är inte bestämda ännu”

Klasser - Konstruktor, användning public class TestClass { public static void main(String[] args) { Barn b = new Barn(); // “b” är nu en referens till ett Barn-objekt // som har null på antalFingrar, vikt och namn } public class Barn { private int antalFingrar; //null private double vikt; //null private String namn; //null public Barn() { } hur sätter vi antalFingrar, vikt och namn?

Klasser - Set och get public class Barn { private int antalFingrar; private double vikt; private String namn; public Barn() { // instantierar ett barn med null på alla attribut. } public void setAntalFingrar(int antalFingrar) { this.antalFingrar = antalFingrar; public int getAntalFingrar() { return this.antalFingrar; public void setVikt(double vikt) { this.vikt = vikt; public double getVikt() { return vikt; //Samma klass public void setNamn(String namn) { this.namn = namn; } public String getNamn() { return this.namn; Ordet THIS kan utläsas som “den här klassens…”. Varje gång ni ser “this” så tänk: “den här klassens”

Klasser - Set och get public class Barn { private int antalFingrar; private double vikt; private String namn; public Barn() { // instantierar ett barn med null på alla attribut. } public void setAntalFingrar(int antalFingrar) { this.antalFingrar = antalFingrar; public int getAntalFingrar() { return this.antalFingrar; public void setVikt(double vikt) { this.vikt = vikt; public double getVikt() { return vikt; //Samma klass public void setNamn(String namn) { this.namn = namn; } public String getNamn() { return this.namn; likt en metod så har en konstruktiv INPARAMETRAR

Klasser - Flera konstruktorer public class Barn { private int antalFingrar; private double vikt; private String namn; public Barn() { // instantierar ett barn med null på alla attribut. } public Barn(int antalFingrar, double vikt, String namn) { //Parametrar som en metod this.antalFingrar = antalFingrar; this.vikt = vikt; this.namn = namn; likt en metod så har en konstruktiv INPARAMETRAR

Klasser - Flera konstruktorer, vilken väljs? public class Barn { private int antalFingrar; private double vikt; private String namn; public Barn() { // instantierar ett barn med null på alla attribut. } //Parametrar som en metod public Barn(int antalFingrar, double vikt, String namn) { this.antalFingrar = antalFingrar; this.vikt = vikt; this.namn = namn; //set och get på alla attribut public class ConstructorDemo { public static void main(String[] args) { Barn b = new Barn(); b.setAntalFingrar(5); b.setVikt(3.4); b.setNamn(“Pelle”); System.out.println(b.getAntalFingrar + “ “ + b.getVikt + “ “ + b.getNamn()); // Printar “5 3.4 Pelle” Barn b2 = new Barn(6, 3.1, “Jöns”); System.out.println(b2.getAntalFingrar + “ “ + b.getVikt + “ “ + b.getNamn()); // Printar ut “6 3.1 Jöns” } likt en metod så har en konstruktiv INPARAMETRAR

Klasser - Instansmetoder vs Klassmetoder Set och Get är instansmetoder, då de är beroende av en instans av klassen. main-metoden är en klassmetod, då den inte är beroende av en instans. Main-metoden är således static Vi kan ju inte fråga klassen vad den heter, då det finns många barn som heter olika saker