单例模式和内部类的初步认识

单例模式比较高深，老师引入了集群的概念：相同的东西复制很多份

比如一个节点集群，可以理解成很多个jvm，他们统一由一个配置文件配置，那么这个配置文件实例化一次还是多次？

那么这个配置文件保存一次还是多次？

实例化多次，而实际上只有一次-----单例

java中，在某些场景下，一个进程中只允许一个对象的实例，那么我们把这种设计模式称为单例/单态

比如代码A：            

将构造方法实例化，只能本类中访问，但是要求是外部类获得一个A对象，但是在外部又不能实例化A，而且必须是，获得同一个同一对象，所以采用加public，static和return的方法，这样就能类.方法获得一个statici对象A。

public class A {
	private String name="张三";
	private static A a;
	
	private A(){
		System.out.println(name);
	}
	
	public static A getA(){
		if (a==null) {
			a=new A();
		}
		return a;
	}
	
}

在B类中测试一下，返回：    张三    turn

public class B {
	public static void main(String[] args) {
		A a=A.getA();
		A a2=A.getA();
		System.out.println(a==a2);
	}
}

需要注意的是，A里的getA()这样的方法是懒汉写法，相对简单的还有一个饥饿写法，但是这两种写法都是 非线程安全 的写法，为何不安全现在还用不到。个人猜测在多线程里如果这样new对象返回是否会造成new多个对象？

-----------------------------------------------------------------------------------------------------------------------

内部类老师说实际上用的并不多，用的话也是双层，因为内部类里还可以写内部类，而且会生成 外部类$内部类.class这样的文件，所以嵌套太多会生成太多。

需要记住的是内部类的特点，可以访问外部类的成员变量，包括private！

例子：

外部类为out，内部类为inner，打印结果为：

可以看出，一般内部类确实可以直接打印外部类的加了private修饰符的变量，而且一般变量和静态变量都能打印出来，而且根据当前对象this的不同也能分辨出内部类和外部类变量，而静态内部类内部可以定义一般变量，但是它访问外部类的静态变量。

内部哪里还经常使用呢？------->方法的回调（扩展）

public class Test {
	public static void main(String[] args) {
		Inner inner=new Out().new Inner();
		inner.show();
		inner.show2();
		inner.show3();
		inner.show4();
		Inner2 inner2=new Inner2();
		inner2.show();
	}
}

public class Out {
	private String name="外部类的一般变量";
	private static String name2="外部类的静态变量";
	private String name3="外部类的name";
	
	public class Inner{
		private String name3="内部类的name";
		public void show(){
			System.out.println(name);
		}		
		public void show2(){
			System.out.println(name2);
		}
		public void show3(){
			System.out.println(Out.this.name3);
		}
		public void show4(){
			System.out.println(Inner.this.name3);
			System.out.println(this.name3);
		}	
	}
	
	public static class Inner2{
		//String name2="内部类2";
		public void show(){
			System.out.println(name2);
		}
	}
}