JAVA基础知识点12-接口、内部类、成员内部类、私有内部类、静态内部类、匿名内部类、局部内部类、lambda

接口:
    公共的抽象方法
    公共的静态的常量

父类:
接口:

java8新增:
    可以在接口中定义带有方法体的方法
    静态方法 : 根据接口名使用
    默认方法 : 根据实现类使用

内部类: (理解)
    类中定义类
    当类中的成员也是一种事物,可以把这个成员定义为内部类

内部类的分类:
    1.成员内部类
    2.私有内部类
    3.静态内部类
    4.匿名内部类 ***
    5.局部内部类
    lambda

 1.成员内部类:
    内部类作为外部类的成员,就称为成员内部类
    成员内部类既有成员的特点,又有类的特点
        可以成员修饰符进行修饰: 权限修饰符 static final.
        类可以继承,实现..

    定义:
        成员内部类中静态的内容不能定义,除了静态常量
    使用:
        在成员内部类中可以直接使用外部类中的成员,包括私有的
        使用内部类中的成员要通过内部类对象使用,包含私有的
        其他类中使用内部类中的成员,需要通过外部类对象构建内部类对象,使用内部类的成员

public class Outer01 {
    //类中方法外->成员
    public int i = 1;
    private int j = 11;

    //成员内部类
    class Inner extends A{
        //静态常量
        static final int A = 5;
        public int b = 15;
        private int c = 20;

        //成员方法
        public void inner(){
            System.out.println(i);
            System.out.println(j);
        }
    }

    //外部类的成员方法
    public void outter(){
        System.out.println(Inner.A);
        //使用内部类中的成员要通过内部类对象使用
        Inner in = new Inner();
        System.out.println(in.b);
        System.out.println(in.c);
        in.inner();
    }

}

 2.私有内部类：
    在私有内部 类中可以直接使用外部类的成员,包含私有
    在外部类中可以通过私有内部类的对象直接使用私有内部类的成员,包含私有
    在其他类中无法使用私有内部类
    可以间接使用私有内部类中的私有成员,可以作为外部类方法的参数返回

public class Outer03 {
    //私有成员变量
    private int i = 1;

    //私有内部类
    private class Inner{
        //私有内部类的私有成员
        private String a = "私有内部类的私有成员";

        private void inner(){
            System.out.println(i);
        }
    }

    public String outer(){
        Inner in = new Inner();
        System.out.println(in.a);
        in.inner();

        return in.a;
    }
}

 3.静态内部类：
    静态内部类中定义静态内容,可以定义成员
    在内部类中可以直接使用外部类中静态的内容,如果想要使用外部类中成员的内容,通过外部类对象使用

public class Outer04 {
    //静态变量
    static int i = 1;
    //成员变量
    int j = 10;

    //静态内部类
    static class Inner{
        static String a = "静态内部类中的静态变量a";
        String b = "静态内部类中的成员变量b";

        static void testStatic(){
            System.out.println("静态内部类中的静态方法");

            System.out.println(a);
            System.out.println(new Inner().b);

            System.out.println(i);
            System.out.println(new Outer04().j);

        }

        void test(){
            System.out.println("静态内部类中的成员方法");

            System.out.println(i);
            System.out.println(new Outer04().j);
            System.out.println(a);
            System.out.println(b);
        }
    }
}

 4.匿名内部类:
    没有名字的内部类

public class Outer06 {
    public static void main(String[] args) {
        Plant plant = new Plant();
        plant.run();

        new HaHa().run();

        //接口多态
        Run haha = new HaHa();
        haha.run();


        //匿名内部类的第一种使用方式: 只在当前行使用一次,后续无法继续使用
        //1.创建没有名字的实现类对象
        new Run(){ //Run实现类的类体,只不过这个实现类没有名字
            @Override
            public void run() {
                System.out.println("变跑变傻笑...");
            }
        }.run();


        //2..匿名内部类的第二种使用方式: 引用指向匿名内部类对象,后续可以多次使用
        Swim swim = new Swim(){

           @Override
           public void swimming() {
               System.out.println("蛙泳...");
           }

           @Override
           public void drink() {
               System.out.println("喝水...");
           }
       };
        swim.swimming();
        swim.drink();

        //3.匿名内部类做参数传递
        test(new Swim() {
            @Override
            public void swimming() {

            }

            @Override
            public void drink() {

            }
        });
    }

    static void test(Swim swim){
        swim.swimming();
    }

}

interface Swim{
    void swimming();
    void drink();
}

interface Run{
    void run();
}

//为了使用接口中的某一个抽象方法,所以需要定义一个实现类,实现这个接口,重写抽象方法,才能通过实现类对象调用
class HaHa implements Run{
    @Override
    public void run() {
        System.out.println("变跑变笑...");
    }
}

//飞机类
class Plant implements Run{
    String brand;


    @Override
    public void run() {
        System.out.println("加速跑...");
    }
}

 5.局部内部类：
   只能在所定义的方法中使用
   如果局部内部类中使用所在方法的参数,默认被final修饰(java7手动添加final,java8之后默认final)

public class Outer05 {
    static int a = 123;

    public static void main(String[] args) {

    }

    void outer(final int args){
        //局部
        int i =1;
        
        //局部内部类
        class Inner{
            //局部内部类成员变量
            String str = "局部内部类成员变量";

            void  inner(){
                System.out.println(i);
                System.out.println(a);
                System.out.println(args);
            }
        }

        Inner in = new Inner();
        System.out.println(in.str);
        in.inner();

        //args = 100;
    }
}

 

lambda
    目的: 为了简化大量使用匿名内部类,可以java8提供的lambda表达式简化

    前提: 函数型接口
    函数型接口:  只要一个必须要被重写的抽象方法的接口
    检查函数型接口的注解: @FunctionalInterface
    语法:
        ()->{}
        (): 重写的抽象方法的参数列表
        ->: lambda符号,箭头符号
        {}: 重写抽象方法的方法体{}

    注意:
        lambda体重写哪一个接口的抽象方法,看前面的引用

 

public class Demo02 {
    public static void main(String[] args) {
//方法一简化匿名内部类
        eat e = ()->{
            System.out.println("吃饭二");
        };
        e.show();
//方法二如果lambda中的方法体{}中语句体只有一句,前后的{}可以省略
        e = ()-> System.out.println("吃饭三");
        e.show();
//方法三如果抽象方法的有形参,参数的数据类型可以省略
        sleep sl = (a)->System.out.println("睡觉" + a + "小时");
        sl.show(6);
//方法四如果抽象方法的有形参,并且参数只有一个,前后()可以省略
        sl = a->System.out.println("睡觉" + a + "小时");
        sl.show(7);
//方法五如果语句体只有一句,并且是return语句
        sum s = a -> a + 10;
        System.out.println(s.show(5));
    }
}

interface eat{
    void show();
}
interface sleep{
    void show(int a);
}
interface sum{
    int show(int a);
}