我讨厌构造函数重载,请大家帮我分析下实例,注释下

Question

package shuren.ren;
class SrTeacher
{
String s="执行父类的构造方法";
public SrTeacher()
{
System.out.println(s);
} 
public SrTeacher (String str)
{
s=str;
System.out.println(s);
}
}
class SrStudent extends SrTeacher
{
 String s="执行子类的构造方法";
public SrStudent()
{
System.out.println(s);
} 
public SrStudent (String str)
{
this();
s=str;
System.out.println(s);
}
public SrStudent (String strA, String strB)
{
super(strA+" "+strB);
s=strA;
System.out.println(s);
}
}
public class Srmethod
{
public static void main(String args[])
{
SrTeacher objt1=new SrTeacher();
SrTeacher objt2=new SrTeacher("父类带参数的构造方法");
SrStudent objs1=new SrStudent();
SrStudent objs2=new SrStudent("子类带一个参数的构造方法");
SrStudent objs3=new SrStudent("参数A","参数B");
}
}

Answer 1

此回复为自动发出,仅用于显示而已，并无任何其他特殊作用
楼主【sure2003】截止到2008-06-29 19:12:46的历史汇总数据(不包括此帖)：
发帖数:191                发帖分:8917               
结贴数:190                结贴分:8877               
未结数:1                  未结分:40                 
结贴率:99.48 %            结分率:99.55 %            
值得尊敬

Answer 2

class SrTeacher {
String s = "执行父类的构造方法"; public SrTeacher() {
System.out.println(s);
} public SrTeacher(String str) {
s = str;
System.out.println(s);
}
}class SrStudent extends SrTeacher {
String s = "执行子类的构造方法"; public SrStudent() {
//先调用父类的默认构造函数
System.out.println(s);
} public SrStudent(String str) {
this();  //调用SrStudent()构造函数初始化
s = str;
System.out.println(s);
} public SrStudent(String strA, String strB) {
super(strA+" "+strB);  //调用父类的SrTeacher(String str)构造函数
s = strA;
System.out.println(s);
}
}public class Srmethod {
public static void main(String args[]) {
SrTeacher objt1 = new SrTeacher();
SrTeacher objt2 = new SrTeacher("父类带参数的构造方法");
SrStudent objs1 = new SrStudent();
SrStudent objs2 = new SrStudent("子类带一个参数的构造方法");
SrStudent objs3 = new SrStudent("参数A", "参数B");
}
}

Answer 3

先不管你的程序有没有问题。按照LZ的意思，得出的结果应该是：
执行父类的构造方法 //objt1  以下依次
//加空行以示区分
父类带参数的构造方法执行父类的构造方法
执行子类的构造方法执行父类的构造方法
执行子类的构造方法
子类带一个参数的构造方法参数A 参数B
参数A

Answer 4

          SrTeacher objt1=new SrTeacher();
          这句只是建了个父类对象，无参，所以执行这句
           public SrTeacher()
          {
                       System.out.println(s);
          }
         SrTeacher objt2=new SrTeacher("父类带参数的构造方法");
         这句也是建了个父类对象，有参，所以执行这句
             public SrTeacher (String str)
            {
                  s=str;
                  System.out.println(s);
             }         SrStudent objs1=new SrStudent();
         这句是建了个子类对象，无参。初始化子类时，JVM会发现他有父类，所以要先初始化父类
         所以先执行父类的无参构造函数
             public SrTeacher()
            {
                  System.out.println(s);
            } 
         然后是执行子类的无参构造函数
             public SrStudent()
            {
                 // 这里隐含着super(); 上次我跟楼主讲过
                 System.out.println(s);
            }         SrStudent objs2=new SrStudent("子类带一个参数的构造方法");
        
        这句是建了个子类对象，有参，所以还是先构造父类的有参构造函数
         public SrTeacher()
         {
          System.out.println(s);
         } 
        然后子类的无参构造函数 因为this()所以执行的
