1.Default method
The default method and static method of an interface can be use a extend method in the class that implement the interface.But,an interface can't override the method extend from class Object such as equals(),hashcode();
2.Functional interface
if an interface has only one abstract method ("abstract" will not be declare but it is default) the interface will be describe as a functional interface eg:(Runnable,ActionListener ,etc) A functional interface could has any number of default method.
3. Lambda
The most valueble properties of a functional interface is that it could be turn to an instance using a lambda expresion
(int x,int y)-> {return x+y;}
using builder to improve code
when you need to create a new instance of an functional interface ,you can use a lambda expression,it is often used when you need to create an annoymous inner class
Runnable r1=new Runnable(){
@Override
public void run(){
// need to do
}
}
Thread t1=new Thread(r1);
using annoymous inner class:
Thread t1=new Thread(new Runnable(){
@Override
public void run(){
System.out.println("things to do here");
}
});
using annoymous inner class and lambda expression
Thread t1 =new Thread(()-> System.out.println("things to do here"));
you can see that the only abstract method of the functional interface will be define in the expression,the the parameter in the bracket is the formal parameter of the abstract funtion ,
We can create an instance of a functional interface using a lambda expression：the list of parameter is in the bracket an the abstract method is on the right of the "->" it could be an expression(a executable) or a statement(could turn to a value) as a return value
(int x,int y)->{return x+y;} //
x->x*x //as a rturn value
x->{System.out.println(x);}//as a expression
String::valueOf x -> String.valueOf(x)
Object::toString x -> x.toString()
x::toString () -> x.toString()
ArrayList::new () -> new ArrayList<>()
4.Closure
When you declare a local variable,that variable has a scope,outside the scope you can't use it;
if I try to access a variable,it will find from the current scope,then the parent scope
A closure is a function that use a free variable ,different environment will lead to different instance.
5.eta-conversion
Langua that support lambda often support eta-conversion,eta-conversion is building a clousure of a method
using a Class::method to automaticly fill in the parameter;
6.Stream api
An object that implement Collection interface could be turn to a stream using Collection.stream() and have several method:
sort() ,you can declare a comparator
filter() only object that accord with the filter could be remained
map() could deal with each object,change it
match() if the boject match the method and return a boolean value
count() return a value the the amount of the object in the stream.
7.Serial and parallel
Collection.stream() //Serial
Collection.parallelStream() //parallel
parallelStream use muti thread to handle the work,the runtime will partition the stream into several substream in parallel and then combine the result .
8.laziness in parallel
There are two kind of operation in stream ,intermediate and terminal ,an intermediate operation will be evaluate only when it required to do so（such as meet a terminal operation)
