java关于子类和父类构造方法的关系，犯迷糊！！

Posted 2023-04-13

/****************自定义异常类*********************/
class AgeException extends Exception//自定义异常
private Date date;
public AgeException(String message,Date date)
super(message);
this.date = date;

public Date getDate()
return this.date;


我就是想问问
父类 Exception构造方法中Exception(String message) 与子类public AgeException(String message,Date date)
String message值是同一个值吗？如果说是同一个值，继承不是继承（成员变量和方法）而Spublic AgeException(String message,Date date)中String message是形参，
super(message)中的message是父类的message,public AgeException(String message,Date date)中的message是子类的message,
都是形参

为什么不调用父类无参数的super()构造方法。调用super(message);有什么效果，我感觉调用Exception(String message) ｛｝
没有任何作用因为默认的方法体里面没有代码。
上面写的有点乱，思路也乱，大家帮我理理谢谢。
例题2
class Father
int x=0,y=0;
Father()
System.out.println("now is in Father's constructor");

Father(int x,int y)
this.x = x;
this.y = y;

public void print()
System.out.println("x="+x+";y="+y);


class Son extends Father
Son()
System.out.println("now is in Son's constructor");

Son(int x,int y)
super(x,y);
//this(); //调用自己的构造器

public void print()
super.print();
System.out.println("My name is son!");


public class Example4_15
public static void main(String[] args)
//通过默认构造器，创建实例。
Son s = new Son();
s.print();
//通过其他构造器，创建实例。
Son f = new Son(10,20);
f.print();


我不明白的地方是
Son f = new Son(10,20);
运行玩后是调用
Son(int x,int y)
super(x,y);
//this(); //调用自己的构造器

这句话吧1.是先把10，20分配给Son(int x,int y)变成Son(10,20);然后在调用super(x,y);
2 还是不把10，20先分配给Son(int x,int y)，直接运行第一句super(x,y);
运行super(x,y);后调用
Father(int x,int y)
this.x = x;
this.y = y;

//this(); //调用自己的构造器
this()这句是调用哪个构造方法，是带参数的还是不带参数，我感觉没有效果，应为super(x,y); 后面没有语句。
我想问的是Son(int x,int y)和Father(int x,int y)中(int x,int y)有区别吗，是同一份还是父类和子类各自有的形参x,y
恳请哪位大侠帮我弟详细说说，我真的迷糊了，其实这两个题有相似的地方，所以我放到一块了，
帮我发下这块的内存分析图。
恳请能把内存帮我分析下楼下说的this()这句话当然是调用自己的无参构造方法，我感觉不对
因为答案是：now is in Father's constructor
now is in Son's constructor
x=0;y=0;
My name is son!
x=10;x=20;
My name is son!
到底这10，20是怎么传递到父类的，请详细的帮我分析下，感觉大家！

子类不能继承父类的显式定义的构造方法，若想要继承父类的构造方法，需要通过覆盖该构造方法，并在方法中通过super调用父类的该构造方法的方式来继承。

三种情况说明：

1、父类中没有显式定义任何构造方法，此时父类中实际有一个默认的无参数构造方法。这时，在子类中显式定义任何构造方法时，可以不用使用super调用父类的默认方法。

 

2、父类中显式定义了默认的无参数构造方法，那么子类可以定义任意的构造方法，而不必使用super调用父类的构造方法

 

3、父类中显示定义了构造方法，却没有显示定义默认的无参数构造方法，那么子类定义任何构造方法中都需要通过super调用父类的构造方法

 

相关代码比较

1.
public class Father 
public void otherMethod()


 
public class Child extends Father 
 
//任意构造方法
public Child(int b)
System.out.println(b);

 
public void otherChildMethod()
 


 
2.
 
public class Father 
 
public Father()
 

public Father(String q)
System.out.println(q);

public void otherFatherMethod()
 


 
public class Child extends Father 
 
//任意构造方法
public Child(int b)
System.out.println(b);

public Father(String q)
System.out.println(q);

 
public Child(String t, int b)
....

 
public void otherChildMethod()
 


 
3.
public class Father 
 
public Father(String q)
System.out.println(q);

public void otherFatherMethod()
 


 
public class Child extends Father 
 
public Child(String b)
super(b);
System.out.println(b);

//任意构造方法
public Child(String t, int b)
super(t);
System.out.println(b);

 
public Child(String t, int b)
....

 
public void otherChildMethod()
 

参考技术A 把int x,int y 理解成一个方法的局部变量 调用这个构造方法的时候会先给x跟y赋值.
之后super(x,y)就是把 这个局部变量的值 传给 父类. 就这样- - 参考技术B 初始化子类时会先调用父类的构造方法，父类如果重写了构造方法(也就是隐藏了默认的构造方法)那么子类在构造方法的第一句必须显示的调用父类的构造方法为父类进行初始化

Son(int x,int y)和Father(int x,int y)中(int x,int y)只是形参，也就是个占位符，构造Son对象时传入的实参x,y其实被传入到父类中进行初始化父类的操作，不存在是不是同一份的概念。

this()这句话当然是调用自己的无参构造方法本回答被提问者和网友采纳

java异常类子类和父类的关系

在java 中，当我们子类要重写父类中的方法，如果父类的方法有异常声明，那么子类重写这个方法时候，所要声明的异常不应该比父类的大。只能是小等，或者可以没有。原因如下。
假如我们自定意义一个异常：

 

public class MyException extends Exception {
public MyException(String message) {}
public MyException() {}
}

那么我们有一个父类它将有一个方法，将声明抛出这个异常。我们把它做成抽象的（无所谓）

 

public abstract class ParentException {
public abstract void test() throws MyException;
}

 

那么将有一个类使用到上面这个类

 

public class ExceptionTest {
private ParentException exception;
public ExceptionTest(ParentException exception){
this.exception=exception;
}
public void app(){
try {
exception.test();
} catch (MyException e) {
e.printStackTrace();
}
}
}

 

对于以上的try~catch 我们就直接捕获MyException异常。这是正确的，它在编译的时候是没有问题的。
假如，有一个ParentException的有一个子类

 

public class ChildException extends ParentException{
public void test() throws Exception{ }
}

 

他的方法可以声明抛出比父类大的异常，假如它是正确的。
那么问题来了。当我们执行ExceptionTest类的时候，我们以这个子类做为对象传进去。
exception.test();这个地方将在运行的时候实际调用的是ChildException这个子类的test()方法，而它的声明抛 出却是比父类大的异常，这就使得在ExceptionTest类中，捕获异常处出现了毛病，因为它无法捕获Exception异常。
综上所诉，子类重写父类的方法时候不能声明抛出比父类大的异常
顶
0
踩