Day07：面向对象02

一、封装

封装（数据的隐藏）：通常，应该禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。
记住：属性私有（private）,get/set

封装的作用：

1. 提高程序的安全性，保护数据
2. 隐藏代码的实现细节
3. 统一接口

//此处两个class文件
public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();//返回一个s1对象
        //因为private私有的这个关键字，所以s1.name="zhu";会报错
        s1.setName("zhu");
        System.out.println(s1.getName());
        s1.setSex('哇');
        System.out.println(s1.getSex());
    }
}
/*输出：
zhu
错

Process finished with exit code 0
*/
public class Student {
    //属性私有
    private  String name;   //名字
    private  int id;   //学号
    private  char sex;   //性别

    //提供一些可以操作这些属性的方法
    //提供一些public的get和set方法

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

    //alt+insert可以自动生成get和set方法
    public int getId() {
        return id;
    }

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

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        if(sex=='男'||sex=='女') {
            this.sex = sex;
        }
        else this.sex='错';
    }
}

二、继承

//此处两个class文件
//子类会继承父类，拥有父类的方法
//在JAVA中，所有的类都默认直接或间接继承object
//ctrl+h查看继承关系
//Person 人 :父类
public class Person {
    public void say(){
        System.out.println("说了一句话！");
    }
}

//Student 也是 person   学生也是人  所以可以继承人
public class Student extends Person{
    public static void main(String[] args) {
        Student student = new Student();
        student.say();//虽然Student类中没有say方法，但是继承了Person类的方法
    }
}
/*输出：
说了一句话！

Process finished with exit code 0
*/

三、Super

1. Super注意点：

• super调用父类的构造方法。
• super必须只能出现在子类的方法或者构造方法中。
• super和this不能同时调用构造方法。

2. 对比super和this

• 代表的对象不同：
  this:本身调用者这个对象
  super:代表父类对象的应用
• 前提：
  this:没有继承也可以使用
  super:只能在继承条件下才可以使用
• 构造方法：
  this():本类的构造
  super():父类的构造

//此处三个class文件

//子类会继承父类，拥有父类的方法
//在JAVA中，所有的类都默认直接或间接继承object
//ctrl+h查看继承关系
//Person 人 :父类
public class Person {
    protected String name="zhu";
    public Person(){
        System.out.println("Person无参执行");
    }
    public void print(){   //如果是private则不可被继承，即私有的不能被继承
       System.out.println("zhuzhuzhu");
    }
}

//Student 也是 person   学生也是人  所以可以继承人
public class Student extends Person{
   private String name="chang";
   public Student(){
       //隐藏代码super();  调用了父类的无参构造,并且要在子类构造器的第一行
       System.out.println("Student无参执行了");
   }

   public void print(){
       System.out.println("changchangchang");
   }

   public void test1(){
       print();  //调用当前的print()
       this.print();//调用当前的print()
       super.print();//调用父类的print()
   }

   public void test(String name){
       System.out.println(name);  //输出test()形参的name
       System.out.println(this.name);//输出Student当前定义的name
       System.out.println(super.name);//输出父类的name
   }
}

public class Application {
    public static void main(String[] args) {
        Student student = new Student();//会执行构造器
        student.test("shuang");
        student.test1();
    }
}
/*输出：
Person无参执行
Student无参执行了
shuang
chang
zhu
changchangchang
changchangchang
zhuzhuzhu

Process finished with exit code 0
*/