Java面象对向的基本思想（三）

最新推荐文章于 2024-09-18 17:04:07 发布

吾爱kobe

最新推荐文章于 2024-09-18 17:04:07 发布

阅读量654

点赞数

文章标签： java

本文链接：https://blog.csdn.net/u013367928/article/details/52423402

版权

设计模式

设计模式的原则

逻辑代码独立到单独的方法中，注重封装性–易读，易复用。
不要在一个方法中，写下上百行的逻辑代码。把各小逻辑代码独立出来，写于其它方法中，易读其可重复调用。

写类，写方法，写功能时，应考虑其移植性，复用性：防止一次性代码！
是否可以拿到其它同类事物中应该？是否可以拿到其它系统中应该？

熟练运用继承的思想：找出应用中相同之处，且不容易发生变化的东西，把它们抽取到抽象类中，让子类去继承它们；继承的思想，也方便将自己的逻辑建立于别人的成果之上。

熟练运用接口的思想：找出应用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代码混在一起。

总体来说设计模式分为三大类：

创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。

结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

创建型模式

FactoryMethod ( 工厂方法 )
AbstractFactory ( 抽象工厂 )
Singleton ( 单态模式 )
Builder ( 建造者模式 )
Prototype ( 原型模式 )

工厂方法

定义一个用于创建对象的接口，让子类决定实例化哪一个类。FactoryMethod使一个类的实例延迟到其子类。

适用性：

1.当一个类不知道它所必须创建的对象的类的时候。

2.当一个类希望由它的子类来指定它所创建的对象的时候。

3.当将创建对象的职责委托给多个帮助*类中的某一个，并且希望将哪一个帮助子类是代理者这一信息局部化的时候。

参与者：

1.Product定义工厂方法所创建的对象的接口。

2.ConcreteProduct实现Product接口。

3.Creator声明工厂方法，该方法返回一个Product类型的对象。Creator也可以定义一个工厂方法的缺省实现，它返回一个缺省的ConcreteProduct对象。可以调用工厂方法以创建一个Product对象。

4.ConcreteCreator重定义工厂方法以返回一个ConcreteProduct实例。

类图：

这里写图片描述

Product

public interface Work {

    void doWork();
}

ConcreteProduct

public class StudentWork implements Work {

    public void doWork() {
        System.out.println("学生做作业!");
    }

}

public class TeacherWork implements Work {

    public void doWork() {
        System.out.println("老师审批作业!");
    }

}

Creator

public interface IWorkFactory {

    Work getWork();
}

ConcreteCreator

public class StudentWorkFactory implements IWorkFactory {

    public Work getWork() {
        return new StudentWork();
    }

}

public class TeacherWorkFactory implements IWorkFactory {

    public Work getWork() {
        return new TeacherWork();
    }

}

Test

public class Test {

    public static void main(String[] args) {
        IWorkFactory studentWorkFactory = new StudentWorkFactory();
        studentWorkFactory.getWork().doWork();

        IWorkFactory teacherWorkFactory = new TeacherWorkFactory();
        teacherWorkFactory.getWork().doWork();
    }

}

result

学生做作业!
老师审批作业!

抽象工厂

提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

适用性:

 1.一个系统要独立于它的产品的创建、组合和表示时。

2.一个系统要由多个产品系列中的一个来配置时。

3.当你要强调一系列相关的产品对象的设计以便进行联合使用时。

4.当你提供一个产品类库，而只想显示它们的接口而不是实现时。

参与者：

1.AbstractFactory:声明一个创建抽象产品对象的操作接口。

2.ConcreteFactory:实现创建具体产品对象的操作.

3.AbstractProduct:为一类产品对象声明一个接口。

4.ConcreteProduct:定义一个将被相应的具体工厂创建的产品对象。实现AbstractProduct接口。

5.Client:仅使用由AbstractFactory和AbstractProduct类声明的接口。

类图：

这里写图片描述

AbstractFactory：

public interface IAnimalFactory {

    ICat createCat();

    IDog createDog();
}

ConcreteFactory :

public class BlackAnimalFactory implements IAnimalFactory {

    public ICat createCat() {
        return new BlackCat();
    }

    public IDog createDog() {
        return new BlackDog();
    }

}

public class WhiteAnimalFactory implements IAnimalFactory {

    public ICat createCat() {
        return new WhiteCat();
    }

    public IDog createDog() {
        return new WhiteDog();
    }

}

AbstractProduct:

public interface ICat {

    void eat();
}

public interface IDog {

    void eat();
}

ConcreteProduct:

public class BlackCat implements ICat {

    public void eat() {
        System.out.println("The black cat is eating!");
    }

}

public class WhiteCat implements ICat
{

    public void eat()
    {
        System.out.println("The white cat is eating!");
    }

}

public class BlackDog implements IDog {

    public void eat() {
        System.out.println("The black dog is eating");
    }

}

public class WhiteDog implements IDog {

    public void eat() {
        System.out.println("The white dog is eating!");
    }

}

Client:

