面向对象

面向对象编程的本质就是：以类的方式组织代码，以对象的组织（封装）数据

封装

属性私有get/set（有时候设置安全性的判断）

提高程序的安全性，保护数据
隐藏代码的实现细节
同意接口
系统可维护增加了

继承

继承的本质是对某一批嘞的抽象，从而实现对现实世界更好的建模
e x t a n d s的意思是“扩展。子类是父类的扩展。
Java中类只有单继承，没有多继承；
继承是类与类之间一种关系，除此之外，类和类之间的关系还有依赖，组合，聚合等
继承关系的俩个类，一个为子类（派生类），一个父类（基类）。子类继承父类，使用关键字extands.
修饰符：public，protected，default，private
快捷键：Ctrl+h（看自己继承的类）

super和this

super注意点：
  1. super调用父类的构造方法，必须在构造方法的第一个排
  2. super必须只能出现在子类的方法或者构造方法中
  3. super和this不能同时调用方法

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

方法重写（Alt+Insert-->override）

都是方法的重写与属性无关

重写：需要有继承关系，子类重写父类的方法。
1. 方法必须相同
2. 参数列表必须相同
3. 修饰符：范围可以扩大但是不能缩小：public-->Protected--->Defunct--->private
4. 抛出异常：范围，可以被缩小，但是不能扩大：Class Not Found Exception---》Exception
重写：子类的方法和父类必须一致，方法体不同

为什么需要重写：
1. 父类的功能，子类不一定需要，或者不一定满足

多态

public class Person {
    public void run(){
        System.out.println("run");
    }

}

public class Student extends Person{
    @Override
    public void run() {
        System.out.println("sun");
    }
    public void eat(){
        System.out.println("cat");
    }
}

import com.oop.Demo05.Person;
import com.oop.Demo05.Student;

import java.util.Scanner;

public class Application {
    public static void main(String[] args) {
        //一个对象的实际类型是确定的
        //可以指向的引用类型就不确定了；父类的引用指向子类

        //student子类能调用的方法都是自己的或者继承父类的
        Student s1 = new Student();
        //person父类，可以指向子类，但是不能调用子类独有的方法
        Person s2 = new Student();
        Object s3=new Student();
        //对象能执行那些方法，主要看对象左边的类型，和右边的关系不大
        s2.run();//子类重写父类的方法，执行的是子类里面的方法
        s1.eat();
        ((Student) s2).eat();

    }

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

public class Application {
    public static void main(String[] args) {
//        //Object > Person > Student
//        Object object = new Student();
//        //是否为父子关系
//        System.out.println(object instanceof Student);//true
//        System.out.println(object instanceof Person);//ture
//        System.out.println(object instanceof Object);//true
//        System.out.println(object instanceof Teacher);//false
//        System.out.println(object instanceof String);//false
//        System.out.println("=============");
//        Person person=new Student();
//        System.out.println(person instanceof Student);//true
//        System.out.println(person instanceof Person);//ture
//        System.out.println(person instanceof Object);//true
//        System.out.println(person instanceof Teacher);//false
//        //System.out.println(person instanceof String);//编译错误
        //这现在是个Person对象，高转低，强转
        //子类转换成父类会丢失一些方法
        Person person = new Student();
        Student student = (Student) person;
        student.go();
    }

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