独到理解@Java面向对象_设计模式

面向对象

设计模式

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

单例模式

• 单例模式的意义 :
  在需要多次初始化同一个对象的应用程序中,为了保证初始化对象只有一个,以达到节约内存的目的

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

实现步骤
首先我们要控制创建对象的数量,就不能让用户决定创建和不创建

比如 : 有一个钱箱子,里面有1000W现金,无人看守,只有一个牌子,写着 : 每人100,禁止多拿
这样是没有用的,总会有人破坏规矩,原因很简单 , 因为拿多少的权利在用户这里,不好控制
那怎么办?
专门有人看着,发钱,每人一百,这个时候每个人的数量的决定权,就不在用户这里了,给你几张你就要几张

同理 : 我想只创建一个对象,那么这个权利肯定不能交给客户控制,因为也控制不住 所以
我们不让客户直接创建对象,我们给创建,你要使用对象的时候,找我要,我就给你 这个时候 给你哪个对象,就是我说了算
既然不能让用户直接创建对象,也就意味着 不能让用户访问我们的构造方法 所以 第一步应该 构造方法私有化

1. 构造方法私有化

上面步骤,我们已经把构造方法私有化,就意味着,用户创建不了对象
那么这个时候,我们必须提供一个让用户能够获取对象的一个方法
这个方法 必须是静态的方法

示例代码 :

/**
 * 用的时候再创建对象,并且只创建一次 : 懒汉模式
 * 
 * @author lenovo
 * @Date 2020年7月13日
 * @Time 下午2:46:43
 */
public class Singleton_01 {
	// 1.私有化构造方法
	private Singleton_01() {

	}

	// 保存当前对象的变量
	private static Singleton_01 s = null;

	// 用于获取对象的方法
	public static Singleton_01 getInstance() {
		// 如果为 null 说明没有创建对象,就创建一个
		// 如果不为 null 说明有对象,就直接返回
		if (s == null) {
			s = new Singleton_01();
		}
		return s;
	}
}

2. 创建一个公共的静态方法,用来返回当前类的实例化对象,并且保证只实例化一次

获取对象的方法有了,还需要有一个存储对象的变量,这个变量必须和类生命周期相关
如果是局部变量,这个变量具有临时性,下一次调用这个方法的时候,局部变量又要初始化,对象还是要更改
如果是成员变量,能在静态方法中直接操作成员变量吗? 不能
所以 这个存储变量 一定是静态的
并且这个变量还要私有化,要么用户直接更改变量的值怎么办?

3. 创建一个用于存储对象的静态变量(这个变量的类型一定是当前类类型)

根据对象的创建时机的不同,分为两种

1 在类加载阶段就初始化对象,叫饿汉模式 2 在第一次使用的时候,再创建对象,叫懒汉模式

示例代码 :

/**
 * 类加载阶段就初始化对象,叫饿汉模式
 * 
 * 一般我们使用懒汉模式
 * 
 * @author lenovo
 * @Date 2020年7月13日
 * @Time 下午2:41:56
 */
public class Singleton_02 {
	// 1.私有化构造方法
	private Singleton_02() {

	}

	// 保存当前对象的变量
	private static Singleton_02 s = new Singleton_02();

	// 用于获取对象的方法
	public static Singleton_02 getInstance() {
		return s;
	}
}

• 无论客户怎么获取实例化对象,都只创建一个实例化对象

测试代码 :

public class Client {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		System.out.println(Singleton_01.getInstance());
		System.out.println(Singleton_01.getInstance());
		System.out.println(Singleton_01.getInstance());
		System.out.println("====");
		System.out.println(Singleton_02.getInstance());
		System.out.println(Singleton_02.getInstance());
		System.out.println(Singleton_02.getInstance());
	}

}

工厂模式

• 把创建对象的语句,封装到一个类中 ,形成工厂模式
• 这样 所有用到这个对象的地方,都去工厂中获取
• 把类和类之间的强依赖关系变弱,灵活度更高

工厂接口类 :

public interface Weapon {
	public void fireInTheHole();
}

工厂实现类 :

public class WeaponFactory {
	public static Weapon getWeapon() {
//		return new ZhuanTou();
		return new RPG();
	}
}

AK47类 :

public class AK47 implements Weapon {

	@Override
	public void fireInTheHole() {
		System.out.println("PAPAPA~");
	}
}

砖头类 :

public class ZhuanTou implements Weapon {

	@Override
	public void fireInTheHole() {
		System.out.println("PA~");
	}
}

火箭筒类 :

public class RPG implements Weapon {

	@Override
	public void fireInTheHole() {
		System.out.println("beng~");
	}
}

测试代码 :

public class Factory_01 {

	public static void main(String[] args) {
		// 队友
//		fight(new ZhuanTou());
//		fight(new ZhuanTou());
//		fight(new ZhuanTou());
//		fight(new ZhuanTou());
//		fight(new ZhuanTou());
//		fight(new RPG());
//		fight(new RPG());
//		fight(new RPG());
//		fight(new RPG());
//		fight(new RPG());

		fight(WeaponFactory.getWeapon());
		fight(WeaponFactory.getWeapon());
		fight(WeaponFactory.getWeapon());
		fight(WeaponFactory.getWeapon());
		fight(WeaponFactory.getWeapon());
		// 敌人
		fight(new AK47());
		fight(new AK47());
	}

	public static void fight(Weapon weapon) {
		weapon.fireInTheHole();
	}
}

类中有什么

静态变量
成员变量
局部变量

静态方法
成员方法
构造方法

静态代码段
动态代码段

this
super

抽象方法

final

常量

类中的一切都不是必须的

class A{

}