Begreber programmering

## Objektorienteret programmering (OOP)

Objektorienteret programmering er at opdele programkoden i klasser, der har hver sit velafgrænsede ansvarsområde i programmet. Ved en god afgrænsning kan en klasse genbruges i andre programmer. Man anvender en klasse ved at oprette én eller flere forekomster (instanser) af klassen, og en sådan forekomst kaldes et objekt.  Der findes tre grundprincipper i objektorienteret programmering:

1. Indkapsling (capsulation)
2. Nedarvning (inheritance)
3. Polymorfi (polymorphism)

Se også: https://en.wikipedia.org/wiki/Objektorienteret\_programmering

## Typer

Sandt eller Falsk
//Edit by Rasm824p
boolean (småt b) er en native type som er true/false mens et Boolean (stort b) er en klasse der kan være true/false/null.
 Char
Char er en datatype, som indeholder én karakter
f.eks. 'A', '4', eller '#'
short
int
long
 Float
32bit (4byte) floating-point tal.
Minimum ~= 1.5\*10^-45
Maximum ~= 3.4\*10^38
s. 18
 Double
64bit (8byte) floating-point tal.
Minimum ~= 5\*10^-324
Maximum ~=1.7\*10^308
s. 18

errors, som eksemplet indeholder.
 Catch;
derefter lave en tekst kasse, som bliver skrevet ud, hvis erroren forekommer.
 Throw;
 Finally;
altid til sidst, hver gang ”try” bliver afprøvet
s. 316

## Conditional statements

### if

```
if(condition)
 statement;

```
Hvis *condition* er sand udføres *statement*.

### switch

```
switch(expression) {
 case constant1:
 statement;
 break;
 case constant2:
 statement;
 break;
 case constant3:
 statement;
 break;
 default:
 statement;
}

```
Switch giver mulighed for valgmuligheder. Switch kører igennem *cases*, indtil der bliver fundet en sand. Når en *case* er sand, udføres dens statement. Hvis ingen af *case’ene* er sande, udføres default’s statement.

### try/catch (er ikke conditional statements)

```
try {
 // block of code to monitor for errors
}
catch (ExcepType1 exOb) {
 // handler for ExcepType1
}
catch (ExcepType2 exOb) {
 // handler for ExcepType2
}

```

## Repetition statements

### for

```
for(initialization; condition; iteration)
 statement;

```

initialization udføres engang før første gennemløb. Kan f.eks. bruges til at initialisere en variable.

Loopen kører så længe *condition* er sand, *iteration* udføres efter hvert gennemløb.

Eksempel på loop der printer 0 til 10:

```
for(int i = 0; i <= 10; i++) {
 System.out.println(i);

```

### while

```
while(condition)
 statement;

```
*statement* udføres så længe *condition* er sand.

### do-while

```
do {
 statements;
} while(condition);

```
*statement* udføres så længe *condition* er sand, dog som minimum en gang.

## String (Side 158)

```
String str = new String("String kan laves på forskellige måder");

String str2 = "tekst kan skrives direkte ind"

String str3= new String

```

 En string er en rækkefølge af tegn der eksisterer som et objekt. *Strings* bliver oprettet og
manipuleret ved hjælp af String class. I Java er *strings* objekter.

Når et String objekt er oprettet, kan det ikke ændres.

Indholdet af et String objekt kan ikke ændres. Det vil sige at når det er oprettet, så kan tegnrækkefølgen ikke ændres. Dette tillader Java at implementere *Strings* mere effektivt.

String class indeholder metoder der opererer på *strings*. Her er formen på nogle få:

mindre end 0, hvis *string* er mindre end *str*
større end 0, hvis *string* er større end *str*
lig med 0, hvis begge *strings* er ens

*Forkortet diagram fra Java a Beinnger's Guide Sixth Edition (Side 160)*

### Nested if (s.67 – 6th edition)

Et nested if bruges som alternativt udfald for et andet **if** eller **else.
Det ligger inde i et andet** if **statement { }**

Eksempel fra terningespillet:

```
if(ch == answer) System.out.println("\*\* Right \*\*");
else {
   System.out.print("...Sorry, you're ");
// Dette er et nested if
  if(ch < answer) System.out.println("too low");
   else System.out.println("too high");
}

```

Man skal huske at et **else** statement, altid referere til den nærmeste **if** statement, som er i samme blok og som ikke allerede er refereret til af et andet **else.**

## Funktion

Funktionsdefinitioner skal være inde i en klasser i java. Vi kalder dem også funktions metoder.

fx.

