2021-07-12内部类,设计模式,工厂模式,

面向对象

1.1内部类

1.1.1概述

内部类 : 类体中还有一个类的声明

当一个事物的内部,还有一个部分需要一个完整的结构进行描述,这个内部的完整结构,一般只是为了让外部类使用

而内部类还有一个作用是 可以访问外部类中的私有化属性

1.1.2分类

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

1.1.3内部成员类

public class _01_OuterClass {
	private static String s1 = "A";
	private String s2 = "B";
	/**
	 * 成员内部类可以等同看做成员变量,类体中不需要使用static修饰
	 * 
	 * 可以使用权限控制修饰符
	 * 
	 * 成员内部类中 不能有静态声明
	 * 
	 * 成员内部类中 可以直接访问外部类的所有属性
	 * 
	 * 内部类的类名 : 外部类$内部类  _01_OuterClass$InnerClass
	 */
	 class InnerClass{
		 // 不能有静态声明
		// public static void m1(){}
		 public void m2(){
			 System.out.println(s1);
			 System.out.println(s2);
		 }
	}
	 
	public static void main(String[] args) {
		// 1 创建外部类对象
		_01_OuterClass out = new _01_OuterClass();
		// 2 创建内部类对象 : 外部类对象.new 内部类();
		InnerClass inerClass = out.new InnerClass();
		// 3 属性调用
		inerClass.m2();
	}
}

1.1.4静态内部类

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

不能直接访问成员属性,但是有对象就可以

public class _02_OuterClass {
	private static String s1 = "A";
	private String s2 = "B";
	
	/**
	 * 静态内部类 等同看做静态变量
	 * 可以使用权限控制修饰符
	 * 静态内部类中,可以声明所有属性,静态和成员都可以
	 * 静态内部类中,可以直接访问外部类的静态属性,不能直接访问成员属性 
	 */
	static class InnerClass{
		public static void m1(){
			System.out.println(s1);
			// System.out.println(s2);
			// 不能直接访问成员属性,但是有对象就可以
			System.out.println(new _02_OuterClass().s2);
		}
		public void m2(){
			System.out.println(s1);
			// 虽然m2是成员方法,但是还是不能直接访问外部类的成员属性
			// 因为m2在InnerClass中,想要执行m2必须创建innerClass对象
			// 但是创建InnerClass对象的时候,不需要依赖于外部类对象
			// System.out.println(s2);
		}
	}
	public static void main(String[] args) {
		// 外部类.内部类
		_02_OuterClass.InnerClass.m1();
		// new 外部类.内部类();
		InnerClass innerClass = new _02_OuterClass.InnerClass();
		innerClass.m2();
		
		// 当前类中 类名可以省略
		InnerClass.m1();
		innerClass = new InnerClass();
	}
}

1.1.5局部内部类

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

public class _03_OuterClass {
	private static String s1 = "A";
	private String s2 = "B";
	// 静态方法
	public static void m1(){
		 int i = 10;
		class InnerClass{
			// 不能有静态声明
			// public static void m3(){}
			public void m3(){
				System.out.println(s1);
				// 因为外部方法是静态方法 所以不能直接访问外部类的成员属性
				// System.out.println(s2);
				// 访问局部变量,需要使用final,但是1.8开始可以省略
				System.out.println(i);
			}
		} 
		// 使用内部类
		InnerClass innerClass = new InnerClass();
		innerClass.m3();
	}
	// 成员方法
	public void m2() {
		int i = 2;
		class InnerClass {
			// public static void m3(){}
			public void m3() {
				System.out.println(s1);
				// 因为外部方法是成员方法,所以可以直接使用外部类中的所有属性
				System.out.println(s2);
				System.out.println(i);
			}
		}
		// 使用内部类
		InnerClass innerClass = new InnerClass();
		innerClass.m3();
	}
	public static void main(String[] args) {
		m1();
		_03_OuterClass out = new _03_OuterClass();
		out.m2();
	}
}

1.1.6匿名内部类

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

public class _04_OuterClass {
	public static void main(String[] args) {
		// UserLoginImpl userLoginImpl = new UserLoginImpl();
		// test(userLoginImpl);

		test(new UserLogin() {
			@Override
			public void login(String username, String password) {
				if (username.equals("admin")) {
					if (password.equals("root")) {
						System.out.println("登陆成功");
					} else {
						System.out.println("密码不正确");
					}
				} else {
					System.out.println("用户名不正确");
				}
			}
		});
	}

	public static void test(UserLogin userLogin) {
		userLogin.login("admin", "root");

	}
}

interface UserLogin {
	public void login(String username, String password);
}

// class UserLoginImpl implements UserLogin {
//
// @Override
// public void login(String username, String password) {
// if (username.equals("admin")) {
// if (password.equals("root")) {
// System.out.println("登陆成功");
// } else {
// System.out.println("密码不正确");
// }
// } else {
// System.out.println("用户名不正确");
// }
// }
// }

1.2设计模式

1.2.1概述

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

1.2.2单例模式

1.2.2.1概述

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

