Java内部类解析

迈不过友情╰ 2022-03-29 15:02 270阅读 0赞

内部类是定义在另一个类中的类。

内部类分类：局部内部类，匿名内部类，静态内部类。

### 局部内部类 ###

### 匿名内部类 ###

### 静态内部类 ###

有些时候，使用内部类只是为了把一个类隐藏在另外一个类的内部，而且并不需要这个内部类引用外围类对象，此时可以将内部类声明为static，以便取消产生的引用。下面是一个使用静态内部类的经典例子。考虑一下计算数组中最大值和最小是的问题。当然可以编写两个方法，一个求最大值，一个求最小值。但是这样做的后果是需要遍历数组两次。假如要求我们只允许遍历一次数组，那么怎么办？这样的好处是提高了效率。

其实遍历一次数组可以求出最大值与最小值，代码如下：

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

double min = Double.MAX_VALUE;
            double max = Double.MIN_VALUE;
            for (double v : values) {
                if (min > v)
                    min = v;
                if (max < v)
                    max = v;
            }

但是从上述代码中我们发现，需要返回max和min两个值。这个时候我们需要一个Pair的对象来存放我们最后需要返回的最大值与最小值。

Pair类的结构如下代码所示：

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

class Pair {
            //成员变量
            private double first;
            private double second;
            //构造函数
            public Pair(double f, double s) {
                first = f;
                second = s;
            }
            //getter and  setter
            public double getFirst() {
                return first;
            }
            public double getSecond() {
                return second;
            }
        }

但是如果将Pair声明为单独的一个类，而Pair这个名字又特别大众化，可能会和项目中的其他类名冲突（比如在同一个包下，两个不同的public class中都定义了一个叫做Pair的外部类，就会编译错误）。解决这个问题的方法就是将Pair定义为ArrayAlg的内部类。此后通过如下方式进行访问。

ArrayAlg.Pair p = ArrayAlg.minmax(d);

ArrayAlg的代码结构如下：

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

class ArrayAlg {
        
        //静态内部类Pair
        public static class Pair {
            //成员变量
            private double first;
            private double second;
            
            //构造函数
            public Pair(double f, double s) {
                first = f;
                second = s;
            }
    
            //getter and  setter
            public double getFirst() {
                return first;
            }
            public double getSecond() {
                return second;
            }
    
        }
    
        //计算数组中的最大值与最小值
        public static Pair minmax(double[] values) {
            double min = Double.MAX_VALUE;
            double max = Double.MIN_VALUE;
            for (double v : values) {
                if (min > v)
                    min = v;
                if (max < v)
                    max = v;
            }
            //最大值最小值有两个数，所以返回一个Pair实例
            return new Pair(min, max);
        }
    }

注意点：

1.  因为在Pair对象中不需要引用任何其他的对象，所以可以将这个Pair内部类声明为static。
2.  在我们上述列举的示例中，必须使用静态内部类，这是因为内部类对象**（new Pair(min, max);）**是在静态方法**（public static Pair minmax(double\[\] values) ）**中构造的。**静态方法（类方法，而不是对象的方法）中使用的变量必须是静态变量（类变量，而不是对象中的变量）。**

静态内部类与普通内部类的区别

1.  静态内部类中不能访问外围类中的属性与方法，而普通内部类是可以访问外围类中的属性与方法的，即使这些属性与方法是private的。
2.  静态内部类相当于外部类的成员，只有在第一次被使用的时候才会被装载。

完整的静态内部类实例

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

package edu.sjtu.erplab.innerclass;
    
    public class StaticInnerClassTest {
        public static void main(String[] args) {
            //定义一个长度为20的数组
            double[] d = new double[20];
            //数组中的元素是100以内的随机数
            for (int i = 0; i < d.length; i++)
                d[i] = 100 * Math.random();
            
            //ArrayAlg.minmax返回一个Pair对象
            ArrayAlg.Pair p = ArrayAlg.minmax(d);
            //输出最大值与最小值
            System.out.println("min = " + p.getFirst());
            System.out.println("max = " + p.getSecond());
            
            //使用静态内部类实例化对象。
            ArrayAlg.Pair p2=new ArrayAlg.Pair(1.0, 2.0);
            System.out.println("min = " + p2.getFirst());
            System.out.println("max = " + p2.getSecond());
            
        }
    }
    
    class ArrayAlg {
        
        //静态内部类Pair
        public static class Pair {
            //成员变量
            private double first;
            private double second;
            
            //构造函数
            public Pair(double f, double s) {
                first = f;
                second = s;
            }
    
            //getter and  setter
            public double getFirst() {
                return first;
            }
            public double getSecond() {
                return second;
            }
    
        }
    
        //计算数组中的最大值与最小值
        public static Pair minmax(double[] values) {
            double min = Double.MAX_VALUE;
            double max = Double.MIN_VALUE;
            for (double v : values) {
                if (min > v)
                    min = v;
                if (max < v)
                    max = v;
            }
            //最大值最小值有两个数，所以返回一个Pair实例
            return new Pair(min, max);
        }
    }

[ContractedBlock.gif]: https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif
[ExpandedBlockStart.gif]: /images/20220329/8a7021af2e4d4cb09196acad10d7e57c.png