静态内部类的作用

一、静态内部类的定义

静态内部类是指在一个类中定义另一个静态类，静态类可以访问外部类的静态变量，但不能访问非静态变量。静态内部类和外部类实例没有直接的联系，就像是一个独立的类一样。在外部类的一个静态方法中使用静态内部类，可以省略外部类名，直接使用静态内部类名。

public class OuterClass {
    private static int outerStaticVar;
    private int outerInstanceVar;

    public static class StaticInnerClass {
        private int innerVar;

        public void innerMethod() {
            outerStaticVar ++;
        }
    }

    public static void outerMethod() {
        StaticInnerClass staticInnerClass = new StaticInnerClass();
        staticInnerClass.innerMethod();
    }
}

二、静态内部类与封装

静态内部类可以帮助我们更好地实现封装，对于一些只在外部类中使用的辅助类，我们可以将它们定义为外部类的静态内部类，从而达到封装的效果，避免了在外部类中暴露不必要的实现细节。

public class EncryptUtil {
    private static String salt;

    public static class MD5Encrypt{
        public String encrypt(String message){
            return MD5Util.encrypt(salt + message + salt);
        }
    }
}

EncryptUtil.MD5Encrypt encryptUtil = new EncryptUtil.MD5Encrypt();
encryptUtil.encrypt("hello world!");

三、静态内部类和多态

静态内部类可以被外部类的静态方法和静态属性使用，因此可以作为静态属性的类型使用。静态属性的类型可以使用多态，因此当外部类有多个子类时，可以通过改变静态属性的具体类型从而实现多态。

public class CarFactory {
    public static abstract class Car {
        protected String name;
        protected String color;

        public abstract void run();
    }

    public static class MercedesBenz extends Car {
        public MercedesBenz() {
            this.name = "MercedesBenz";
            this.color = "black";
        }

        public void run() {
            System.out.println(name + " is running.");
        }
    }

    public static class BMW extends Car {
        public BMW() {
            this.name = "BMW";
            this.color = "white";
        }

        public void run() {
            System.out.println(name + " is running.");
        }
    }

    private static Car car = new MercedesBenz();

    public static Car getCar() {
        return car;
    }

    public static void main(String[] args) {
        Car car1 = CarFactory.getCar();
        car1.run();

        // 改变静态属性的类型
        CarFactory.car = new BMW();
        Car car2 = CarFactory.getCar();
        car2.run();
    }
}

四、静态内部类和Lambda表达式

Java 8引入了Lambda表达式，可以简化事件监听器、线程等代码的编写，而静态内部类也可以帮助我们更好地使用Lambda表达式。

public class LambdaDemo {
    public static void main(String[] args) {
        List names = Arrays.asList("Alice", "Bob", "Charlie");

        names.forEach(new Consumer
   () {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });

        names.forEach(new PrintString());
    }

    public static class PrintString implements Consumer
     {
        @Override
        public void accept(String s) {
            System.out.println(s);
        }
    }
}

    
   
  

五、结语

本文详细介绍了静态内部类的定义、封装、多态和Lambda表达式等几个方面的作用。静态内部类是一种实现封装和多态的好方式，也可以帮助我们更加便捷地使用Lambda表达式等新特性。