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

秒速五厘米 2022-07-15 06:22 171阅读 0赞

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