day16- 继承封装

## 私有属性

private

有特殊操作获取私有属性的方法

get获得数据

set设置数据

 1 ```
 2 public class Student {
 3 //属性私有 private
 4 //名字 学号 性别 年龄
 5 // 学习（）
 6 //睡觉()
 7 private String name;
 8 private int id;
 9 private char sex;
10 
11 private int age;
12 //提供操作私有属性的方法
13 //get 获得数据
14 
15 public String getName() {
16 return name;
17 }
18 
19 //set数据设置
20 
21 public void setName(String name){
22 this.name = name;
23 
24 }
25 
26 public int getId() {
27 return id;
28 }
29 
30 public void setId(int id) {
31 this.id = id;
32 }
33 
34 public char getSex() {
35 return sex;
36 }
37 
38 public void setSex(char sex) {
39 this.sex = sex;
40 }
41 
42 public int getAge() {
43 return age;
44 }
45 
46 public void setAge(int age) {
47 if(age>100||age<0){
48 this.age = -1;
49 }else {
50 this.age = age;
51 }
52 
53 }
54 }
55 ```

main函数：

 1 ```
 2 Student s1 = new Student();
 3 s1.setName("gugu");
 4 String name = s1.getName();
 5 System.out.println(name);
 6 s1.setAge(999);
 7 System.out.println(s1.getAge());
 8 /*
 9 封装的意义：
10 1. 提高程序的安全性，保护数据
11 2. 隐藏代码的实现细节
12 3. 统一接口
13 4. 系统的可维护性增加了
14 属性私有，get/set
15 */
16 ```

## 继承

父类>>子类

一个父类可以有多个子类

一个子类只能由一个父类

子类纪承父类，拥有父类的所有公共方法，使用super（）调用

父类中私有的东西无法被继承

public 子类可以纪承

private 子类不能纪承

protected 受保护的

子类调用无参构造时默认先调用父类的无参构造

若显示调用父类的构造器，必须放在子类构造器的第一行

父类：

```

 1 //Person :父类
 2 // 在Java中 所有的类都默认继承object类
 3 public class Person {
 4 private int money = 10_0000_0000;
 5 protected String name = "gugu";
 6 
 7 public Person() {
 8 System.out.println("Person 无参构造执行了");
 9 }
10 
11 //私有的东西无法被继承
12 public void print(){
13 System.out.println("Person");
14 }
15 public void say(){
16 System.out.println("say a word");
17 //public 子类可以用
18 //private 子类不能调用
19 //protected 受保护的
20 }
21 
22 public int getMoney() {
23 return money;
24 }
25 
26 public void setMoney(int money) {
27 this.money = money;
28 }
29 }

```

子类：student

```

 1 // 学生也是人
 2 public class Student extends Person{
 3 
 4 //子类继承父类，就可以拥有父类的所有方法。
 5 
 6 //java中只有单继承 没有多继承，一个儿子只能有一个父亲，一个父亲可以有多个儿子
 7 
 8 
 9 public Student() {
10 //默认调用父类的无参构造
11 //若显示调用父类的构造器，必须放在子类构造器的第一行
12 super();
13 
14 System.out.println("student无参构造执行了");
15 }
16 
17 private String name = "gugugu";
18 public void test(String name){
19 System.out.println(name);//gugugugu
20 System.out.println(this.name);//gugugu
21 System.out.println(super.name);//gugu
22 print();//Student
23 this.print();//Student
24 super.print();//Person
25 }
26 
27 public void print(){
28 System.out.println("Student");
29 }
30 }

```

## 小结

```

 1 super 注意点：
 2 1. super调用父类的构造方法，必须在构造方法的第一个
 3 2. super必须只能出现在子类的方法或者构造方法中
 4 3. super和this不能同时调用构造方法
 5 
 6 super 与 this的不同：
 7 1. 代表的对象不同：
 8 this代表调用者的对象
 9 super代表父类对象的引用
10 2. 前提：
11 this在没有继承时也可以使用
12 super只能在纪承条件下才可以使用
13 3. 构造方法：
14 this（）本类的构造
15 super（）父类的构造