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<Job> jobal = new ArrayList<>();
private ArrayList<WorkMan> 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));
}
}