public static void main(String[] args) {
    IAnimalFactory blackAnimalFaatory = new BlackAnimalFactory();
    ICat blackCat = blackAnimalFaatory.createCat();
    blackCat.eat();
    IDog blackDog = blackAnimalFaatory.createDog();
    blackDog.eat();

    IAnimalFactory whiteAnimalFactory = new WhiteAnimalFactory();
    ICat whiteCat = whiteAnimalFactory.createCat();
    whiteCat.eat();
    IDog whiteDog = whiteAnimalFactory.createDog();
    whiteDog.eat();
}

result:

The black cat is eating!
The black dog is eating!
The white cat is eating!
The white dog is eating!

建造者模式

将一个复杂对象的构造与它的表示分离，使其同样的构建过程可以创建不同的表示。

适用性：

1.当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时。

2.当构造过程必须允许被构造的对象有不同的表示时。

参与者：

1.Builder：为创建一个Product对象的各个部件指定抽象接口。

2.ConcreteBuilder：实现Builder的接口以构造和装配该产品的各个部件。定义并明确它所创建的表示，提供一个检索产品的接口。

3.Director:构造一个使用Builder接口的对象。

4.Product:表示被构造的复杂对象。ConcreteBuilder创建该产品的内部表示并定义它的装配过程。包含定义组成部件的类，包括将这些部件装配成最终产品的接口。

类图:

这里写图片描述

Builer：

public interface PersonBuilder {

    void buildHead();

    void buildBody();

    void buildFoot();

    Person buildPerson();
}

ConcreteBuilder:

public class ManBuilder implements PersonBuilder {

    Person person;

    public ManBuilder() {
        person = new Man();
    }

    public void buildbody() {
        person.setBody("建造男人的身体");
    }

    public void buildFoot() {
        person.setFoot("建造男人的脚");
    }

    public void buildHead() {
        person.setHead("建造男人的头");
    }

    public Person buildPerson() {
        return person;
    }
}

Director:

public class PersonDirector {

    public Person constructPerson(PersonBuilder pb) {
        pb.buildHead();
        pb.buildBody();
        pb.buildFoot();
        return pb.buildPerson();
    }
}

Product:

public class Person {

    private String head;

    private String body;

    private String foot;

    public String getHead() {
        return head;
    }

    public void setHead(String head) {
        this.head = head;
    }

    public String getBody() {
        return body;
    }

    public void setBody(String body) {
        this.body = body;
    }

    public String getFoot() {
        return foot;
    }

    public void setFoot(String foot) {
        this.foot = foot;
    }
}

public class Man extends Person {

}

Test

public class Test{

    public static void main(String[] args) {
        PersonDirector pd = new PersonDirector();
        Person person = pd.constructPerson(new ManBuilder());
        System。out.println(person.getBody());
        System.out.println(person.getFoot());
        System.out.println(person.getHead());
    }
}

result 建造男人的身体建造男人的脚建造男人的头

单例模式

单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例。在计算机系统中，线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。这些应用都或多或少具有资源管理器的功能。每台计算机可以有若干个打印机，但只能有一个Printer Spooler，以避免两个打印作业同时输出到打印机中。

java中单例模式是一种常见的设计模式，单例模式分两种：懒汉式单例、饿汉式单例。如果要实现单利，那么必然需要对类中的构造方法进行控制，将构造方法私有化，必然需要系统共有的方法来返回类中实例化的对象的操作。

饿汉式单例

在类初始化时，已经自行实例化，然后通过公有的方法返回实例化的对象。

public class Singleton1 {
    private final static Singleton1 single = new Singleton1();
    //将构造方法私有化
    private Singleton1(){
    }

    //提供共有的方法返回对象
    public static Singleton1 getInstance(){
        return single;
    }
}

懒汉模式

在第一次调用的时候实例化并返回结果，如果再次调用则不再实例化对象。

public class Singleton2 {
    private static Singleton2 single;
    //将构造方法私有化
    private Singleton2(){
    }

    //提供共有的方法返回对象，同步
    public synchronized static Singleton2 getInstance(){
        if(single == null){
            single = new Singleton2();
        }
        return single;
    }
}

单例的使用目前只需要知道用法就可以了，实际的作用还需要在具体的项目中进行体现。

原型模式

用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。

适用性:

1.当一个系统应该独立于它的产品创造、构成和表示时。

2.当要实例化的类是在运行时刻指定时，例如，通过动态装载。

3.为了避免创建一个与产品类层次平行的工厂的层次时。

4.当一个类的实例只能有几个不同状态组合中的一种时。建立相应数目的原型并克隆它们可能比每次用合适的状态手工实例化该类更方便一些

参与者

 1. Prototype：声明一个克隆自身的接口。

2. ConcretePrototype：实现一个克隆自身的操作。

3. Client：让一个原型克*自身从而创建一个新的对象。

类图：

这里写图片描述

Prototype ：

public class Prototype implements Cloneable {

    private String name;

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return this.name;
    }

    public Object clone(){
        try {
            return super.clone();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
}

ConcretePrototype：

public class ConcretePrototype extends Prototype {

    public ConcretePrototype(String name) {
        setName(name);
    }
}

Client:

public class Test {

    public static void main(String[] args) {
        Prototype pro = new ConcretePrototype("prototype");
        Prototype pro2 = (Prototype)pro.clone();
        System.out.println(pro.getName());
        System.out.println(pro2.getName());
    }
}

result: