设计原则:
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、资源加载和性能:
饿汉式在类创建的同时就实例化一个静态对象出来,不管之后会不会使用这个单例,都会占据一定的内存,但是相应的,在第一次调用时速度也会更快,因为其资源已经初始化完成,
而懒汉式顾名思义,会延迟加载,在第一次使用该单例的时候才会实例化对象出来,第一次调用时要做初始化,如果要做的工作比较多,性能上会有些延迟,之后就和饿汉式一样了。