class Res
{
private String name;  //私有
private String sex;
private boolean flag=false;
//对外提供访问方式
public synchronized void set(String name,String sex)    //同步
{
  if(flag)         //唤醒
   try{this.wait();}catch(Exception e){}
  this.name=name;
  this.sex=sex;
  flag=true;
  this.notify();
}
public synchronized void out()                   //同步
{
  if(!flag)
   try{this.wait();}catch(Exception e){}
  System.out.println(name+"...."+sex);
  flag=false;
  this.notify();
}
}
class Input implements Runnable
{
private Res r;
Input(Res r)
{
  this.r=r;
}
public void run()
{
  while(true)
  {
    int x=0;
    if(x==0)
     r.set=("mike","man");
    else
     r.set=("丽丽","女女女女女"）;
    x=(x+1)%2;
  }
}
}
class Output implements Runnable
{
private Res r;
Output(Res r)
{
  this.r=r;
}
public void run()
{
  while(true)
  {
    r.out();
  }
}
}
class InOutput
{
public static void main(String[] args)
{
  Res r=new Res();
  new Thread(new Input(r)).start();
  new Thread(new Output(r)).start();
}
}

这个问题怎样用单例设计来解决呢？

我给你一个简单的静态工厂也可以叫单例的例子
class Car
{
        private Car car = new Car();//私有化返回对象
        private Car(){}//私有化构造函数避免创建对象
        //创建一个获取对象的方法
        public static Car newInstance()
                {
                        return car;
                }
}
//这样你就可以直接调用这个静态方法来得到Car的对象
//无论你用了几次这个静态方法最终获得的都是car这个对象
//下面是测试程序
class Test
{
        public static void main(String[] args)
        {
                Car car = Car.newInstance();//获得Car对象
                Car car1 = Car.newInstance();//获得Car对象
                System.out.println(car==car1);//结果为true
                //因为car和car1是同一个对象
                //这就是单利设计模式 从头到脚只能创建一个Car对象
                //设计模式是一个灵活运用的东西,但是不要在乎那些条条框框
                //这只是一种设计程序的方法和思路
        }
}

黑马_许芸 发表于 2012-8-24 21:50
单例模式应该就那几个步骤吧：
1：构造函数设为private 。
2：在这个类里设置一个自身的成员变量  private  ...

额，你说的对，我忘了。

哥们你的代码实在是让我胃疼！！！！
贴上来那么一大段，格式混乱，各种空格(以后用Tab键把)，中间还有英文全角格式的括号，原谅我的自我强迫症把，我修改你的代码格式化了五分钟，最后整理好一看，天呐函数调用方法写成这r.set=("","man");，我差点吐血，这不是毕老师视频讲的代码嘛，照着抄过来，是这。。。请原谅我的直接。

我找来我以前学习时的代码贴给你吧(代码是等待唤醒机制那块的)：

1. package com.itheima.bixiangdong;
   
2. /* 黑马程序员_毕向东_Java基础视频教程第12天-03-多线程(线程间通信-等待唤醒机制)
   
3. * 对同一个对象，同时进行向内存入和向外打印
   
4. * */
   
5. 
   
6. 
   
7. class Resource {
   
8.         
   
9.         private String name;
   
10.         private String sex;
    
11.         private boolean flag = false;
    
12.         
    
13.         synchronized void set(String name, String sex) {
    
14.                 if(flag)
    
15.                         try {
    
16.                                 this.wait();
    
17.                                 }
    
18.                         catch(InterruptedException e) {
    
19.                                 e.printStackTrace();
    
20.                                 }
    
21.                 this.name = name;
    
22.                 this.sex = sex;
    
23.                 flag = true;
    
24.                 this.notify();
    
25.         }
    
26.         
    
27.         synchronized void show() {
    
28.                         if(!flag)
    
29.                                 try {
    
30.                                         this.wait();
    
31.                                         }
    
32.                                 catch (InterruptedException e) {
    
33.                                         e.printStackTrace();
    
34.                                         }
    
35.                         System.out.println(name +" is "+ sex);
    
36.                         flag = false;
    
37.                         this.notify();
    
38.         }
    
39. }
    
40. 
    
41. class Input implements Runnable {
    
42.         
    
43.         private Resource r;
    
44.         
    
45.         Input(Resource r) {
    
46.                 this.r = r;
    
47.         }
    
48.         public void run() {
    
49.                 int i = 0;
    
50.                 while(true) {
    
51.                         if(0 == i)
    
52.                                 r.set("Jack", "man");
    
53.                         else
    
54.                                 r.set("Rose", "woman");
    
55.                         i = ++i % 2;
    
56.                 }
    
57.         }
    
58. }
    
59. 
    
60. class Output implements Runnable {
    
61.         
    
62.         private Resource r;
    
63.         
    
64.         Output(Resource r) {
    
65.                 this.r = r;
    
66.         }
    
67.         public void run() {
    
68.                 while(true) {
    
69.                         r.show();
    
70.                 }
    
71.         }
    
72. }
    
73. 
    
74. public class InputOutput {
    
75.         
    
76.         public static void main(String[] args) {
    
77.                
    
78.                 Resource r = new Resource();
    
79.                
    
80.                 new Thread(new Input(r)).start();
    
81.                 new Thread(new Output(r)).start();
    
82.         }
    
83. }

复制代码

程序是死循环，运行结果为：

1. Jack is man
   
2. Rose is woman
   
3. Jack is man
   
4. Rose is woman
   
5. Jack is man
   
6. Rose is woman
   
7. Jack is man
   
8. Rose is woman
   
9. Jack is man
   
10. Rose is woman
    
11. Jack is man
    
12. Rose is woman
    
13. Jack is man
    
14. Rose is woman
    
15. Jack is man
    
16. Rose is woman
    
17. Jack is man
    
18. Rose is woman
    
19. Jack is man
    
20. Rose is woman
    
21. Jack is man
    
22. Rose is woman
    
23. Jack is man
    
24. Rose is woman
    
25. .......

复制代码

单例模式应该就那几个步骤吧：
1：构造函数设为private 。
2：在这个类里设置一个自身的成员变量  private Res res = new Res();
3：为这个成员变量 res 提供 get 方法。