内部类（Java）

内部类（Java）

hello hello~ ，这里是 code袁~💖💖 ，欢迎大家点赞🥳🥳关注💥💥收藏🌹🌹🌹

💥个人主页：code袁
💥 所属专栏：Java

1、内部类

内部类是指定义在另一个类内部的类。在Java中，内部类可以分为四种类型：成员内部类、静态内部类、局部内部类和匿名内部类

2、成员内部类

2.1 定义

成员内部类：成员内部类是定义在另一个类的内部，并且可以访问外部类的成员变量和方法。成员内部类可以使用外部类的实例来创建对象，也可以直接使用外部类的静态成员。

public class Outer {
    private int age=12;
    //成员内部类
    public class Inner{
        private String name;
        
        public void test(){
            System.out.println("ooo");
        }
        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }
    }
}

2.2 使用

public class Test {
    public static void main(String[] args){
        //成员内部类的使用
        Outer.Inner in=new Outer().new Inner();
        in.test();
    }
}

2.3 成员内部类变量的使用

public class Inner{
        private String name;
        private int age=55;

        public void test(){

            //成员内部类访问外部类
            int age=12;
            System.out.println(age);
            //访问内部变量
            System.out.println(this.age);
            //访问外部变量
            System.out.println(Outer.this.age);
        }
    }

3、静态内部类

3.1 定义

静态内部类：静态内部类是使用static关键字修饰的内部类，它与外部类的实例无关，可以直接通过外部类名访问。静态内部类不能访问外部类的非静态成员，但可以访问外部类的静态成员。

public class Outer {
    //静态内部类
    public static class Inner{
        private String name;
        public void test(){
           
        }
    }
}

3.2 使用

public class Test {
    public static void main(String[] args){
        //静态内部类的访问 可以直接访问
        Outer.Inner inner=new Outer.Inner();
        inner.test();
    }
}

3.3 注意事项

1、静态内部类可以直接访问外部类的静态成员吗？ 可以的
2、静态内部类中是否可以直接访问外部类的实例成员？ 不可以的

4、局部内部类

4.1 定义

局部内部类：局部内部类是定义在方法内部的类，作用域仅限于所在方法内部。局部内部类可以访问外部方法的局部变量，但这些变量必须是final的或事实上是final的。

public class Outer {
    public void outerMethod() {
        final int localVar = 10;

        class LocalInner {
            public void localInnerMethod() {
                System.out.println("Accessing localVar from local inner class: " + localVar);
            }
        }

        LocalInner inner = new LocalInner();
        inner.localInnerMethod();
    }
}

5、匿名内部类

5.1 定义

匿名内部类：匿名内部类是没有类名的内部类，通常用于创建只需使用一次的类的实例。匿名内部类通常用于实现接口或继承抽象类。

public class Test {
    public static void main(String[] args){
        Animal a=new Animal(){
            @Override
            public void cry(){
                System.out.println("11111");
            }
        };
        a.cry();
    }
}
//抽象类
abstract class Animal{
    public abstract void cry();
}

5.2 使用

package com.ham.demo1.dy08_NoNameClass;

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

        Swimming s1=new Swimming() {
            @Override
            public void swim() {
                System.out.println("游泳");
            }
        };
        go(s1);
    }

    //定义方法
    public static void go(Swimming swimming){
        System.out.println("开始——————————————————");
        swimming.swim();
    }
}

interface Swimming{
    void swim();
}

在上面的示例中，我们创建了一个匿名内部类来实现Swimming接口，
并重写了其中的swim方法。然后我们创建了一个go对象，
并将这个匿名内部类的实例传递给的go构造函数，最后启动线程执行其中的逻辑。

5.3 注意事项

匿名内部类的优点在于可以简化代码结构，避免单独定义一个类，使得代码更加紧凑和易读。它通常用于只需要一次性使用的场景，避免了定义一个完整的类的开销。
需要注意的是，匿名内部类在定义时可以访问外部类的成员变量和方法，但需要将外部类的成员变量声明为final或事实上是final的。这是因为匿名内部类在编译时会创建一个单独的对象，如果外部类的成员变量发生变化，可能会导致匿名内部类访问到的是旧值。
总的来说，匿名内部类是一种方便且灵活的方式来实现接口或继承抽象类，适用于一次性使用的场景，能够简化代码并提高代码的可读性。

🎉写在最后

🍻伙伴们，如果你已经看到了这里，觉得这篇文章有帮助到你的话不妨点赞👍或 Star ✨支持一下哦！手动码字，如有错误，欢迎在评论区指正💬~

你的支持就是我更新的最大动力💪~