java面向对象进阶进阶篇--《成员、静态、局部、匿名内部类》

最新推荐文章于 2024-09-02 22:29:33 发布

●VON

最新推荐文章于 2024-09-02 22:29:33 发布

阅读量756

点赞数 16

分类专栏： java从入门到起飞文章标签： java 开发语言 gpt 学习方法面向对象

本文链接：https://blog.csdn.net/2302_80329073/article/details/140698598

版权

java从入门到起飞专栏收录该内容

25 篇文章 0 订阅

订阅专栏

个人主页→VON

收录专栏→java从入门到起飞

接口和接口与抽象类综合案例

一、成员内部类

Java 中的成员内部类是定义在另一个类中的类。它具有与普通类相似的结构，但有一些特殊的访问规则和使用方式。

特性：

定义方式：

成员内部类的定义方式如下：

public class OuterClass {
    // 外部类的成员和方法

    class InnerClass {
        // 内部类的成员和方法
    }
}

内部类 InnerClass 定义在外部类 OuterClass 的内部，可以直接访问外部类的成员变量和方法，包括私有成员。

访问规则：

外部类可以直接访问内部类的成员，包括私有成员。
内部类可以访问外部类的所有成员，包括私有成员。
内部类可以被声明为 private、protected、public 或 package-private（默认），其访问权限不影响外部类对内部类的访问权限。

实例化：

成员内部类需要通过外部类的实例来实例化，例如：

OuterClass outer = new OuterClass();
OuterClass.InnerClass inner = outer.new InnerClass();

这里 new InnerClass() 必须依附于一个外部类的实例 outer。

生命周期：

成员内部类的生命周期和外部类的实例绑定，如果外部类实例被销毁，则内部类实例也无法再被访问。

静态成员：

成员内部类可以包含静态成员（静态字段或静态方法），但不能有静态的顶层类（即不能声明为 static class InnerClass）。

使用场景：

封装性：可以将内部类隐藏在外部类中，只有外部类才能访问，从而增强了封装性。
逻辑关联：当内部类只对外部类可见并且仅用于实现外部类的一部分功能时，使用成员内部类能够更清晰地表达逻辑关联性。
回调函数：内部类通常用于实现回调函数，例如事件监听器的实现方式。
复杂数据结构：可以使用内部类来实现复杂的数据结构，例如迭代器等。

示例：

Outer类：

package com.von.day15e;

public class Outer {
    private int a = 10;
    class Inner{
        private int a = 20;
        public void show(){
            int a = 30;
            System.out.println(Outer.this.a);//10
            System.out.println(this.a);//20
            System.out.println(a);//30
        }
    }
}

Text测试类：

package com.von.day15e;

public class Text {
    public static void main(String[] args) {
        Outer outer = new Outer();//先创建外部类的对象
        Outer.Inner inner = outer.new Inner();//再创建内部类的对象
        inner.show();
    }
}

结果展示：

二、静态内部类

Java 中的静态内部类是定义在另一个类中且使用 static 修饰的类。静态内部类与非静态内部类（即成员内部类）有着一些重要的区别和特性。

特性：

定义方式：

静态内部类的定义方式如下：

public class OuterClass {
    // 外部类的成员和方法

    static class StaticInnerClass {
        // 内部类的成员和方法
    }
}

内部类 StaticInnerClass 被声明为 static，因此它与外部类 OuterClass 的实例无关，可以直接通过 OuterClass.StaticInnerClass 的方式访问。

访问规则：

静态内部类可以直接访问外部类的静态成员和静态方法，包括私有的静态成员。
静态内部类不能直接访问外部类的非静态成员和实例方法，因为静态内部类在没有外部类实例的情况下也可以存在。

实例化：

静态内部类的实例化与普通类类似，不需要依附于外部类的实例，例如：

OuterClass.StaticInnerClass inner = new OuterClass.StaticInnerClass();

生命周期：

静态内部类的生命周期与外部类的生命周期无关，它独立存在于外部类之外，直到虚拟机结束或被回收。

静态成员：

静态内部类可以包含静态成员（静态字段或静态方法），但不能直接访问外部类的非静态成员。

使用场景：

独立功能模块：当内部类不需要访问外部类的实例变量或方法，且希望将其组织为一个独立的类时，可以使用静态内部类。
增强封装性：静态内部类可以有效地隐藏实现细节，仅暴露必要的接口给外部。
工厂模式：可以将静态内部类作为工厂类，用于创建外部类的实例。
辅助类：可以作为外部类的辅助类来实现一些特定的功能，例如迭代器、比较器等。

示例：

Outer类：

package com.von.day15f;

public class Outer {
    //静态内部类
    static class Inner{
        public void show1(){
            System.out.println("静态内部类非静态方法");
        }
        public static void show2(){
            System.out.println("静态内部类静态方法");
        }
    }
}

Text测试类：

package com.von.day15f;

public class Text {
    public static void main(String[] args) {
        Outer.Inner inner = new Outer.Inner();
        inner.show1();//非静态方法
        inner.show2();//静态方法
        Outer.Inner.show2();//一般用这种方法
    }
}

结果展示：

三、局部内部类

局部内部类（Local Inner Class）是定义在方法体内部的类，它与方法的局部变量具有相似的作用域。局部内部类可以访问外部类的成员变量和方法，以及方法中的 final 局部变量（Java 8 之后可以访问非 final 局部变量，但是需要保证该变量在局部内部类中不发生改变）。

