构造器 java

package com.jsu.study.monththree;

public class Student {
    String name = "笨笨熊";
    int age = 18;
    private int score = 96;
    protected String hobby = "看帅哥";
    String status = "单身";

    public Student(String name, int age, int score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }

//        public Student(String name,int age,int score){
//        setName(name);
//        setAge(age);
//        setScore(score);
//    }
//    public Student(){          //子类 无法直接调用父类中的构造器，无论是有参构造器还是无参构造器，
//        System.out.println("父类中的无参构造器被调用");    //通过输出我们看到在创建子类时，会输出父类的无参构造器被调用
//    }                                                  //子类必须调用父类的无参构造器完成对父类的的初始化
                                                       //此时如果我不对父类中的无参构造器显式定义呢
                                                       //通过尝试 成功的报错了
    public void testing(){
        System.out.println(this.name + " " + "正在考试");
    }

    public void test_info(){
        System.out.println(this.name + "的分数为" + this.score);
    }


    public String getName() {
        return name;
    }


    public void setName(String name) {
        if(name.length() >= 2 && name.length() <= 6){
            this.name = name;
        }else{
            System.out.println("您输入的姓名长度不合理，请输入长度为2-6的姓名");
            this.name = "无名";
        }
    }

    public int getAge() {return age;
    }

    public void setAge(int age) {
        if(age >= 5 && age <= 14){
            this.age = age;
        }else{
            System.out.println("您输入的年龄不合法，请输入范围为[5,14]的年龄");
            this.age = 0;
        }
    }
    public int getScore() {               //因为在父类Student中，score被访问权限控制符private所修饰
        return score;                     //因此不能被子类直接访问，所以我们在父类中提供了一个公开的方法使得子类的实例(对象)
    }                                     //能通过调用该方法访问父类中定义的私有属性

    public void setScore(int score) {
        if(score >= 0 && score <= 100){
            this.score = score;
        }else{
            System.out.println("您输入的分数不合理，请输入范围为[0,100]的分数");
            this.score = 0;
        }
    }
//    public String getHobby() {
//        return hobby;
//    }
//
//    public void setHobby(String hobby) {
//        this.hobby = hobby;
//    }
//
//    public String getStatus() {
//        return status;
//    }
//
//    public void setStatus(String status) {
//        this.status = status;
//    }
}







package com.jsu.study.monththree;

public class Pupil extends Student {
    public int unknow = 10;
    public  Pupil(){
                                                           //如果我在父类中没有对无参构造器进行显示定义
        super("怡宝",8,88);               //那么我必须调用父类中的有参构造器完成对父类的初始化
    }                                                     //只要我想调用父类中的有参构造器我就必须在子类的使用super(参数);
//
    public Pupil(String name,int age,int unknow){                 //在这里我想创建属于子类的有参构造器，但是在这里报错了
        super("农夫山泉",10,88);      //？？？？？？？？？？？？？？？？？？？？？？？？？？
        this.name = name;                           //在文心一言的帮助下
        this.age = age;                            //我想大概是这样 我现在想在子类中创建一个构造函数无论有参无参
        this.unknow = unknow;
    }                 //我都必须调用父类中的构造函数(无论有参无参)目的是对父类的初始化
                     //如果父类中没有显示定义无参构造函数，那么我必须调用父类中的有参构造函数（利用super(参数);）
                    //并且我得保证父类中存在一个这样的有参构造函数供我子类调用
                   //如果在父类中显示定义了无参构造函数，那么在创建子类的对象时就会自动调用父类中的无参构造函数对父类进行初始化
                  //反正不管怎么样  我都要完成对父类的初始化
                 //当父类中对无参构造器进行了显示定义，那我就不需要再用super了，因为在创建子类的对象时会默认调用父类中的无参构造器对父类进行初始化

//    String name;
//    int age;
//    private int score;
//    public void testing(){
//        System.out.println(name + " " + "正在考试");
//    }
//
//    public String getName() {
//        return name;
//    }
//
//    public void setName(String name) {
//        if(name.length() >= 2 && name.length() <= 6){
//            this.name = name;
//        }else{
//            System.out.println("您输入的姓名长度不合理，请输入长度为2-6的姓名");
//        }
//    }
//
//    public int getAge() {
//        return age;
//    }
//
//    public void setAge(int age) {
//        if(age >= 5 && age <= 14){
//            this.age = age;
//        }else{
//            System.out.println("您输入的年龄不合法，请输入范围为[5,14]的年龄");
//        }
//
//    }
//    public int getScore() {
//        return score;
//    }
//
//    public void setScore(int score) {
//        if(score >= 0 && score <= 100){
//            this.score = score;
//        }else{
//            System.out.println("您输入的分数不合理，请输入范围为[0,100]的分数");
//        }
//    }
    public void testing(){
    System.out.println("小学生" + this.name + "正在考试");
   }
   public void test_info(){
//       System.out.println("小学生" + this.name + "的考试成绩为" + this.score);
       System.out.println("小学生" + this.name + "的考试成绩为" + getScore());
   }
}






