java常见的几种设计模式

设计模式

1、概述

1)设计模式(Design pattern)：是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结；

2)分类：

创建型模式(创建对象的): 单例模式、抽象工厂模式、建造者模式、工厂模式、原型模式。

行为型模式(对象的功能): 适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式。

结构型模式(对象的组成): 模版方法模式、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、职责链模式、访问者模式。

2、简单工厂模式

1)概述：又叫静态工厂方法模式，它定义一个具体的工厂类负责创建一些类的实例

2)实现：

                        public abstract class Animal {
				public abstract void eat();
			}
			
			public class Cat extends Animal{
				@Override
				public void eat() {
					System.out.println("猫吃鱼");
				}
			}
			
			public class Dog extends Animal{
				@Override
				public void eat() {
					System.out.println("狗吃肉");
				}
			}
			
			public class AnimalFactory {
				public static Animal get(String name){
					if(name.equals("Dog")){
						return new Dog();
					}else if(name.equals("Cat")){
						return new Cat();
					}else{
						return null;
					}
				}
			}
			
			public class Test {
				public static void main(String[] args) {
					AnimalFactory.get("Cat").eat();
					AnimalFactory.get("Dog").eat();
				}
			}

3、工厂方法模式

1)概述：工厂方法模式中抽象工厂类负责定义创建对象的接口，具体对象的创建工作由继承抽象工厂的具体类实现

2)实现：

                        public interface AnimalFactory {

public abstract Animal get() ;

}

--------------------------

public class DogFactory implements AnimalFactory {

@Override

public Animal get() {

return new Dog();

}

}

-------------------------------------

AnimalFactory af = new DogFactory() ;

Animal animal = af.get() ;

animal.eat() ;

4、单例模式

概述：保证类在内存中只有一个对象

1)饿汉式

                        public class Student {
				private final static Student s = new Student();
				private Student() {
					super();
				}
				public static Student get(){
					return s;
				}
			}

2)懒汉式

        

                        public class Teacher {
				private static Teacher t = null;
				public Teacher() {
					super();
				}
				public static Teacher get(){
					if(t == null){
						t = new Teacher();
					}
					return t;
				}
			}

3)Runtime类(单例模式的实现)

概述：每个Java应用程序都有一个Runtime类实例，使应用程序能够与其运行的环境相连接。可以通过getRuntime方法获取当前运行时对象。

public Process exec(String command)执行Dos命令

5、模版设计模式

1)概述：定义一个算法的骨架，而将具体的算法延迟到子类中来实现

2)实现：

                        public abstract class GetTime {
				public long getTime(){
					long startTime = System.currentTimeMillis();
					work();	//一些耗时操作
					long endTime = System.currentTimeMillis();
					return endTime - startTime;
				}
				public abstract void work();
			}
			
			public class ExtendsGet extends GetTime{
				@Override
				public void work() {
					for(int i = 0;i < 1000;i ++){
						System.out.print(i);
					}
					System.out.println();
				}
			}
			
			public class Test {
				public static void main(String[] args) {
					ExtendsGet eg = new ExtendsGet();
					long time = eg.getTime();
					System.out.println(time);
				}
			}

6、装饰模式

1)概述：使用被装饰类的一个子类的实例，在客户端将这个子类的实例交给装饰类。是继承的替代方案

2)实现：(IO流中将File包装成一个高效字符流)

                        public interface Phone {
				void call();
			}
			
			public class CallPhone implements Phone{
				@Override
				public void call() {
					System.out.println("打电话");
				}
			}
			
			public class PhoneDecorate extends CallPhone{
				private Phone phone;
				public PhoneDecorate(Phone phone) {
					super();
					this.phone = phone;
				}
				@Override
				public void call() {
					phone.call();
				}
			}
			
			public class MusicPhone extends PhoneDecorate{
				public MusicPhone(Phone phone) {
					super(phone);
				}
				@Override
				public void call() {
					super.call();
					System.out.println("听音乐");
				}
			}
			
			public class VideoPhone extends PhoneDecorate{
				public VideoPhone(Phone phone) {
					super(phone);
				}
				@Override
				public void call() {
					super.call();
					System.out.println("看视频");
				}
			}
			
			public class Test {
				public static void main(String[] args) {
					new VideoPhone(new MusicPhone(new CallPhone())).call();
				}
			}

7、观察者模式

1)概述：一种一对多的依赖关系，让多个观察者对象同时监听一个主题对象；

2)实现：

                        public class WorkMan {
    				String Manname;
				public WorkMan(String manname) {
					super();
					Manname = manname;
				}
			}
			
			public class Job {
				String jobname;
				int jobmoney;
				public Job(String jobname, int jobmoney) {
					super();
					this.jobname = jobname;
					this.jobmoney = jobmoney;
				}
			}
			
			public class Headhunter {
				private ArrayList jobal = new ArrayList<>();
				private ArrayList manal = new ArrayList<>();
				
				public void addWorkMan(WorkMan wm){
					manal.add(wm);
				}
				public void delWorkMan(WorkMan wm){
					manal.remove(wm);
				}
				public void addJob(Job job){
					jobal.add(job);
					sent(job);
				}
				public void delJob(Job job){
					jobal.remove(job);
				}
				private void sent(Job job) {
					for(WorkMan wm : manal){
						System.out.println(wm.Manname + ",你好！有份" + job.jobname 
								+ "的工作，薪资" + job.jobmoney + "元，有意者请及时面试");
					}
				}
			}
			
			public class Test {
				public static void main(String[] args) {
					Headhunter headhunter = new Headhunter();
					WorkMan wm1 = new WorkMan("张三");
					WorkMan wm2 = new WorkMan("李四");
					WorkMan wm3 = new WorkMan("王五");
					headhunter.addWorkMan(wm1);
					headhunter.addWorkMan(wm2);
					headhunter.addWorkMan(wm3);
					Job job1 = new Job("司机", 8000);
					Job job2 = new Job("保姆", 9000);
					Job job3 = new Job("清洁员", 6000);
					headhunter.addJob(job1);
					headhunter.addJob(job2);
					headhunter.addJob(job3);
					headhunter.delWorkMan(wm3);
					headhunter.delJob(job3);
					headhunter.addWorkMan(new WorkMan("赵六"));
					headhunter.addJob(new Job("保安", 7000));
				}
			}