05面向对象的三大特征

- 封装

package com.oop.demo03;
//类  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;
    }
    //学习（）
    //睡觉（）
    
    //alt+ insert 添加get set

    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>150||age<0){
            this.age = 1;
        }else {
            this.age = age;
        }

    }
}
/**
测试类
 *     public static void main(String[] args) {
 *         Student s1 = new Student();
 *         s1.setName("duzehou");
 *         System.out.println(s1.getName());
 *         s1.setAge(189);
 *         System.out.println(s1.getAge());
 */
/**
 * 1.提高程序安全性，保护数据
 * 2.隐藏代码实现细节
 * 3.统一接口
 * 4.提高系统可维护性
 */

- 继承

继承

public class Person {
    public int money  = 1000_000_000;
    //private
    //default
    //protected

    private int age = 2;

    public int getAge() {
        return age;
    }
    
    public void setAge(int age) {
        this.age = age;
    }

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

package com.oop.demo04;
//老师 is 人  子类 派生类

public class Teacher extends Person{
}

package com.oop.demo04;
//学生 is 人  子类，派生类
//子类拥有父类所有方法
public class Student extends Person{
//Ctrl + H   继承树

}

//一个项目应该只存在一个main方法
public class Application {
public static void main(String[] args) {
    Student student = new Student();
    student.say();
    System.out.println(student.money);
}
}

super

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

VS this：
    1.代表的对象不同
        this ：本身调用者这个对象
        super：代表父类对象的应用
    2.前提不同
        this：没有继承也可以使用
        super：只能在继承条件下才能使用
    3.构造方法不同
        this：本类的构造
        super：父类的构造

方法重写

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

public class A extends B{
    //override 重写   alt + Insert
    
    @Override//注解：有功能的注释
    public void test() {
        System.out.println("A=test");
    }
}

//静态和非静态方法的区别很大！！！
        //静态方法：静态方法的调用只和左边（定义的对象类型A，B）相关
        A a = new A();
        a.test();//A

        //父类的引用指向了子类
        B b = new A();//子类重写了父类的方法
        b.test();//B

//静态和非静态方法的区别很大！！！
        //非静态的方法
    }

总结：
重写：需要有继承关系，子类重写父类的方法！
    1.方法名和参数列表完全相同
    2.修饰符：（从父类到子类）范围可以扩大：public--->protected-->Default-->private
    3.抛出的异常：(从父类到子类)范围可以被缩小，不能被扩大：ClassNotFoundException ---->  Exception(大)
重写：子类方法和父类必须一致！方法体不同！

为什么需要重写？
    1.父类的功能子类不一定需要或者，不一定满足。
  
快捷键：  
    //override 重写   alt + Insert

- 多态

//人---------> 父类
public class Person {
   public void test(){
      System.out.println("run");
   }
}

//学生---------> 子类
public class Student extends Person {

    @Override
    public void test() {
        System.out.println("son run");
    }

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

public class Application {

    public static void main(String[] args) {
        //一个对象的实际类型是确定的。
        //但是一个对象可以指向的类型就不确定了，父类的引用指向子类
        //Student能调用的方法都是自己的或者继承父类的
        Student s1 = new Student();
        //Person 父类型，可以指向子类，但是不能调用子类独有的方法
        Person s2 = new Student();
        Object s3 = new Student();

        //对象能执行哪些方法，主要看对象左边的类型，和右边关系不大
        s1.test();
        s2.test();//子类重写了父类的方法，执行子类的方法
        ((Student) s2).eat();

    }



}

多态注意事项：
    1.多态是方法的多态，属性没有多态。
    2.父类和子类有联系  类型转换异常，ClassCastException
    3.存在条件：继承关系，方法需要重写，父类引用指向子类对象：Father f1 = new Son()

不能重写的情况：
    1.static方法，属于类，不属于实例
    2.final 属于常量；
    3.private方法

instanceof

a is instanceof A？

a是A的实例吗

public class Application {

    public static void main(String[] args) {
        //Object > String
        //Object > Person > Teacher
        //Object > Person > Student
        Object object = new Student();
        
        // x instanceof Y 能否编译通过取决于x是不是Y的子类或本身的对象

        System.out.println(object instanceof Student);//true
        System.out.println(object instanceof Person);//true
        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);//true
        System.out.println(person instanceof Object);//true
        System.out.println(person instanceof Teacher);//true
        //System.out.println(person instanceof String);//编译不通过


        System.out.println("===============================");
        Student student = new Student();

        System.out.println(student instanceof Student);//true
        System.out.println(student instanceof Person);//true
        System.out.println(student instanceof Object);//true
        //System.out.println(student instanceof Teacher);//编译不通过
        //System.out.println(student instanceof String);//编译不通过
    }

引用类型的类型转换

//将person转换成Student类，就可以使用Student类的方法了！
//父转子
Student s1 = (Student) person;
s1.go();
//or
((Student) person).go();


//子转父 ，可能丢失自己本来的一些方法！
student.go();
Person person1 = student;
// person1.go(); 报错

     /*
        1.父类的引用指向子类的对象
        2.把子类转换为父类，向上转换
        3.把父类转换为子类，强制转换
        4.方便方法调用，减少重复代码，简洁代码！
        
        封装、继承、多态！
        越来越抽象
        抽象类
         */

抽象的编程思想，持续的学习，茅塞顿开，多实践大脑中的想法！

实践出真知！