java中的内部类（lambda表达式！）

• 内部类: 类中存在类,就是内部类
• 什么时候需要定义内部类:
• 在一个类中,内部的成员又是一个其他的事物,这个成员就可以定义为内部类
• class Car{

•  class 发动机{
  

•  }
  

• }
• 内部类的分类:
• 1.成员内部类
• 2.静态内部类
• 3.私有内部类
• 4.局部内部类
• 5.匿名内部类 ?**（重点）
• 成员内部类:
• 在外部类的成员位置,定义的类,叫做成员内部类
• 即是成员也是类,既有成员的特性,能够使用成员修饰符(public ,static…),既然是类就有类的特性,类之间可以继承,可以实现接口
• 内部类中可以 使用外部类中的内容,包括私有
• 在成员内部类中只能定义静态的常量,其他静态内容不可以
• 在外部类中通过内部类的对象使用内部类中的内容
• 内部类编译后使用$表示
• 在其他类中如何使用内部类中的内容:
  外部类 引用 = new 外部类();
  外部类.内部类 引用 =引用.new 内部类();
  外部类.内部类 引用 =new 外部类().new 内部类();

• 私有内部类
  私有的内部类:
  只能在外部类中通过私有内部类的对象使用私有内容
  public class PrivateInner {
  private int a=10;
  //私有的内部类
  private class Inner{
  private String name=“施哥”;
  private int age=19;
  //成员方法
  private void inner(){
  System.out.println(a);
  System.out.println(name);
  System.out.println(age);
  }
  }
  //外部类中的成员方法
  public void outer(){
  Inner in=new Inner();
  System.out.println(in.name);
  System.out.println(in.age);
  in.inner();
  }
  }

• 静态内部类:

• 只能在静态的内部类中定义静态的内容,除了静态的常量

• 静态内部类可以定义静态的可以定义成员的

• 其他类中使用静态内部类中的内容:

• 外部类.内部类 引用 = new 外部类.内部类();
  */
  public class StaticInner {
  private int a=10;
  private static int b=22;

  //静态内部类
  static class Inner{
  static String name=“李四今天穿了一个纱裙”;
  int age=20;

  /*
   * 内部类中的静态方法中
   * 静态的内部类中的静态方法中,可以直接使用静态内部类和外部类中的静态内容,要通过对象使用非静态的内容
   */
  static void testStatic(){
  	System.out.println("我是静态内部类中的静态方法");
  	StaticInner staticInner=new StaticInner();
  	System.out.println(staticInner.a);
  	System.out.println(b);
  	System.out.println(name);
  	Inner in=new Inner();
  	System.out.println(in.age);
  }
  
  /*
   * 静态内部类中的成员方法
   * 静态的内部中的成员方法中可以直接使用静态内部类中的成员,可以直接使用外部类的中的静态的内容,但是外部类中的成员内部要通过外部类对象使用
   * 	因为静态的内部类也是静态的环境
   */
  void test(){
  	System.out.println("我是静态内部类中的成员方法");
  	System.out.println(age);
  	System.out.println(name);
  	System.out.println(b);
  	StaticInner staticInner=new StaticInner();
  	System.out.println(staticInner.a); 
  }
  

  }

  //外部类中的成员方法
  public void outer(){
  System.out.println(Inner.name);
  Inner in=new Inner();
  System.out.println(in.age);
  }

}
public class Test {
public static void main(String[] args) {
//其他类中使用成员内部类中的内容
//外部类 引用 = new 外部类();
Outer01 out=new Outer01();
//外部类.内部类 引用 =引用.new 内部类();
Outer01.Inner in=out.new Inner();
System.out.println(in.c);
in.inner();
//外部类.内部类 引用 =new 外部类().new 内部类();
Outer01.Inner in2=new Outer01().new Inner();
in2.inner();

	//私有内部类中的私有内容
	//PrivateInner.Inner in3=new PrivateInner().new Inner();
	
	//静态内部类中的内容
	//外部类.内部类  引用 = new 外部类.内部类();
	StaticInner.Inner in5=new StaticInner.Inner();
	System.out.println(in5.age);
	System.out.println(in5.name);
	in5.testStatic();
	in5.test();

	new Demo().new Inner().test();
}

}
局部内部类:

