lambda学习记录

package lambda;
//启动一个线程，在控制台输出：多线程程序启动了
public class Text1 {
      public static void main(String[] args) {
      //匿名内部类
//    	new Thread(new  Runnable() {	
//			@Override
//			public void run() {
//				// TODO Auto-generated method stub
//			System.out.println("多线程程序启动了");
//			}
//		}).start();
    	  //lambda表达式的方式改进 组成lambda表达式的三要素：形式参数，箭头，代码块
    	  /*
    	   * 
			lambda格式：(形式参数)->{代码块}
			形式参数:如果有多个参数，参数之间用逗号隔开;如果没有参数，留空即可
			->:由英文中画线和大于符号组成，固定写法。代表指向动作
			代码块:是我们具体要做的事情，也就是以前我们写的方法体内容
         */
    	  new Thread( () -> {
    		  System.out.println("多线程程序启动了");
    	  }).start();
    	  }
	}

---

 抽象方法无参无返回值：

package lambda;
/*
 * Lambda表达式的使用前提:
      必须有一个接口
      接口中有且仅有一个抽象方法
 */
public class Text2 {
   /*
    * 抽象方法无参无返回值
    * 定义一个接口(Eatable)，里面定义一个抽象方法: void eat()
	     定义一个测试类，在测试类中提供两个方法一个方法是: useEatable(Eatable e)
	     一个方法是主方法在主方法中调用useEatable方法
    */
	public static void main(String[] args) {
		//lambda表达式
		useEatable( () ->{
			System.out.println("吃饭");
		});
		//匿名内部类
		useEatable(new Eatable() {
			public void eat() {
				System.out.println("吃饭");
			}
		});
	}
	private static void useEatable(Eatable e) {
		e.eat();
	}
}

接口(Eatable)：

package lambda;

public interface Eatable {
   void eat();
}

---

 抽象方法带参无返回值：

package lambda;
/*
 * 抽象方法带参无返回值
 * 定义一个接口(Fly)，里面定义一个抽象方法:  void fly(String s);
	     定义一个测试类，在测试类中提供两个方法一个方法是:flyable(Fly f)
	     一个方法是主方法在主方法中调用flyable方法
 */
public class Text3 {
  public static void main(String[] args) {
	//匿名内部类
	  flyable(new Fly() {	
		@Override
		public void fly(String s) {
			// TODO Auto-generated method stub
			System.out.println(s);
			System.out.println("天天开心");
		}
	});
	  //lambda表达式
	  flyable( (String s) ->{
		  System.out.println(s);
			System.out.println("天天开心");
	  });
}
  private static void flyable(Fly f) {
	  f.fly("轻松自在，快快乐乐");
  }
}

package lambda;

public interface Fly {
     void fly(String s);
}

 

---

 抽象方法带参有返回值：

package lambda;
/*
 * 抽象方法带参有返回值
 * 定义一个接口(Add)，里面定义一个抽象方法: int add(int x,int y);
	     定义一个测试类，在测试类中提供两个方法一个方法是:addable(Add a)
	     一个方法是主方法在主方法中调用addable方法
 */
public class Text4 {
        public static void main(String[] args) {
        	//匿名内部类
        	addable(new Add() {
				
				@Override
				public int add(int x, int y) {
					// TODO Auto-generated method stub
					return x+y;
				}
			});
        	//lambda表达式
        	addable( (int x,int y) ->{
        		return x+y;
        	});
			}
       private static void addable(Add a) {
    	   int sum =a.add(10, 30);
    	   System.out.println(sum);
       }
}

 

package lambda;

public interface Add {
	int add(int x,int y);
}

 

---

lambda表达式的省略模式：

package lambda;
//lambda表达式的省略模式
public class Text5 {
    public static void main(String[] args) {
    	addable( (int x,int y) ->{
    		return x+y;
    	});
  //--------------------------------------	
  	  flyable( (String s) ->{
		  System.out.println(s);
			System.out.println("天天开心");
	  });
  //--------------------------------------	
         //参数的类型可以省略，但是有多个参数的情况下不能只省略一个
	addable(  (x, y) ->{
		return x+y;
	});
	     //参数的类型可以省略且如果参数有且只有一个那么小括号可以省略
	  flyable( s ->{
		  System.out.println(s);
			System.out.println("天天开心");
	  });
	  //如果代码块的语句只有一句，那么可以省略大括号和分号
	  flyable( s ->System.out.println("天天开心"));
	  //如果代码块的语句只有一句，那么可以省略大括号和分号,如果有return，return也要省略掉
		addable(  (x, y) -> x+y);
	} 
   private static void addable(Add a) {
	   int sum =a.add(10, 30);
	   System.out.println(sum);
   }
   private static void flyable(Fly f) {
		  f.fly("轻松自在，快快乐乐");
	  }
}

对应的接口

package lambda;

public interface Fly {
     void fly(String s);
}

package lambda;

public interface Add {
	int add(int x,int y);
}

Lambda表达式的使用前提:  必须有一个接口，接口中有且仅有一个抽象方法！！！

 Lambda表达式和匿名内部类的区别：
1.所需类型不同：
匿名内部类:可以是接口，也可以是抽象类，还可以是具体类

lambda表达式:只能是接口
2.使用限制不同：
如果接口中有且仅有一个抽象方法，可以使用Lambda表达式，也可以使用匿名内部类如果接口中多于一个抽象方法，只能使用匿名内部类，而不能使用Lambda表达式
3.实现原理不同：
匿名内部类:编译之后，产生一个单独的.class字节码文件
Lambda表达式:编译之后，没有一个单独的.class字节码文件。对应的字节码会在运行的时候动态生成