详述静态内部类与非静态内部类

静态内部类

按照是否有static修饰分为静态内部类和非静态内部类，有static修饰
的为静态内部类，没有static修饰的为非静态内部类

public class Body {

	/**
	 * 静态有名内部类
	 */
	public static class Heart{

		public void beat(){
			System.out.println("正在跳动...");
		}
	}
}

public class Test {

	public static void main(String[] args) {
		Heart heart = new Body.Heart();
		heart.beat();
	}
	public void getHeart(){
	  Heart heart = new Body.Heart();
	}
}

非静态有名内部类

public class Body {

	/**
	 * 非静态有名内部类
	 */
	public class Heart{

		public void beat(){
			System.out.println("正在跳动...");
		}
	}

public void getHeart(){
	Heart heart=this.heart();
	Heart heart=new heart();
	heart.beat();//直接在非静态类中定义的非静态方法，在创建对象时，需要先创建外部类对象，也可以用默认的外部类对象
}
public static void getHeart(){
	Heart heart=new body().heart();
	heart.beat();//在非静态类中定义的静态方法，在创建对象时，必须先显式创建外部类对象
}
}

静态内部类仅能直接访问外部类的静态成员变量和方法，可以通过创建外部类的对象间接使用非静态的成员变量和方法。

public class OutClass {
	
	private double weight=72;
	
	public static void print(String name) {
		System.out.println(name);
	}
	
	static class InClass{
		{
			double weight = new OutClass().weight;//由于weight是非静态的，所以在静态内部类中使用时必须先创建外部类对象
			print("Tom");//由于print方法为静态方法，所以可以直接使用。
		}
	}
}

在非外部类中定义的内部类和局部变量一样，其使用范围从定义的位置开始到其所在直接语句块结束。

public class OutClass {
	public static void main(String[] args) {
		if(args!=null) {
			class InClass{
				
			}
		}
		InClass inClass = new InClass();//无法创建对象，因为内部类作用范围无法作用到这里
	}
}

只有有名静态内部类中才允许有静态成员（静态属性、静态代码块和静态方法）。
在局部变量作用的范围内，如果定义的内部类需要使用该局部变量，则该变量必须有final修饰。

public class OutClass {

	public void print(final String name) {//由于局部变量name要在InClass内部类中使用，所以需要加final；方法参数前面加final修饰表示只能在调用方法时为该参数指定值，不允许再在方法体中进行二次修改。
		final int weight = 9;//由于局部变量weight要在InClass内部类中使用，所以需要加final;
		class InClass{
			public void print() {
				System.out.println(name+","+weight);
			}
		}
		new InClass().print();
	}
	
	public static void main(String[] args) {
		new OutClass().print("Tom");
	}
}

public class OutClass {

	public static void main(String[] args) {
		final int i = 8;//由于局部变量i要在InClass内部类中使用，所以需要加final;
		class InClass {
			public void print() {
				System.out.println(i);
			}
		}
		InClass inClass = new InClass();
		inClass.print();
	}
}

Lambda表达式
Java支持Lambda 表达式始于Java 8，它的出现简化了函数式接口匿名内部类的语法，其表达式语法如下：([参数1], [参数2], [参数3],… [参数n])->{代码块}

interface  IComputer {
	int add(int a,int b);
}
public class Moon{
	public static void main(String[] args) {
		IComputer computer =new IComputer() {//匿名内部类

			@Override
			public int add(int a, int b) {
				System.out.println("Ok");
				return a+b;
			}
			
		};
		lambda表达式
		computer=(int a,int b)->{
			return a+b;
		};
		
		computer=(a,b)->{
			return a+b;
		};
	//如果方法没有返回值且只有一行代码，则Lambda表达式语法可以是这种形式：([参数1], [参数2], [参数3],.... [参数n])->单行语句，如下例：
	computer=(a,b)->a+b;	
		

如果方法有返回值且只有一行代码，则Lambda表达式语法可以是这种形式：([参数1], [参数2], [参数3],… [参数n])->表达式，如下例：

匿名内部类：
@FunctionalInterface
interface IComputer {
	int add(int a, int b);
}

public class Test {

	public static void main(String[] args) {
		IComputer computer = (a, b) -> {
			return a+b;
		};
		int result = computer.add(1,2);
		System.out.println(result);
	}
}

Lambda 表达式：
@FunctionalInterface
interface IComputer {
	int add(int a, int b);
}

public class Test {

	public static void main(String[] args) {
		IComputer computer = (a, b) -> a+b;
		int result = computer.add(1,2);
		System.out.println(result);
	}
}