1. package com.lee.calc.test010;
   
2. 
   
3. import java.util.ArrayList;
   
4. import java.util.Iterator;
   
5. 
   
6. public class Bug4Visit {
   
7.    
   
8.     public static void main(String[] args) {
   
9.         
   
10.         //该方法输出的报异常
    
11.         BB b = new BB();
    
12.         b.setA(true);
    
13.         b.setB(true);
    
14.         b.start();
    
15.         BB c = new BB();
    
16.         c.setA(true);
    
17.         c.start();
    
18.         
    
19.         //正确输出的方法
    
20.         AA a = new AA();
    
21.         a.setA(true);
    
22.         a.start();
    
23. 
    
24.     }
    
25. 
    
26. }
    
27. 
    
28. class BB{
    
29.     private ArrayList<String> alist;
    
30.     private ArrayList<String> blist;
    
31.     private boolean isA = false;
    
32.     public boolean isA() {
    
33.         return isA;
    
34.     }
    
35. 
    
36.     public void setA(boolean isA) {
    
37.         this.isA = isA;
    
38.     }
    
39. 
    
40.     public boolean isB() {
    
41.         return isB;
    
42.     }
    
43. 
    
44.     public void setB(boolean isB) {
    
45.         this.isB = isB;
    
46.     }
    
47. 
    
48.     private boolean isB = false;
    
49.     public BB() {
    
50.         
    
51.     }
    
52.    
    
53.     void start(){
    
54.         if(isA){
    
55.             newAddPrint(alist);
    
56.         }
    
57.         if(isB){
    
58.             newAddPrint(blist);
    
59.         }
    
60.     }
    
61.    
    
62.     void newAddPrint(ArrayList<String> list){
    
63.         newList(list);            
    
64.         addList(list);            
    
65.         printList(list);
    
66.     }
    
67.      
    
68.     void newList(ArrayList<String> list){
    
69.         list = new ArrayList<String>();
    
70.     }
    
71.    
    
72.     void addList(ArrayList<String> list){
    
73.         list.add("1");
    
74.         list.add("2");
    
75.         list.add("3");
    
76.     }
    
77.    
    
78.     void printList(ArrayList<String> list){
    
79.         Iterator<String> it = list.iterator();
    
80.         String s;
    
81.         while(it.hasNext()){
    
82.             s = it.next();
    
83.             System.out.println(s);
    
84.         }
    
85.     }
    
86. }
    
87. 
    
88. class AA{
    
89.     private ArrayList<String> alist = new ArrayList<String>();
    
90.     private ArrayList<String> blist = new ArrayList<String>();
    
91.     private boolean isA = false;
    
92.     public boolean isA() {
    
93.         return isA;
    
94.     }
    
95. 
    
96.     public void setA(boolean isA) {
    
97.         this.isA = isA;
    
98.     }
    
99. 
    
100.     public boolean isB() {
     
101.         return isB;
     
102.     }
     
103. 
     
104.     public void setB(boolean isB) {
     
105.         this.isB = isB;
     
106.     }
     
107. 
     
108.     private boolean isB = false;
     
109.     public AA() {
     
110.         
     
111.     }
     
112.    
     
113.     void start(){
     
114.         if(isA){
     
115.             addList(alist);
     
116.             printList(alist);
     
117.         }
     
118.         if(isB){        
     
119.             addList(blist);            
     
120.             printList(blist);
     
121.         }
     
122.     }
     
123.      
     
124.    
     
125.     void addList(ArrayList<String> list){
     
126.         list.add("1");
     
127.         list.add("2");
     
128.         list.add("3");
     
129.     }
     
130.    
     
131.     void printList(ArrayList<String> list){
     
132.         Iterator<String> it = list.iterator();
     
133.         String s;
     
134.         while(it.hasNext()){
     
135.             s = it.next();
     
136.             System.out.println(s);
     
137.         }
     
138.     }
     
139. }

复制代码

请教一下，这个问题也困扰我一段时间了。
看BB这个类，直面上应该可以看出我的用意是，用户需要用到blist的时候，在new blist，但是我那样子写是报错的

