java类执行顺序

1.首先我们先创建一个java类  (随便建的,命名不规范,请忽视)

public class java extends javaFather{
    private int id;
    private String name;

    static {
        System.out.println("我是静态方法");
    }

    {
        System.out.println("我是初始化方法");
    }

    public java(){
        System.out.println("我是无参构造函数");
    }

    public java(int id, String name) {
        this.id = id;
        this.name = name;
        System.out.println("我是构造函数");
    }

    @Override
    public String toString() {
        return "java{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }


}

2. 在创建一个子类 继承java类

public class javaSon extends java{
    private int age;

    static {
        System.out.println("我是java的儿子的静态方法");
    }

    {
        System.out.println("我是java的儿子的初始化方法");
    }

    public javaSon(){
        System.out.println("我是java的儿子的无参构造函数");
        javaFather javaFather = new javaFather();
    }

    public javaSon(int age) {
        this.age = age;
        System.out.println("我是java的儿子的构造函数");
    }

    @Override
    public String toString() {
        return "javaSon{" +
                "age=" + age +
                '}';
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

3.在创建一个超类,java类继承这个超类

public class javaFather{
    private String sex;

    static {
        System.out.println("我是java的父亲的静态方法");
    }

    {
        System.out.println("我是java的父亲的初始化方法");
    }

    public javaFather() {
        System.out.println("我是java的父亲的无参构造函数");
    }

    public javaFather(String sex) {
        this.sex = sex;
        System.out.println("我是java的父亲的构造函数");
    }

    @Override
    public String toString() {
        return "javaFather{" +
                "sex=" + sex +
                '}';
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }
}

4.然后我们测试一下看看那个先输出

public static void main(String[] args) {
    javaSon java = new javaSon();
    java.setId(123);
    java.setName("小明");
    java.setAge(18);
    java.setSex("男");
    System.out.println(java.getName());
    System.out.println(java.getAge());
    System.out.println(java.getId());
    System.out.println(java.getSex());
    javaSon java1 = new javaSon();
    java1.setId(124);
    java1.setName("小红");
    java1.setAge(18);
    java.setSex("女");
    System.out.println(java1.getName());
    System.out.println(java1.getAge());
    System.out.println(java1.getId());
    System.out.println(java.getSex());

    System.out.println("===========================");
    javaSon javayou = new javaSon(12);
    System.out.println(javayou);

}

5.结果

可以很清晰的看见最先执行的是超类的静态方法然后是父类(也就是java类)最后是子类的

然后执行了超类的初始化方法和无参构造方法  然后是父类 最后是子类

接着我们又创建了一次子类对象  去没有执行静态方法但其他的是一样的

最后我们调用的子类的有参构造方法,发现前面的执行顺序是一样的但最后并没有调用子类的无参构造方法而是调用了子类的有参构造

总结:

1.静态方法只会执行一次,在第一次启动时.

2.子类是可以直接调用父类和超类的属性

3.如果调用了有参构造则不会再调用无参构造

4.静态方法-----初始化方法-----无参构造(有参构造)

(如果有错误请指教)