Java 匿名内部类 、 设计模式

 

目录

1.内部类

1.1匿名内部类

2.设计模式

2.1是什么

2.2单例模式 

2.2.1是什么

2.2.2饿汉模式

2.2.3懒汉模式

2.3工厂模式

2.3.1是什么

---

1.内部类

1.1匿名内部类

package _01_InnerClass;
/**
 * 匿名内部类 : 就是没有名字的类
 * 
 * 一般方法参数需要接收一个接口类型的数据 , 那么我们调用的时候需要传入对应的实现类对象
 * 此时 可以直接传递一个匿名内部类,匿名内部类 就等于是子类
 * 匿名内部类没有名字, 不能重复使用, 类名为 外部类类名$1 ,, 以此类推
 * 匿名内部类中 不能有静态声明 , 但是可以声明常量 (public static final)
 * 不能直接调用外部类的成员属性,需要用对象才行
 * @author 人间失格
 * @data     2021年10月16日下午6:53:32
 */

public class OuterClass_01 {

	public static void main(String[] args) {
		int i = 2;
		System.out.println(2);
		//不能创建对象调用
//		 UserServiceImpl userService = new UserServiceImpl();
//		 m1(userService);

		// 匿名内部类
		m1(new UserService() {
			@Override
			public void login() {
				System.out.println("登陆失败");
			}
		});
	}

	public static void m1(UserService userService) {
		userService.login();
	}
}
//匿名内部类的接口数据
// interface : 定义接口关键字   语法 : [权限修饰符] interface 接口名 { 类体 }
interface UserService {
	//构造方法 无返回值 方法名login
	public void login();
}

2.设计模式

2.1是什么

设计模式 代表了最佳的实践 ,通常被有经验的面向对象的软件开发人员采用.设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案 ,这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的.

2.2单例模式 

2.2.1是什么

/**
 * 什么是设计模式 : 设计模式 代表了最佳的实践, 通常被有经验的面向对象的软件开发人员采用。
 * 设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案,
 * 这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的
 * 
 * 单列模式 : 让某个类只创建一个对象,可以避免垃圾回收问题
 * 例如Windows中的任务管理器,只能打开一个,打开多个造成资源浪费
 * 实现方式 :  
 *                   1.  实例化对象 , 需要调用构造方法 ,想要控制创建对象啊的数量,
 *   第一步就是不能让别人创建对象,就意味着不能让别的类访问构造方法 构造方法私有化
 *                   2. 提供一个用于获取当前类对象的静态方法 
 *   上面的已经把构造方法私有化了,用户创建不了对象了,那么我们需要提供一个方法用来获取对象
 *   这个方法一定是公共的静态方法, 如果是成员方法,必须得先有对象才能调用, 而这个方法的作用就是用来获取对象的
 *                  3. 保证只有一个实例
 *   数据不存储不能重复使用,所以为了保证对象的唯一性,必须先准备一个变量用来存储对象
 *             变量声明 :  数据类型  变量名 = 值;
 *             值  就是对象;
 *             变量名  随便一个就行
 *             数据类型  SingLeton_01  当前类类型  
 *如果是成员变量  : 必须用对象调用,在静态方法中不能直接使用,而我们的方法是静态方法所以不能直接操作成员变量
 *如果是静态变量  : 整个程序生命周期中,只会初始化一次
 *
 *
 *一般步骤: 
 *1.构造方法私有化 
 *2.提供一个静态变量用来保存类对象
 *3.提供一个静态方法, 用来获取当前类对象
 *
 *根据对象的创建实际不同, 分为两类 
 *                                      1.饿汉模式 : 类加载完之后, 就立刻创建对象
 *                                      2.懒汉模式 : 第一次用到的时候,再创建对象
 *                                      这里一般推荐使用懒汉对象
 *                   
 * @author 人间失格
 * @data     2021年10月16日下午7:07:32
 */

2.2.2饿汉模式

public class SingLeton_01 {

	public static void main(String[] args) {
		
	}
	//饿汉模式
	//静态变量 s 保存类对象 
	static SingLeton_01 s =new SingLeton_01();
	// 构造一个静态方法 用来获取当前类的对象
	public static SingLeton_01 getInstance(){
		return s;
	}

}

2.2.3懒汉模式

package _02_SingLeton;
/**
 * 懒汉模式
 * 单例模式，一般用于比较大，复杂的对象，只初始化一次，
 * 应该还有一个private的构造函数，使得不能用new来实例化对象，
 * 只能调用getInstance方法来得到对象，而getInstance保证了每次调用都返回相同的对象。
 * @author 人间失格
 * @data     2021年10月16日下午7:44:15
 */
public class SingLeton_02 {
	// 1 构造方法私有化
	private SingLeton_02() {
	}

	// 2 静态变量
	private static SingLeton_02 s;

	// 3 静态方法
	public static SingLeton_02 getInstance() {
		if (s == null) {
			s = new SingLeton_02();
		}
		return s;
	}
}

2.3工厂模式

2.3.1是什么

把实例化对象的语句,单独放到工厂类中, 负责创建对象

这样我们用到这个对象的时候,只需要去工厂中获取即可,使类和类之间的依赖关系变弱,耦合度降低

package _03_Factory;

/**
 * 工厂模式 : 把创建对象的语句单独封装成一个工厂模式
 * 
 * 这样 所有用到这个对象的地方,都去工厂中获取,把类之间强依赖关系变弱,灵活度更高
 * 
 * 工厂模式 工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。
 * 
 * 这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
 * 
 * 在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，
 * 
 * 并且是通过使用一个共同的接口来指向新创建的对象。
 * 
 *  意图：定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。
 * 
 * 主要解决：主要解决接口选择的问题。
 * 
 * 何时使用：我们明确地计划不同条件下创建不同实例时。
 * 
 * 如何解决：让其子类实现工厂接口，返回的也是一个抽象的产品。
 * 
 * 关键代码：创建过程在其子类执行。
 * 
 * @author 人间失格
 * @data 2021年10月16日下午7:53:39
 */

public class Factory_01 {
	public static void main(String[] args) {
		Animal a = Factory.getAnimal(1);
		Animal b = Factory.getAnimal(2);
	}
}

class Animal {

}

class Cat extends Animal {

}

class Dog extends Animal {

}

class Pig extends Animal {

}

class Factory {
	public static Animal getAnimal(int x) {
		if (x == 1) {
			return new Cat();
		} else if (x == 2) {
			// return new Dog();
			return new Pig();
		}
		return null;
	}
}