• 局部:{}–>作用域

• 方法中的内部类–>局部内部类

• 注意:

• 局部内部类中的内容只能在当前所有在方法中通过对象使用

• 局部内部类不能使用成员修饰符,但是final可以

• 在局部内部类中使用当前所在方法的参数,需要把这个参数定义为final修饰,jdk1.7及之前必须显示定义final,1.8中可以省略final,默认存在
  */
  public class LocalInner {
  int age=11;
  public String test(final int x){
  int a=10;
  //局部内部类
  class Inner{
  String name="";
  void test(){
  System.out.println(a);
  System.out.println(age);
  System.out.println(name);
  System.out.println(x);
  }
  }
  Inner in=new Inner();
  System.out.println(in.name);
  return in.name; //可以把局部内部类中的属性当做当前方法的返回值
  }
  void outer(){
  //方法中的局部不能在其他位置使用
  String name=test(5);
  System.out.println(name);
  }
  }
  public class Demo {
  int a=5;
  class Inner{
  int a=10;
  public void test(){
  int a=15;
  //分别获取到三个a的值
  System.out.println(a);
  Inner in=new Inner();
  System.out.println(in.a);
  Demo demo=new Demo();
  System.out.println(demo.a);

  	System.out.println(this.a);
  	System.out.println(Demo.this.a);
  }
  

  }
  }

• 匿名内部类:

•  简化接口的实现类|子类,可以使用匿名内部类
  

*/
public class AnonymousInner {
public static void main(String[] args) {
//HaHa ha=new HaHa();
//ha.run();
//匿名内部类,只能使用一次,用完销毁
/new Car(){ //–实现类的类体,就是匿名内部类的类体
@Override
public void run() {
System.out.println(“重写的run()方法,哈哈哈”);
}
@Override
public void run2() {
System.out.println(“重写的run2()方法,呵呵呵”);
}
}.run2();/
//通过引用使用,可以多次调用
Car car=new Car(){ //接口多态
@Override
public void run() {
System.out.println(“重写的run()方法,哈哈哈”);
}
@Override
public void run2() {
System.out.println(“重写的run2()方法,呵呵呵”);
}
};
car.run();
car.run2();
//匿名内部类可以作为一个方法的参数使用
test(new Car(){
@Override
public void run() {
System.out.println(“1”);
}
@Override
public void run2() {
System.out.println(“2”);
}
});
}
static void test(Car car){ //Car car=–>匿名内部类
car.run();
}
}
interface Car{
void run();
void run2();
}
//实现类只用了一次,没有其他作用,可以使用匿名内部类简化
/class HaHa implements Car{
@Override
public void run() {
System.out.println(“重写的run()方法,哈哈哈”);
}
}/

• Lambda表达式

• jdk1.8新增

• 目的:为了简化匿名内部类

• ()->{}

• (): 抽象方法的参数列表

• ->:箭头函数,箭头符号,具有上下文推倒的作用

• {}:抽象方法的方法体

• 前提:函数式接口

• 函数式接口:只有一个抽象方法的接口,叫做函数式接口

• 检测是否为函数式接口: @FunctionalInterface
  */
  public class LambdaDemo05 {
  public static void main(String[] args) {
  A a=null;
  /a=new A(){
  @Override
  public void a(int a) {
  System.out.println(“我是匿名内部类的方法体实现”);
  }
  };
  a.a();/

  /*a=()->{System.out.println("我是Lambda的方法体实现");};
  a.a();*/
  
  /*a=(age)->{System.out.println("抽象方法存在一个参数,参数的数据类型可以省略,前后()可以省略"+age);};
  a.a(20);*/
  
  /*a=(age,height)->{System.out.println("抽象方法存在2个参数,参数的数据类型可以省略,前后的()不可以省略"+age+height);};
  a.a(20,180);*/
  
  //a=(age,height)->System.out.println("抽象方法的方法体语句只有一句,前后的{}可以省略"+age+height);
  
  //如果抽象方法有返回值,只有一条返回值语句,return和前后的{}都可以省略
  a=(age,height)-> -111 ;
  System.out.println(a.a(18,185));
  

  }
  }

//函数式接口
@FunctionalInterface
interface A{
int a(int age,int height);
//void b();
}