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表达式都是建立在类存在时间非常短，只有一次应用的基础上，否则我们使用单纯的接口继承即可。