内部类、静态内部类、局部内部类、匿名内部类的区别

最新推荐文章于 2024-04-04 20:29:56 发布

原创最新推荐文章于 2024-04-04 20:29:56 发布 · 240 阅读

0 ·

CC 4.0 BY-SA版权

2019年专栏收录该内容

14 篇文章

订阅专栏

本文深入解析Java中的内部类、静态内部类、局部内部类及匿名内部类，通过具体实例阐述各自特点与应用场景，帮助读者理解并掌握不同内部类的使用技巧。

内部类、静态内部类、局部内部类、匿名内部类的区别

《Java核心技术卷Ⅰ》-以下简称《卷Ⅰ》学习小结：
$\quad$ $\quad$ 在第一次看完P242-P258页后，我感觉自己对以上列出的几种类，都是掌握了的，区别不都写在名字里面了嘛。但是，当我自己真正要写一个例子，去用这几种类去分别实现的时候，那种刚刚的自信荡然无存。我竟无从下手，我想这就是理论与实践的相辅相成，缺一不可。遂决心从头到尾再看一遍，自己想例子去操练，这才略有收获。
$\quad$ $\quad$ 想起老师说的，学习代码就像学开挖掘机，理论考试考得再好，不上手就是在浪费自己的时间。不搞清楚原理，出了问题眼睛就只会盯在最表面，永远没有更深层次的思考，永远只能当个开挖掘机的。
$\quad$ $\quad$ 多说无益，直奔主题。
$\quad$ $\quad$ 1.内部类，即定义在另一个类中的类，内部类有什么用呢？以下是《卷Ⅰ》的原话，三点：
$\quad$ $\quad$ $\quad$ $\quad$ ①内部类可以访问该类定义所在的作用域中的数据，包括私有的数据。
$\quad$ $\quad$ $\quad$ $\quad$ ②内部类可以对同一个包中的其他类隐藏起来。
$\quad$ $\quad$ $\quad$ $\quad$ ③当想定义一个回调函数且不想编写大量代码时，使用匿名内部类比较便捷。
$\quad$ $\quad$ 前两点好理解，第三点我自己还没理解，就先不在这里说了。我想的例子是，在某个数值范围内，产生一个由该范围内的随机数组成的数组，返回其中的最大最小值。直接上代码：

public class Main {
     private LocalDate localDate =LocalDate.now();
    //获取一个[min,max]范围内的随机数
    public static int createRandomDigital(int max, int min) {
        return (int) (min + Math.random() * (max - min + 1));
    }

    //获取一个由随机数组成的随机数组
    public static int[] createRandomArray(int length) {
        int[] random = new int[length];
        for (int i = 0; i < length; i++) {
            random[i] = createRandomDigital(100, 1);
        }
        return random;
    }

    public static void main(String[] args) {
        MaxMin maxMin = new Main().
                new MaxMin(100, 1).
                getMaxMin(createRandomArray(20));
        System.out.println("最大值：" + maxMin.getMax());
        System.out.println("最小值：" + maxMin.getMin());

    }

      class MaxMin {
        int max;
        int min;

        public MaxMin(int max, int min) {
            this.max = max;
            this.min = min;
        }

        public int getMax() {
            return max;
        }

        public int getMin() {
            return min;
        }

        public MaxMin getMaxMin(int[] arr) {
            int min = Integer.MAX_VALUE;
            int max = Integer.MIN_VALUE;
            for (int value : arr) {
                if (value < min) {
                    min = value;
                }
                if (value > max) {
                    max = value;
                }
            }
            System.out.println(localDate);
            return new MaxMin(max, min);
        }
    }
}
结果：
2019-08-07
最大值：100
最小值：8

可以看出：
$\quad$ $\quad$ 1.内部类MaxMin实现了对超类私有数据localData的访问。
$\quad$ $\quad$ 2.内部类实现了，对与超类再同一个包中的其他类的隐藏。
$\quad$ $\quad$ 3.当一个方法有多个返回值的时候，我们可以通过返回一个类的形式来实现。
$\quad$ $\quad$ 2.静态内部类，《卷Ⅰ》原话：有时候，使用内部类只是为了把一个类隐藏在另一个类的内部，并不需要内部类引用外围类的对象。为此，可以把内部类设置为static，以便取消产生的引用。
$\quad$ $\quad$ 用前面的例子来说的话，就是当我用不到外部类的localDate对象的时候，我可以把MaxMin设置为静态的。这样，我实例化MaxMin类的时候，就不用先实例化超类，再去实例化内部类。
区别如下：

//实例化的过程可以简化为：
MaxMin maxMin = new MaxMin(100, 1).
                getMaxMin(createRandomArray(20));

$\quad$ $\quad$ 3.局部内部类，如果类的实例在方法中只被使用一次，那么我们可以在这个方法中定义一个局部类。局部内部类可以对外部世界完全地隐藏起来。除了局部内部类所在的方法知道它外，没人知道它的存在。
代码如下：

public class Main {

  public static void main(String[] args) {
     getMaxMin(createRandomArray(20));
  }


  public static void getMaxMin(int[] arr) {//方法中的类
       class MaxMin {
          int max;
          int min;

          public MaxMin(int max, int min) {
              this.max = max;
              this.min = min;
          }

          public int getMax() {
              return max;
          }

          public int getMin() {
              return min;
          }
      }

      int min = Integer.MAX_VALUE;
      int max = Integer.MIN_VALUE;
      for (int value : arr) {
          if (value < min) {
              min = value;
          }
          if (value > max) {
              max = value;
          }
      }
      MaxMin maxMin = new MaxMin(max,min);
      System.out.println("最大值："+maxMin.getMax());
      System.out.println("最小值："+maxMin.getMin());
  }
}

$\quad$ $\quad$ 4.匿名内部类，顾名思义，匿名内部类就是没有名字的类。《卷Ⅰ》原话：假如只创建这个类的一个对象，就不必命名了。这种类被称为匿名内部类。

public static void main(String[] args) {
      MaxMin maxMin = new MaxMin() {
          @Override
          public void getMaxMin(int[] arr) {
              int max = Integer.MIN_VALUE;
              int min = Integer.MAX_VALUE;
              for (int value : arr) {
                  if (value > max) {
                      max = value;
                  }
                  if (value < min) {
                      min = value;
                  }
              }
              System.out.println("最大值：" + max);
              System.out.println("最小值：" + max);
          }
      };
      maxMin.getMaxMin(createRandomArray(20));
  }


}

abstract class MaxMin {

  public void getMaxMin(int[] arr) {

  }
}

$\quad$ $\quad$ 觉得自己真的很笨，学这么些东西总是学了忘，忘了学。时间就这么一天天花去了，感觉自己还是没有掌握方法。也是自己现在还没有实践的机会，纸上写的再多，也没有工作中跟一个项目来的收获多，那也没办法。
$\quad$ $\quad$ 每次写博客，都是对自己学习历程的一次总结，总是在自己感觉有收获后，去选择用这种方式去记录自己的喜悦。所以，写的不对的地方，真心欢迎大家多多指正，感谢！