面向对象三大特性（Java）：封装继承多态——

封装

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

package com.oop.Test04;
//类 private:私有
public class Student {
    //属性私有
    //姓名
    private String name;
    //学号
    private int id;
    //性别
    private char 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 char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age > 120 || age < 0){
            age = 3;
        }
        this.age = age;
    }
//IDEA快捷键Alt+Insert+Fn 快速生成set/get方法。
}
       /*
        封装的意义：
        1.提高程序的安全性，保护数据
        2.隐藏代码的实现细节
        3.统一接口
        4.提高了系统的可维护性
         */

继承

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。

extends的意思是"扩展"。子类是父类的扩展。

Java中类只有单继承，没有多继承。

• 继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。
• 继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示。
• 子类和父类之间，从意义上讲应该具有"is a"的关系。

package com.oop.Test05;
//Person 人 ： 父类
public class Person /*extends Object*/ {
//    public
//    protected
//    default
//    private
    private int money = 10_0000_0000;
    public void say(){
        System.out.println("说了一句话");
    }
    public void setMoney(int money) {
        this.money = money;
    }
    public int getMoney() {
        return money;
    }
}
/*测试类
    public static void main(String[] args) {
        Person person = new Person();
        person.getClass();
        System.out.println(person.getMoney());
        }
 */
//在Java中，所有的类都默认直接或者间接继承object

object类

super

方法重写

关于方法重写

package com.oop;
import com.oop.Test05.A;
import com.oop.Test05.B;
public class Application {
    public static void main(String[] args) {
        //静态方法：方法的调用只和左边定义的数据类型有关
        //非静态：重写
        A a = new A();
        a.test();//A类
        //父类的引用指向了子类
        B b = new A();//子类重写了父类的方法
        b.test();//B类


    }

}
/*
重写：
需要有继承关系，子类重写父类的方法！
1.方法名必须相同
2.参数列表必须相同
3.修饰符：范围可以扩大，但不能缩小；
4.抛出的异常：范围，可以被缩小，但不能扩大；ClassNotFoundException -->Exception(大)
重写：子类的方法和父类必须要一致；方法体不同！
为什么需要重写？
父类的功能，子类不一定需要，或者不一定满足！
IDEA快捷键 Alt+Fn+Insert：选中Override可以自动帮我们重写方法。
 */

多态

• 动态编译
• 即同一方法可以根据发送对象的不同而采用多种不同的行为方式
• 一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多（父类，有关系的类）
• 多态存在的条件：
  • 有继承关系
  • 子类重写父类方法
  • 父类引用指向子类对象
• 注意：多态是方法的多态，属性没有多态性。
• instanceof （类型转换） 引用类型

/*
多态注意事项：
1.多态是方法的多态，属性没有多态
2.父类和子类，有联系 才能转换  类型转换异常! ClassCastException!
3.存在的条件：继承关系，方法需要重写，父类引用指向子类对象！father f1 = new Son();
     1.static 方法，属于类，它不属于实例
     2.final 无法重写 常量；
     3.private方法：不能重写；
 */

    public static void main(String[] args) {
        //一个对象的实际类型是确定的
        //new Student();
        //new Person();
        //可以指向的引用类型就不确定了:父类的引用指向子类
        //Student 能调用的方法都是自己的或者继承父类的！
        //Person 父类型，虽然可以指向子类，但是不能调用子类独有的方法
        Student s1 = new Student();
        Person s2 = new Student();
        Object s3 = new Student();
        s2.run();//子类重写了父类的方法，就是执行子类的方法
        s1.run();
        //对象能执行哪些方法，主要看对象左边的类型，和右边关系不大！
        s1.eat();
        ((Student) s2).eat();
    }

X instanceof Y：判断X和Y是否存在父子关系

X：对象，Y：类，如果X对象是Y类（或者其子类）的实例，输出true，否则输出false。

若X和Y之间不存在父子关系，则编译不通过。

也可以说，编译看左边，运行看右边！

例如：

package com.oop;

import com.oop.Test06.Person;
import com.oop.Test06.Student;
import com.oop.Test06.Teacher;
public class Application {
    public static void main(String[] args) {
        //Object>String
        //Object>Person>Teacher
        //Object>Person>Student
        //System.out.println(X instanceof Y);
//能不能编译通过，X和Y之间是否存在父子关系，总结就是：编译看左边，运行看右边！
        Object object = new Student();
        System.out.println(object instanceof Student);
        System.out.println(object instanceof Person);
        System.out.println(object instanceof Object);
        System.out.println(object instanceof Teacher);//obejct是new Student出来的，而Student和Teacher是同一级，所以结果返回false。
        System.out.println(object instanceof String);//obejct是Student的实例，而Student和String并没有直接关联，所以结果返回false。
        System.out.println("========================================");
        Person person = new Student();
        System.out.println(person instanceof Student);
        System.out.println(person instanceof Person);
        System.out.println(person instanceof Object);
        System.out.println(person instanceof Teacher);//obejct是new Student出来的，而Student和Teacher是同一级，所以结果返回false。
        //System.out.println(person instanceof String);///不存在父子关系，编译报错！
        System.out.println("========================================");
        Student student = new Student();
        System.out.println(student instanceof Student);
        System.out.println(student instanceof Person);
        System.out.println(student instanceof Object);
        //System.out.println(student instanceof Teacher);//不存在父子关系，编译报错！
        //System.out.println(student instanceof String);//不存在父子关系，编译报错！
    }
}

输出：

true
true
true
false
false
========================================
true
true
true
false
========================================
true
true
true

类型转换：

我们之前的基本类型转换：低到高，满足自动转换，高到低则需要强制转换。

多态中的类型转换：父类：高，子类：低。同样满足高到低，强制转换，低转高自动转。

在编写Java程序时，引用变量只能调用它编译时类型的方法，而不能调用它运行时类型的方法，如果想要让这个引用变量来调用它运行时类型的方法，必须使用强制类型转换把它转换成运行时类型。

向下类型转换：

语法格式：

(( 目标子类类型)当前待转换的对象名).子类方法()

例如：

((Student) obj).go();

package com.oop;

import com.oop.Test06.Person;
import com.oop.Test06.Student;
public class Application {
    public static void main(String[] args) {
        //基本类型转换：高 低 64 32 高转低，就得强制转换。
        //父子类型之间的转化：父到子，高->低，需要强制转换。
        Person obj = new Student();
        //将这个对象转换为Student类型，就可以使用Student类型的方法了。强转！！
        Student student = (Student) obj;
        student.go();
        ((Student) obj).go();//这句等同于上面那句等同于上面的那两句！
        Person person = student;//低转高，可自动转换！
        //person.go();编译报错，此时person是父类，无法执行子类的go方法。
        //由此可以发现：子类转换为父类，可能会丢失一些自己本身的方法！
    }
}

输出：

go
go

多态总结：
    1.父类引用指向子类的对象。
    2.把子类转换为父类：向上转型，不用强转，但可能会丢失一些方法
    3.把父类转换为子类：向下转型，强转，重写失效。
    4.方便方法的调用，减少重复的代码。

视频学习，来源于B站狂神说Java，欢迎小伙伴们学习~