设计模式的学习

设计原则:
单一职责原则:
低耦合,高内聚
耦合性:类与类之间产生的关系
低耦合:让类与类之间的关系不复杂
内聚:执行一个件事情(功能)的能力
高内聚:一个类能够完成的事情,不要使用多个类一起来执行!

数据库
对某个数据进行增删改查(查询很重要的)
定一个接口:
增();
删();
改();
查();
实现类:
业务逻辑层:
增(){
增加xxx联系人/商品列表
}

2:开闭原则

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

开发好一个程序(项目),尽量不要修改原有代码
类和类之间假设有关系
更改一个类的功能,其他类已需要更改(增加代码的代码的书写量)
SVN(版本控制)/git

设计模式:
创建型模式 对象的创建

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

行为型模式 对象的行为

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

 
  设计一个工厂类:
  工厂类提供一些静态方法,间接的去创建具体的对象
 
 优点:
不需要再创建具体类的对象,而是把创建的工作交给了工厂类来创建!

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

我们通过代码来学习这个模式。

//提供了一个动物抽象类
public abstract  class Animal {
	
	//抽象功能
	public abstract void eat() ;
}

public class Cat extends Animal {

	@Override
	public void eat() {
		System.out.println("猫吃鱼...");
	}

}

public class Dog extends Animal{

	@Override
	public void eat() {
		System.out.println("狗吃骨头...");
	}
	
}

//动物工厂类
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;
	}
}

public class AnimalDemo {

	public static void main(String[] args) {
		
		//养猫
		Cat c = new Cat() ;
		c.eat();
		Dog d = new Dog() ;
		d.eat(); 
		
		System.out.println("---------------------");
		//使用抽象类多态的形式改进工厂类
		Animal a = AnimalFactory.createAnimal("cat") ;
		a.eat();
		a = AnimalFactory.createAnimal("dog") ;
		a.eat();
		
		a = AnimalFactory.createAnimal("pig") ;
		// java.lang.NullPointerException
		//对象进行非空判断
		if(a!=null) {
			a.eat();
		}else {
			System.out.println("抱歉,当前工厂类不提供该动物类的创建");
		}
	}
}//猫吃鱼...
//狗吃骨头...
//---------------------
//猫吃鱼...
//狗吃骨头...
//抱歉,当前工厂类不提供该动物类的创建

工厂方法模式
     提供一个抽象类(抽象工厂)还需要提供一个接口(工厂接口),每一个具体的类都有对应的工厂类(实现工厂接口)
 具体对象的创建工作由继承抽象工厂的具体类实现
 
 优点:
        客户端不需要再负责对象的创建(不需显示创建具体对象)，从而明确了各个类的职责，
        如果有新的对象增加，只需要增加一个具体的类和具体的工厂类即可，不影响已有的代码，后期维护容易，增强了系统的扩展性
弊端:

书写代码量大了!

我们通过一段代码来具体学习这个模式。

//抽象类
public abstract class Animal {

	public abstract void eat() ;
}

public class Cat extends Animal {

	@Override
	public void eat() {
		System.out.println("猫吃鱼...");
		
	}
	
}

public class Dog extends Animal {

	@Override
	public void eat() {
		System.out.println("够吃骨头...");
	}

}

public interface Factory {
	
	//该工厂接口的方法的返回值是抽象工厂类
	public abstract Animal creatAnimal() ;
}

//猫的工厂类--->创建一个只猫
public class CatFactory implements Factory {

	@Override
	public Animal creatAnimal() {
		return  new Cat() ;
	}

}

public class DogFactory implements Factory {

	@Override
	public Animal creatAnimal() {
		return new Dog();
	}

}

public class DogFactory implements Factory {

	@Override
	public Animal creatAnimal() {
		return new Dog();
	}

}//猫吃鱼...
//-------------------
//狗吃骨头...

设计模式之单例模式
  单例模式核心思想:某些类的对象在创建的时候 ,在系统内存始终只有一个对象!
  单例模式分类:
  1)饿汉式 2)懒汉式(类似于多线程环境..)
 
 饿汉式:
在加载那个类的时候,对象的创建工作就已经完成了!

两种分类在设计上几乎一样:
1)定义一个类,将该类的无参构造方法私有化；
2)在该类的成员位置创建该类对象，并且一定要私有化,防止外界更改这个对象；
3)在该类中提供静态成员方法(返回值就是创建的那个对象),能被当前类直接调用,static修饰。

//学生类
public class Student {

	//无参构造私有化,目的为了防止用户创建对象的时候,会产生多个对象!
	//为了不让直接通过构造方法创建该类对象
	
	private Student() {}
	//成员位置创建该类的实例
	//静态方法只能访问静态变量
	//加入私有修饰
	private static Student s = new Student() ; //静态的类变量
	
	//提供一个公共的成员方法
	public  static Student getStudent() {
		return s ;
	}
}

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
	}
}//true
//org.westos_03.Student@52e922
//org.westos_03.Student@52e922

懒汉式:
符合单例模式核心思想
   1)自定义一个类,将无参构造私有化；
  2)在成员位置声明变量；
3)提供公共静态功能,在里面判断的时候创建该类对象,返回该类对象。
 

懒汉式(延迟加载 -->懒加载)
可能会出现问题
---> 多线程的问题
         --->校验多线程安全问题的标准
1)是否是多线程环境
  2)是否有共享数据
3)是否有多条语句对共享数据进行操作  (使用同步机制进行操作)

public class Teacher {
	
	//无参构造私有化
	private Teacher() {
		
	}
	
	//在成员位置声明变量
	//私有化,并且
	private static Teacher t = null ;
	
	//静态的同步方法  (锁对象: 类名.class)
	public synchronized static Teacher getTeacher() {
		if(t==null) {
			t = new Teacher() ;
		}
		return t ;
	}
}

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(t2);
		}
}//true
//org.westos_04.Teacher@52e922
//org.westos_04.Teacher@52e922