码迷,mamicode.com
首页 > 编程语言 > 详细

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

时间:2015-07-25 01:47:39      阅读:162      评论:0      收藏:0      [点我收藏+]

标签: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");
	}
}

小结:Java的接口本身就是一种为扩展程序而使用的,在Java8中应该避免让实现类去覆盖具有多个相同default方法的接口,这样没有什么意义。Java8在接口中的新特性仅作为一个扩展而使用。而对于接口中的静态方法,在实现类中去“重写”(实际上不是)是没有意义的。


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

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!