匿名内部类

匿名内部类

匿名内部类可以使你的代码更加简洁，你可以在定义一个类的同时对其进行实例化。它与局部类很相似，不同的是它没有类名，如果某个局部类你只需要用一次，那么你就可以使用匿名内部类

匿名内部类的定义格式：
接口名称 对象名 = new 接口名称() {
// 覆盖重写所有抽象方法
};

对格式“new 接口名称() {…}”进行解析：

new代表创建对象的动作
接口名称就是匿名内部类需要实现哪个接口
{…}这才是匿名内部类的内容
另外还要注意几点问题：

匿名内部类，在【创建对象】的时候，只能使用唯一一次。
如果希望多次创建对象，而且类的内容一样的话，那么就需要使用单独定义的实现类了。
匿名对象，在【调用方法】的时候，只能调用唯一一次。
如果希望同一个对象，调用多次方法，那么必须给对象起个名字。
匿名内部类是省略了【实现类/子类名称】，但是匿名对象是省略了【对象名称】
强调：匿名内部类和匿名对象不是一回事！！！

package com.xxxx.lambda;
/* 

- 匿名内部类:简化一些没有自己作用实现类,可以选择使用匿名内部类简化

-  */
  public class Demo01 {
  public static void main(String[] args) {
  	//new Demo().swimming();
  	

  //匿名内部類1
  //创建一个对象  没有名字的实现类的对象   是Swim接口的实现类的对象
  new Swim() {  //没有名字 的实现类的类型
  	@Override
  	public void swimming() {
  		// TODO Auto-generated method stub
  		
  	}

  ​	@Override
  ​	public void haha() {
  ​		// TODO Auto-generated method stub
  ​		
  ​	}
  }.swimming();;

  //匿名對象 : 只能在当前行使用一次
  new String("aaa").toString();

  ​	

  //匿名内部类 2
  Swim o = new Swim() {
  	@Override
  	public void swimming() {
  		System.out.println("打死犟嘴的,淹死会水的..");
  	}

  ​	@Override
  ​	public void haha() {
  ​		// TODO Auto-generated method stub
  ​		
  ​	}
  };

  o.swimming();
  o.swimming();
  o.swimming();
  o.swimming();
  o.haha();

  //匿名内部类3
  test(new Swim() {

  ​	@Override
  ​	public void swimming() {
  ​		System.out.println("hhhhhhhhhh");
  ​	}

  ​	@Override
  ​	public void haha() {
  ​		// TODO Auto-generated method stub
  ​		
  ​	}
  ​	
  });

  }

  //聚会  会游泳的
  static void  test(Swim s) {
  	s.swimming();
  }
  }

class Person{
	String name;
	

void eat() {}

}
interface Swim{
	void swimming();
	void haha();
}

class ZhangSan extends Person{}

class Lisi extends Person implements Swim{

@Override
public void swimming() {
	System.out.println("边喝水边游泳...");
}

@Override
public void haha() {
	// TODO Auto-generated method stub
	
}

}

//class Demo implements Swim{
//
//	@Override
//	public void swimming() {
//		System.out.println("边吃饭边游泳...");
//		
//	}
//}

Lambda表达式

• 一个 Lambda 表达式可以有零个或多个参数
• 参数的类型既可以明确声明，也可以根据上下文来推断。例如：(int a)与(a)效果相同
• 所有参数需包含在圆括号内，参数之间用逗号相隔。例如：(a, b) 或 (int a, int b) 或 (String a, int b, float c)
• 空圆括号代表参数集为空。例如：() -> 42
• 当只有一个参数，且其类型可推导时，圆括号（）可省略。例如：a -> return a*a
• Lambda 表达式的主体可包含零条或多条语句
• 如果 Lambda 表达式的主体只有一条语句，花括号{}可省略。匿名函数的返回类型与该主体表达式一致
• 如果 Lambda 表达式的主体包含一条以上语句，则表达式必须包含在花括号{}中（形成代码块）。匿名函数的返回类型与代码块的返回类型一致，若没有返回则为空

/*

- jdk1.8 新增Lambda表达式

- 作用:  简化匿名内部类的

- 使用前提: 函数式接口

- 函数式接口: 只有一个必须被重写的抽象方法的接口

- 强制检测是否为函数式接口: 注解@FunctionalInterface

- 

- 语法:

- () -> {}

- ():匹配要重写的抽象方法的参数列表

- ->:lambda符号  箭头符号 具有上下文推倒的作用

- {}::匹配要重写的抽象方法的方法体

-  */
  public class Lambda02 {
  public static void main(String[] args) {
  	//匿名内部类
  	/*
  	 * Smoke ss = new Smoke() {
  	 * 
  	 * @Override public void smoking() { System.out.println("00000"); } };
  	 */
  	

  //lambda1

  //		Smoke s = ()->{
  //			System.out.println("11111");
  //			System.out.println("11111");
  //		};
  //		s.smoking();
  //		s.smoking();
  //		s.smoking();
  	

  //lambda2 方法体中如果方法体语句只有一句,方法体前后的{}可以省略

  //		Smoke s = ()->System.out.println("11111");
  //		s.smoking();
  //		s.smoking();
  //		s.smoking();
  	
  	

  //lambda3  如果有参数,参数的数据类型可以省略

  //		Smoke s = (a, b)->System.out.println("11111"+a+b);
  //		s.smoking(1,2);
  //		s.smoking(2,3);
  //		s.smoking(4,5);
  	

  //lambda4  如果有参数只有一个,前后的()可以省略

  //		Smoke s = a->System.out.println("11111"+a);
  //		s.smoking(1);
  //		s.smoking(2);
  //		s.smoking(4);
  	

  //lambda5 如果语句体还有一句,并且3还是return语句,return关键字 以及前后{}可以一起省略
  Smoke s = a-> "返回"+a;

  System.out.println(s.smoking(2));;
  System.out.println(s.smoking(3));;

  }
  }

@FunctionalInterface
interface Smoke{
	String smoking(int a);
}