迭代器模式
通过聚合对象的遍历行为分离出来,抽象成迭代器来实现,目的是不暴露内部结构。
主要角色
1.抽象聚合(Aggregate):定义存储,添加,删除聚合对象以及迭代器对象的接口。
2具体聚合(ConcreteAggregate):实现抽象聚合类,返回一个具体迭代器的实例
3抽象迭代器(Iterator):定义访问和遍历聚合元素的接口,
4具体迭代器(Concretelterator):实现迭代器接口中的所有方法。
Aggregate有一个iterator方法返回Iterator接口对象。
Iterator的实现类是ConcreteIterator
ConcreteAggregate继承了Aggregate接口,重写iterator类,return ConcreteIterator是Iterator的实例。
ConcreteAggregate继承了父亲的方法,重写方法后
适配器模式Adapter
类适配器模式(使用继承的适配器)
对象适配器模式(使用委托的适配器)
1.类适配器模式。
一个接口Print对外提供两个抽象方法。一个类Banner正好有两个方法可用不同名,子类PrintBanner继承Banner实现Print,PrintBanner重写Print方法去调用Banner的党法。
就是把Banner的方法适配到Print上
代码如下:
public interface Print {
public abstract void printWeak();
public abstract void printStrong();
}
public class Banner {
private String string;
public Banner(String string) {
this.string = string;
}
public void showWithParent(){
System.out.println("("+string+")");
}
public void showWithAster(){
System.out.println("*"+string+"*");
}
}
public class PrintBanner extends Banner implements Print{
//如果父类只有一个有参构造,没有无参构造,子类必须继承构造方法,super调用父类的构造
public PrintBanner(String string) {
super(string);
}
@Override
public void printWeak() {
showWithParent();
}
@Override
public void printStrong() {
showWithAster();
}
}
public class Main {
public static void main(String[] args) {
Print p=new PrintBanner("Hello");
p.printStrong();
p.printWeak();
}
}
2.对象适配模式
把Print改成抽象类,一个类只能继承一个类,让对外提供方法的子类PrinterBanner继承Print类,重写方法,聚合Banner,去调用Banner的方法。
代码如下:
public abstract class Print {
//方法是抽象的,类一定是抽象的
public abstract void printWeak();
public abstract void printStrong();
}
public class Banner {
private String string;
public Banner(String string) {
this.string = string;
}
public void showWithParent(){
System.out.println("("+string+")");
}
public void showWithAster(){
System.out.println("*"+string+"*");
}
}
public class PrintBanner extends Print {
private Banner banner;
@Override
public void printWeak() {
banner.showWithParent();
}
@Override
public void printStrong() {
banner.showWithAster();
}
}
public class Main {
public static void main(String[] args) {
Print p=new PrintBanner("Hello");
p.printStrong();
p.printWeak();
}
}
Adapter模式的角色:
Targer(对象)
Client(请求者)
Adaptee(被适配)
Adapter(适配)
Template Method模板模式
再父类中定义处理流程的框架,再子类中实现具体的处理,这种模式就叫Templatemethod
父类是抽象类,子类继承父类,实现父类的抽象方法,父类的一般方法调用自己抽象方法。
代码如下:
public abstract class AbstractDisplay {//抽象类
public abstract void open();//交给子类的抽象方法
public abstract void print();//交给子类的抽象方法
public abstract void close();//交给子类的抽象方法
public final void display(){
open();
for(int i=0;i<5;i++){
print();
}
close();
}
}
public class CharDisplay extends AbstractDisplay {
private char ch;
public CharDisplay(char ch) {//接收字符保存再ch中
this.ch = ch;
}
@Override
public void open() {
System.out.print("<<");
}
@Override
public void print() {
System.out.print(ch);
}
@Override
public void close() {
System.out.println(">>");
}
}
public class StringDisplay extends AbstractDisplay {
private String string;
private int width;
public StringDisplay(String string) {
this.string = string;//将传进来的字符串保存string
this.width=string.getBytes().length;//把字符串的长度也保存
}
@Override
public void open() {
pringLine();
}
@Override
public void print() {
System.out.println("|"+string+"|");
}
@Override
public void close() {
pringLine();
}
public void pringLine(){
System.out.print("+");
for (int i=0;i<width;i++){
System.out.print("-");
}
System.out.println("+");
}
}
public class Main {
public static void main(String[] args) {
AbstractDisplay d1=new CharDisplay('H');
AbstractDisplay d2=new StringDisplay("Hello");
AbstractDisplay d3=new StringDisplay("你好世界");
d1.display();
d2.display();
d3.display();
}
}
Template Method模式的角色:
AbstractClass(抽象类):再模板中实现模板方法,声明所有的抽象方法
ConcreteClass(具体类)
优点:逻辑算法都在父类中写好了,调试bug比价好找
父类和子类是共同工作的,子类实现父类的抽象方法必须知道这些抽象方法被调用的时机。
再子类中可以使用父类中定义的方法
可以通过子类中增加方法以实现新的功能
再子类中重写父类方法可以改变程序的行为
再抽象类阶段确定处理的流程
Factory Method模式
Factory Method是用Template Method模式来构建生长城实例工厂,这就是FactoryMethod模式。
父类决定实例的生成方式,但不决定所要生成的具体的类,具体的处理全部交给子类负责。
Factory接口提供创建Product接口的方法,IDCardFactory实现了Factory,负责创建IDCard.看似是Factory创建Product,实则是儿子创建儿子,Product想创建啥样的就弄啥样的儿子,不取决于Factory。
代码如下:
public abstract class Factory {
public final Product create(String owner){
Product p=createProduct(owner);
registerProduct(p);
return p;
}
protected abstract Product createProduct(String owner);
protected abstract void registerProduct(Product product);
}
public abstract class Product {
public abstract void use();
}
public class IDCard extends Product{
private String owner;
IDCard(String owner){
System.out.println("制作"+owner+"IDCard");
this.owner=owner;
}
@Override
public void use() {
System.out.println("使用"+owner+"IDCard");
}
public String getOwner(){
return owner;
}
}
public class IDCardFactory extends Factory {
private List owners=new ArrayList();
protected Product createProduct(String owner){
return new IDCard(owner);
}
protected void registerProduct(Product product){
owners.add(((IDCard)product).getOwner());
}
public List getOwners(){
return owners;
}
}
测试类
public class Main {
public static void main(String[] args) {
Factory factory=new IDCardFactory();
Product card1 = factory.createProduct("小明");
Product card2 = factory.createProduct("小刚");
Product card3 = factory.createProduct("大名");
card1.use();
card2.use();
card3.use();
}
}
单例模式Singleton
饿汉式单例
只会生成一个实例,Singleton定义static字段,并将其初始化为Singleton类的实例,类加载时初始化一次,Singleton的构造函数时private。线程安全
代码如下:
public class Singleton {
private static Singleton singleton=new Singleton();
private Singleton(){
System.out.println("生成一个实例");
}
public static Singleton getInstance(){
return singleton;
}
}
public class Main {
public static void main(String[] args) {
System.out.println("Start");
Singleton obj1=Singleton.getInstance();
Singleton obj2=Singleton.getInstance();
if (obj1==obj2){
System.out.println("同一个实例");
}else {
System.out.println("不是同一个实例");
}
System.out.println("End");
}
}
懒汉式单例
什么时候用什么时候调用才生成实例,线程不安全
代码如下:
public class SingletonLazy {
private static SingletonLazy instance;
private SingletonLazy(){}
public static synchronized SingletonLazy getInstance(){
if (instance==null){
instance=new SingletonLazy();
}
return instance;
}
}
Prototype模式
MessageBox类和UnderLinePen类是两个实现了Product接口的类。只要事先将这两个类注册到Manage类中,随时复制新的实例。
代码如下
public interface Product extends Cloneable{
public abstract void use(String s);
public abstract Product createClone();
}
public class MessageBox implements Product {
private char decochar;
public MessageBox(char decochar){
this.decochar=decochar;
}
@Override
public void use(String s) {
int length=s.getBytes().length;
for(int i=0;i<length+4;i++){
System.out.print(decochar);
}
System.out.println("");
System.out.println(decochar+" "+s+" "+decochar);
for (int i=0;i<length+4;i++){
System.out.print(decochar);
}
System.out.println("");
}
@Override
public Product createClone() {
Product p=null;
try {
p= (Product) clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return p;
}
}
public class UnderlinePen implements Product {
private char ulchar;
public UnderlinePen(char ulchar){
this.ulchar=ulchar;
}
@Override
public void use(String s) {
int length=s.getBytes().length;
System.out.println("\""+s+"\"");
System.out.println(" ");
for(int i=0;i<length;i++){
System.out.print(ulchar);
}
System.out.println("");
}
@Override
public Product createClone() {
Product p=null;
try {
p= (Product) clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return p;
}
}
public class Manager {
private HashMap showcase=new HashMap();
public void register(String name,Product proto){
showcase.put(name,proto);
}
public Product create(String protoname){
Product p= (Product) showcase.get(protoname);
return p.createClone();
}
}
public class Main {
public static void main(String[] args) {
Manager manager=new Manager();
UnderlinePen upen=new UnderlinePen('~');
MessageBox messageBox=new MessageBox('*');
MessageBox messageBox1=new MessageBox('/');
manager.register("strong message",upen);
manager.register("warning box",messageBox);
manager.register("slash box",messageBox1);
Product p1=manager.create("strong message");
p1.use("HelloWorld");
Product p2=manager.create("warning box");
p2.use("HelloWorld");
Product p3=manager.create("slash box");
p3.use("HelloWorld");
}
}