Java设计模式视频

Java设计模式视频
2011年03月01日
　　1. 抽象类与适配器模式
　　什么是抽象：抽象是处理对象复杂性的一种技术，它只关注对象的主要细节而忽略了对象的次要细节。
　　抽象类？
　　1. 类和方法都要被关键字abstract去修饰
　　2. 抽象的方法不用去实现而只要声明一下就可以了
　　3. 抽象类不可以去实例化，也就是不能去new
　　4. 一个类中如果含有抽象方法，那么这个类就必须被声明为抽象类，继承它的子类必须去覆写这个抽象方法才可以被实例化
　　定义的格式：
　　abstract class 类名{
　　//声明数据成员；
　　//抽象方法
　　abstract 返回值类型 方法名（参数1，参数2.。。。）；//此方法为抽象方法，所以没有实现
　　//一般方法
　　}
　　大家可以看到，在抽象类中，即可以有抽象方法有可以有一般方法，不同的是，抽象方法必须被子类去覆写。
　　接口
　　大家知道，在java中只允许单继承，但是在实际问题中往往都需要多继承，java引入了接口这一概念。（一个类可以实现多个接口）
　　由于接口中都是抽象方法，那么我们在实现它的时候就必须全部覆写这些方法。假如我有一个类，这个类只想覆写一部份方法怎么办？
　　在接口与这个类中间可以加一个抽象类：
　　抽象类去覆写接口中的全部方法，而那个类去继承这个抽象类，根据需要覆写抽象类中的方法。（简单的适配器模式）
　　2.单态模式和简单工厂模式
　　Singleton模式主要作用是保证在Java应用程序中，一个类Class只有一个实例存在。
　　在项目的很多地方都会用到它，比如说数据库的链接。
　　使用Singleton的好处还在于可以节省内存，因为它限制了实例的个数，有利于Java垃圾回收（garbage collection）。
　　简单工厂模式又叫静态工厂模式，顾名思义，它是用来实例化目标类的静态类。下面我主要通过一个简单的实例说明简单工厂及其优点。
　　getCarInstance 反射去掉
　　3. 工厂方法模式
　　工厂方法模式和简单工厂模式在结构上的不同是很明显的。工厂方法模式的核心是一个抽象工厂类，而简单工厂模式把核心放在一个具体类上。工厂方法模式可以允许很多具体工厂类从抽象工厂类中将创建行为继承下来，从而可以成为多个简单工厂模式的综合，进而推广了简单工厂模式。
　　此模式涉及到抽象工厂角色（汽车厂），具体工厂角色（具体的汽车车间），抽象产品角色（汽车）以及具体产品角色（私车，公交巴士）。
　　4. 抽象工厂 interface Person{ public void eat(); public void talk(); } //男人 class Man implements Person{ public void eat(){ System.out.println("男人再吃东西。。。。"); } public void talk(){ System.out.println("男人在说话。。。。"); } } //女人 class Woman implements Person{ public void eat(){ System.out.println("女人再吃东西。。。。"); } public void talk(){ System.out.println("女人在说话。。。。"); } } interface Animal{ public void eat(); public void sleep(); } //公牛 class Bull implements Animal{ public void eat(){ System.out.println("Bull再吃东西。。。。。"); } public void sleep(){ System.out.println("Bull睡觉了。。。。"); } } //母牛 class Cow implements Animal{ public void eat(){ System.out.println("Cow再吃东西。。。。。"); } public void sleep(){ System.out.println("Cow睡觉了。。。。"); } } //NWFactory-->女娲 interface NWFactory{ public Person getPerson(String type); public Animal getAnimal(String type); } //阳绳-->用来造男人和雄性动物（Bull） class YangSheng implements NWFactory{ Man m=null; Bull b=null; public Man getPerson(String type){ try { m=(Man)Class.forName("org.jzkangta.factorydemo03." +type).newInstance(); } catch (Exception e) { e.printStackTrace(); } return m; } public Bull getAnimal(String type){ try { b=(Bull)Class.forName("org.jzkangta.factorydemo03. "+type).newInstance(); } catch (Exception e) { e.printStackTrace(); } return b; } } //阴绳-->用来造女人和雌性动物（Cow） class YinSheng implements NWFactory{ Woman w=null; Cow c=null; public Woman getPerson(String type){ try { w=(Woman)Class.forName("org.jzkangta.factorydemo03 ."+type).newInstance(); } catch (Exception e) { e.printStackTrace(); } return w; } public Cow getAnimal(String type){ try { c=(Cow)Class.forName("org.jzkangta.factorydemo03." +type).newInstance(); } catch (Exception e) { e.printStackTrace(); } return c; } } public class FactoryDemo03 { public static void main(String[] args) { //实例化一个阳绳,ys YangSheng ys=new YangSheng(); //实例化一个阴绳,ys1 YinSheng ys1=new YinSheng(); //造男人和女人,p1是男人,p2是女人 Person p1=ys.getPerson("Man"); Person p2=ys1.getPerson("Woman"); //造动物，a1是公牛（Bull），a2是母牛（Cow） Animal a1=ys.getAnimal("Bull"); Animal a2=ys1.getAnimal("Cow"); a1.eat(); a1.sleep(); a2.eat(); a2.sleep(); p1.eat(); p1.talk(); p2.eat(); p2.talk(); } }
　　5. 代理模式 package org.jzkangta.proxydemo; abstract class SaleComputer{ abstract public void SaleComputer(); } //真实的主题角色（ComputerMaker） class ComputerMaker extends SaleComputer{ public void SaleComputer(){ System.out.println("卖出了一台电脑。。。"); } } //代理的主题角色(ComputerProxy) class ComputerProxy extends SaleComputer{ ComputerMaker cm=null; public void youHui(){ System.out.println("我给你优惠...."); } public void giveMouse(){ System.out.println("我还送你一个鼠标。。。"); } public void SaleComputer(){ youHui(); giveMouse(); if(cm==null){ cm=new ComputerMaker(); } cm.SaleComputer(); } } public class ProxyDemo { public static void main(String[] args) { //SaleComputer sc=new ComputerMaker(); SaleComputer sc=new ComputerProxy(); sc.SaleComputer(); } }
　　6. 动态代理
　　7. 策略模式（Strategy模式）
　　策略模式是对算法的包装，是吧使用算法的责任和算法本身分割开来，委派给不同的对象管理。
　　优点：
　　1.提供了管理相关的算法族的办法。
　　2.提供了可以替换继承关系的办法。
　　3.避免使用多重条件转移语句
　　缺点：
　　1.客户端必须知道所有的策略类，并自行决定使用哪一个策略类。
　　2.造成很多的策略类。
　　//抽象的策略角色 public abstract class Operation { public abstract void oper(float a,float b); }
　　8. 门面模式
　　什么是门面模式(Facade)
　　外部与一个子系统的通信必须通过一个统一的门面对象进行。这就是门面模式。
　　涉及两个角色：
　　门面角色：客户端可以调用这个角色的方法。此角色知道子系统的功能和责任。在正常情况下，本角色会将所有从客户端发来的请求委派到相应的子系统中去。
　　子系统角色：可以同时有一个或者多个子系统。每一个子系统都不是一个单独的类，而是一个类的集合。每个子系统都可以被客户端直接调用，或者被门面角色调用。
　　在什么情况下使用门面模式
　　1.为一个复杂的子系统提供一个简单的接口
　　2.引入门面模式可以将一个子系统与他的客户端以及其他的子系统分离，可以提高子系统的独立性和可移植性
　　3.层次化结构，如果层与层之间是互相依赖的，那么引用门面模式可以向鼎他们仅仅通过门面进行通信，从而简化了层与层之间的依赖关系。
　　9. 建造模式
　　建造模式是对象的创建模式，可以讲一个产品的内部表象与产品的生成过程分割开来，从而可以使一个建造过程生成具有不同的内部表象的产品对象。 import java.util.ArrayList; interface Builder{ public void buildPartA(); public void buildPartB(); public void buildPartC(); public Product getProduct(); } class Product{ private ArrayList parts=new ArrayList(); public void add(String part){ parts.add(part); } public void show(){ System.out.println("Product有以下几部分构成:"); for(String s:parts){ System.out.println(s); } } } class Worker implements Builder{ private Product product; public void buildPartA() { product=new Product(); product.add("A部分"); } public void buildPartB() { product.add("B部分"); } public void buildPartC(){ product.add("C部分"); } public Product getProduct(){ return product; } } class Designer{ public void order(Builder builder){ builder.buildPartA(); builder.buildPartB(); builder.buildPartC(); } } public class Test { public static void main(String[] args) { Designer designer=new Designer(); Builder builder=new Worker(); designer.order(builder); Product product =builder.getProduct(); product.show(); } }
　　10. 模板方法模式
　　模版方法模式（Template Method）
　　准备一个抽象类，将部分逻辑以具体方法的形式实现，然后申明一些抽象方法来迫使子类实现剩余的逻辑。不同的子类可以以不同的方式实现这些抽象方法，从而对剩余的逻辑有不同的实现。
　　Java语言里面使用过的模板方法模式
　　HttpServlet技术
　　HttpServlet类提供了一个service（）方法。这个方法调用了一个或者几个do方法，完成对客户端调用的处理。这些do方法则要由具体的HttpServler类提供。那么这里的service（）方法就是模版方法。