Java设计模式

设计原则:

1>单一职责原则:低耦合,高内聚

    耦合性:类与类之间产生的关系

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

    内聚:执行一个件事情(功能)的能力

        高内聚:一个类能够完成的事情,不要使用多个类一起来执行!

2>:开闭原则

核心思想是：一个对象对扩展开放，对修改关闭

开发好一个程序(项目),尽量不要修改原有代码

类和类之间假设有关系

更改一个类的功能,其他类已需要更改(增加代码的代码的书写量)

设计模式分类:

    创建型模式 对象的创建

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

    行为型模式 对象的行为

简单工厂模式--->静态工厂方法模式

    优点:不需要在创建具体类的对象,而是把创建的工作交给了工厂类来创建!

              弊端:如果有新的对象增加，或者某些对象的创建方式不同，就需要不断的修改工厂类，不利于后期的维护

简单工厂模式的代码：

创建抽象动物类和它的子实现类

package org.westos_01;

//动物工厂类

public class AnimalFactory {

//无参构造私有:外界不能创建该类对象

private AnimalFactory() {

}

//想办法用多态的形式解决:代码扩展性

public static Animal createAnimal(String type) {

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

return new Cat() ;

}else if("dog".equals(type)) {

return new Dog() ;

}

return null;

}

}

package org.westos_01;

public class AnimalDemo {

public static void main(String[] args) {

//使用抽象类多态的形式改进工厂类

Animal a = AnimalFactory.createAnimal("cat") ;

a.eat();

a = AnimalFactory.createAnimal("dog") ;

a.eat();

a = AnimalFactory.createAnimal("pig") ;

//对象进行非空判断

if(a!=null) {

a.eat();

}else {

System.out.println("抱歉,当前工厂类不提供该动物类的创建");

}

}

}

工厂方法模式

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

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

 优点:

         客户端不需要在负责对象的创建(不需显示创建具体对象)，从而明确了各个类的职责，

         如果有新的对象增加，只需要增加一个具体的类和具体的工厂类即可，不影响已有的代码，后期维护容易，增强了系统的扩展性

弊端:

书写代码量大了!

设计模式之单例模式

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

 单例模式分类:

1) 饿汉式

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

 饿汉式:

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

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

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

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

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

饿汉式在类创建的同时就已经创建好一个静态的对象供系统使用，以后不再改变，所以天生是线程安全的。

package org.westos_03;

 

//学生类

public class Student {

//无参构造私有化,目的为了防止用户创建对象的时候,会产生多个对象!

private Student() {}

//成员位置创建该类的实例，加载类的时候就创建了对象

private static Student s = new Student() ; //静态的类变量

//提供一个公共的成员方法

public  static Student getStudent() {

return s ;

}

}

package org.westos_03;

public class StudentDemo {

public static void main(String[] args) {

Student s1 = Student.getStudent() ;

Student s2 = Student.getStudent();

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

System.out.println(s1);//org.westos_03.Student@70dea4e

System.out.println(s2);//org.westos_03.Student@70dea4e

}

}

 

 

 懒汉式:

  符合单例模式核心思想

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

  2)在成员位置声明变量（只是声明，没有创建对象）

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

package org.westos_04;

public class Teacher {

//无参构造私有化

private Teacher() {

}

//在成员位置声明变量

//私有化,并且

private static Teacher t = null ;

//提供公共的静态功能

//静态的同步方法  (锁对象: 类名.class)

public synchronized static Teacher getTeacher() {

if(t==null) {

t = new Teacher() ;

}

return t ;

}

}

package org.westos_04;

 

public class TeacherDemo {

public static void main(String[] args) {

//调用getTeacher()功能

Teacher t1 = Teacher.getTeacher() ;

Teacher t2 = Teacher.getTeacher() ;

System.out.println(t1==t2);

System.out.println(t1);//org.westos_04.Teacher@70dea4e

System.out.println(t1);

}

}

 

饿汉式和懒汉式区别

A.初始化时间不同

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

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

 

B、线程安全：

饿汉式天生就是线程安全的，可以直接用于多线程而不会出现问题，

懒汉式本身是非线程安全的，需要用同步机制解决这个问题。

 

C、资源加载和性能：

饿汉式在类创建的同时就实例化一个静态对象出来，不管之后会不会使用这个单例，都会占据一定的内存，但是相应的，在第一次调用时速度也会更快，因为其资源已经初始化完成，

而懒汉式顾名思义，会延迟加载，在第一次使用该单例的时候才会实例化对象出来，第一次调用时要做初始化，如果要做的工作比较多，性能上会有些延迟，之后就和饿汉式一样了。