内部类

1 成员内部类创建对象  外部类.内部类     

对象名=new 外部类对象.new内部类对象

Outer.Inner i=new Quter().new Inner();

　　内部类可以访问外部类私有

 

　　外部类访问内部类 需要创建对象

　　外部类名.内部类名 对象名=new 外部类对象.new内部类对象

　　

       私有内部类 不能通过上述方法创建对象，在自己所在的内部类中创建对象

　　静态内部类 创建对象   外部类名.内部类名 对象名=new 外部类名.内部类名（）；

　　

package com.yang.innerClass;

public class Car {
    String brand="外部类小马";
    class Engin{
        String brand="内部类中马";
        public void run(){
            String brand="局部老马";
            System.out.println(brand+this.brand+Car.this.brand);
        }
    }

}

　　

package com.yang.innerClass;

public class MTest {
    public static void main(String[] args) {
        Car.Engin c=new Car().new Engin();
        c.run();
    }
}

 

　　

2 局部内部类（该类在类的成员方法中）

只能在内部类所在的方法中，创建对象并访问

该内部类可以访问外部类成员，也可以访问方法的局部变量

 

匿名内部类

　　new 接口名 或者类名(){

　　　　重写方法

}.方法

　　

package com.yang.innerclass;

public class MTest {
    public static void main(String[] args) {
        new Inner(){
            public void study(){
                System.out.println("好好学习");
            }
            public void  show(){
                System.out.println("show......");
            }
        }.show();
    }
}

 

想用两个方法  Inner i=new Inner(){实现}; i.方法；

　　

package com.yang.innerclass;

public interface Inner {
    public abstract void study();
    public  void show();
}

 

 

Lambda表达式 函数式编程思想 （自己想做什么）

1 必须是接口

2 抽象方法数量必须是一个，只能是一；

三要素 形式参数 箭头 代码块

　　　　（形式参数） -> {代码块}

 

package com.yang.Lambda;

public class TestLambda {
    public static void main(String[] args) {
        useShowHandler(()-> System.out.println("Labmbda使用方法"));
    }

    public static void useShowHandler(ShowHandler showHandler){
            showHandler.show();
    }
}
interface ShowHandler{
    void show();
}

　　

package com.yang.Lambda;

public class TestLambda1 {
    public static void main(String[] args) {
        printMessage((String mes)->{
            System.out.println("匿名内部类"+mes);
        });
    }
    public static void printMessage(StringHander stringHander){
        stringHander.printMessage("王");
    }
}
interface StringHander{
    void printMessage(String mes);
}

 

　Lambda无参带有返回值　

package com.yang.innerReturn;

import java.util.Random;

public class MTest {
    public static void main(String[] args) {
        getNum(()->{
            Random random=new Random();
            int i=random.nextInt(10)+1;
            return i;
        });
    }
    public static void getNum(InnerHander innerHander){
        System.out.println(innerHander.getNum());
    }
}

 

　　

package com.yang.innerReturn;

public interface InnerHander {
    int getNum();
}

 

Lambda 有参数有返回值  和上面的例子类似就不写了

Lambda省略模式  参数可以省略，如果参数有多个不能只省略一个，参数只有一个可以省略小括号，大括号中只有一条语句 大括号可以省略 renturn 可以省略，分号可以省略

package com.yang.innerReturn1;

import com.yang.innerReturn.InnerHander;

import java.util.Random;

public class MTest {
    public static void main(String[] args) {
        getNum(()-> new Random().nextInt(10)+1
        );
    }
    public static void getNum(InnerHander innerHander){
        System.out.println(innerHander.getNum());
    }
}

 

Lambda表达式和匿名内部类

匿名内部类 可以接口，可以抽象类，可以具体类。 编译后会产生独立字节码文件

Lambda 只能是接口 只能有一个抽象方法。编译后不会产生字节文件，对应的字节码会在运行中动态的生成。