Java 静态成员类优于非静态成员类

嵌套类分为四种：静态成员类、非静态成员类、匿名类以及局部类，除了第一种，其余三种称为内部类。

一、静态成员类

类被声明为静态类，必须为静态成员类

静态类，一定为静态成员类

静态成员类作为公有的辅助类，只有与它的外部类一起使用才有意义

声明方式：

静态类：public static class StaticClass{}
非静态类：public class ClassName

访问权限：
静态类只能访问类内部的静态成员
非静态类可以访问类中所有成员

静态和非静态的唯一区别，静态成员类的声明中包含修饰符 static，非静态成员类的每个实例都隐含地与外围类的一个一个外围实例相关联

所以在没有外围实例的情况下，要想创建非静态成员类的实例，是不可能的。

如果声明成员类不要求访问外围实例，就要始终把修饰符static放在它的声明中，使它成为静态成员类，而不是非静态成员类，如果省略了static修饰符，则每个实例都将包含一个额外的指向外围对象的引用。保存这份引用要消耗时间和空间，并且会导致外围实例符合垃圾回收时仍然得以保留
容易引起内存泄漏

二、静态内部类的使用

如果A类要使用B类，同时B仅为A类服务，那么就没有必要单独写一个B类，因为B类在其他类中不会被使用，所以只需要将B类作为A的内部类

例如：

public class TestDemo {
    private static class Water{
        int capacity;
        public Water(int capacity){
            this.capacity = capacity;
        }
        public int getCapacity(){
            return capacity;
        }
        public static String getComponent(){
            return "H2O";
        }
    }
    private class Food{
        public String getFood(){
            return "Pizza";
        }
    }
    public static void main(String[] args) {
        Water water = new TestDemo.Water(10);
        System.out.println(water.getCapacity());
        // 创建非静态内部类实例，必须先创建外部类的实例TestDemo，然后才能创建Food
        TestDemo testDemo = new TestDemo();
        Food food = testDemo.new Food();
    }
}

三、某个类的多个参数需要初始化时，推荐使用静态类创建

例如：当可选参数比较多时，采用 重叠构造器模式也可以，但是此时代码的可读性不好，也很难编写

public class NutritionFacts {
    private final int servingSize;
    private final int servings;
    private final int calories;
    private final int fat;
    private final int sodium;

    public NutritionFacts(int servingSize, int servings) {
        this(servingSize, servings, 0);
    }

    public NutritionFacts(int servingSize, int servings, int calories) {
        this(servingSize, servings, calories, 0);
    }

    public NutritionFacts(int servingSize, int servings, int calories, int fat) {
        this(servingSize, servings, calories, fat, 0);
    }

    public NutritionFacts(int servingSize, int servings, int calories, int fat, int sodium) {
        this.servingSize = servingSize;
        this.servings = servings;
        this.calories = calories;
        this.fat = fat;
        this.sodium = sodium;
    }
}

正常初始化：未使用静态类的初始化构造函数 初始化变量很不灵活。

public class Main {
    public static void main(String[] args) {
        NutritionFacts n1 = new NutritionFacts(1,2);
        NutritionFacts n2 = new NutritionFacts(1,2,3,4);
        NutritionFacts n3 = new NutritionFacts(1,2,3,4,5);
    }
}

静态内部类的实现：

public class NutritionFacts {
    private final int servingSize;
    private final int servings;
    private final int calories;
    private final int fat;
    private final int sodium;


    public static class Builder {
        // 必须的参数
        private final int servingSize;
        private final int servings;
        // 可选的参数
        private int calories = 0;
        private int fat = 0;
        private int sodium = 0;

        public Builder(int servingSize, int servings) {
            this.servingSize = servingSize;
            this.servings = servings;
        }

        public Builder calories(int val) {
            calories = val;
            return this;
        }

        public Builder fat(int val) {
            fat = val;
            return this;
        }

        public Builder sodium(int val) {
            sodium = val;
            return this;
        }

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

    private NutritionFacts(Builder builder) {
        servingSize = builder.servingSize;
        servings = builder.servings;
        calories = builder.calories;
        fat = builder.fat;
        sodium = builder.sodium;
    }
}

NutritionFacts cocaCola = new Builder(240, 8)
                .calories(100).sodium(34).build();

也可以借助注解：参考