Programmering 2 Flashcards

Question

Hvordan fungerer dette? Person person = new Snekker()? Hva er objekt polymorfi? Hva er instanceof? Hvordan vil dette se ut med objekt-polymorfi? Hvordan kan en foreldreklasse få tilgang til banreklassers metoder?

Answer 1

Dette funker fordi java anser Snekker som også en del av Person-klassen. Men i eksemplet over fungerer det objekt bare som et Person-objekt, som betyr at man bare har tilgang til variabler og slikt i Person-klassen. Hvis man gjør det motsatte (Snekker snekker = new Person(), så fungerer ikke dette, fordi Snekker arver fra Person. public void metode(Object object) { //kode som gjør noe med objektet } public void metode(Snakker antallHus) { //kode som gjør noe med objektet } Man bruker et objekt som parameter i andre objekter og metoder. Også, hvis man har et objekt som en parameter i en klasse, så kan man direkte referere til variabler til det innførte objekte, i klassen. Dette fungerer også for arvede objekter. Så hvis Snekker arver fra Person, kan man også passere inn et objekt av snekkerklassen, selv om metoden spør om et Personobjekt. gir en boolean om hvilken type objekt noe er. eks: int number; boolean bool = number instanceof Double Dette gir false. Man kan også bruke dette med objekter d selv har laget fra en klasse. Hvis et objekt er en barneobjekt av en annet objekt, så vil det vise true boolean bool = enSnekker instanceof Person men hvis man bruker feks et barn av snekkerklassen, så bvil det ikke fugnere, fordi det er et barn av Snakker, men ikke Person Person person = new Person() ((Snekker) person).getAntallHusBygd(); (([klasse man ønsker å tolke objektet som]) [objekt av annen klasse].[metode til annen klasse](); Dette fungerer også for klasser der det er et oldeforelder/oldebarn forhold ((Snekkerlærling) person).getOpplæringsPeriode();

Answer 2

final, konstanter(final static), "verktøy klasser" final static er som en konstant til en klasse. En verdi som tilhører klassen som aldri endrer seg Verdien er i UPPER CAPS eks: private final static int MENING_MED_LIVET = 42;

Answer 3

Checked excetions: Forvtentet fiel - feil man bør håndtere Runtime exceptions - indikerer feil internt i applikasjon, som man håndterer error - errors som at det ikke er nok plass i pc, disse fikser man ikke unchecked exceptions - exceptionsman ikke forventer, men som man fortsatt håndterer "throwing exceptions" Når en exceptions oppstår, bli det i bakgrunnen laget et exceptions objekt, så sendes det videre ``` Throwable ^ | ------------------ | | Error exceptions ^ | RuntimeExceptions ``` Når exceptions oppstår, kan programmerer: - Ikke gjøre noe, da skriver program feilmelding til konsoll, og stopper opp program - Behandle feilen som oppstår. - Behandle feilen et annet sted i rpogrammet. syntax try {} - kjører kode catch {ExceptionKlasse ex) {} - skjer hvis ex1 skjer catch (EnAnnenExceptionKlasse ex2) {] - skjer hvis ex2 skjer finally {] - skjører etterpå uansett om det kom en ex eller ikke

Answer 4

``` "Flat fil" Ustrukturert fil som ikke skal tolkes Bare en ren string Innholer eks: Hei hvordan går det. Jeg heter Lars. Jeg har det bra..... ``` Strømmer: Klasser som skriver/leser til ting kontinuelig. En kontiuelig strøm av ting som skjer FInnes mange klasser I to hoevkateforier Byte Stream - leser/skriver nytes (Hvis de har "Stream" i navnet) InputStream, OutputStream Character stream - leser/skriver characters (hvis de har Reader/Writer i navnet) Reader, Writer Slik: BufferedReader [klassenavn] = new BufferedReader(new InputStreanReader(System.in)) - Buffered betyr at den leser hele linjer med tekst, "Reader" ville lest tegn for tegn - InputStreamReader leser input fra bruker - Det må være en reader, for at Buffered skal lese hele linjen - System.in sier at man skal ta fra konsoll ``` try { FileWriter [klassenavn] = new FileWriter("minTextFil.txt", true); } catch (IOException IOEx) {System.err.println(IOEx.getMessage())} ``` - IO - Input/Output - System.err er spesialisert for errors - Etter at man oppretter klassen FileWriter, vil man få en error, "surround with try/catch blocks". - Det i parameter kan være: En filsti som man skriver til, et objekt, en filsti der man appender - Hvis filen ikke eksisterer, blir den laget - true gjør at det appendes - IOException er en exception som har med å skrive til og lese filer, eks feil filsti, korrupt fil, tomt minne... String tekst = ""; sout("Skriv avslutt for å avslutte: skriv noe tekst"); try ( BufferedReader bf... FIleWriter fw... ) { - Denne try greien lukker automatisk bf og fw while (tekst.equals("avslutt" != true)) { tekst = bf.readLine(); bf.append(tekst); } ) catch (IOException ioEx) { System.err.println(ioEx.getMessage()); } String fileName = "c://lines.txt"; try (BufferedReader br = new BufferedReader(new FileReader(fileName))) { String line; while ((line = br.readLine()) != null) { System.out.println(line); } } catch (IOException e) { e.printStackTrace(); } }

Answer 5

Anonyme klasser: Gir mulighet til å oprette et objekt, og definere dets funksjonalitet i samme handling. Man trenger ikke å oprette en klasse for dette. Dette gjøres ofte i henhold til et interface. Man opretter interfacets metoder ved oprettelse av objektet ``` Vanlig interface: public interface RandomInterface { void randomMethod(); } ``` Implementering av funksjonalitet og objekt: RandomInterface anonClassObject = new RandomInterface() { @Overrride public void randomMethod() { //implementasjon } }

Answer 6

upcasting upcasting fungerer alltid, man trenger aldri noe ekstra kode for at det skal fungere. Man kan altså behandle en barneklasse som sin superklasse, fordi en hund er også et dyr caste et object til dets superklasse (parent) Lager et hundeobjekt, som castes til Animal Animal myAnimal = new Dog() Animal - refrence klasse Dog - klassen til objektet myAnimal kan kun bruke metoder fra Animal klassen, ikke fra Dog klassen Så hvorfor bruker man upcasting i det hele tatt? Fordi da kan man gjøre dette... ``` public static void makeAnimalNoise(Animal animal) { animal.makeNoise(); } makeAnimalNoise(myAnimal) konsoll: woof woof! (hundemetoden) ``` Upcasting brukes fordi: Da kan man passere en subklasse som parameter til en metode som kun tar superklassen ``` Men dette skjer også automatisk. eks hvis man gjør så: Dog dog = new Dog() makeAnimalNoise(dog) så fungerer dette. ``` ALTSÅ: Man trenger ikke å spesifisere upcasting, dette skjer automatisk. downcaste caste et objekt til en subklasse, en barneklasse F.eks. man kan caste et animal til å være en hund growl er en metode som bare dog har. makeNoise er en metode som alle barn overrider, og som finnes i superklassen makeAnimalNoise(new Dog()) public static void makeAnimalNoise(Animal animal) { animal.makeNoise() animal.growl() } Denne metoden vil feile, fordi "growl" ikke er spesifikt til animal. ``` Men hvis man gjør slik: public static void makeAnimalNoise(Animal animal) { animal.makeNoise() Dog dog = (Dog)animal animal.growl() } ``` Da fungerer det å bruke en Dog spesifikk metode Gi subklasse agang til superklasses metoder: Hver subklasse har automatisk adgang til superklassens metoder Gi superklasse adgang til subklasses metoder Animal animal = new Animal() ((Dog) animal).bark() ``` instanceof La oss si man passerer inn noe slik: makeAnimalNoise(new Cat()) ``` ``` public static void makeAnimalNoise(Animal animal) { animal.makeNoise() Dog dog = (Dog)animal animal.growl() } ``` Denne metoden vil feile, fordi "growl" animal objektet som man passerer inn, ikke er av klassen Dog, og har derfor ikke tilgang til "growl". For å skjekke hvilken subklasse man bruker, kan man gjøre slik: ``` public static void makeAnimalNoise(Animal animal) { animal.makeNoise() if (animal instanceof Dog) { Dog dog = (Dog)animal animal.growl() } } ``` casting med primitive datatyper: hvis man har to variabler av forskjellige primitive datatyper, så tar å kombinerer det i en ny variabel, float num1 = 2f; int num2 = 1; double num3 = num1 + num2; så kan to ting skje: 1: det funker helt fint å kombinere variablene 2: kombinasjonen fungerer ikke. Man må caste Når må man caste? Med størrelsen til en datatypen, mener jeg størrelsen i bits. Når man setter en datatype som er større, lik en mindre datatype, int num1 = 2; double num2 = num1; kalles dette Widening casting. Dette gjør java automatisk. ``` Når man setter en datatype som er mindre, lik en større datatype, double num1 = 2; int num2 = num1 så får man en feil.. Man må caste til det mindre datatypen. Dette kalles Narrowing casting. Gjøres slik: int num2 = (int) num1; ``` ``` datatyper fra største til mindre double - størst float long int char short byte - minst ``` Hvilken info kan man minste når man gjør narrowing casting? Hvis verdien som castes som noe mindre (x) overstiger kapasiteten til den mindre verdien (y), så går man tilbake til y sin minste verdi, deretter så langt opp i y som så langt x går opp i verden på nytt. Det er som om man looper verdiene y kan ha. F.eks. byte kan ha verdiene: -128 127 int num1 = 130 byte num2 = (byte) num1; num2 sin verdi er -126 Hvis man har desimaler, så kan man miste infoen bak desimalene. float num1 = 2.7f; int num2 = (int) num1; num2 sin verdi er 2.

Answer 7

disse datatypene: long, float, double long num = 2L float num = 2.5f double num = 2.5d

Answer 8

inheretance og access modifiere: -Hvis en metode i en superklasse er private, så kan ikke en subklasse bruke metoden. Det er som om metoden ikke vil finnes for subklassen. Dette gjelder så klart også interface og abstract -Altså metoder som er abstract og i interface, trenger man ikke å spesifisere tilgjengeligheten til, siden det er klart at de er public. Men når man implementerer eller arver metodene, så må man spesifisere access modifieren. Accessmodifieren i subklassen må være public, den kan ikke være private. abstract klasse: void abstract myAbstractMethod(); ``` interface klasse: void myInterfaceMethod(); ```

Answer 9

Hvis man driver med en klasse i pakke x, og vil bruke noe fra en klasse i pakke y, så må man importere den andre pakken. Dette gjelder også i slike tilfeller: pakke y ligger under pakke x. Hvis man er i pakke y, og bruker noe fra pakke x, så må man fortsatt importere Hvis man er i pakke x, og bruker noe fra pakke y, så må man også importere. Hvis man lager en subklasse av en klasse i en annen pakke, så må man fortsatt importere. Man må altså alltid importere ``` pakke path syntax Man må spesifisere hele veien fra etter src (altså ikke inkludere src, men pakken under der igjen). eks: project out venv src pakke1 pakkeunder1 pakkeunderigjen klassen.fil External libraries ``` pakke1.pakkeunder1.pakkeunderigjen.klassen La oss si: klasse Animal er i pakke x, Man skal lage en subklasse i pakke y pakke y ligger under pakke x package pakkeX.pakkeY import pakkeY.Animal ``` public class Cat extends Animal { ... } ```

Answer 10

no modifier - bare innenfor samme pakke dette gjelder også funksjoner: void myMethod() {} Det er også selv om klassen er en subklasse av klassen med metoden. Så hvis subklassen er i en annen pakke, så har den ikke adgang til superklassens metode private - bare innenfor samme klasse public - innenfor alle pakker protected - innenfor alle klasser, så lenge klassen er en subklasse

Answer 11

``` imports og exceptions: io ting: BufferedReader bufferedReader = new BufferedReader(new FileReader(path)); BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(path, false)); BufferedReader bfInput = new BufferedReader(new InputStreamReader(System.in)); ``` import: java.io.*; catch: catch (IOException e) { e.printStackTrace(); } Variabler (int, String, double, Integer): Man trenger ingen import eller catch lister: import java.util.ArrayList; import java.util.HashMap; import java.util.LinkedList; Men man kan også bare gjøre: import java.util.*; ``` exceptions: Man kan få en index out of bound exception. den skriver man sånn: try { array.get(2); } catch (IndexOutOfBoundException IOOBException) { //kode } ``` swing: swing: import java.swing.*; action event listener: java.awt.event.*;

Answer 12

catch beskjeder man kan gi e.printStackTrace - gir mer informativ beskjed, som en vanlig exeption error, men den stopper ikke programmet sout(e.getMessag) - gir beskjed viktig med exceptions: hvis du har en catch hierarki try {} catch {} catch {} finally {} Hvis man har flere ting som kan gi en exception, så er det sånn at så snart en exceptionen oppstår, så vil den hoppe til catch Det er derfor man ikke burde håndtere flere exceptioner samtidig, (eks IOException og IndexOutOfBoundsException), men heller en exception, så mer og mer generelle exceptions

Answer 13

``` Lese fil: public static void readFile() { System.out.println("reading file..."); try (BufferedReader bufferedReader = new BufferedReader(new FileReader(FILE_PATH))) { String currentLine; while ((currentLine = bufferedReader.readLine()) != null) { System.out.println(currentLine); } ``` } catch (IOException e) { e.printStackTrace(); } } Skrive til fil: public static String makeStringToAdd() throws IOException { String returnString = ""; ``` try (BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in))) { String currentLine; while (!(currentLine = bufferedReader.readLine()).equals("quit")) { returnString += currentLine + "\n"; } } ``` return returnString; } ``` public static void writeToFile(String content) throws IOException { try (BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(FILE_PATH, true))) { bufferedWriter.write(content); } } ```

Answer 14

arv i java: arv betyr at noe kan ha samme trekk som en annen ting. I java gjøres dette med arving av klasser (extends) og implementasjoner av interfaces. Abstraksjon abstraksjon betyr at man kan lett gjenbruke kode. man trenger ikke å vite hvordan koden fungerer, men man kan fortsatt bruke komplekse kodeblokker. I java kan man gjøre dette med metoder. polymorfisme polymorfisme er at en ting kan oppføre seg på flere forskjellige måter. I java kan man gjøre dette med parametere, og med objekt polymorfisme. innkapsulasjon Innkapsulasjon betyr at en ting bare er nålig fra visse steder. I java kan man gjøre dette med access modifiers (no modifer, private, private, protected), for å styre hvilke klasser og pakker som har adgang til kode.

Answer 15

mutable - at noe kan forandres immutable - at noe ikke kan forandres etter at det har blitt laget. Alle wrapper klasse(Integer, String, Double osv) er immutable. Det betyr at hvis man lager et objekt av en slik klasse, og gir det en verdi. Så peker det til et sted i minne. Hvis man gir objektet en ny verdi, så endrer man ikke verdien i minne, men man gjør heller så variablet peker til et nytt sted. Man endrer altså ikke minnet, man bare redefinerer hvor variablet peker. Dette er for minnehåndtering. Man gjør så flere variabler kan peke til samme minneposisjon. Hvis man skal hardkode slik at to variabler ikke peker på samme objekt, selv om de har samme verdi, kan man manuelt lage et nytt objekt. Slik: String myString = new String("John"); Man kan gjøre ting immutable i java, med bruk av final når du lager et variabel som er final, MÅ du sette verdien. Du kan ikke gjøre slik: public final static int number; Da vil du få en feil Du kan heller ikke gjøre slik: public final static int number = null; Da får du også en feil. Du kan heller ikke endre noe final i konstruktøren hva er en final metode? en metode som ikke kan overkjøres av en subklasse. Man kan altså ikke lage en metode med samme navn i subklassen. Det har ingenting å si om man bruker andre modifiere i metoden i subklassen som, variabler, static osv.

Answer 16

Unified Modeling Language aka klassediagram. Gir oversikt over klasser, og klasserelasjoner Eksempel ``` --- Fly --- - seter: int - passasjerer: Arraylist ---- + LeggTilPassasjerer(String passasjer): void ``` +: public -: private #: protected ``` Statiske variabler: har understrek Final variabler: har fullt caps Konstanter (final + static): både caps og understrek Abstrakte klasser og metoder er i kursiv Interface vises med slik: <> ``` Arv: ----Extends------|> (Direkte) assosiasjon: ------> Aggregering: -------<> Implements: - - - - - |> Arv indikerer at en at en klasse arver fra en annen. Altså extends Klasse som arver peker mot klassen det arves fra. Fly Flyplass ``` Aggregering indikerer at en klasse inneholder en liste av objekter fra en annen klasse Eks: Flyplass ---- - String: navn - fly: Arraylist ``` Klassen som har listen, blir pekt på av klassen som objektene i listen er av. Fly -----<> Flyplass Implementering Indikeres med en lik linje som med arv, bare at linjen er striplet. Interfaces er noe man implementerer. Interfaces har pilene pekende mot seg, fra klassene som implementerer interfacet. Når en klasse implementerer et interface, skrives ikke opp metodene som implementeres, de skrives kun i interfacet. <>

Answer 17

Paradigmer: Klassifikasjoner av programmerinsspråk, basert på hvordand e skrives og benyttes Noen paradigmer: Imperativ programmering: OOP Deklarativ programmering: Funksjonell programmering ``` Forskjeller: Imperativ Sier til hvordan hva det skal gjøre, og hvordan stegvis typisk for applikasjoner Eks: Java, C++, Pascal ``` Deklarativ: Deklarer HVA vi ønsker skal skje, men ikke hvordan Overordnede komandoer Ofte brukt til (men ikke ekslusivt) databasespørringer Eks: SQL, Prolog, Miranda ``` Imperativ: ArrayList result = new ArrayList<>(); for (int number : numbers) { if (number % 2 == 0) { result.add(number); } } ``` Deklerativ: var result = numbers.Where(number => number % 2 == 0); SELECT * FORM Table Funksjonell programmering Man bruker gjerne ting som kommandoer, og setter opp ting i programmeringsspråket slik at man kan gjøre en hel del operasjoner med lite kode. Dette kan eks gjøres igjennom en funksjonskall Kodeblokker behandles som byggestener i koden,ikke som objekter. Benytter ofte recursion, der en funksjon kaller på seg selv. Deterministiske matematiske funksjoner har ikke gettere og settere har ikke mutable states Bruker gjerne ikke løkker, men heller recursion ``` Det påstås at funksjonell programmering gir: Færre bugs Kode som er letere å debugge og teste Kode som skal formelt verifiseres Mer kompakt kode. ```

Answer 18

Å ha metoder med samme navn, men som gjør forskjellige ting, f.eks. utifra parametere overloading fungerer med hva som helst, så lenge man har forskjellige parametere. Hvorfor det? Fordi når du bruker et objekts metode, må det være en måte java kan vite hvilken metode du vil bruke. Hvis du kun bruker det samme navnet, så gir ikke det noe innblikk i hvilken metode man vil bruke (fordi med overloading vil flere metoder ha samme navn). Men så lenge parameterene er forskjellige, kan man ha forskjellige metoder med samme navn, der fe.ks. noen gir annen returntype, noen er static, og noen har andre access modifiers.

Answer 19

overloading overriding objektpolymorfisme

Answer 20

``` public MountainBike(int startHeight, int startCadence, int startSpeed, int startGear) { super(startCadence, startSpeed, startGear); this.seatHeight = startHeight; } ```

Answer 21

Primitive Data Type: In Java, the primitive data types are the predefined data types of Java. They specify the size and type of any standard values. Java has 8 primitive data types namely byte, short, int, long, float, double, char and boolean Eksempler på primitive datatyper: boolean, int, float Eksempler på non-primitive datatyper: String, ArrayList,

Answer 22

``` Double bool = new Double(true); Float myfloat = new Float(2.5);/Float myfloat = new Float(2.5f); Integer munum = new Integer(2); ```

Answer 23

``` Following are the requirements: -The class must be declared as final so that child classes can’t be created. ``` - Data members in the class must be declared private so that direct access is not allowed. - Data members in the class must be declared as final so that we can’t change the value of it after object creation. - A parameterized constructor should initialize all the fields performing a deep copy so that data members can’t be modified with an object reference. - Deep Copy of objects should be performed in the getter methods to return a copy rather than returning the actual object reference)

Programmering 2 Flashcards

(47 cards)