java基础--内部类和Lamda表达式

       内部类是在java内部又定义的内部类，它最大的优势在于，它可以访问外部类所有的数据成员，但外部类不能访问内部类的私有成员，使用最多的是匿名内部类。java 8根据匿名为简化匿名内部类的写作习惯，提出了lamda表达式。

        首先我们看一下内部类的定义和引用：

  

/*普通内部类*/
class Out{
	class In{
		public in(String msg){
			System.out.println(msg);
		}
	} 
}

public class CreateInfo{
	public static void main(String[] msg){
		Out.In in=new Out().new In("测试信息");//内部类的定义是通过类来定义的
		
	}
}

/*静态内部类*/
class StaticOut{
	Static class StaticIn{
		public StaticIn(){
			System.out.println("静态内部测试类");
		}
	}
}

public class TestStaticOut{
	public static void main(String[] args){
		StaticOut.StaticIn in=new StaticOut.StaticIn();
	}
}

/*匿名内部类*/
interface Person(){
	public String getName();
	public String getId();
}

public Class TestPerson(){
	public void testt(Person per){
		System.out.println(per.getName());
	}
	
	public static void main(String[] args){
		public final String name="LiMing";
		ta.test(new Person(){
			public String getName(){
				return name;
			}
			public String getId(){
				return "1";
			}
		})
	}
}

       匿名内部类是定义类的接口，在方法使用时才初始化相应的类和对象，因此它所具有如下特性：

       

        1、只用到类的一个实例。
        2、类在定义后马上用到。
        3、类非常小（SUN推荐是在4行代码以下）
        4、给类命名并不会导致你的代码更容易被理解。

        因为匿名内部类的使用都是在方法内部重新定义类的整个过程，相对复杂了很多，因此大家就想办法简化内部类，最终定义了lamda表达式。

        lamda表达式的组成成分：参数列表，箭头（->）和代码块。实现的接口必须是函数式接口（只包含一个抽象方法的接口），例如java 8 的runable接口。

	@FuncitonalInterface
	Interface FkTest
	{
		Void run();
	} 
	
	Object obj2=(FkTest)()->{
		For(int i=0;i<100;i++){
			System.out.println();
		}
	}

         因为FkTest只定义了run（）抽象方法，（）表示参数列表为空，箭头后面是代码块。

         下面通过lamda表达式实现命令模式：

/*lamda表达式化简匿名内部类对象--新命令模式*/
interface Command(){
	public void process(int[] target);
}

public class ProcessAttray {
	public void process(int[] target,Command cmd){
		cmd.process(target);
	}
}

public class testCommand{
	public static void main(String[] args){
		ProcessAttray proA=new ProcessAttray();
		int[] intArray={2,1,5,5};
		proA.target(intArray,(int[] target)->{
			int sum=0;
			for(int tmp:target){
				sum+=tmp;
			}
			System.out.println("数组元素的和是："+sum);
		})
	}
}

        内部类和lamda表达式都是建立在类存在时间非常短，只有一次应用的基础上，否则我们使用单纯的接口继承即可。