class Res
{
bollean flag=false;
}
class Input
{
Res r = new Res();
if (r.flag){....}
}

请问if条件中的r.flag是为true 还是false？？？

我正在看毕老师的基础班第12天的多线程，如果像楼下几位描述的if(r.flag)中的r.flag为false的话，那下面那段代码就不对了

1. class Res
   
2. {
   
3.         String name;
   
4.         String sex;
   
5.         boolean flag=false;
   
6. }
   
7. class Input implements Runnable
   
8. {
   
9.         private Res r;
   
10.         Input(Res r)
    
11.         {
    
12.                 this.r=r;
    
13.         }
    
14.         public void run()
    
15.         {
    
16.                 int x =0;
    
17.                 while (true)
    
18.                 {
    
19.                         synchronized(r)
    
20.                         {
    
21.                                 if (r.flag)
    
22.                                         try{r.wait();}catch(Exception e){}
    
23.                                 if (x==0)
    
24.                                 {
    
25.                                         r.name="Mike";
    
26.                                         r.sex="man";
    
27.                                 }
    
28.                                 else
    
29.                                 {
    
30.                                         r.name="丽丽";
    
31.                                         r.sex="女";
    
32.                                 }
    
33.                                 x=(x+1)%2;
    
34.                                 r.flag=true;
    
35.                                 r.notify();
    
36.                         }       
    
37.                 }
    
38.         }
    
39. }
    
40. class Output implements Runnable
    
41. {
    
42.         private Res r ;
    
43.         Output(Res r)
    
44.         {
    
45.                 this.r=r;
    
46.         }
    
47.         public void run()
    
48.         {
    
49.                 while (true)
    
50.                 {
    
51.                         synchronized(r)
    
52.                         {
    
53.                                 if (!r.flag)
    
54.                                         try{r.wait();}catch(Exception e){}
    
55.                                 System.out.println(r.name+"........"+r.sex);
    
56.                                 r.flag=false;
    
57.                                 r.notify();
    
58.                         }
    
59.                 }
    
60.         }
    
61. }
    
62. class InputOutputDemo
    
63. {
    
64.         public static void main(String[] args)
    
65.         {
    
66.                 Res r = new Res();
    
67.                 Input in = new Input(r);
    
68.                 Output out = new Output(r);
    
69.                 Thread t1 = new Thread(in);
    
70.                 Thread t2 = new Thread(out);
    
71.                 t1.start();
    
72.                 t2.start();
    
73.         }
    
74. }
    

复制代码

我另外又做了一个测试代码，执行的是if(!r.flag)，就等于说!r.flag=false,那么r.flag=true咯，那就跟前几位哥们说的相反咯。

1. class Res
   
2. {
   
3.         boolean flag=false;
   
4. }
   
5. class Input
   
6. {
   
7.         Res r = new Res();
   
8.         public void run()
   
9.         {
   
10.                 if (r.flag)
    
11.                 {
    
12.                         System.out.println(r.flag+"执行的是r.flag");
    
13.                 }
    
14.                 if (!r.flag)
    
15.                 {
    
16.                         System.out.println(!r.flag+"执行的是!r.flag");
    
17.                 }
    
18.         }
    
19.        
    
20. }
    
21. class IfTest
    
22. {
    
23.         public static void main(String[] args)
    
24.         {
    
25.                 Input in = new Input();
    
26.                 in.run();
    
27.         }
    
28. }
    

复制代码

楼主，
  1，你定义了两个同名的类  Input
  2，.r是一个对象，创建对象r的时候，会调用res类，res类会对对象中的flag进行初始化，所以r.flag为false
   

r是一个引用，指向new Res()这个对象，这个对象一创建起，flag属性就被赋false，当然后面括号中r.flag的值也为false。

当你通过Res r = new Res();创建对象时，会加载上面的Res类，这时候就会对Res类里面flag初始化为false，你里面两个input类完全相同，两个flag都是false.

Res r = new Res();这是以Res类创建一个新的对象，r指向这个对象，同时这个对象的属性flag被自动初始化为false。故r.flase为flase。你那两个Input类应该是重复了。

class Res
{
        public boolean flag=false;
}

class Input
{
        public static void main(String[] args){
        Res r = new Res();
          if(!r.flag)  
                   System.out.println("r.flag="+r.flag);
        }
}

打印结果为r.flag=false,若在Res中定义flag为true则没有结果输出，说明初始化flag为false，对象一建立，flag就赋值为false。

李明 发表于 2011-12-11 11:22
class Res
{
        public boolean flag=false;

我也就好奇了，既然打印的r.flag=false的话，那么说!r.flag=true，则if(!r.flag)就等于if(true)，那么你一开始定义的r.flag=false，怎么还会去执行if的判断语句呢

class Res
{
        String name;
        String sex;
        boolean flag=false;
}
class Input implements Runnable
{
        private Res r;
        Input(Res r)
        {
                this.r=r;
        }
        public void run()
        {
                int x =0;
                while (true)
                {
                        synchronized(r)
                        {
                                if (r.flag)//flag为false，则执行赋值动作。
                                        try{r.wait();}catch(Exception e){}
                                if (x==0)
                                {
                                        r.name="丽丽";
                                    r.sex="女";
                                }
                                else
                                {
                                        r.name="Mike";
                                    r.sex="man";
                                }
                                x=(x+1)%2;
                                r.flag=true;
                                r.notify();
                        }        
                }
        }
}
class Output implements Runnable
{
        private Res r ;
        Output(Res r)
        {
                this.r=r;
        }
        public void run()
        {
                while (true)
                {
                        synchronized(r)
                        {
                                if (!r.flag)//flag为false，则被挂起。释放锁
                                        try{r.wait();}catch(Exception e){}
                                System.out.println(r.name+"........"+r.sex);
                                r.flag=false;
                                r.notify();
                        }
                }
        }
}
class P
{
        public static void main(String[] args)
        {
                Res r = new Res();
                Input in = new Input(r); //初始化对象拿到锁旗标r
                Output out = new Output(r);//初始化对象拿到锁旗标r
                Thread t1 = new Thread(in);
                Thread t2 = new Thread(out);
               
                t2.start();t1.start();
        }
}
//程序开始运行，如果t2先先拿到锁，开始运行，则flag为false，进入之后会执行wait（），线程被挂起，
//然后t1运行，flag为false，则运行，然后给r初始化，运行完，flag被设置成true，再次运行，就会被挂起
//然后唤醒t2，//t2拿到锁，flag为true，执行输出语句，把flag设为false，唤醒t1，所以能做到两个数据
//交替输出。所以无论是t1或者t2先拿到锁，程序都会先运行t1的初始化动作。

执行的是if(!r.flag)，就等于说!r.flag=true,那么r.flag=false，和初始化的一样。