Det finnes mange forskjellige programmeringsmetoder.
Vi har iterativ 
- programmering 
- rekursiv programmering 
- objektorientert programmering 
- strukturert programmering 
- og nå med Java SE 8: funksjonell programmering.


I Java SE 7 og tidligere kunne interface kunne bare inneholde
konstanter og abstrakte metoder. 

Java SE 8 innfører default-metoder i interfacet, dvs. ikke-abstrakte metoder, 
der metodekroppen er definert. 
Når en klasse implementerer et interface med default metoder holder det 
å implementere de abstrakte metodene. Klassen får automatisk default-metodene,
men disse kan selvfølgelig rediefineres hvis det er ønskelig.


eks

interface Grensesnitt
{
  int metoden();
  
  default int sum( int x, int y )
  {
    return x + y;
  }
}

default-metoder kan legges til eksisterende interface uten av
det bryter med den "avtalen" som alle klasser som har implementert 
interface har inngått, fordi disse metodene nå får den nye default-metoden 
automatisk uten å måtte foreta seg noe.

Forskjellen mellom abstrakte klasser og interface viskes nå delvis ut:

abstract class:
konstanter - variable - abstrakte metoder - konkrete metoder

interface:
konstanter - abstrakte metoder - konkrete metoder (default-metoder) 

Forskjellen blir at abstrakte klasser kan ha variabler som datafelt,
noe interface ikke kan ha.

Tidligere hadde ofte et interface en "parallell" klasse med static-metoder:

Collection<E> hadde den parallelle klassen Collections med static-metoder
som kunne gjøre operasjoner på Collection-objekter (samlinger)

I Java SE 8 kan disse static-metodene legges inn i interfacet, 
i stedet for i ligge i separate klasser. 

Nytt begrep:

functional interface - funksjonelt interface
er et interface med kun èn abstrakt metode:

Eksempler på funksjonelle interface som vi kjenner fra før:
ActionListener - med metoden actionPerformed
Comparator - med metoden  compare
Runnable - med metoden run

Funksjonelle interface brukes i forbindelse med Lambda-uttrykk
som vi heretter vil kalle lambdaer.

Funksjonelle interface:

Consumer<T>: void apply( T t ); Konsument - tilsvarer set-metodene

Supplier<T>: T get();        Produsent - tilsvarer get-metodene

Functional<T,R> :  R apply( T t ); Funksjon - tilsvarer det matematiske begrepet 

Predicate<T>: boolean test( T t ); Predikat - boolsk tilsvarer et utsagn/betingelse

BinaryOperator<T>:  T apply( T t1, T t2 ); Binær operator

UnaryOperator<T>: T get();  Unær operator

Lambda innfører ny syntaks:

(parameterliste) -> { setninger }

eks: (int x, int y  ) -> { return x + y; } 

Utfra metoden i det funksjonelle interface kan kompilatoren resonnere seg frem 
til parameternes typer og typen til returverdien:  R apply( T t ); 

Mange av tegnene kan utelates:

(x,y) -> {return x + y;}

(x,y) ->  x + y

s.forEach( (int i) -> { utskrift.append( i + " " ); } );

s.forEach( i -> utskrift.append( i + " " ) );

Alt som kompilatoren kan slutte seg til kan utelates. 


Nye og viktige begreper: 

streams - strømmer

pipelines - ( rørledninger - ingen god norsk oversettelse, bruker derfor pipeline )
er en kjede av metoden-kall

intermediate operations - mellom-operatsjoner

terminal operations - slutt-operasjoner

Eks: 
Stream.of( 1,2,3,4,5,6,2,8).filter( i -> i%2 == 0 ).sort().forEach( i -> utskrift.append( i + " " ) );

Linjeskift øker lesligheten:

Stream.of( 1,2,3,4,5,6,2,8)
.filter( i -> i%2 == 0 )
.sort()
.forEach( i -> utskrift.append( i + " " ) );


Ny og viktig klasse: Stream 
Inneholder mange nyttige metoder og brukes sammen med Lambdaer:

filter - gir en strøm med elementer som oppfyller en gitt betingelse
distinct - gir en strøm med kun forskjellige elementer (duplikater fjernes)
limit - gir en strøm med et gitt antall elementer fra og med et gitt start-element
map - gir en strøm der alle elementene i den originale strømmen er "mappet" til en ny verdi
sorted - gir en sortert strøm som inneholder de samme elementene som den originale

average - returnerer gjennomsnittet
count - returnerer antallet
max - returnerer største verdi
min - returnerer minste verdi
reduce - reduserer strømmen til en enkelt verdi

collect - returnerer en samling
toArray - konverterer til en array som returneres

findFirst - finner første forekomst av noe
findAny - finner en forekomst av noe
anyMatch - avgjør om det finnes minst en match
allMatch - avgjør om alle matcher