package com.jsu.study.monththree;

public class Graduate extends Student {
    public Graduate(){
        super("农夫山泉",9,77);
    }
//    String name;
//    int age;
//    private int score;
//    public void testing(){
//        System.out.println(name + " " + "正在考试");
//    }
//
//    public String getName() {
//        return name;
//    }
//
//    public void setName(String name) {
//        if(name.length() >= 2 && name.length() <= 6){
//            this.name = name;
//        }else{
//            System.out.println("您输入的姓名长度不合理，请输入长度为2-6的姓名");
//        }
//    }
//
//    public int getAge() {
//        return age;
//    }
//
//    public void setAge(int age) {
//        if(age >= 5 && age <= 14){
//            this.age = age;
//        }else{
//            System.out.println("您输入的年龄不合法，请输入范围为[5,14]的年龄");
//        }
//
//    }
//    public int getScore() {
//        return score;
//    }
//
//    public void setScore(int score) {
//        if(score >= 0 && score <= 100){
//            this.score = score;
//        }else{
//            System.out.println("您输入的分数不合理，请输入范围为[0,100]的分数");
//        }
//    }
    public void testing(){
        System.out.println("大学生" + this.name + "正在考试");
    }
}







class Test{
    public static void main(String[] args){
        Pupil pupil = new Pupil();
        Graduate graduate = new Graduate();
        System.out.println(pupil.age + " " + pupil.name);
        System.out.println(graduate.age + " " + graduate.name);
        //在这里我将Pupil和Graduate中的属性以及方法都注释掉了，但是因为Pupil和Graduate都是Student的子类
        //故Pupil和Graduate会自动拥有父类Student的属性和方法


//        System.out.println(pupil.score + " " + graduate.score);
        //而在这里报错是因为父类Student中的属性被访问权限控制符private所修饰，不能被子类继承


//        pupil = new Pupil("蠢熊",18,95);
//        Student student = new Student("呆呆狗",23,90);
        //然而这里又出现了一个问题  那就是子类不能调用父类中的构 造器
//        在Java中，子类不能直接调用父类的构造器（无论是无参构造器还是有参构造器）。
//        如果子类构造器中没有显式地使用super关键字来调用父类的构造器，
//        那么编译器会隐式地插入一个调用父类无参构造器的语句。此时需将父类中的默认无参构造器显示定义，否则子类无法调用
//        如果父类没有显示定义默认无参构造器，并且子类构造器中没有显式调用父类的有参构造器，
//        那么在编译时Java编译器会报错，因为找不到默认的父类无参构造器来调用。


        pupil.setName("呆呆狗");
        pupil.setAge(23);
        pupil.setScore(98);
        pupil.testing();
        pupil.test_info();
        //在这里我又遇到一个疑惑
        //当我在子类Pupil中定义了与父类Student中同名的方法，也就是我在子类中重写了父类中的方法
        //当我通过Pupil的实例(对象)取调用该方法时，实际执行的并不是父类中的该方法，而是子类中的该方法
        //所以我认为在调用此种方法时，存在着某种优先级关系
        graduate.setName("波波鸡");
        graduate.setAge(3);
        graduate.setScore(59);
        graduate.testing();
        graduate.test_info();
        //在这里，我并没有在Graduate类中重写父类中的方法
        //因此当我通过Graduate类的实例(对象)调用方法时，实际执行方法的是父类中的方法


        System.out.println(pupil.name + "是一只" + pupil.status + "并且喜欢" + pupil.hobby + "的" + pupil.name);
        //在这里name是被public修饰的，status被default修饰的，hobby是被protected修饰的
        //因为在被public和protected修饰的的属性可以被同包，同类，子类调用
        //因此在父类Student中我将它提供的用于访问私有属性的公开方法注释掉，依然可以通过同包下的Pupil类的实例(对象)访问


        //被default修饰的hobby只能通过同包中的类的实例或者在同类中被访问  不能被子类访问
        //但因为此处父类Student和子类在同一个包中，子类的实例可以直接访问父类中被默认修饰符defaul修饰的属性
        //但如果此处父类Student和子类不在同一个包中，那么就需要父类提供公开的方法供子类调用以访问父类中的被默认修饰符修饰的属性
    }
}

package com.jsu.study.monththree;

public class TopBase {
    public TopBase(){
        System.out.println("TopBase的无参构造器被调用");
    }
}




package com.jsu.study.monththree;

public class Base extends MediumBase{
    public Base(){
        System.out.println("Base的无参构造器被调用");
    }
}





class Test{
    public static void main(String[] args){
        Base base = new Base();
    }
}
//TopBase的无参构造器被调用
//MediumBase的无参构造器被调用
//Base的无参构造器被调用

//java中所有类都是Object的子类
//父类构造器的调用不限于直接父类，一直追溯到Object类（即想调哪个调哪个只要在权限控制范围内）