实现步骤 :
 *         现在需要控制创建对象的数量,只有一个,所以就不能让用户决定创建或者不创建
 *             1 不能让用户创建对象
 *                 创建对象需要调用构造方法,如果不让用户创建对象,也就意味着不能让用户访问构造方法
 *                 所以 构造方法 需要私有化
 *             2 我们创建一个给他,并且只创建一次即可 
 *                 上面已经把构造方法私有化了,就意味着用户创建不了对象了
 *                 那么这个时候,我们必须提供一个让用户能够获取对象的一个方法
 *                 既然是用于获取对象的方法,那么这个方法一定是静态方法
 *                     如果是成员方法的话,调用该方法需要用到对象,而对象获取需要调用这个方法,相互矛盾
 *             3 存储对象的变量
 *                     变量不存储,不能重复使用,所以为了保证对象只有一个,我们肯定是创建对象之后,进行重复使用
 *                         局部变量 : 具有临时性,方法执行完后就不存在了,下一次调用该方法时,变量重新初始化
 *                         成员变量 : 静态方法中不能 操作成员变量
 *                         静态变量 : 和类相关,和类生命周期一致
 *                     所以应该创建一个用来保存当前类对象的静态变量
 *         总结 : 
 *                 1 构造方法私有化
 *                 2 提供一个私有的静态的用来保存当前类对象的静态变量
 *                 3 提供一个公共的静态方法,用来获取该对象
 *根据创建对象的时机不同,分为两种
 *         1 懒汉模式
 *                 用到的时候再创建对象,也就是第一次获取的时候
 *         2 饿汉模式
 *                 类加载的时候,就立刻创建对象
 * 
 * 懒汉模式和饿汉模式的区别 : 
 *         1 内存角度
 *                 懒汉模式要好一些,用到的时候再创建使用,一般叫做懒加载/迟加载
 *                 饿汉模式浪费内存,还不用呢,对象就已经先创建了
 *         2 线程安全角度
 *                饿汉模式是在类加载阶段就初始化的,所以在多线程环境下没有问题,因为类在生命周期中只会加载一次
 *                懒汉模式在多线程并发性的情况下,就不行了,可能创建多个对象,但是可以通过双重校验加锁解决
 *        所以 一般我们使用懒汉模式居多,尽管在多线程下,也使用懒汉模式,使用双重校验加锁解决并发问题即可 
 * 

1.2.2.2懒汉模式

懒汉模式 : 第一次获取的时候初始化
 * 
 * 
 */
public class Singleton_02 {
	private Singleton_02() {
	}

	private static Singleton_02 s;

	public static Singleton_02 getInstance() {
		if (s == null) {
			s = new Singleton_02();
		}
		return s;
	}
}

12.2.3饿汉模式

public class Singleton_01 {
	private static Singleton_01 singleton_01 = new Singleton_01() ;
	public static Singleton_01 getInstance(){
		return singleton_01;
	}
	private Singleton_01(){
		
	}
}

 1.2.3工厂模式

1.2.3.1概述

工厂模式

工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

介绍

意图：定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。

主要解决：主要解决接口选择的问题。

何时使用：我们明确地计划不同条件下创建不同实例时。

如何解决：让其子类实现工厂接口，返回的也是一个抽象的产品。

关键代码：创建过程在其子类执行。

应用实例： 1、您需要一辆汽车，可以直接从工厂里面提货，而不用去管这辆汽车是怎么做出来的，以及这个汽车里面的具体实现。 2、Hibernate 换数据库只需换方言和驱动就可以。

优点： 1、一个调用者想创建一个对象，只要知道其名称就可以了。 2、扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。 3、屏蔽产品的具体实现，调用者只关心产品的接口。

缺点：每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。

使用场景： 1、日志记录器：记录可能记录到本地硬盘、系统事件、远程服务器等，用户可以选择记录日志到什么地方。 2、数据库访问，当用户不知道最后系统采用哪一类数据库，以及数据库可能有变化时。 3、设计一个连接服务器的框架，需要三个协议，"POP3"、"IMAP"、"HTTP"，可以把这三个作为产品类，共同实现一个接口。

注意事项：作为一种创建类模式，在任何需要生成复杂对象的地方，都可以使用工厂方法模式。有一点需要注意的地方就是复杂对象适合使用工厂模式，而简单对象，特别是只需要通过 new 就可以完成创建的对象，无需使用工厂模式。如果使用工厂模式，就需要引入一个工厂类，会增加系统的复杂度。

实现

我们将创建一个 Shape 接口和实现 Shape 接口的实体类。下一步是定义工厂类 ShapeFactory。

FactoryPatternDemo 类使用 ShapeFactory 来获取 Shape 对象。它将向 ShapeFactory 传递信息（CIRCLE / RECTANGLE / SQUARE），以便获取它所需对象的类型。

public class Test {
	public static void main(String[] args) {
		A a = new A();
		// a = new B();
		 a = new B();
		 a = new B();
		 a = new B();
		 a = new B();
		 a = new B();
		a = AFactory.getA();
		a = AFactory.getA();
		a = AFactory.getA();
		a = AFactory.getA();
		a = AFactory.getA();
		a = AFactory.getA();
	}
}

class AFactory {
	public static A getA() {
		return new B();
	}
}

class A {

}

class B extends A {

}

class C extends A {

}