特性：

定义方式：

局部内部类的定义位于方法内部，形式如下：

public class OuterClass {
    // 外部类的成员和方法

    public void outerMethod() {
        class LocalInnerClass {
            // 局部内部类的成员和方法
        }

        // 在方法内部实例化局部内部类
        LocalInnerClass inner = new LocalInnerClass();
    }
}

访问规则：

局部内部类只在方法内部有效，出了方法就无法访问。
局部内部类可以访问外部类的所有成员，包括私有成员。
局部内部类可以访问方法内的局部变量，但是要求局部变量必须是 final 的或者在 Java 8 及以后版本中被隐式声明为 final。

生命周期：

局部内部类的生命周期仅限于方法调用过程中，当方法返回时，局部内部类的对象也会被销毁。

使用场景：

当一个类仅在方法内部使用，并且对外部代码没有任何意义时，可以考虑使用局部内部类，这样能够将相关逻辑封装在一起，提高代码的局部性和封装性。
在需要实现某些接口或继承某个类，并且仅在方法中使用时，局部内部类是一个比较合适的选择。

示例：

Outer类：

package com.von.day15g;

public class Outer {
    int a=10;
    public void show(){
        int b=20;
        //局部内部类
        class Inner{
            String name;
            int age;
            public void text1(){
                System.out.println("测试一");
            }
            public void text2(){
                System.out.println("测试二");
            }
        }

        Inner inner=new Inner();
        inner.text1();
        inner.text2();
        System.out.println(a);
        System.out.println(b);
    }
}

Text类：

package com.von.day15g;

public class Text {
    public static void main(String[] args)
    {
        Outer outer = new Outer();
        outer.show();
    }
}

结果展示：

四、匿名内部类（重点）

匿名内部类（Anonymous Inner Class）是一种没有显式定义类名的内部类，它允许在创建对象的同时定义类的实例。通常情况下，匿名内部类用于创建一个只需使用一次的类的实例，避免了显式定义一个新的类

特性和使用场景：

语法：

匿名内部类的语法比较特殊，通常在创建对象时使用，形式如下：

interface Greeting {
    void greet();
}

public class Main {
    public static void main(String[] args) {
        Greeting greeting = new Greeting() {
            public void greet() {
                System.out.println("Hello, world!");
            }
        };

        greeting.greet(); // 输出 "Hello, world!"
    }
}

在这个例子中，Greeting 是一个接口，通过匿名内部类的方式实现了 greet() 方法。

特性：

匿名内部类没有类名，直接在创建对象的地方定义类的实例。
匿名内部类必须继承一个类或实现一个接口，不能同时做到。
匿名内部类不能定义任何静态成员、方法和初始化块。
匿名内部类可以访问外部类的成员变量和方法，但是外部类的局部变量必须是 final 的或者事实上的 final（Java 8+）。

使用场景：

事件监听器：在GUI编程中，常常使用匿名内部类作为事件监听器的实现。
线程类：在启动线程时，可以通过匿名内部类直接定义线程类的实例。
集合类的参数：在某些集合类的方法参数中，需要传递接口实例，可以使用匿名内部类快速实现接口方法。

示例：

Animal类：

package com.von.day15g;

public class Animal {
    public void eat() {
        System.out.println("吃东西");
    }
}

Swim类：

package com.von.day15g;

public interface Swim {
    abstract void swim();
}

Text测试类：

package com.von.day15g;

public class Text {
    public static void main(String[] args){
        new Swim(){
            @Override
            public void swim() {
                System.out.println("匿名内部类实现接口");
            }
        }.swim();
        new Animal(){
            @Override
            public void eat() {
                System.out.println("匿名内部类实现抽象类");
            }
        }.eat();
        methon(
            new Animal(){
                @Override
                public void eat() {
                    System.out.println("狗吃骨头");
                }
            });
    }
    public static void methon(Animal a){
        a.eat();
    }
}
package com.von.day15g;

public class Text {
    public static void main(String[] args){
        new Swim(){
            @Override
            public void swim() {
                System.out.println("匿名内部类实现接口");
            }
        }.swim();
        new Animal(){
            @Override
            public void eat() {
                System.out.println("匿名内部类实现抽象类");
            }
        }.eat();
        methon(
            new Animal(){
                @Override
                public void eat() {
                    System.out.println("狗吃骨头");
                }
            });
    }
    public static void methon(Animal a){
        a.eat();
    }
}

Text2测试类：

package com.von.day15g;

public class Text2 {
    public static void main(String[] args) {
        Swim s =  new Swim(){

            @Override
            public void swim() {
                System.out.println("游泳");
            }
        };
        s.swim();

        new Swim(){
            @Override
            public void swim() {
                System.out.println("游泳");
            }
        }.swim();
    }
}

结果展示：

●VON

关注

16
点赞
踩
21

收藏

觉得还不错? 一键收藏
3
评论
java面向对象进阶进阶篇--《成员、静态、局部、匿名内部类》

Java 中的成员内部类是定义在另一个类中的类。它具有与普通类相似的结构，但有一些特殊的访问规则和使用方式。成员内部类的生命周期和外部类的实例绑定，如果外部类实例被销毁，则内部类实例也无法再被访问。成员内部类可以包含静态成员（静态字段或静态方法），但不能有静态的顶层类（即不能声明为。的内部，可以直接访问外部类的成员变量和方法，包括私有成员。必须依附于一个外部类的实例。
复制链接

扫一扫