一.单例模式
二.模板模式
三.代理模式
单例模式
单例模式：确保一个类在内存中只有一个实例对象
1.私有化所有的构造方法，不让外部自己创建
2.给外部提供一个静态方法，获取当前类的一个对象
3.必须定义一个静态变量来保存当前类唯一的一个
4.创建方法:
①饿汉式
②懒汉式
public class HttpOperation0 {
//饿汉式
//直接实例化，最终只有一个实例
private static HttpOperation0 instance = new HttpOperation0();
private HttpOperation0(){
}
public static HttpOperation0 getInstance(){
return instance;
}
}
public class HttpOperation1 {
//懒汉式
private static HttpOperation1 instance;
private HttpOperation1(){
}
public static HttpOperation1 getInstance(){
if(instance == null){
//使用synchronized加锁防止被两次实例化
synchronized (HttpOperation1.class) {
if(instance == null){
instance = new HttpOperation1();
}
}
}
return instance;
}
}
public class Main {
public static void main(String[] args) {
HttpOperation0 instance01 = HttpOperation0.getInstance();
HttpOperation0 instance02 = HttpOperation0.getInstance();
HttpOperation0 instance03 = HttpOperation0.getInstance();
HttpOperation1 instance11 = HttpOperation1.getInstance();
HttpOperation1 instance12 = HttpOperation1.getInstance();
HttpOperation1 instance13 = HttpOperation1.getInstance();
System.out.println(instance01);
System.out.println(instance02);
System.out.println(instance03);
System.out.println(instance11);
System.out.println(instance12);
System.out.println(instance13);
}
}
image.png
可以看到用这两种方法实例只能创建一个实例对象
模板模式
模板设计模式：解决同一类问题时，只需按照同一模式解决就可，只是具体方法不同。
1.抽象类使用abstract修饰
2.抽象类不能被实例化
3.抽象类中可以定义成员变量和方法
- 抽象方法（抽象方法需用abstrct修饰）不能被实现，只能在子类中实习抽象方法
- 子类不需要修改的方法可不用abstract修饰，即可在抽象类中实现
4.如果不想在子类中实现抽象类里面的方法，可将子类也变成抽象类
//在抽象类中只定义不实现，指定实现步骤
public abstract class Activity {
private String className;
//界面布局顺序
public Activity(){
onCreate();
onStart();
onResume();
onPause();
onStop();
onDestroy();
}
//用abstract修饰的抽象方法
abstract public void onCreate();
abstract public void onStart();
abstract public void onResume();
abstract public void onPause();
abstract public void onStop();
abstract public void onDestroy();
//子类不会修改的默认方法
public String getClassName(){
return className;
};
}
在它的子类中写实现方法,需要哪些方法就重写哪些方法
public class MainActivity extends Activity{
@Override
public void onCreate() {
System.out.println("创建首页界面");
}
@Override
public void onStart() {
System.out.println("界面启动");
}
@Override
public void onResume() {
System.out.println("开始交互!");
}
@Override
public void onPause() {
System.out.println("暂停!");
}
@Override
public void onStop() {
System.out.println("停止!");
}
@Override
public void onDestroy() {
System.out.println("销毁!");
}
}
public class QQzoneActivity extends Activity{
@Override
public void onCreate() {
System.out.println("创建QQ空间界面");
}
@Override
public void onDestroy() {
System.out.println("QQ空间界面已销毁!");
}
@Override
public void onStart() {
}
@Override
public void onResume() {
}
@Override
public void onPause() {
}
@Override
public void onStop() {
}
}
public class MyClass {
public static void main(String[] args) {
MainActivity mainActivity = new MainActivity();
QQzoneActivity qQzoneActivity = new QQzoneActivity();
}
}
image.png
代理模式
为对象提供代理，以控制其他对象对该对象的访问
接口
1.使用interface关键字定义一个接口
2.接口支持多继承
3.接口不能被实例化（接口无构造方法）
4.接口只能定义静态成员变量，且必须被初始化（默认修饰符 public abstract）
5.方法实现：
①抽象方法：
- 接口中的方法（接口中的方法默认是抽象方法）不需要自己实现，由接口创建的新类来实现
- 使用implements关键字创建新类，在新类中重写实现方法
//定义一个接口，接口中声明抽象方法
public interface DataInteraction{
void input();
void output();
}
//电脑使用该接口时
public class Computer implements DataInteraction {
public Computer(){
input();
output();
}
@Override
public void input() {
System.out.println("电脑从缓冲区中结束数据");
}
@Override
public void output() {
System.out.println("电脑将数据输出到显示屏");
}
}
//打印机使用该接口时
public class Printer implements DataInteraction{
public Printer(){
input();
output();
}
@Override
public void input() {
System.out.println("打印机从电脑接收数据!");
}
@Override
public void output() {
System.out.println("打印机开始打印数据!");
}
}
public class MyClass {
public static void main(String[] args) {
Computer computer = new Computer();
Printer printer = new Printer();
}
}
image.png
②内部接口：接口中还可以声明接口。对于部分类，它不需要继承接口中的全部方法时，可使用内部接口的定义方式
public interface DataInteraction{
interface Input{
void input();
}
interface Output{
void output();
}
}
//使用 . 进行接口中的接口访问
public class Computer implements DataInteraction.Input,DataInteraction.Output {
public Computer(){
input();
output();
}
@Override
public void input() {
System.out.println("电脑从缓冲区中结束数据");
}
@Override
public void output() {
System.out.println("电脑将数据输出到显示屏");
}
}
public class Mouse implements DataInteraction.Output {
public Mouse(){
output();
}
@Override
public void output() {
System.out.println("鼠标输出数据到电脑");
}
}
public class MyClass {
public static void main(String[] args) {
Computer computer = new Computer();
Mouse mouse = new Mouse();
}
}
image.png
6.接口回调与中介找房演示
public class Agent {//定义个代理类，代理中有个接口OnAgentFinishListener
private OnAgentFinishListener listener;
public void rentHouse() {
System.out.println("我是中介:开始找房源");
System.out.println("房子找到了!");
if (listener != null){
listener.onFinish("四合院");
}
}
/**因为OnAgentFinishListener被Person和Dog实现，
*所以这里用OnAgentfinishListener声明setListener函数的参数后，
*实际传参为Person和Dog可以向OnAgentFinishListener转换，
*这是多态的运用
*/
public void setListener(OnAgentFinishListener listener){//声明一个监听，记录数据传入者的信息
this.listener = listener;
}
//数据传出的接口（数据回调的接口）
public interface OnAgentFinishListener{
void onFinish(String des);
}
}
//定义一个类，用于传入个人数据
public class Person implements Agent.OnAgentFinishListener{
public void needOneHouse(){
Agent xw = new Agent();
xw.setListener(this);
xw.rentHouse();
}
@Override
public void onFinish(String des){
System.out.println("我是xw喜欢你的房子"+des);
}
}
public class Dog implements Agent.OnAgentFinishListener {
public void needOneHouse(){
Agent wc = new Agent();
wc.setListener(this);
wc.rentHouse();
}
@Override
public void onFinish(String des){
System.out.println("我是旺财你的房子太大了"+des);
}
}
public class MainClass {
public static void main(String[] args) {
Person person = new Person();
person.needOneHouse();
Dog dog = new Dog();
dog.needOneHouse();
}
}
image.png
image.png
代理设计模式实现的过程就是把代理需要的用户信息交给代理，由代理将用户想做的事完成后将结果返还给用户。