Java8新特性小结-接口与Lambda表达式

标签：java

Java8的新特性相对于前版本（Java7）来说，主要体现在两个方面：

1．   接口定义与使用

2．   Lambda表达式对匿名内部类的简化使用。

Java8新特性的具体表现如下：

1.在接口中的体现

（1）在接口中可以定义实体方法，但除原先的抽象方法外只能定义两种方法：

A．公共的静态方法

如：

package com.jasberyon.java8.interfacer;

public interface InterfaceA {

	public static void sayHi(){
		System.out.println("InterfaceA---sayHi");
	}
}

需要注意的是：

a．由于静态方法是属于类（文件）的，所以调用时需要使用对应的接口（静态方法所在类）名去调用。所以在Java8中调用接口中静态方法时，只能通过接口名去调用，使用实现类是无法调用的。

B．使用default关键字声明的普通方法

如：

<span style="font-size:12px;">package com.jasberyon.java8.interfacer;

public interface InterfaceA {
	
	public default void sayHi2(){
		System.out.println("InterfaceA---sayHi2");
	}
}
</span>

需要注意的是：

b．default关键字只能在接口中使用。那么当在接口的具体实现类中重写该default关键之标识的方法时就需要去掉default关键字。如：

package com.jasberyon.java8.interfacer;

public class InterfaceImpl implements InterfaceA {

	public static void main(String[] args){
		InterfaceA.sayHi();
		InterfaceImpl.sayHi();
	}
	
	public static void sayHi(){
		System.out.println("InterfaceImpl---sayHi");
	}
	
	public void sayHi2(){
		System.out.println("InterfaceB---sayHi2");
	}
}

在上面的代码情况（重写接口中的default关键字标识的方法）下当多态调用时，同样会走现实类（子类）的方法，如果没有重写，则走接口中的default方法。

例如：

package com.jasberyon.java8.interfacer;

public class InterfaceImpl implements InterfaceA {

	public static void main(String[] args){
		InterfaceA.sayHi();
		InterfaceImpl.sayHi();
		InterfaceA ia = new InterfaceImpl();
		ia.sayHi2();
	}
	
	public static void sayHi(){
		System.out.println("InterfaceImpl---sayHi");
	}
	
	public void sayHi2(){
		System.out.println("InterfaceB---sayHi2");
	}
}

输出结果：

InterfaceA---sayHi

InterfaceImpl---sayHi

InterfaceB---sayHi2

注意： 因为在Java中类是单继承的，而接口却是可以多实现的。这样这几的初衷是出于安全性的考虑。因为在多继承的模式中，如果子类C继承了父类A和B，而A和B中又有相同的方法methodAlike。那么这时就无法区分子类C中使用方法时到底是使用哪一父类中的方法了。而（原先的设计）接口则不同，实现类需要实现接口中定义的方法，则不存在上述的安全性问题。

那么，现在的问题是：由于在Java8的新特性中可以在接口中定义非静态的方法，那么当多个接口中定义了相同的非静态default方法时，如果实现类实现了这多个接口时，是不是就出现了多继承了呢？

答案是否定的

这时就会产生编译时错误，需要在实现类中覆盖相同的接口中定义的所有方法方法。

如：

定义接口InterfaceA

package com.jasberyon.java8.interfacer;

public interface InterfaceA {

	public static void sayHi(){
		System.out.println("InterfaceA---sayHi");
	}
	
	public default void sayHi2(){
		System.out.println("InterfaceA---sayHi2");
	}
}

定义接口InterfaceB

package com.jasberyon.java8.interfacer;

public interface InterfaceB {

	public static void sayHi(){
		System.out.println("InterfaceB---sayHi");
	}
	
	public default void sayHi2(){
		System.out.println("InterfaceB---sayHi2");
	}
}

那么此时就会发现接口InterfaceA和InterfaceB中有相同的方法：public defaultvoidsayHi2()，那么此时实现类就必须去重写相同的方法。

实现类InterfaceImpl

package com.jasberyon.java8.interfacer;

public class InterfaceImpl implements InterfaceA, InterfaceB {

	public static void sayHi(){
		System.out.println("InterfaceImpl---sayHi");
	}
	
	public void sayHi2(){
		System.out.println("InterfaceB---sayHi2");
	}
}

2. Lambda表达式对匿名内部类的简化使用

Lambda表达式替换了原有的匿名内部类的写法，简化了匿名内部类的使用方式。当然简化的方式总是会使得功能使用时有所限制，Just like 增强型for（for-each）循环。

Lambda表达式的语法结构：

(参数1，参数2...)->{

    重写方法内容，不写定义方法名。

}

（1）多线程时使用Lambda表达式

原来的使用匿名内部类实现多线程的栗子：

package com.jasberyon.java8.lambda;

public class ThreadDemo {

	public static void main(String[] args) {
		
		new Thread(new Runnable() {
			@Override
			public void run() {
				for(int i=0; i<200; i++){
					System.out.println("执行run---------"+i);
				}
				
			}
		}).start();
			
		for(int j=0; j<200; j++){
			System.out.println("执行mian---------------"+j);
		}
		
	}
}

