java23种设计模式

           

1普通工厂模式

public interface Book {
public void bookKind();
}

public class EnglishBook implements Book{
public void bookKind() {
System.out.println("英语书");
}
}

public class MathBook implements Book{
public void bookKind() {
System.out.println("数学书");
}
}

public class BookFactory {


public Book produce(String bookName){
if("english".equals(bookName)){
return new EnglishBook();
}else if("math".equals(bookName)){
return new MathBook();
}else{
System.out.println("输入的书名错误");
return null;
}
}
}

public class Test {


public static void main(String[] args) {
BookFactory bookFactory = new BookFactory();
Book produce = bookFactory.produce("english");
produce.bookKind();
}
}

测试结果：英语书

此时如果输入字符串有误，则创建不了实例

2多个工厂模式

public class BookFactory1 {
public   Book produceEnglish() {
return new EnglishBook();
}
public  Book produceMath() {
return new MathBook();
}
}

public class Test {


public static void main(String[] args) {
BookFactory1 bookFactory = new BookFactory1();
Book produce = bookFactory.produceEnglish();
produce.bookKind();
}
}

还可以优化，

3静态工厂模式

public class BookFactory1 {
public static  Book produceEnglish() {
return new EnglishBook();
}
public static Book produceMath() {
return new MathBook();
}
}

public class Test1 {


public static void main(String[] args) {
Book produceEnglish = BookFactory1.produceEnglish();
produceEnglish.bookKind();
}
}

此方法创建实例很方便，但是又有问题来了，如果要增加生产的实例，就要修改代码，就违背了闭包原则

4抽象工厂模式

增加一个接口

public interface Provider {
public Book produce();
}

每一个要创建的实力新建一个工厂类并且都要事先Provider接口

public class BookEnglishFactory implements Provider{
public Book produce() {
return new EnglishBook();
}
}

public class BookMathFactory implements Provider{
public Book produce() {
return new MathBook();
}
}

测试：

public class Test {


public static void main(String[] args) {
Provider provider=new StudentFactory();
Book produce = provider.produce();
produce.bookKind();
}
}

如果要增加的话，只需要新建这个类并实现Book,再创建这个类的工厂类实现Provider接口就行

5单例模式

第一种：

public class Singleton {
//持有私有静态实例，此处赋值为null，目的是实现延迟加载
private static Singleton instance=null;

//私有构造方法，防止被实例化
private Singleton(){}

public static Singleton getInstance(){
if(instance==null){
synchronized (instance) {
if(instance==null){
instance=new Singleton();
}
}
}
return instance;
}
public Object readResolve(){
return instance;
}
}

第二种：

public class Singleton1 {


/**
* 私有构造方法，防止被实例化
*/
private Singleton1(){

}
/**
* 此处使用一个内部类来维护单例
* @author 严
*
*/
private static class SingletonFactory{
private static Singleton1 instance=new Singleton1();
}
/**
* 获取实例
* @return
*/
public static Singleton1 getInstance(){
return SingletonFactory.instance;
}
/**
* 如果该对象用于序列化，可以保证对象在序列化前后保持一致
*/
public Object readResolve(){
return getInstance();
}
}

第二种设计模式优势在于，jvm内部的机制能够保证当一个类被加载的时候，这个类的加载过程是线程互斥的，这样就保证了Instance只被创建一次，算是挺完美的，

6建造者模式

public class Prototype implements Cloneable {
public Object clone() throws CloneNotSupportedException {
Prototype proto = (Prototype) super.clone();
return proto;
}
}

6.1深复制和浅复制

深复制：将一个对象复制后，不论是基本数据类型还有引用类型，都是重新创建的。简单来说，就是深复制进行了完全彻底的复制，而浅复制不彻底。

浅复制：将一个对象复制后，基本数据类型的变量都会重新创建，而引用类型，指向的还是原对象所指向的

这个建造者模式我还没弄懂

7适配器模式

public class Source {


public void method1(){
System.out.println("this is source");
}
}

public interface Targetable {


public void method1();
public void method2();
}

public class Adapter extends Source implements Targetable{


public void method2() {
System.out.println("this is the targetavb;e");
}


}

public class Test {


public static void main(String[] args) {
Targetable target=new Adapter();
target.method1();
target.method2();
}
}

8代理模式

public interface Sourceable {


public void method();
}

public class Source implements Sourceable {


public void method() {
System.out.println("the source");
}
}

public class Proxy implements Sourceable{


private Source source;
public Proxy(){
super();
this.source=new Source();
}

public void method() {
before();
source.method();
after();
}
private void before(){
System.out.println("before");
}


private void after(){
System.out.println("after");
}
}

public class Test {


public static void main(String[] args) {
Sourceable source=new Proxy();
source.method();
}
}

                                                                              2017年6月19号，学习了java23中设计模式，做的学习记录