如果照AA这个类写，没有报错，可是实例化这个类就连带吧blist也给new了，如果这个类里边还有clist dlist elist flist.....
而用户在使用这个类，只是用到其中的一个alsit或者其他一个list的时候，难道只能像AA这样写，实例化AA这个类的时候，就非得把这么多list实例化不管有没用到？

准备上课去了，混脸熟。。。

自己顶一下

1. import java.util.ArrayList;
   
2. import java.util.Iterator;
   
3. public class BugTest {
   
4.      
   
5. public static void main(String[] args) {
   
6.         
   
7.    //该方法输出的报异常
   
8.   
   
9.          BB b = new BB(true,true);
   
10.   
    
11.          b.start();
    
12.   
    
13.          BB c = new BB(true,false);
    
14.   
    
15.          c.start();
    
16.          
    
17.          //正确输出的方法
    
18.   
    
19.          AA a = new AA();
    
20.   
    
21.          a.setA(true);
    
22.   
    
23.          a.start();
    
24.          
    
25.      }
    
26. }
    
27. class BB{
    
28.   
    
29.      private ArrayList<String> alist;
    
30.   
    
31.      private ArrayList<String> blist;
    
32.   
    
33.      private boolean isA = false;
    
34.      private boolean isB = false;
    
35.      
    
36.      BB(boolean isA,boolean isB)
    
37.      {
    
38.       this.isA=isA;
    
39.       this.isB=isB;
    
40.      }
    
41.      void start()
    
42.      {
    
43.       if(isA)
    
44.       {
    
45.        alist=new ArrayList<String>();
    
46.        newAddPrint(alist);
    
47.       }
    
48.       if(isB)
    
49.       {
    
50.        blist=new ArrayList<String>();
    
51.        newAddPrint(blist);
    
52.       }
    
53.       System.out.println(alist instanceof ArrayList);
    
54.       System.out.println(blist instanceof ArrayList);
    
55.          }
    
56.   
    
57.      
    
58.      void newAddPrint(ArrayList<String> list){  
    
59.   
    
60.          addList(list);           // 用你的方法调用创建对象的方式，我在addList之前加 instanceof 判断语句显示alist或blist都还不是ArrayList实例，我觉得可能是Jvm执行顺序决定的
    
61.   
    
62.          printList(list);
    
63.   
    
64.      }
    
65.      void addList(ArrayList<String> list){
    
66.   
    
67.          list.add("1");
    
68.   
    
69.          list.add("2");
    
70.   
    
71.          list.add("3");
    
72.   
    
73.      }
    
74.   
    
75.      
    
76.      void printList(ArrayList<String> list){
    
77.   
    
78.          Iterator<String> it = list.iterator();
    
79.   
    
80.          String s;
    
81.   
    
82.          while(it.hasNext()){
    
83.   
    
84.              s = it.next();
    
85.   
    
86.              System.out.println(s);
    
87.   
    
88.          }
    
89.   
    
90.      }
    
91.   
    
92. }
    
93. 
    

复制代码

package com.lee.calc.test010;

import java.util.ArrayList;

import java.util.Iterator;

public class Bug4Visit {

   
    public static void main(String[] args) {

        

        //该方法输出的报异常

        BB b = new BB();

        b.setA(true);

        b.setB(true);

        b.start();

        BB c = new BB();

        c.setA(true);

        c.start();

        

        //正确输出的方法

        AA a = new AA();

        a.setA(true);

        a.start();

    }

}

class BB{

    private ArrayList<String> alist;

    private ArrayList<String> blist;
//这里的alist、blist只是一个引用变量，没有指向任何对象，所以方法里面的list只是一个副本，new出来的对象也跟原来的没关系。
所以这里要先给对象进行实例化。
其实在Java中，所有的方法调用，无论参数是基本数据类型还是对象，都是值传递。


    private boolean isA = false;

    public boolean isA() {

        return isA;

    }

    public void setA(boolean isA) {

        this.isA = isA;

    }

    public boolean isB() {

        return isB;

    }

    public void setB(boolean isB) {

        this.isB = isB;

    }

    private boolean isB = false;

