Question

我可以理解内部类是什么以及如何编写程序。我的问题是程序员在什么情况下真的需要内部课程？

Answer 1

有时候有一些功能最好被表示为一个对象，但它只在另一个对象的上下文中有意义，它不一定需要暴露给外部世界，并且可以从访问父类数据（以免违反封装）。

我能想到的最好的例子是将一个Node类放在LinkedList中。节点仅对LinkedList有意义，因此它们只存在于一个节点中。 LinkedList之外的任何人都不关心节点或应该有权访问它们。

Answer 2

内部类允许我们删除该逻辑并将其放入自己的类中。因此，从面向对象的角度来看，我们已经将功能从它不属于的地方中取出并将其放入自己的类中。

请浏览此链接....

http://www.javaworld.com/javaworld/javaqa/2000-03/02-qa-innerclass.html

Answer 3

另外正如您所知，在Java中存在嵌套类，这是静态内部clasess。

当我们需要使用内部类时，之前的帖子变得清晰但我认为你也对“为什么我们需要嵌套类（静态内部类）”这个问题感兴趣。

答案很简单，除了很少的东西外，其他目的与内在阶层有着相同的目的。

1）当我们想要排除一些涉及另一个对象的逻辑时，需要嵌套类（静态内部），但这个逻辑可能会在outworld中使用。

最简单的例子是某个对象的构建者或编辑者。例如，我们有Foo类可能有很多可选字段，为了构造这样的对象，我们可能会决定引入一个可以完成这项工作的构建器类。

    public class Foo {
    private int param1;
    private int param2;
    private int param3;

    private Foo(FooBuilder builder) {
        this.param1 = builder.param1;
        this.param2 = builder.param2;
        this.param3 = builder.param3;
    }

    public int getParam1() {
        return param1;
    }

    public void setParam1(int param1) {
        this.param1 = param1;
    }

    public int getParam2() {
        return param2;
    }

    public void setParam2(int param2) {
        this.param2 = param2;
    }

    public int getParam3() {
        return param3;
    }

    public void setParam3(int param3) {
        this.param3 = param3;
    }

    public static class FooBuilder {
        private int param1;
        private int param2;
        private int param3;

        public FooBuilder() {
        }

        public FooBuilder withParameter1(int param1) {
            this.param1 = param1;
            return this;
        }

        public FooBuilder withParameter2(int param2) {
            this.param2 = param2;
            return this;
        }

        public FooBuilder withParameter3(int param3) {
            this.param3 = param3;
            return this;
        }

        public Foo build() {
            return new Foo(this);
        }
    }
}

这个例子说明了为什么我们需要这样的类

2）内部和内部类之间的第二个区别是第一个内部类总是有指向父类的指针。 Actully编译器为其父类型的非静态内部类创建合成字段成员，因此我们可以访问父类的私有成员。静态内部clasess没有这样生成的场成员。例如，我们只有简单的父类，声明了非静态内部类：

public class Foo {
    public class FooBuilder {
    }
}

但实际上如果考虑字节代码，它就像：

public class Foo {
    public class FooBuilder {
        private Foo generatedNameHere;
    }
}

如果您愿意，可以通过生成的字节代码来解决这个问题。

Answer 4

内部类的一个用途是：

内部类有助于多重继承。 内部类允许您从多个非接口继承。

//第一个案例;如果两个类是接口

，则可以实现

interface A {  }
interface B {  }

class X implements A, B { }

//第二个案例;你只能扩展一个班级。这个案例内部类也可以帮助继承其他类

 class D {  }
 abstract class E { }
 class Z extends D {
    void method() {
      return new E()  {   };   //Anonymous inner class
    }
 }

Answer 5

如果要指定仅在有界的上下文中具有意义的类。

例如，您编写了一个可以执行四个操作的MathOperations类。因此，操作可以表示为内部枚举MathOps。
除了inbounded之外的任何地方都没有使用内部类。

使用匿名内部类仅指定操作，例如，如果要对集合进行排序，则只为一个方法比较指定Comparable类。

  Collections.sort(employments, new Comparator<Employment>() {


    @Override
    public int compare(Employment o1, Employment o2) {
        return o1.getStartDate().before(o2.getStartDate()) ? 1 : -1 ;
    }
});

Answer 6

使用内部类，您可以访问封闭类的私有成员。
它们对于仅由封闭类（应用程序中的事件处理程序）使用的接口实现很有用。
它们对于从外部检索的接口实现（可能类似于Iterator实现）提供细粒度访问和创建控制非常有用。

内部类的用法

6 个答案: