Java面向对象：封装，继承，多态

封装：
该露的露，该藏的藏
我们程序设计要求“高内聚，低耦合”，高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用
封装就是数据的隐藏：属性私有private，通过set/get方法操作数据

继承：
继承是类和类之间的一种关系，继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类用关键字extends表示
extends的意思是“扩展”，子类是父类的扩展。可表示为子类 is a 父类，如学生 is a 人
Java中只有单继承，没有多继承；孩子只有一个爹，但可以有多个兄弟
在Java中所有类都直接或间接继承Object类

方法重写：
重写：需要有继承关系，子类重写父类方法
1.方法名必须相同
2.参数列表必须相同
3.修饰符：范围可以扩大但不能缩小：public>protected>default>private
4.抛出的异常：范围可以缩小但不能扩大：ClassNotFoundException–>Exception(大)
重写：子类的方法必须和父类一致；方法体不同
为什么要重写：父类的功能，子类不一定需要或者不一定满足

多态：
同一方法可以根据发送对象的不同而采取多种不同的行为方式
一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多
多态存在的条件：有继承关系、子类重写父类方法、父类引用指向子类对象
多态是方法的多态

代码写的比较多，也比较乱，仔细看应该能看懂

package com.zdz.oop;

//一个项目只存在一个main方法
public class Appliction {
    public static void main(String[] args) {
        //类：抽象的，实例化
        //类实例化后会返回一个自己的对象
        //student对象就是一个Student类的具体实例
        Student student = new Student();

        System.out.println("=========================");
        //封装
        student.setName("张生");//set赋值
        System.out.println(student.getName());//get取值
        student.setAge(999);//不合法，3岁小孩输入的
        System.out.println(student.getAge());
        student.setAge(22);//张生自己输入的，合法的
        System.out.println(student.getAge());

        System.out.println("====================");
        //继承
        //子类继承了父类，就会有父类除private的全部方法和属性，继承一般用public
        //修饰符：public，protected，default，private越来越私有，此为优先级
        student.say();
        System.out.println(student.getMoney());//通过手段方法去要钱
        student.test("zdz");
        student.test1();
        //方法重写
        A a=new A();
        B b=new A();//父类的引用指向了子类；多态
        //方法的调用只和左边定义的数据类型有关-->静态方法
        a.test();//A
        b.test();//B
        //重写-->非静态方法
        a.name();//实际类型确定
        b.name();

        System.out.println("====================");
        //多态
        //一个对象的实际类型是确定的
        //new A();
        //可以指向的引用类型不确定了：父类的引用指向了子类
        A x1=new A();//子类A能调用的方法都是自己的或继承父类的
        B x2=new A();//父类B可以指向子类，但不能调用子类独有的方法
        x2.run();//子类重写了父类方法，执行子类的方法
        x2.eat();//子类没重写父类方法，执行父类方法
        //x2.sleep();//Cannot resolve method 'sleep' in 'B'；在类B中没有sleep方法，
        // 由此可知：对象执行哪些方法，主要看对象左边的类型，与右边关系不大，可以强制转换：
        ((A)x2).sleep();//高转低
    }
}

/*
封装的意义：
1.提高程序安全性，保护数据
2.隐藏代码的实现细节
3.统一接口
4.系统可维护性增加
 */
class Student extends Person{//同包下不能有重名类
    //属性：字段
    //属性私有private
    private String name="zdz";//姓名，默认初始化，null
    private int age;//年龄

    /*
    构造方法类初始化时就执行了，最早执行
    super注意点：
    1.super调用父类的构造方法，必须在构造方法的第一行
    2.super必须只能出现子类的方法或者构造方法中
    3.super和this不能同时调用构造方法
    VS this
        代表的对象不同
            this：代表本身对象的应用
            super：代表父类对象的应用
        前提
            this：没有继承也可以使用
            super：只能在继承条件下才可以使用
        构造方法
            this();本类的构造
            super();父类的构造
     */
    public Student() {//构造方法
        //隐藏代码：调用了父类Person的构造方法
        //super();//此方法不写效果一样，为隐藏代码，若写出来必须放在代码第一行
        System.out.println("Student无参构造执行了");
    }

    //提供一些方法去操作这些属性set/get
    //get取值，set赋值
    public void setName(String name){
        this.name=name;
    }

    public String getName(){
        return this.name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if ((age<120)&&(age>0)){
            this.age = age;
        }else{
            this.age=3;//三岁小孩才会把年龄输错
        }
    }

    public void test(String name){
        System.out.println(name);//zdz，方法传进来的值
        System.out.println(this.name);//张生，set赋给私有属性的值
        System.out.println(super.name);//张端庄，父类的值
    }

    public void say(){
        System.out.println("说了句：I Heat You !");
    }

    public void test1(){
        say();//I Heat You
        this.say();//I Heat You
        super.say();//I Love You
    }
}

class Person{
    private int money=100000000;//不会被继承，你爹有钱，跟你有啥关系？
    protected String name="张端庄";

    public Person() {//构造方法
        System.out.println("Person无参构造执行了");
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {//但是，你可以通过一些方法去要来你爹的钱
        this.money = money;
    }

    public void say(){
        System.out.println("说了句：I Love You !");
    }
}


/*
重写：需要有继承关系，子类重写父类方法
1.方法名必须相同
2.参数列表必须相同
3.修饰符：范围可以扩大但不能缩小：public>protected>default>private
4.抛出的异常：范围可以缩小但不能扩大：ClassNotFoundException-->Exception(大)
重写：子类的方法必须和父类一致；方法体不同
为什么要重写：父类的功能，子类不一定需要或者不一定满足

 */
class A extends B{
    public static void test(){
        System.out.println("A=>test()");
    }
    //Override 重写
    @Override//注解：有功能的注释
    public void name(){
        //super.name();//将父类方法内容继承过来
        System.out.println("张小生");
    }

    @Override
    public void run() {
        //super.run();
        System.out.println("张小生在跑步");
    }
    public void sleep(){
        System.out.println("张小生在睡觉");
    }
}
/*
多态：
1.多态是方法的多态，属性没有多态
2.父类和子类，有联系 类型转换异常：ClassCastException
3.存在条件：继承关系，方法需要重写，父类引用指向子类对象！ Father dog = new Son();
以下没有多态：
1.static方法：属于类，不属于实例
2.final常量
3.private方法
 */
class B{
    public static void test(){
        System.out.println("B=>test()");
    }
    public void name(){
        System.out.println("张生");
    }
    public void run(){
        System.out.println("张生在跑步");
    }
    public void eat(){
        System.out.println("张生在吃饭");
    }
}