Java基础之内部类

Java基础之内部类

引言

内部类顾名思义：类中可以存在一个类！

- 成员内部类

我们的类中可以在嵌套一个类：

public class Demo_test {

    @Data
    public class inner_Two{
        private int age;
        private String name;
    }
    
}

成员内部类和成员变量和成员方法一样，都是属于对象的，也就是说，必须存在外部对象，才能创建内部类的对象！

public class Main {
    public static void main(String[] args) {

//        1.成员内部类创建实例方法:需要先创建类实例，再用类实例创建内部类对象
        Demo_test demo_test = new Demo_test();
        Demo_test.inner_Two inner_two = demo_test.new inner_Two();
        inner_two.setAge(12);
        inner_two.setName("魏");
        System.out.println(inner_two.toString());
    }
}

- 静态内部类

静态内部类其实就和类中的静态变量和静态方法一样，是属于类拥有的，我们可以直接通过类名.去访问:

public class Demo_test {

    @Data
    public static class inner {
        private int age;
        private String name;

    }
}

public class Main {
    public static void main(String[] args) {

//        2.静态内部类创建实例方法：用类.内部类名创建内部类对象
        Demo_test.inner inner= new Demo_test.inner();
        inner.setAge(10);
        inner.setName("魏");
        System.out.println(inner.toString());
    }
}

- 局部内部类

和局部内部类类似

public class Main {

    public static void main(String[] args) {
		test();
    }
    
        //        3.局部内部类
    public static void test(){

        @Data
        class inner{
            public int age;
            public String name;
        }
        
        inner inner = new inner();

        inner.setAge(10);
        inner.setName("魏");
        System.out.println(inner.toString());
    }
}

- 匿名内部类

匿名内部类是对接口或抽象类的实现：

public abstract class Person {
    
    public abstract void run();
    
}

public class Main {
    public static void main(String[] args) {

//        4.匿名内部类：对接口或抽象类的直接实现
        Person person=new Person() {
            @Override
            public void run() {
                System.out.println("人跑了");
            }
        };
        
    }
}

注：无法实现复用，只能在这里使用！

- lambda表达式

lambda表达式是对接口匿名实现的简化

它仅对内含一个抽象方法的接口有效

- 内含一个无参方法

public interface Dog {
    public abstract void run();
}

public class Main {
    public static void main(String[] args) {
    
//        匿名内部类格式
        Dog dog1=new Dog() {
            @Override
            public void run() {
                System.out.println("狗子跑了");
            }
        };

//        lambda表达式格式
        Dog dog=()->{
            System.out.println("狗子跑了");
        };
        
        
    }
}

- 内含一个有参方法

public interface Cat {
    public abstract String name(String name);
}

public class Main {
    public static void main(String[] args) {
    
//        匿名内部类格式
        Cat cat=new Cat() {
            @Override
            public String name(String name) {
                return null;
            }
        };

//        lambda表达式格式
        Cat cat1=name ->null;
        
        
    }
}

- lambda表达式拓展使用