内部类、设计模式

一、 内部类

1.概念

类体中还有一个类的声明

2.作用

1.当一个事物的内部,还有一个部分需要一个完整的结构进行描述,这个内部的完整结构,一般只是为了让外部类使用
2.可以访问外部类中的私有化属性

3.分类

成员变量 --> 成员内部类/普通内部类
静态变量 --> 静态内部类
局部变量 --> 局部内部类
形参/实参 --> 匿名内部类

4.成员内部类/普通内部类

成员内部类可以等同看做成员变量,类体中不需要使用static修饰
可以使用权限控制修饰符
成员内部类中 不能有静态声明
成员内部类中 可以直接访问外部类的所有属性
内部类的类名 : 外部类$内部{类}_0{1}_{O}uterClass$InnerClass

5.静态变量 --> 静态内部类

静态内部类 等同看做静态变量
可以使用权限控制修饰符
静态内部类中,可以声明所有属性,静态和成员都可以
静态内部类中,可以直接访问外部类的静态属性,不能直接访问成员属性

6.局部变量 --> 局部内部类

局部内部类等同于局部变量
局部内部类,不能有静态声明
局部内部类 不能使用static修饰符,也不能使用权限控制修饰符
如果外部方法是静态方法,则局部内部类不能直接访问外部类的成员属性
如果外部方法 是成员方法,则局部内部类中可以直接访问外部类的所有属性
局部内部类中如果要使用外部方法中的局部变量,则该变量必须使用final修饰(1.8开始,final可以省略)

7.形参/实参 --> 匿名内部类

匿名内部类 : 在方法调用的时候,需要传入一个类的对象,这个时候可以直接传入一个匿名内部类
一般该对象,是接口的实现类对象,匿名内部类 等于是子类,可以使用super等关键字
语法 : 方法(new 父类/接口(){ 类体 });
匿名内部类,会自动创建一个对象传入
好处 少定义一个类,缺点 无法重复使用

二、设计模式

概念

就是在编码实践中,人们发现有很多的编码方式会经常用到,于是就总结出来,形成了固定的结构,就是设计模式

1.单例模式

实例化多次,得到同一个对象,让某个类只能被实例化一次

1.1实现步骤

现在需要控制创建对象的数量,只有一个,所以就不能让用户决定创建或者不创建
1 不能让用户创建对象
创建对象需要调用构造方法,如果不让用户创建对象,也就意味着不能让用户访问构造方法。所以 构造方法 需要私有化

2 我们创建一个给他,并且只创建一次即可
上面已经把构造方法私有化了,就意味着用户创建不了对象了，那么这个时候,我们必须提供一个让用户能够获取对象的一个方法，既然是用于获取对象的方法,那么这个方法一定是静态方法
如果是成员方法的话,调用该方法需要用到对象,而对象获取需要调用这个方法,相互矛盾

3 存储对象的变量
变量不存储,不能重复使用,所以为了保证对象只有一个,我们肯定是创建对象之后,进行重复使用

局部变量 : 具有临时性,方法执行完后就不存在了,下一次调用该方法时,变量重新初始化
成员变量 : 静态方法中不能 操作成员变量
静态变量 : 和类相关,和类生命周期一致
所以应该创建一个用来保存当前类对象的静态变量

总结 :
1 构造方法私有化
2 提供一个私有的静态的用来保存当前类对象的静态变量
3 提供一个公共的静态方法,用来获取该对象

1.2 两种模式

1 懒汉模式
用到的时候再创建对象,也就是第一次获取的时候
2 饿汉模式
类加载的时候,就立刻创建对象

区别：
1 内存角度
懒汉模式要好一些,用到的时候再创建使用,一般叫做懒加载/迟加载
饿汉模式浪费内存,还不用呢,对象就已经先创建了
2 线程安全角度
饿汉模式是在类加载阶段就初始化的,所以在多线程环境下没有问题,因为类在生命周期中只会加载一次
懒汉模式在多线程并发性的情况下,就不行了,可能创建多个对象,但是可以通过双重校验加锁解决
所以 一般我们使用懒汉模式居多,尽管在多线程下,也使用懒汉模式,使用双重校验加锁解决并发问题即可

public class Singleton {

	private  Singleton() {
		
	}
	//饿汉模式、类加载阶段就初始化，类生命周期中只加载一次
	private static Singleton singleton=new Singleton();
	public static Singleton getInstance() {
		return singleton;
	}
	
	//懒汉模式：第一次获取的时候初始化
	//先声明一个静态对象名 一开始不初始化，是null
	private static Singleton s2;
	public static Singleton getInstance2() {
		//是null就new实例化对象
		if (s2 == null) {
			s2 = new Singleton();
		}
		//已经初始化，就不管了，返回
		return s2;
	}

}

2.工厂模式

属于创建型模式，它提供了一种创建对象的最佳方式。在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

public class Test {
	public static void main(String[] args) {
		A a = new A();
		// a = new B();
		 a = new B();
		 a = new B();
		a = AFactory.getA();
		a = AFactory.getA();
		a = AFactory.getA();
		a = AFactory.getA();
		//当后期需要其他类的实例化对象时，不需要一个个代码更改，只需要当工厂类中去更改就可以
	}
}
//创建一个工厂类，从静态方法中获取实例化对象
class AFactory {
	public static A getA() {
		return new A();
		//return new B();
	}
}

class A {

}

class B extends A {

}

class C extends A {

}