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) {
//1,2,3
synchronized (Test2.ob2) {
//1
//判断商品是否存在
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();
}
}