☀public class Main {

```
    public static void foo() {
        // Do something here
    }
}

```

Funktioner

## Access Modifiers

Alle elementers synlighed (visibility) bestemmes af dets adgangs specifikation (Acess specifikation) som er: Private, Public, Protected og Default. Hvis et member i en klasse ikke har en specifik acces modifier, så er den synlig indenfor dets pakker og ikke udenfor, det vil sige den Default.

**Public:** Members der er erklæret **Public** er synlig overalt! Herunder de forskellige klasser og pakker. Der er ingen begrænsning på deres brug eller adgang.

**Private:** Et **Private** member er kun tilgængelig til andre members i sin klasse.

**Protected:** Et **Protected** member har adgang indenfor dets pakke og alle subclasses, også subclasses i andre pakker

https://beginnersbook.com/2013/03/packages-in-java/

## Klasser

#### Super og sub class – Inheritance

Superclass er
”moder” klassen hvis attributter nedarves til subclassen.

Altså hvis
subclassen er æble, kan dens superclass være frugt,

Jo længre man går
ned i hierakiet, jo mere specialiseret bliver klassen.

Mere info side 10 i
”Java a beginners guide.”

## Java IO

(side 329 i bogen, pdf versionen)

Anbefalet at tage et kig på denne her hjemmeside som har alt indenfor Java IO.

Java IO er bygget op omkring indput/output. Det er basseret omkring kommunikationen fra eksempelvis computere til mennesker. Java IO er et API der indeholder sub-classer så som: InputStream og OutputStream, Reader og en Writer. De kan gøre mange forskellige ting, formålet er således:

* File Access
* Network Access
* Internal Memory Buffer Access
* Inter-Thread Communication (Pipes)
* Buffering
* Filtering
* Parsing
* Reading and Writing Text (Readers / Writers)
* Reading and Writing Primitive Data (long, int etc.)
* Reading and Writing Objects

### Operators

Operators er et symbol, som fortæller compileren, at den skal lave en speciel matematisk eller logisk manipulation.

### Arithmetic Operators - Java 6th Edition s. 46

Når vi arbejder med /, fungerer det lidt ligesom i lommeregneren,
dog giver resultatet kun hele tal.
eks. 10/3 = 3,33 i lommeregneren. Men i java giver det: 10/3 = 3

% minder lidt om /, men giver os resterne fra resultatet.
eks. 10 % 3 = 1. Når 10/3 resulterer i 3, betyder det altså at 1 er tilbage,
hvilke % regner ud.

++ og – lægger/trækker +1 eller -1 til en variable
eks. X++ er det samme som x = x +1
eks. Y—er det samme som y = y – 1

 \*
 /
 %
 ++
 --

### Relational Operators - Java 6th Edition s. 48

fungere ligesom i klassisk matematik

== og
!= bruges til at sammenligne om noget er lig med hinanden eller ikke
<, >, <=, >= bruges til at sammenligne om noget er større, mindre,
lig med eller større og lig med eller mindre.

 !=
 >
 <
 >=
 <=

### Logical Operators - Java 6th Edition s. 48

 ^
 &&
 !

Bitwise Operators

 ^
 >>
 >>>
 <<
 ~

## JavaFX

er et vindue, som skal indeholde scener.
 Scene
er den der bliver vist inde i vinduet. Den indeholder det visuelle i vindue
 Pane | Layout til scener

## Unit test

Formålet med unit test er, at man hele tiden kan teste, om ens program stadig virker hensigtsmæssigt, og fordi det er let at teste, er der ingen grund til at frygte at lave ændringer i koden.

Optimalt set laver man først en test blot for at se den fejle, og dernæst laver man en lille stump kode til ens program, som gør, at testen ikke fejler mere - eksempel på denne praksis kan findes her.

Kapitel 9 s. 121 i Clean Code beskriver Unit Tests.

## Enum

Enum er en data type der gør det muligt at definere en gruppe konstanter, fremfor at definere hver enkel konstant separat.

Så fremfor:

```
class Color
{
 public static final int RED = 0;
 public static final int BLUE = 1;
 public static final int GREEN = 2;
}

```

Kan man det gøres "pænere" med enum:

```
enum Color {
 RED, GREEN, BLUE;
}

```

Se nedenstående link for en mere udbydende forklaring:

* http://tutorials.jenkov.com/java/enums.html

Derudover er følgende links et også et kig værd:

* https://docs.oracle.com/javase/tutorial/java/javaOO/enum.html
* https://www.geeksforgeeks.org/enum-in-java/

CRUD

 Create
 Read
 Update
 Delate