Day09

封装

高内聚，低耦合

package oop.Demo04;
​
/**
 * @author senko
 * @date 2022/9/26 18:32
 */
public class Student {
    //属性私有
    private String name;
    private int id;
    private String 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 String getSex() {
        return this.sex;
    }
​
    public void setSex(String sex) {
        this.sex = sex;
    }
​
    public int getAge() {
        return this.age;
    }
​
    public void setAge(int age) {
        if (age<120&&age>0){
            this.age=age;
        }else {
            System.out.println("输入错误");
        }
    }
​
}

/*封装的意义
1.提高程序的安全性
2.隐藏代码的实现细节
3.统一接口
4.系统可维护增加了
* */
public class Appication {
    public static void main(String[] args) {
        Student s1=new Student();
        s1.setName("请将");
        System.out.println(s1.getName());
        s1.setSex("男");
        System.out.println(s1.getSex());
        s1.setAge(999);
        System.out.println(s1.getAge());
​
​
    }
}

Person类（父类）

public class Person {
    public int money=1000000;
    public void say(){
        System.out.println("说了");
    }
​
    public int getMoney() {
        return money;
    }
​
    public void setMoney(int money) {
        this.money = money;
    }
}

Student类（子类）

public class Student extends Person {
​
}

Teacher类（子类）

public class Student extends Person {
​
}

Application调用

import oop.Demo05.Person;
import oop.Demo05.Student;
​
/**
 * @author senko
 * @date 2022/9/26 19:06
 */
//student类继承了Person类，在被Application类调用
public class Application {
    public static void main(String[] args) {
        Person student = new Student();
        student.say();
        System.out.println(student.getMoney());
        System.out.println(student.money);
    }
}

继承

super注意点：

1.super调用父类的构造方法，必须在构造方法的第一个

2.super必须只能出现在子类的方法或者构造方法中

3.super和this不能同时调用构造方法

VS this：

代表的对象不同：

this：本身调用者这个对象

super：代表父类对象的应用

前提：

this：没有继承也可以使用

super：只能在继承条件下才能使用

构造方法

this（）：本类的构造

super（）：父类的构造

//在Java中  所有的类，都默认直接或者间接继承object
//Person 人：父类
public class Person {
    public Person() {
        System.out.println("Person无参执行了");
    }
​
    protected String name="昌隆";
//私有的东西无法被继承，所以protect不能改成private
   public void print(){
        System.out.println("Person");
    }
}

//学生  is  人 ：派生词,子类
//子类继承了父类，就会拥有父类的全部方法
public class Student extends Person {
​
    public Student() {
        //隐藏代码：调用了父类的无参构造
        super();//这就是隐藏代码，自己打出来的，调用父类的构造器，必须要在子类构造器的第一行
        System.out.println("Student无参执行了");
    }
​
    private String name="changlong";
    public void print(){
        System.out.println("Student");
    }
    public void test1(String name){
        System.out.println(name);//夏昌隆
        System.out.println(this.name);//changlong
        System.out.println(super.name);//昌隆
    }
    public void test2(){
       print();//与this.print()相同由于不好识别所以尽量使用this.print()
       this.print();
       super.print();
    }
}

import oop.Demo06.Student;
​
/**
 * @author senko
 * @date 2022/9/26 21:19
 */
public class ApplicationDemo06 {
    public static void main(String[] args) {
        Student student = new Student();
        //student.test1("夏昌隆");
        student.test2();
    }
}