使用Lambda表达式改造后：

package com.jasberyon.java8.lambda;

public class ThreadDemo {

	public static void main(String[] args) {
		
		Runnable runnable = ()->{
			for(int i=0; i<200; i++){
				System.out.println("执行run---------"+i);
			}
		};
		new Thread(runnable).start();
		
		for(int j=0; j<200; j++){
			System.out.println("执行mian---------------"+j);
		}	
		
	}
	
}

又或者这样写：

package com.jasberyon.java8.lambda;

public class ThreadDemo {

	public static void main(String[] args) {
		
		new Thread(()->{
			for(int i=0; i<200; i++){
				System.out.println("执行run---------"+i);
			}
		}).start();
		
		for(int j=0; j<200; j++){
			System.out.println("执行mian---------------"+j);
		}
	}
	
}

那么，Lambda的弊端也是显而易见的，如果接口中定义了多个抽象方法，那么就只能使用传统方式了。

（2）集合排序“比较器”中使用Lambda表达式

TreeSet会将字符串按照自然顺序进行排序，如下代码：

package com.jasberyon.java8.lambda;

import java.util.Set;
import java.util.TreeSet;

public class TreeSetDemo {

	public static void main(String[] args) {
		
		Set<String> set = new TreeSet<String>();
		set.add("asdafa");
		set.add("abcdefsadf");
		set.add("sahdfoad");
		set.add("bhsayuadasdfasdf");
		set.add("auiweyqwergeawgfasdasd");
		System.out.println(set);
	}

}

结果输出：

[abcdefsadf, asdafa,auiweyqwergeawgfasdasd, bhsayuadasdfasdf, sahdfoad]

使用自定义的比较器后：

package com.jasberyon.java8.lambda;

import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;

public class TreeSetDemo {

	public static void main(String[] args) {
		
		Set<String> set = new TreeSet<String>(new MyCompareMethod());
		set.add("asdafa");
		set.add("abcdefsadf");
		set.add("sahdfoad");
		set.add("bhsayuadasdfasdf");
		set.add("auiweyqwergeawgfasdasd");
		System.out.println(set);
	}

}

class MyCompareMethod implements Comparator<String>{

	@Override
	public int compare(String o1, String o2) {
		int length = o1.length() - o2.length();
		return length == 0?o1.compareTo(o2):length;
	}
	
}

结果输出：

[asdafa, sahdfoad, abcdefsadf,bhsayuadasdfasdf, auiweyqwergeawgfasdasd]

使用匿名内部类后：

package com.jasberyon.java8.lambda;

import java.util.Comparator;
import java.util.Set;
import java.util.TreeSet;

public class TreeSetDemo {

	public static void main(String[] args) {
		
		Set<String> set = new TreeSet<String>(new Comparator<String>(){
			@Override
			public int compare(String o1, String o2) {
				int length = o1.length() - o2.length();
				return length == 0?o1.compareTo(o2):length;
			}
		});
		set.add("asdafa");
		set.add("abcdefsadf");
		set.add("sahdfoad");
		set.add("bhsayuadasdfasdf");
		set.add("auiweyqwergeawgfasdasd");
		System.out.println(set);
	}

}

使用Lambda表达式改造：

package com.jasberyon.java8.lambda;

import java.util.Set;
import java.util.TreeSet;

public class TreeSetDemo {

	public static void main(String[] args) {
		
		Set<String> set = new TreeSet<String>((String o1, String o2)->{
			int length = o1.length() - o2.length();
			return length == 0?o1.compareTo(o2):length;
		});
		set.add("asdafa");
		set.add("abcdefsadf");
		set.add("sahdfoad");
		set.add("bhsayuadasdfasdf");
		set.add("auiweyqwergeawgfasdasd");
		System.out.println(set);
	}
	
}

也可写成：

package com.jasberyon.java8.lambda;

import java.util.Set;
import java.util.TreeSet;

public class TreeSetDemo {

	public static void main(String[] args) {
		
		Set<String> set = new TreeSet<String>((o1, o2)->{
			int length = o1.length() - o2.length();
			return length == 0?o1.compareTo(o2):length;
		});
		set.add("asdafa");
		set.add("abcdefsadf");
		set.add("sahdfoad");
		set.add("bhsayuadasdfasdf");
		set.add("auiweyqwergeawgfasdasd");
		System.out.println(set);
	}
	
}

值得注意的是，此时需要泛型标注。也就是比较的类型必须在<>中声明，否则无法通过编译。

同时，使用Lambda表达式的实现不会再有额外的类文件（原来的方式匿名内部类也是要产生形如Ttt$xx.class的文件的）产生。

其它的还有很多就不在列举了。记住一点，构造匿名内部类时，如果只有一个方法需要重写，那么就可以使用Lambda表达式。

Java8新特性小结-接口与Lambda表达式

标签：java

原文地址：http://blog.csdn.net/miner_jasber_yon/article/details/47049967