public SrStudent()
         {
          System.out.println(s);
         } 
        然后子类有参构造函数
         public SrStudent (String str)
         {
          this();
          s=str;
          System.out.println(s);
         }  
        SrStudent objs3=new SrStudent("参数A","参数B");
        
        这里子类有2个参数的构造函数里面有super(strA+" "+strB);
        会执行父类的构造函数，传进去的参是"参数A"+"  "+","参数B"         public SrTeacher (String str)
    {
        s=str;这里的str = "参数A  参数B"
        System.out.println(s);
    }
        
        然后是
public SrStudent (String strA, String strB)
    {
        super(strA+" "+strB);
        s=strA;
        System.out.println(s);
    }
我靠写这么多  快给分吧~~~~~~~~~~~~~~~~

Answer 5

SrStudent objs2=new SrStudent("子类带一个参数的构造方法");
        
这句是建了个子类对象，有参，所以还是先构造父类的有参构造函数刚才这两句写错了，但代码没个你写错应该是先构造父类无参的构造函数，因为子类构造函数里隐含着super(); 然后是执行this() 然后是自身的构造函数 最后一个例子  我也没说全
super(strA+" "+strB); 这句就把自身隐含的super()覆盖掉了  所以不会执行父类无参的构造函数了

Answer 6

重载是多态的重要体现,lz要讨厌这个,那java怎么学好呢?

Answer 7

这个就是有点乱
其实没什么不好理解的
LZ可以把main中的只留一个实例化语句
剩下的先注释掉
debug一下就清楚执行顺序了
实例化子类的时候会默认调用父类的无参构造方法
如果父类没有无参构造方法并显示的定义了有参数的构造方法
则要在子类中显示调用父类的有参的构造方法
如下例：class SrTeacher {
public SrTeacher(String str) {
System.out.println(str);
}
}class SrStudent extends SrTeacher {
String s = "执行子类的构造方法";
public SrStudent() {
super("父类带参数的构造方法");
System.out.println(s);
}
}class Srmethod {
public static void main(String args[]) {
SrStudent objs2 = new SrStudent();
}
}

Answer 8

你讨厌构造函数重载是因为你还没有体会到它的方便之处。
package shuren.ren;
class SrTeacher { String s = "执行父类的构造方法"; public SrTeacher() {
System.out.println(s);
} public SrTeacher(String str) {
s = str;
System.out.println(s);
}}class SrStudent extends SrTeacher { //String s = "执行父类的构造方法";  //从超类继承下来的实例域 s
String s = "执行子类的构造方法";  //自己又声明了一个实例域 s，实际开发中最好不要这样做，很容易把自己搞迷糊 public SrStudent() {
//super();  //你不加编译器帮你加上的，作用是调用超类的构造方法，这里指 SrTeacher()
System.out.println(s);  //打印自己声明的那个实例域 s 的值
} public SrStudent(String str) {
this();  //调用本类的其它构造方法，这里是指 SrStudent()
s = str;  //使用构造方法参数 str 对实例域 s 进行初始化
System.out.println(s);  //打印自己声明的那个实例域 s 的值
} public SrStudent(String strA, String strB) {
super(strA + " " + strB);  //调用超类的构造方法，这里是指 SrTeacher(String str)
s = strA;  //使用构造方法参数 strA 对实例域 s 进行初始化
System.out.println(s);  //打印自己声明的那个实例域 s 的值
}}public class Srmethod { public static void main(String[] args) {
//Java 是以方法签名来区分不同方法的，而方法签名是指方法名加参数类型列表，
//例如 public SrStudent(String strA, String strB) 方法的签名是 SrStudent(String, String)
//编译时编译器会自动根据你调用时给的参数个数和类型找到与之匹配的一组重载方法中的一个去生成调用指令，
//此过程也叫重载解析。
//好处显而易见，你不用记一大堆方法名了，记住它们共同的功能就行，调用哪个编译器帮你选。典型的就属
//System.out.println() 方法了。
SrTeacher objt1 = new SrTeacher();
SrTeacher objt2 = new SrTeacher("父类带参数的构造方法");
SrStudent objs1 = new SrStudent();
SrStudent objs2 = new SrStudent("子类带一个参数的构造方法");
SrStudent objs3 = new SrStudent("参数A", "参数B");
}}