day07-封装-继承

day07 9-2

😸

简单总结类和对象

/*
1. 类和对象
	类是模块-抽象，对象是类的实例化-具体
2. 方法
	修饰符 返回类型 方法名
    定义和调用

3. 对象的引用
	基本类型（8种）
	引用类型
	  对象存在堆里
	  对象是通过引用类型来进行操作的：栈---> 堆
	  引用在栈里
4. 属性：字段Filed成员变量
	默认初始化：
		0
		null
		false
5. 对象的创建和使用 
	- 必须new才能创建对象，调用了隐式构造函数（与类名同名的无返回的构造方法）
	- 属性 pet.name
	- 方法 pet.eat（）
6. 类：
	静态的属性
	动态的行为
**/

封装

该露露，该藏藏。高内聚，低耦合

高内聚： 类的内部数据细节自己完成，不允许外部干涩

低耦合： 仅暴露少量的方法供外部使用

[!IMPORTANT]

属性私有，get/set-private

package com.example.demo.oop.obj;

public class Student {
    //属性私有
    private String name;
    private int id;
    private char sex;

    //提供一些public的get/set方法来使用私有属性/方法
    //get 获得这个值
    public String getName(){
        return this.name=name;
    }
    //set 设置这个值
    public void setName(String name){
        this.name=name;
    }
    //alt+ins 可以自动生成getter/setter

    public int getId() {
        return id;
    }

    public void setId(int id) {
        if(id<0||id>100){
            System.out.println("invalid id");
            return;
        }else{
            this.id = id;
        }
    }
}

package com.example.demo.oop.obj;
/*9-2
封装-继承-多态
封装private-get/set
    1.提高了程序的安全性，保护数据
    2.隐藏代码的实现细节
    3.统一接口
    4.维护性和可扩展性
* */
public class Demo01 {
    public static void main(String[] args) {
        Student student = new Student();
        //student.getName().sout可以补全
        System.out.println(student.getName());
        student.setName("xxx");
        System.out.println(student.getName());

        student.setId(999);//可以对数据的合法性进行检查
        System.out.println(student.getId());
    }
}

封装private-get/set

1. 提高了程序的安全性，保护数据

2. 隐藏代码的实现细节

3. 统一接口

4. 维护性和可扩展性

继承extends

java只有单继承，没有多继承---儿子可以有多个，但是父亲只有一个

所有的类默认直接或间接继承Object类

继承是对抽象批类的扩展 🌰:人是一个高层次的抽象，黄种人就是对人这个概念的扩展

父类（基类）--子类（派生类）

😆Student isn't Perso

public class Student extends Person(){}//Student is Person
//ctrl+h 打开继承树-一键打开族谱（

super-指父类（基类）-this（指当前对象）

私有的无法继承，即无法通过super调用。其实就是访问修饰符权限问题

构造器，子类会先调用父类的构造方法，再调用自己的构造器,即子类构造器隐藏了一个super()方法，且必须先执行。

package com.example.demo.oop.obj;

public class Person {
    protected String name="father";

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

package com.example.demo.oop.obj;

import java.util.TreeMap;

public class Teacher extends Person {
    private String name="child";

    public void test(String name){
        System.out.println("test:name: "+name);
        System.out.println("this.nname: "+this.name);
        System.out.println("super.name: "+super.name);
    }
    public void print(){
        System.out.println("child");
    }
    public void test1(){
        print();
        this.print();
        super.print();
    }
}

package com.example.demo.oop.obj;

public class Demo02 {
    public static void main(String[] args) {
        Teacher te = new Teacher();
        te.test("test");
        te.test1();
    }
}

如果父类有参构造，子类就无法调用父类的无参构造了，只能进行有参构造和super（）：由前面可知，一旦有参构造就会略过无参构造

super

1. super调用父类的构造方法，必须在构造方法的第一位
2. 只能出现在子类的方法里
3. 不能和this同时调用构造方法