Day11 java面向对象：封装、继承、super和this

封装

封装的意义

1. 提高程序的安全性，保护数据。
2. 隐藏代码的实现细节。
3. 统一接口。
4. 系统可维护性增加了。

//类
public class Student {
    //属性私有化
    private String name;//名字
    private int id;    //学号
    private char sex;    //性别
    private int age;//年龄
    //提供一些可以操作这些属性的方法！
    //提供一些public的get，set方法
    //get 获得这个数据
    public String getName() {
        return this.name;
    }

    //set 给这个数据设置值
    public void setName(String name) {
        this.name = name;
    }

    public int getId() {
        return id;
    }

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

    public char getSex() {
        return sex;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age>120||age<0){//不合法
            this.age = 3;
        }else
        {
            this.age = age;
        }
    }
//学习（）
// 睡觉（）
}

public static void main(String[] args) {
    Student student=new Student();
    student.setName("jyw");
    System.out.println(student.getName());

    student.setAge(999);//不合法
    System.out.println(student.getAge());
}

继承

1. 在java中，所有的类都直接或间接继承Object。

2. 子类继承了父类，就用拥有父类的全部方法。

3. 子类无法继承父类私有的属性和方法。

4. 子类构造器默认调用了父类的无参构造，调用父类的构造器，必须要在子类构造器里面的第一行。

5. this指向当前类，super指向父类。

super注意点

1. super调用父类的构造方法，必须在子类构造方法中放在第一个执行。
2. super必须只能出现在子类的方法或者构造方法中。
3. super和this不能同时调用构造方法！

super 和 this的区别

1. 代表的对象不同：

   • this:代表本身调用者，这个对象。
   • super：代表父类对象的哟引用。

2. 前提

   • this：没有继承情况下也可以使用。
   • super：只能在继承条件下才可以使用

3. 构造方法

   • this（）：调用本类的构造。
   • super（）：调用父类的构造。

//persion 人：父类
public class Persion {
    //public
    //proteded
    //defalt
    //private
    private int money = 1_000_000;
    protected String name = "父类jyw";

    public Persion() {
        System.out.println("父类的无参构造函数执行了");
    }

    public void say() {
        System.out.println("说了一句话。");
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }

    public void print(){
        System.out.println("Persion父类");
    }
}

//student is 人：派生类，子类
//子类继承了父类，就用拥有父类的全部方法
public class Student extends Persion {
    //ctrl+h 打开继承树
    private String name = "子类jyw";

    public Student() {
        //默认调用了父类的无参构造
        super();//默认隐藏，调用父类的构造器，必须要在子类构造器里面的第一行。
        System.out.println("子类的无参构造函数执行了");
    }

    public void test(String name) {
        System.out.println(name);//取值来自形式参数
        System.out.println(this.name);//this指向当前子类，取值来自子类变量
        System.out.println(super.name);//super指向父类，取值来自父类变量
    }

    public void print() {
        System.out.println("Student子类");
    }

    public void test1(String name) {
        print();//调用子类的print
        this.print();//调用子类的Student的print
        super.print();//调用父类的Persion的print
    }
}