JavaSE-13 面向对象三大特性：封装、继承、多态

一、封装

• 封装（信息隐藏）：通常，应禁止直接访问一个对象中数据的实际表示，应通过操作接口来访问
• 程序设计追求**“高内聚，低耦合”**。高内聚：类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用
• 属性私有，get/set

创建一个Student类

public class Student {

    //属性私有,无法直接操作这些属性
    private String name;
    private int age;
    private char sex;
    private int id;

    //set/get是提供给外部操作这些属性的方法,
    //alt+insert ---》生成 getter和setter 可以根据属性自动生成set/get方法
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    //安全检查，设置默认值
    public void setAge(int age) {
        if(age<0 || age>150){
            this.age = -1;
        }else{
            this.age = age;
        }

    }

    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;
    }
}

主程序类Application

public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();
        System.out.println(s1.getName());  //null
        s1.setName("zhangsan");
        System.out.println(s1.getName());   //zhangsan

        s1.setAge(70);
        System.out.println(s1.getAge());  //70
        s1.setAge(180);
        System.out.println(s1.getAge());  //-1

    }
}

最后，我们简单描述下封装的作用

• 隐藏代码的实现细节
• 提高程序的安全性
• 统一接口
• 增加系统的可维护性

扩展：修饰符 public>protected>default>private

二、继承

• 继承是类与类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合和聚合等
• 继承关系的两个类，一个叫做父类（基类），另一个叫做子类（派生类）。每个父类可以有多个子类，但每个子类只能继承一个父类。比如，人类是一个父类，男人类和女人类是继承于人类的子类。
• 继承使用关键字 “extends”
• super和重写
• 所有类都直接或者间接的默认继承于Object类

首先定义一个Person类

//父类
public class Person {

    public int money = 1_0000;
    public void say(){
        System.out.println("说话");
    }
}

然后，定义一个Student类，继承于Person类

//子类，继承父类的所有方法和属性
public class Student extends Person{
}

最后，主程序类Application

public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.say();  //说话
        System.out.println(s1.money);  //10000
    }
}

这里父类中的属性是public，但一般的情况下应该设置为private（封装），所以我们要进行一下修改

Person类

public class Person {

    //public int money = 1_0000;
    //若设置为private，子类不能直接操作该属性，但可以通过set/set方法进行操作
    private int money = 1_0000;

    public void say(){
        System.out.println("说话");
    }

    public int getMoney() {
        return money;
    }

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

主程序类

public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.say();  //说话
//        System.out.println(s1.money);  //10000
        System.out.println(s1.getMoney());  //10000
    }
}

super

• super和this用于区别子类和父类中的同名的属性和方法

Person类

//父类
public class Person {
    public String name = "zhangsan";

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

Student类

//子类
public class Student extends Person {

    private String name = "lisi";
    public void print(){
        System.out.println("student");
    }

    public void test1(){
        System.out.println(name);  //lisi
        System.out.println(this.name);  //lisi
        System.out.println(super.name);  //zhangsan
    }

    public void test2(){
        print();  //student
        this.print();  //student
        super.print();  //person
    }
}

主程序类

public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.test1();
        System.out.println("=======================");
        s1.test2();
    }
}

注意点：

• super 只能出现在子类的方法或构造方法中
• super 调用父类的构造方法，必须在子类构造方法中的首行
• super 和 this 不能同时调用构造方法
• super()：父类的构造；this()：子类的构造

看不懂的去看原视频：B站狂神说

重写

• 为什么重写：父类中的方法，子类不一定需要或者不一定满足
• 重写都是方法的重写，和属性没有关系
• 重写是多态的基础
• static 方法不能被重写

我们先看一下非重写的情况，B类

public class B {

    public static void test(){
        System.out.println("B==>test");
    }

}

A类

public classA extends B{

    public static void test(){
        System.out.println("A==>test");
    }
}

主程序类

public class Application {
    public static void main(String[] args) {

        A a = new A();
        a.test();  //A==>test

        B b = new A();
        b.test();  //B==>test
    }
}

把static去掉，重写test方法，B类

public class B {

    public void test(){
        System.out.println("B==>test");
    }
}

A类

public class A extends B{

//    public void test(){
//        System.out.println("A==>test");
//    }

    //重写
    @Override  //注解，有功能的注释
    public void test() {
        super.test();
    }
}

主程序类

public class Application {
    public static void main(String[] args) {
				//方法的调用只和左边的数据类型有关（数据类型有哪些方法，该对象就有哪些方法）
        A a = new A();
        a.test();  //A==>test
        
        //父类的引用指向了子类，若子类重写了方法，执行子类的子类中的方法
        B b = new A();
        b.test();  //A==>test
    }
}

注意点：

• 有继承关系，子类继承父类的方法
• 方法名必须相同，方法体不同
• 参数列表必须相同（参数类别不同的是重载）
• 修饰符的范围可以扩大，但不能缩小： public>protected>default>private（父类中protected的方法在子类中可以重写成public的方法）

三、多态

• 多态：同一方法可以根据发送对象的不同而采用多种不同的行为方式
• 一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多
• 多态是方法的多态，属性没有多态性

				//方法的调用只和左边的数据类型有关（数据类型有哪些方法，该对象就有哪些方法）
        A a = new A();
        a.test();  //A==>test
        
        //父类的引用指向了子类，若子类重写了方法，执行子类的子类中的方法
				**//b 不能调用子类中有而父类中没有的方法**
        B b = new A();
        b.test();  //A==>test

多态存在的条件：

• 有继承关系
• 子类重写父类的方法
• 父类引用指向子类对象