多线程（5）Lamda表达式

一：理解Functional  Interface（函数式接口）是学习Java8 lamda表达式的关键所在

Lamda表达式使用条件：前提是接口为函数式接口；（函数式接口是指接口中只有一个方法）

Lamda表达式主要是将我们的匿名内部类省略后的结果（匿名内部类主要是要接口实现的：没有实现类）

public class NImiBean {
	public static void main(String[] args) {
		Ni ni=new Ni() {
			@Override
			public void Dao() {
				System.out.println("我就知道吃：123");
			}
		};
		ni.Dao();
	}
}
interface Ni{
	public void Dao();
}

用Lamda表达式：

public class NImiBean {
	public static void main(String[] args) {
		Ni ni=()->{
				System.out.println("我就知道吃：123");
			};
		ni.Dao();
	}
}
interface Ni{
	public void Dao();
}

 

函数式接口的定义：

   任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口。

  对于函数式接口，我们可以通过lamda表达式来创建该接口的对象。

1.我们原本的写法

package test;

public class TestLamda {
	public static void main(String[] args) {
		Daii daii=new Pou();
		daii.DD();
	}

}
//1.定义一个函数式接口
interface Daii{
		void DD();
}
//2.实现类
class  Pou implements Daii {
	@Override
	public void DD() {
		System.out.println("吃饭了");
	}
}

 2.静态内部类（记住静态内部类要加static）

package test;

public class TestLamda {
        //3.静态内部类
	static class  Pou22 implements Daii {
		@Override
		public void DD() {
			System.out.println("吃饭了22222");
		}
	}
	public static void main(String[] args) {
		Daii daii=new Pou();
		daii.DD();
		daii=new Pou22();
		daii.DD();
	}

}
//1.定义一个函数式接口
interface Daii{
		void DD();
}
//2.实现类
class  Pou implements Daii {
	@Override
	public void DD() {
		System.out.println("吃饭了");
	}
}

 3.局部内部类

package test;

public class TestLamda {
	//3.静态内部类
	static class Pou22 implements Daii {
		@Override
		public void DD() {
			System.out.println("吃饭了22222");
		}
	}

	public static void main(String[] args) {
		Daii daii = new Pou();
		daii.DD();
		daii = new Pou22();
		daii.DD();
		//4.局部内部类
		class Pou33 implements Daii {
			@Override
			public void DD() {
				System.out.println("局部内部类吃完饭了");
			}
		}
		daii = new Pou33();
		daii.DD();

	}
}
//1.定义一个函数式接口
interface Daii{
	void DD();
}
//2.实现类
class  Pou implements Daii {
	@Override
	public void DD() {
		System.out.println("吃饭了");
	}
}

 4.匿名内部类

package test;

public class TestLamda {
	//3.静态内部类
	static class Pou22 implements Daii {
		@Override
		public void DD() {
			System.out.println("吃饭了22222");
		}
	}

	public static void main(String[] args) {
		Daii daii = new Pou();
		daii.DD();
		daii = new Pou22();
		daii.DD();
		//4.局部内部类
		class Pou33 implements Daii {
			@Override
			public void DD() {
				System.out.println("局部内部类吃完饭了");
			}
		}
		daii = new Pou33();
		daii.DD();
		//5.匿名内部类 ，没有类的名称，必须借助接口或者父类
		daii =new Daii(){

			@Override
			public void DD() {
				System.out.println("匿名内部类吃完饭了");
			}
		};
		daii.DD();

	}
}
//1.定义一个函数式接口
interface Daii{
	void DD();
}
//2.实现类
class  Pou implements Daii {
	@Override
	public void DD() {
		System.out.println("吃饭了");
	}
}

 6.Lamda表达式（这种必须是函数式接口，函数式接口只有一个抽象方法）一个接口，这个接口中只能有一个方法

package test;

public class TestLamda {
	//3.静态内部类
	static class Pou22 implements Daii {
		@Override
		public void DD() {
			System.out.println("吃饭了22222");
		}
	}

	public static void main(String[] args) {
		Daii daii = new Pou();
		daii.DD();
		daii = new Pou22();
		daii.DD();
		//4.局部内部类
		class Pou33 implements Daii {
			@Override
			public void DD() {
				System.out.println("局部内部类吃完饭了");
			}
		}
		daii = new Pou33();
		daii.DD();
		//5.匿名内部类 ，没有类的名称，必须借助接口或者父类
		daii =new Daii(){

			@Override
			public void DD() {
				System.out.println("匿名内部类吃完饭了");
			}
		};
		daii.DD();
		//6.lamda
		daii=()->{
			System.out.println("Lamda吃完饭了");
		};

	}
}
//1.定义一个函数式接口
interface Daii{
	void DD();
}
//2.实现类
class  Pou implements Daii {
	@Override
	public void DD() {
		System.out.println("吃饭了");
	}
}