Java静态内部类Demo解析

本文已参与「新人创作礼」活动，一起开启掘金创作之路。

什么是内部类
大部分时候，类被定义成一个独立的程序单元。在某些情况下，也会把一个类放在另一个类的内部定义，这个定义在其他类内部的类就被称为内部类（有些地方也叫做嵌套类），包含内部类的类也被称为外部类（有些地方也叫做宿主类）

作用？？
更好的封装性
内部类成员可以直接访问外部类的私有数据，因为内部类被当成其外部类成员，但外部类不能访问内部类的实现细节，例如内部类的成员变量
匿名内部类适合用于创建那些仅需要一次使用的类
静态or非静态？？

使用static来修饰一个内部类，则这个内部类就属于外部类本身，而不属于外部类的某个对象。称为静态内部类（也可称为类内部类），这样的内部类是类级别的，static关键字的作用是把类的成员变成类相关，而不是实例相关

注意：
1.非静态内部类中不允许定义静态成员
2.外部类的静态成员不可以直接使用非静态内部类
3.静态内部类，不能访问外部类的实例成员，只能访问外部类的类成员

Demo:
package com.aimuti.innerTest;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class EmpTest {
	private Integer id;
	private Integer empLevel;
	private String mapingOrderLevel;
	private String empNo;
	private Integer orderNumLimit;
	
	//	外部类私有的构造方法
	private EmpTest(Builder builder) {
		 setId(builder.id);
	     setEmpLevel(builder.empLevel);
	     setMapingOrderLevel(builder.mapingOrderLevel);
	     setEmpNo(builder.empNo);
	     setOrderNumLimit(builder.orderNumLimit);
	     System.out.println(id);
	     System.out.println(empNo);
	     System.out.println(empLevel);
	}
//	对外提供初始化EmpTest类的唯一接口,通过这个方法,获得内部类的实例
	public static Builder newBuilder() {
		return new Builder();
	}
//	静态内部类:Builder
	public static final class Builder{
		private Integer id;
		private Integer empLevel;
		private String mapingOrderLevel;
		private String empNo;
		private Integer orderNumLimit;
		
		public Builder() {
		}
		
		public Builder id(Integer val) {
			id = val;
			return this;
		}
		 public Builder empLevel(Integer val) {
	            empLevel = val;
	            return this;
	        }

	        public Builder mapingOrderLevel(String val) {
	            mapingOrderLevel = val;
	            return this;
	        }

	        public Builder empNo(String val) {
	            empNo = val;
	            return this;
	        }

	        public Builder orderNumLimit(Integer val) {
	            orderNumLimit = val;
	            return this;
	        }
//	             通过内部类的build方法,实例化外部类,并给其实例各个字段赋值
	        public EmpTest build() {
	        	return new EmpTest(this);
	        }
	}

		public Integer getId() {
			return id;
		}
		
		public void setId(Integer id) {
			this.id = id;
		}

		public Integer getEmpLevel() {
			return empLevel;
		}

		public void setEmpLevel(Integer empLevel) {
			this.empLevel = empLevel;
		}

		public String getMapingOrderLevel() {
			return mapingOrderLevel;
		}

		public void setMapingOrderLevel(String mapingOrderLevel) {
			this.mapingOrderLevel = mapingOrderLevel;
		}

		public String getEmpNo() {
			return empNo;
		}

		public void setEmpNo(String empNo) {
			this.empNo = empNo;
		}
		
		public Integer getOrderNumLimit() {
			return orderNumLimit;
		}

		public void setOrderNumLimit(Integer orderNumLimit) {
			this.orderNumLimit = orderNumLimit;
		}
			
	public static void main(String[] args) {
		List emplist = new ArrayList<>();
		for (int i = 0; i < 20; i++) {
			emplist.add(EmpTest.newBuilder().empLevel(getRandom(5)).empNo("emp"+i).id(i).mapingOrderLevel("hh"+i).build());
		}
	}
	public static int getRandom(int num) {
		Random random = new Random();
		int rnum = random.nextInt(num);
		return rnum;
	}
}

讲解：
1.EmpTest中 定义了一个Builder的静态内部类，还定义了一个newBuilder的公共静态方法，上边讲过加了static关键字，那么就是类相关，所以我不需要实例化外部类，直接使用外部类就可以调用newBuilder的方法

2.Builder的实例在调用各个内部类中的方法，给Builder的字段赋值

3.最后调用build()方法，实例化EmpTest，它的构造方法需要builder的对象，所以将builder的对象传入，通过builder的字段值给EmpTest的对象赋值

经过了静态内部类与静态方法相结合，给实体赋值的时候才能一句话(如下)就能完成任务，而不再需要通过传统的set方法

EmpTest类.newBuilder.id(“xxx”).empLevel(xxx)……build();