为什么这个程序可以运行？

Question

class Person {
    private String name;
    private int age;
    public void setName(String name) {
this.name = name;
    }
    public void setAge(int age) {
  this.age = age;
    }
    public int getAge() {
return age;
    }
    public String getName() { return name;
    }
}class Student extends Person {
    private String school;
    public String getSchool() {
return school;
    }
    public void setSchool(String school) {
this.school = school;    }
}
public class TestPerson {
    public static void main(String[] args) {
Student student = new Student();
    student.setName("john");
student.setAge(18);
student.setSchool("SCN");
System.out.println(student.getName());
System.out.println(student.getAge());
System.out.println(student.getSchool());
   }
}
不是说子类的构造的过程中必须调用基类的构造方法，可是这个程序子类没有构造方法，基类同时也没有构造方法。

Answer 1

"子类的构造的过程中必须调用基类的构造方法"这句话是胡扯，子类构造一定会先执行父类的static代码块，但是从来不是调用什么父类构造方法
所有Java对象在不写extends的情况默认都继承Object对象，而Object对象有public Object(){}的空构造方法，因此上面的类都有默认空的构造方法，“程序子类没有构造方法，基类同时也没有构造方法”这个认识也是错误的
任何Java类都有构造方法

Answer 2

构造函数的定义是：和类同名，没有返回值。基类中没有看到Person的构造方法啊！

Answer 3

没有明确指定构造器，系统默认构造器，类似public person(){}如果没有默认你怎么新建对象呢
你在person类加一个public person(String arg){this.name=arg};你就可以看到你想要出现的了，子类会报错

Answer 4

Java语言中，如果没有显式书写类的构造函数，那么类会自动添加一个默认构造函数。所以，楼主的父类和子类虽然没有明确给出构造函数，但是有默认的构造函数。
《Java编程思想》一书中，作者专门对此作了说明。该书是本好书，我正在啃，也推荐楼主看下。
希望能帮到楼主。:-D

Answer 5

这话不是胡扯。。
楼主给的两个类其实是省略了
public Person(){ }；
public Student(){super();}
感觉是编译时自动加上的

Answer 6

class SuperClass {
    private int n;
  
    /*
    SuperClass() {
        System.out.println("SuperClass()");
    }
    */
    
  
    SuperClass(int n) {
        System.out.println("SuperClass(" + n + ")");
        this.n = n;
    }
}class SubClass extends SuperClass {
    private int n;
    
    SubClass(int n) {
     super();
        System.out.println("SubClass(" + n + ")");
        this.n = n;
    }
    
    SubClass() {
     super(300);
        System.out.println("SubClass()");
    }
}public class TestSuperSub {
    public static void main(String arg[]) {
        //SubClass sc1 = new SubClass();
        SubClass sc2 = new SubClass(400);
    }
}
可是这段代码为什么不能运行呢？不是说有默认的构造方法吗？

Answer 7

默认继承了无参构造啊！
    要不你在Person里写个有写构参，你再Student类里面也写个有参构构，试试！
  看能看出问题来不！

Answer 8

子类构造一定会先执行父类的static代码块？
请问一下LZ的这段代码子类执行了分类的哪段static代码块啊？

Answer 9

0、
1、使用继承，子类的构造方法无需显示地调用父类的构造方法。
注：所有的类都是继承Object对象，而Object对象有public Object(){}的空构造方法。
若一个类没有显示写明自己的constructor，在编译的时候classloader会为导出类执行默认的空参constructor。
2、static函数优先constructor执行。若实例化一个导出类，基类必在先。
给个例子吧public class GrandFather {
public GrandFather(){
System.out.println("GrandFather constructor block!");
}
static{
System.out.println("GrandFather static block!");
}
}
public class Father extends GrandFather{
public Father(){
System.out.println("Father constructor block!");
}
static{
System.out.println("Father static block!");
}
}
public class Son extends Father{
public Son(){
System.out.println("Son constructor block!");
}
static{
System.out.println("Son static block!");
}
public static void main(String[] args) {
// TODO Auto-generated method stub
Son s = new Son();
}
}执行结果必是：
GrandFather static block!
Father static block!
Son static block!
GrandFather constructor block!
Father constructor block!
Son constructor block!

Answer 10

楼主还是多看点书吧。如果你不写构造函数，系统会默认加载一个无参的构造函数，而Student会调用如下构造函数：
public Student()
{
 super();
}

Answer 11

这位朋友，大家既然是在讨论问题，我们都应该虚心一些我们不说别的，就说：子类的构造的过程中必须调用基类的构造方法，这一句如果我们概念不是很清楚，完全可以去做一个实验你写一个这样的类public class A {

private A() {
}}即一个只有一个私有构造方法的类然后你写个其他的类去继承它看一下，编译器会报什么错public class B extends A {}编译器会告诉你：父类没有可见的构造方法，必须定义一个可见的构造方法这说明什么问题？如果子类不是必须调用父类的构造的方法，编译器为什么会报错？
好，我们把实验继续下去，把 A 类改一下，加一个构造方法public class A {

private A() {

}

public A(int n) {

}}这时再看 B 类，OK，编译器终于允许你写构造方法了，那这样写可以嘛？public class B extends A { public B() {

}}编译器继续报错，告诉你 A() 这个方法不可见，所以必须这样写:public class B extends A { public B() {
super(1);
}}在调用父类的唯一个可见的构造方法后，终于通过编译那我们定义第二个构造方法是否就没有问题了呢？public class B extends A { public B() {
super(1);
}

public B(int n) {

}}编译器依然报错，public B(int n)这个构造方法依然需要调用父类的构造方法才行所以可以这样写：public class B extends A { public B() {
super(1);
}

public B(int n) {
this();
}}难道，这就是熊猫兄所谓的可以不用调用父类的构造方法？难道 this() 即 B() 这个方法不是最终依然调用了父类的可见构造方法嘛？所以概念不清，可以像我一样，做些实验，不要直接误导别人你的分也不低，误导的话，很容易让别人真的信的，那就叫误人子弟了

Answer 12

没有明写构造器的时候，jvm会自动调用默认的构造器的

Answer 13

不过不为类制定构造器，系统会为类提供一个默认的构造器及无参的构造器，这个可以通过class反编译看到。如果你提供了自己的构造器就不会在提供默认的。如果基类只有带参数的构造器，那么子类在构造器重必须显式的调用父类的构造器。

Answer 14

你把父类Person加一个构造方法
就比如最简单的构造：
public Person(){
    System.out.println("子类的构造的过程绝对是调用了基类的构造方法的！");
}

Answer 15

public class A {
    
    private A() {
    }}public class B extends A {    public B() {
       //这里什么也不写 默认调用父类 无参构造方法  什么也不写相当于写了 super()
      如果父类无参构造 被私有了当然找不到报错 默认是公有的
    }}

Answer 16

当你不显示构造方法时，系统自动给你构造一个，只是看不见而已. public  Person(){} 
子类 Student 也有 默认构造函数, public Student(){} 自动先调用 public Person(){}