一个父类中含有多个构造函数，而子类中一个构造函数只能使用一次super（）函数，请问：子类中是否应该定义与父类相同个数及参数的构造函数相匹配，再在每个子类构造函数中使用super（）函数。我们知道一个类中构造函数只能调用一次，那子类也只能调用和父类相同的构造函数？再者，修改子类函数值是否会影响父类中对应函数的值？求解

子类的构造函数都有隐式super（）调用父类对应的构造参数。修改子类正常来说是不影响父类的，因为父类优先子类的构造函数运行。但是要是操作的全局变量就有影响了。

你为谁归来 发表于 2014-4-27 15:55
子类的构造函数都有隐式super（）调用父类对应的构造参数。修改子类正常来说是不影响父类的，因为父类优先 ...

int i = -3;
int j = 11;
int k = i & j;
请问i&j代表什么意思？

public class TestBit
{
        public static void main(String[] args)
        {
                int i = -3;//定义了一个整数型变量i，并对 i  赋值为-3
                int j = 11;//定义了一个整数型变量j，并对 j 赋值为-3
                int k = i & j;  //定义了一个整数型变量k，对k赋值 i & j，&代表位运算符。他们是怎么样进行运算的？               
                System.out.printf("%d\n", k);//对 k 的值进行输出，得出的结果是8.
        }
      结论：i & j 是不是相当于 i +  j，-3 + 11 = 8？？？
求解
}

houyudong 发表于 2014-4-27 18:35
int i = -3;
int j = 11;
int k = i & j;

与运算符，判断二进制数的的位的

能说具体点吗？最好有个例子，这样好理解，谢谢

。构造方法之间的相互调用：
*this：1，必须位于构造方法中的第一句类调用本类中的其他构造方法，
  2，只能在构造方法中用this调用其他构造方法，而不能再其他人方法中用this调用构造方法
  3.必须通过this语句来调用构造方法，而不能直接通过方法名调用！
三。子类的构造方法需要调用父类的构造方法吗？
是的，子类必须要先调用父类的构造方法，从而保证父类的成员变量和成员方法被继承！
super：是指直接父类对象的引用！
     1，子类的构造方法必须调用父类的构造方法
     2，子类的构造方法调用父类的构造方法必须位于第一句。
     3，调用父类的构造方法必须用super（）或者super（param)带参数，
     4，如果在子类的构造方法中没有显示的调用父类的构造方法，系统默认会在子类的构造方法中加上super（）；如果父类没有无参构造函数
          则编译会报错.
     5，还有一种比较复杂的情况是在子类的构造方法中用this调用了本类的其他构造方法，但其他构造方法必须调用父类的构造方法。

//Java中传的到底传是值还是引用？
        public void addInt(int i){
                i+=1;//i=i+1与i+=1的区别是：后者会做类型的自动转换，如果i+1超出int型范围的话会将超出的部分切掉，结果有可能变成负数。
                                //而前者如果溢出直接编译不通过
        }
        public void addStr(String str){
                str+="111";
        }
        public void addList(List<String> strList){
                strList.add("List111");
        }
        public static void main(String[] args) {
                Demo01 d = new Demo01();
                int i = 0;
                String str = "s";
                List<String> strList = new ArrayList<String>();
                d.addInt(i);//java中参数传递时实质上只存在传值，当传递的是基本数据类型的时候他传递的值是的一个副本！
                                        //int i = 10;int j = i;j+=5的值是15 但i的值没有改变！
                d.addStr(str);//而当传递的是引用类型的参数时候，实际上传递还是一个引用类型的副本！既然引用类型参数传递的是引用类型的副本，那么两个引用
                                                //地址指向的对象将是同一个，但因为String对象的值不可改变，所以会在堆内存中重新开辟String对象，并将新的地址赋值给局
                                                //        部变量str（局部变量str作用的范围只有整个函数和整个代码块），
                                               
               
                d.addList(strList);//
                System.out.println(i);
                System.out.println(str);
                System.out.println(strList);
        }
}

遇到问题多多思考，尽量自己解决。这样才能更加坚实。

对于你的疑问：子类的构造函数并不需要与父类的构造函数参数相同，也不需要定义跟父类数量一样多的构造函数。
请认真理解理解下面的话
子父类中的构造函数：
    子类的所有构造函数，默认都会访问父类中空参数的构造函数。因为子类每一个构造函数内的第一行都有一句隐式super();
    当父类中没有空参数的构造函数时，子类必须手动通过super语句形式来指定要访问父类中的构造函数。
    当然：子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数。子类中至少会有一个构造函数
会访问父类中的构造函数。

1. class father
   
2. {
   
3.         father()
   
4.         {
   
5.                 System.out.println("调用无参父类构造函数");
   
6.         }
   
7.         father(int x)//4.调用父类构造函数进行父类初始化。
   
8.         {
   
9.                 System.out.println("父类的带一个参数的构造函数"+x);
   
10.         }
    
11. }
    
12. class son extends father
    
13. {
    
14.         son()
    
15.         {
    
16.                 super(5);//3.由于手动指定访问父类的带参数的构造函数，所以调用父类的带参数的构造函数
    
17.                 System.out.println("调用无参子类构造函数");
    
18.         }
    
19.         son(int x)
    
20.         {
    
21.                 this();//2.由于第一行是this（），所以这个构造函数中没有super（）语句。他会调用子类的无参构造函数
    
22.                 System.out.println("调用带一个参数子类构造函数"+x);
    
23.         }
    
24. }
    
25. class test1
    
26. {
    
27.         public static void main(String[] args)
    
28.         {
    
29.                 son s=new son(2);//1.先去子类的带参数的子类构造函数读
    
30.         }
    
31. }

复制代码

这主要是体现了，子类构造函数间的this调用，和手动指定访问父类的构造函数，你也可以取消super(5)的指定，可以直接让子类构造函数默认访问super()

菠萝包丶 发表于 2014-4-27 21:47
对于你的疑问：子类的构造函数并不需要与父类的构造函数参数相同，也不需要定义跟父类数量一样多的构造函数 ...

对于输出结果，有点不明白，为什么父类带参数的构造函数会输出？构造函数不是只执行一次吗？ son s=new son(2);制造一个类对象名，给他分配一块空间，他带有参数，就直接调用son带参数的构造函数，由于是子类，应该继承父类，而子类带参函数调用父类无参构造函数，进行输出，再输出子类的函数，不是应该为 son s=new son(2);  >>  son(int x) >> father() >> son(int x), 其输出结果不是应该为：("调用无参父类构造函数");("调用带一个参数子类构造函数");还有this()在函数中充当了什么角色，他的作用是什么呢?在线坐等。。。。

你看我的，注释的顺序！
为什么父类会输出带参数的，是因为我在子类的构造函数中手动指定了super(x)，所以就没有了默认的super()，它就只会访问父类的带参数的构造函数进行初始化，
this()我只是演示可以在构造函数间调用自身别的构造函数，但是他始终还是会回先回去调用父类的构造函数进行初始化。
一定要认真多看几遍，多读几遍那几个结论。要注意，注释标记的顺序，是我们读代码的顺序，
我们要根据子父类构造函数的特点，来理解。输出的顺序是按父类先进行初始化，然后才是子类的顺序来显示的