设计原则和设计模式

设计原则和设计模式

设计原则:

单一职责原则:

低耦合,高内聚

耦合性:类和类之间的关系

低耦合:让类与类之间的关系不复杂

内聚:执行意见事情的能力

高内聚:一个类能完成的事情,尽量不要用多个类执行.

2. 开闭原则

核心思想:一个对象对扩展开放,对修改关闭

开发项目时,尽量不要修改原有代码.这样容易出错.

因为修改一个代码时,其他代码可能也要进行修改

设计模式:

创建型模式 对象的创建

结构型模式 对象的组成(结构)

行为型模式 对象的行为

简单工厂模式

又称为静态工厂方法模式,

它定义一个具体的工厂类负责创建一些类的事例

工厂类提供一些静态方法,间接去创建具体的对象

优点:

不需要再创建具体类的对象,而是把创建工作交给了工厂类来创建

弊端:

如果有新的对象增加或者某些对象的创建方式不同,就需要不断的修改工厂类

不利于后期维护

下面是单间工厂模式的示例

Flower接口,为其他花提供开花的功能

Rose类,接口实现类

Lily类,接口实现类

FactoryFlower类: 工厂类负责创建一些类的实例

FlowerTest类:测试类

Flower接口,为其他花提供开花的功能

package simplefactor;

public interface Flower {

public  abstract void bloom();

}

Rose类,接口实现类

package simplefactor;

public class Rose implements Flower {

@Override

public void bloom() {

System.out.println("玫瑰花开");

}

Lily类,接口实现类

}

package simplefactor;

public class Lily implements Flower {

@Override

public void bloom() {

System.out.println("百合花开");

}

}

}

FactoryFlower类: 工厂类负责创建一些类的实例

}

package simplefactor;

public class FactoryFlower {

//私有化无参,让外界无法创建该类对象

private FactoryFlower () {};

/*public static Rose creatRose() {

return new Rose();

}

public static Lily creatLily() {

return new Lily();

}*/

//上述代码显得很麻烦,因为一旦加入新的类型,又要创建一个新的方法,测试的时候也显得很麻烦

public static Flower creatFlower(String type) {

//加入判断,如果里面存在该类型的对象可以进行创建

//这里使用多态,返回值类型是它们的父类

if ( "Rose".equals(type)) {

return new Rose();

}

else if ("Lily".equals(type)) {

return new Lily();

}

//没有找到符合类型的对象

return null;

}

}

FlowerTest类:测试类

package simplefactor;

public class FlowerTest {

public static void main(String[] args) {

/*//调用工厂类的方法

//玫瑰

Rose r = FactoryFlower.creatRose();

r.bloom();

//百合

Lily  l = FactoryFlower.creatLily();

l.bloom();

这种方法仍然觉得麻烦,继续改进

*/

//使用多态的方法调用玫瑰类

Flower f = FactoryFlower.creatFlower("Rose");

f.bloom();

//百合,这里直接将引用指向玫瑰类,在栈空间节省了内存

f = FactoryFlower.creatFlower("Lily");

f.bloom();

//进行一个不存在的类的判断

f = FactoryFlower.creatFlower("juhua");

if (f==null) {

System.out.println("您输入的类型在工厂类中不存在");

}

else {

f.bloom();

}

工厂方法模式

提供一个抽象类(抽象工厂)还需要提供一个接口(工厂接口),每一个具体类都有对应的工厂类(实现工厂接口)

具体对象创建工作由继承工厂的具体类实现

优点:

客户端不需要再负责对象的创建(不需要显示创建具体对象)

从而确定了各个类的职责

如果有新的对象增加,只需要增加一个具体的类和具体的工厂类即可,不影响已有的代码

后期维护简单,增强了系统的扩展性

设计模式之单例模式

  单例模式核心思想:某些类的对象在创建的时候 ,在系统内存始终只有一个对象!

  单例模式分类:

 1)饿汉式 2)懒汉式(类似于多线程环境..)

 饿汉式:

  在加载那个类的时候,对象的创建工作就已经完成了!

 两种分类在设计上几乎一样:

  1)定义个类,将该类的无参构造方法私有化

  2)在该类的成员位置创建该类对象 并且一定要私有化,防止外界更改这个对象

  3)在该类中提供静态成员方法(返回值就是创建的那个对象),能被当前类直接调用,static修饰

区别:

从名字上来说，饿汉和懒汉，

饿汉就是类一旦加载，就把单例初始化完成，保证getInstance的时候，单例是已经存在的了，

而懒汉比较懒，只有当调用getInstance的时候，才回去初始化这个单例。

饿汉式:

Student类:

package signfun;

public class Student {

//构造一个类,私有化构造方法

private Student() {};

//构造一个成员变量为该类对象,并私有它,防止外界更改

private static Student s = new Student();

//构造一个方法,返回该对象,因为静态方法只能访问静态变量,故而将上面的值也设为静态的

public static Student getStudent() {

return s ;

}

StudentTest类:

public class StudentTest {

public static void main(String[] args) {

//获取该Student对象

/*因为方法是静态的,Student的对象是静态变量,在该类被调用的时候自动加载,

只加载一次,两个获取对象得到的是对内存中的同一个对象

*/

Student s1 = Student.getStudent();

Student s2 = Student.getStudent();

System.out.println(s1==s2);

}

懒汉式:

   符合单例模式核心思想

   1)自定义一个类,将无参构造私有化

   2)在成员位置声明变量

   3)提供公共静态功能,在里面判断的创建该类对象,返回该类对象

}

  如果是开发中,那么就使用饿汉式(饿汉式它不会出现问题的单例模式)

  如果是面试中,那么使用懒汉式(因为他是可能出现问题的一种单例模式)

 面试题:

   你使用过单例模式吗?简单介绍一种单例模式,请用代码设计

   面试官想问的是:使用设计单例的懒汉式,能否想到使用同步机制解决线程的安全问题..

 懒汉式(延迟加载 -->懒加载)

   可能会出现问题

   ---> 多线程的问题

   --->校验多线程安全问题的标准

   1)是否是多线程环境

   2)是否有共享数据

3)是否有多条语句对共享数据进行操作  (使用同步机制进行操作)

除了安全问题方面,还有其他问题不推荐使用懒汉式:

每次都要做初始化,比较慢,如果加上了同步保证安全 ,但是每次都要同步,会影响性能.毕竟大多数情况是不需要同步的

懒汉式代码:

package signfun;

public class Student {

//构造一个类,私有化构造方法

private Student() {};

//设置懒汉式

private static Student s = null ;

//故名思意,就是调用方法的时候才去创建该对象,

public static Student getStudent() {

synchronized(Student.class) {

if (s==null) {

s = new Student();

}

return s;

}

package signfun;

public class StudentTest {

public static void main(String[] args) {

//获取该Student对象

/*因为方法是静态的,Student的对象是静态变量,在该类被调用的时候自动加载,

只加载一次,两个获取对象得到的是对内存中的同一个对象

*/

Student s1 = Student.getStudent();

Student s2 = Student.getStudent();

System.out.println(s1==s2);

}

}

Runtime

 每个 Java 应用程序都有一个 Runtime 类实例，使应用程序能够与其运行的环境相连接。

  public static Runtime getRuntime()返回与当前 Java 应用程序相关的运行时对象

public Process exec(String command)

             throws IOException

在单独的进程中执行指定的字符串命令。

最后

以上就是忧伤缘分为你收集整理的设计原则和设计模式的全部内容，希望文章能够帮你解决设计原则和设计模式所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。