java-07 内部类、匿名内部类、局部内部类、lambda

本文主要记录内部类、匿名内部类、局部内部类、lambda表达式的用途和lambda表达式的推导及使用

1.直接内部类

　　直接内部类可以分为两种： 成员内部类和静态内部类

　　1.1 成员内部类

　　　　　　成员内部类，就如同成员一样存在一个类中，该内部类可以直接访问外部类成员和方法，但是外部类不能使用内部类方法或者属性。

　　　　　　成员内部类访问外部类属性或方法的方式： 外部类名.this.成员名/方法名

　　　　　　成员内部类声明方式： （假设外部类叫Outer 内部类叫Inner）  Outer.Inner inner = new Outer().new Inner();

public class TestInnerClass {
    private String name;  //外部类属性 
    private int age;
    
    
    class InnerClass{ //内部类以成员的方式存在外部类中
        public void test() {
            TestInnerClass.this.name = "张三";  //内部类修改外部类值 
        }
        
        public void print() {
            System.out.println(TestInnerClass.this.name);
        }
    }
    
    public static void main(String[] args) {
        //声明一个内部类对象
        TestInnerClass.InnerClass inner = new TestInnerClass().new InnerClass();
        inner.test(); 
        inner.print(); //张三
    }

}

　　1.2 静态内部类

　　　　　　顾名思义，静态内部类就是以外部类静态成员的方式存在在一个类中 该内部类不依靠外部类对象（这一点与成员内部类不同！）

　　　　　　同理，静态内部类可以访问外部类的静态成员或方法 

　　　　　　声明一个静态内部类的方式：  （假设外部类叫Outer 内部类叫Inner） Outer.Inner inner = new Outer().Inner();

　　　　　　

public class TestInnerClass {
    private static String name;  //外部类属性 
    private int age;
    
    
    static class InnerClass{ //内部类以成员的方式存在外部类中
        public void test() {
            TestInnerClass.name = "张三";  //内部类修改外部类值 
        }
        
        public void print() {
            System.out.println(TestInnerClass.name);
        }
    }
    
    public static void main(String[] args) {
        //声明一个内部类对象
        TestInnerClass.InnerClass inner = new TestInnerClass.InnerClass();
        inner.test(); 
        inner.print(); //张三
    }

}

2.匿名内部类

　　　　匿名内部类，实际上就是隐式的继承了一个接口或者抽象类，并实现该接口或抽象类的方法。

　　　　注意：匿名内部类是不能有构造函数的，这也就决定了每一个匿名内部类是只会用一次的。同时匿名内部类是不能存在任何静态变量或方法的。如果内部类想调用外部变量 则外部变量必须是final的。

　　　　语法  new 接口/抽象类 {　　类体实现　　}.调用方法（）。

interface Test{
    public void print();
}

public class TestNoName {
    public static void main(String[] args) {
        
        new Test() {
            
            @Override
            public void print() {
                // TODO Auto-generated method stub
                System.out.println("我是一个接口的匿名抽象类方法");
            }
        }.print();
        
    }
}

3.局部内部类

　　　　局部内部类就是方法内部的内部类，基本不使用，这里不介绍，请大家自行了解。

4.lambda表达式

　　　　lambda表达式时java8中一个重要的特性，虽然看起来非常高大上，实际上只是java的一个语法糖，最后还是由我们的编译器编译成正常的代码，不过对于程序员来说编写代码会更轻松，代码会更简洁。

　　　　基本语法：（params） ->  expression   或者  (params) -> {语句；}

// 1. 不需要参数,返回值为 5  
() -> 5  
  
// 2. 接收一个参数(数字类型),返回其2倍的值  
x -> 2 * x  
  
// 3. 接受2个参数(数字),并返回他们的差值  
(x, y) -> x – y  
  
// 4. 接收2个int型整数,返回他们的和  
(int x, int y) -> x + y  
  
// 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)  
(String s) -> System.out.print(s)

　　　　一些例子：

　　　　

String[] atp = {"Rafael Nadal", "Novak Djokovic",  
       "Stanislas Wawrinka",  
       "David Ferrer","Roger Federer",  
       "Andy Murray","Tomas Berdych",  
       "Juan Martin Del Potro"};  
List<String> players =  Arrays.asList(atp);  
  
// 以前的循环方式  
for (String player : players) {  
     System.out.print(player + "; ");  
}  
  
// 使用 lambda 表达式以及函数操作(functional operation)  
players.forEach((player) -> System.out.print(player + "; "));  
   

// 使用匿名内部类  
btn.setOnAction(new EventHandler<ActionEvent>() {  
          @Override  
          public void handle(ActionEvent event) {  
              System.out.println("Hello World!");   
          }  
    });  
   
// 或者使用 lambda expression  
btn.setOnAction(event -> System.out.println("Hello World!"));

// 1.1使用匿名内部类  
new Thread(new Runnable() {  
    @Override  
    public void run() {  
        System.out.println("Hello world !");  
    }  
}).start();  
  
// 1.2使用 lambda expression  
new Thread(() -> System.out.println("Hello world !")).start();  
  
// 2.1使用匿名内部类  
Runnable race1 = new Runnable() {  
    @Override  
    public void run() {  
        System.out.println("Hello world !");  
    }  
};  
  
// 2.2使用 lambda expression  
Runnable race2 = () -> System.out.println("Hello world !");  
   
// 直接调用 run 方法(没开新线程哦!)  
race1.run();  
race2.run();