Java中有6大设计原则&饿汉式单例模式&懒汉式单例模式&生产者和消费者模式

Java中有6大设计原则,23种设计模式.还有一种,有人归纳为设计原则,有人归纳为设计模式.

1.设计原则(扩展):前人经过经验的总结出写Java代码的规则,平时写代码遵循这些规则,写出代码就规范性好.java要求程序高内聚低耦合.

内聚性:独立性.

耦合度:依赖性.

1.1:单一职能原则:一个类只做一件事.

作用:提高程序内聚性,降低程序耦合度.

1.2:里氏替换原则:所有使用父类父接口的地方,都可以用子类去替换.

作用:提高程序可扩展性.

1.3:依赖倒置原则:能依赖抽象的就不依赖于具体的.

作用:提高程序可扩展性.

1.4:接口隔离原则:一个接口只被设计一种功能.

作用:提高程序灵活性和可扩展性.

1.5:迪米特原则:一个对象应该对其他对象保持最少的了解.

作用:提高程序内聚性,降低程序耦合度.

1.6:开闭原则:对扩展开发,对修改关闭.

作用:提高程序的可维护性.

2.设计模式:前人经过项目经验的总结,总结出对特定问题的特定解决方案.

3.单例模式:一个类只有一个对象.

优点:减少频繁创建对象所消耗系统资源.

实现方式:私有化构造方法,声明私有静态当前对象变量,给他提供一个公有的静态的获得对象的方法.

3.1:饿汉式单例模式:相懒汉式单例模式来说,优点:在多线程中使用安全.缺点:耗系统资源.

eg:public class King {
	private String sname;
	private int wifeCount;
	
	/**
	 * 私有化构造方法
	 */
	private King() {
		
	}
	
	/**
	 * 声明私有这个类的对象变量
	 */
	private static King k1=new King();
	
	/**
	 * 公有的静态获得对象的方法
	 * @return
	 */
	public static King getKing() {
		return k1;
	}
	
	public String getSname() {
		return sname;
	}
	public void setSname(String sname) {
		this.sname = sname;
	}
	public int getWifeCount() {
		return wifeCount;
	}
	public void setWifeCount(int wifeCount) {
		this.wifeCount = wifeCount;
	}
}

3.2:懒汉式单例模式:相对于饿汉式单例模式:优点:不耗资源.缺点在多线程中使用不安全.如果想在多线程中使用就用线程同步.

eg:public class Boss {
	private String name;
	private double money;
	
	/**
	 * 私有构造方法
	 */
	private Boss() {
		
	}
	
	/**
	 * 私有的静态的对象的变量
	 */
	private static Boss b1;
	
	/**
	 * 公有的静态的获得对象的方法
	 * @return Boss
	 */
	public synchronized static Boss getBoss() {
		if (b1==null) {
			b1=new Boss();
		}
		return b1;
	}
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public double getMoney() {
		return money;
	}
	public void setMoney(double money) {
		this.money = money;
	}
}

4.生产者和消费者模式:如果没有商品,生产者就要生产商品,如果有商品,生产者必须等待,等待这个商品被消费才能再生产.如果没有商品,消费者就要等待;如果有商品,消费者就要消费商品.

优点:安全性高.

缺点:效率低.

注意:监视器要监视所有线程,所以一般要是所有线程共用的一个对象,而我们的锁对象刚好是监视所有的线程,所以可以用锁对象作监视器来监视所有线程.

eg:public class Goods {
	private int gid;
	private String gname;
	
	@Override
	public String toString() {
		return "Goods [gid=" + gid + ", gname=" + gname + "]";
	}
	
	public int getGid() {
		return gid;
	}
	/**
	 * 实现商品编号自增
	 */
	public void setGid() {
		this.gid++;
	}
	public String getGname() {
		return gname;
	}
	public void setGname(String gname) {
		this.gname = gname;
	}
}

public class Consumer implements Runnable{
	//声明商品变量
	public Goods g;
	
	/**
	 * 通过构造方法将商品对象传过来
	 * @param g
	 */
	public Consumer(Goods g) {
		this.g=g;
	}

	/**
	 * 消费者的任务方法
	 */
	@Override
	public void run() {
		while (true) {
			synchronized (Test2.ob2) {
				//判断商品是否存在
				if (Test2.flag==false) {//商品不存在,
					try {
						//等待
						Test2.ob2.wait();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
					
				}else {//商品存在,消费
					System.out.println(Thread.currentThread().getName()+"在消费"+this.g);
					//改变商品标记
					Test2.flag=false;
					//唤醒所有生产者
					Test2.ob2.notifyAll();
				}
			}
		}
	}
}

public class Producer implements Runnable{
	//声明商品变量
	public Goods g;

	/**
	 * 用构造方法将商品对象传过来
	 * @param g
	 */
	public Producer(Goods g) {
		this.g=g;
	}

	/**
	 * 生产者的任务方法
	 */
	@Override
	public void run() {
		while (true) {
			
			synchronized (Test2.ob2) {
				//判断商品是否存在
				if (Test2.flag==false) {//商品不存在,生产商品
					//生产商品
					this.g.setGid();
					this.g.setGname("衣服");
					System.out.println(Thread.currentThread().getName()+"在生产"+this.g);
					//改变商品标记
					Test2.flag=true;
					//唤醒所有消费者去消费
					Test2.ob2.notifyAll();
				}else {//商品存在
					try {
						Test2.ob2.wait();//让当前所有生产者来等待
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
			}
			if (this.g.getGid()==100) {
				break;
			}
		}
	}
}

public class Test2 {
	/**
	 * 声明一个变量作标记,标记当前的商品是否存在
	 */
	public static boolean flag=false;//默认不存在
	/**
	 * 创建一个生产者锁对象,也作为生产者监视器,监视器要监视所有对象
	 */
	public static Object ob2=new Object();
	
	public static void main(String[] args) {
		//声明一个商品对象
		Goods g=new Goods();
		
		//创建生产者任务对象
		Producer p1=new Producer(g);
		
		//创建三个生产者
		Thread t1=new Thread(p1, "张三1");
		Thread t2=new Thread(p1, "张三2");
		Thread t3=new Thread(p1, "张三3");
		
		//创建消费都任务对象
		Consumer c1=new Consumer(g);
		
		//创建三个消费者
		Thread t4=new Thread(c1, "李四1");
		Thread t5=new Thread(c1, "李四2");
		Thread t6=new Thread(c1, "李四3");
		
		//启动线程
		t1.start();
		t2.start();
		t3.start();
		t4.start();
		t5.start();
		t6.start();
	}
}