    public BB() {

        

    }

   
    void start(){

        if(isA){

            newAddPrint(alist);

        }

        if(isB){

            newAddPrint(blist);

        }

    }

   
    void newAddPrint(ArrayList<String> list){

        newList(list);            

        addList(list);            

        printList(list);

    }

     

    void newList(ArrayList<String> list){

        list = new ArrayList<String>();

    }

   
    void addList(ArrayList<String> list){

        list.add("1");

        list.add("2");

        list.add("3");

    }

   
    void printList(ArrayList<String> list){

        Iterator<String> it = list.iterator();

        String s;

        while(it.hasNext()){

            s = it.next();

            System.out.println(s);

        }

    }

}

class AA{

    private ArrayList<String> alist = new ArrayList<String>();

    private ArrayList<String> blist = new ArrayList<String>();

    private boolean isA = false;

    public boolean isA() {

        return isA;

    }

    public void setA(boolean isA) {

        this.isA = isA;

    }

    public boolean isB() {

        return isB;

    }

    public void setB(boolean isB) {

        this.isB = isB;

    }

    private boolean isB = false;

    public AA() {

        

    }

   
    void start(){

        if(isA){

            addList(alist);

            printList(alist);

        }

        if(isB){        

            addList(blist);            

            printList(blist);

        }

    }

     

   
    void addList(ArrayList<String> list){

        list.add("1");

        list.add("2");

        list.add("3");

    }

   
    void printList(ArrayList<String> list){

        Iterator<String> it = list.iterator();

        String s;

        while(it.hasNext()){

            s = it.next();

            System.out.println(s);

        }

    }

}

黑马张涛 发表于 2012-8-29 16:39

所以，在new对象的时候，都必须显式的将  ... 变量 = new ...这样写出来，而不能像我BB类写的根据传一个值
.... 传值 = new ...这样的写法？

黄珊珊 发表于 2012-8-29 16:49
package com.lee.calc.test010;

import java.util.ArrayList;

那有什么修改的方法吗

private ArrayList<String> alist;
private ArrayList<String> blist;
将class BB中的这两句代码该为：
private ArrayList<String> alist = new ArrayList<String>();
private ArrayList<String> blist = new ArrayList<String>();
这样当主函数在调用相应的对象时，就不会出现null了。

其实你这种想要在调用时再建对象的思路是不错。但在这里不太适用，你这样不先进行实例初始化，除了java中方法的值传递特性外，有时候还有可能会出现绕过某些程序，直接去访问null对象的情况。所以建议你还是先实例化对象。

黑马张涛 发表于 2012-8-29 16:39

觉得这个可行。

看代码中我注释标记的部分，是你的b.start()开始执行后，函数调用运行顺序。其中你的参数传递有问题，所以到  list.add("1");这句话报空指针异常！

1. class BB {
   
2.         private ArrayList<String> alist;//隐式默认初始化为null

复制代码

1.         void start() {
   
2.                 if (isA) {
   
3.                         newAddPrint(alist);//alist = this.alist;
   
4.                 }
   
5.                 if (isB) {
   
6.                         newAddPrint(blist);
   
7.                 }
   
8.         }
   
9. 
   
10.         void newAddPrint(ArrayList<String> list) {//list = alist(值为this.alist)
    
11.                 newList(list);
    
12.                 addList(list);//list = alist(值为this.alist)
    
13.                 printList(list);
    
14.         }
    
15. 
    
16.         void newList(ArrayList<String> list) {//传这个参数你就没用，那传他干嘛呀？
    
17.                 list = new ArrayList<String>();//这句话没用，因为list没用到
    
18.         }
    
19. 
    
20.         void addList(ArrayList<String> list) {//list = alist(值为this.alist)
    
21.                 list.add("1");//此时list是this.alist（值为对象创建时隐式默认初始化null）。故此报空指针异常。
    
22.                 list.add("2");
    
23.                 list.add("3");
    
24.         }

复制代码

黄珊珊 发表于 2012-8-29 17:34
private ArrayList alist;
private ArrayList blist;
将class BB中的这两句代码该为：

这样说我懂了，谢谢