面向对象-封装和继承

封装（student类）

 /*
    * 封装（属性私有，get/set）：
    * 我们的程序设计追求高内聚，低耦合，高内聚即类的内部数据操作细节自己完成，不允许外部干涉，低耦合即仅暴露少量的方法给外部使用
    * 封装（数据的隐藏）：一般禁止直接访问一个对象中数据的实际表示，而应该通过操作接口来访问，这称为信息隐藏。
    *
    * */
    /*
    * 继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模
    * extends意思是扩展.子类是父类的扩展
    * Java中类只有单继承，没有多继承；
    * 继承是类与类之间的关系。除此之外，类和类直接的关系还有依赖，组合，聚合等；
    * 继承关系的两个类，一个为子类（派生类），一个为父类（基类），子类继承父类，使用关键字extends来表示
    * 子类和父类之间，从意义上讲应该具有“is a ”的关系
    * ①Object类 ②super ③方法重写
    * */
    /*
    * super注意点：
    * 1.super调用父类的构造方法，必须在构造方法的第一个
    * 2.super必须只能出现在子类的方法或者构造方法中
    * 3.super 和 this不能同时调用构造方法；
    * this：
    * 代表的对象不同：this：代表本身调用者这个对象；super：代表父类对象的应用；
    * 前提：this：没有继承也可以使用；super：只能在继承条件才可以使用；
    * 构造方法：this：本类的构造；super：父类的构造
    * */
    /*
    * 多态（是方法的多态，属性没有多态性）：
    * 动态编译
    * 即同一方法可以根据发送对象的不同而采取多种不同的行为方式
    * 一个对象的实际类型是确定的，但可以指向对象的引用类型有很多
    * 多态存在的条件：
    * ①有继承关系 ②子类重写父类的方法 ③父类引用指向子类对象
    * */

student类

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

public class Student {
    /*封装的核心：私有
    //名字 学号 性别 学习（） 睡觉（）
    //属性私有
    封装的好处：①提高程序安全性，保护数据；②隐藏代码的实现细节；③统一接口；④系统课维护性增加了
     */
    private String name;
    private int id;
    private char sex;
    private int age;
    //提供一些可以操作这个属性的方法，public的get,set方法 alt+insert自动生成get set方法

    //get获得这个数据
    public String getName(){
        return this.name;
    }

    public int getId() {
        return id;
    }

    public char getSex() {
        return sex;
    }
    //set给这个数据设置值
    public void setName(String name){
        this.name = name;
    }
    public void setId(int id) {
        this.id = id;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age > 130 || age < 0){
            this.age = 3;
            System.out.println("不合法");
        }else {
            this.age = age;

        }
    }
}

继承（A继承B，Teacher继承Person）

Person类

package com.Oop.Demo03;

public class Person {
    /*
    * public：公共
    * protected:
    * default:
    * private（属性私有，通过get,set方法调用）:
    * */
    public Person(){
        System.out.println("Person无参执行了");
    }
    protected String name = "qiqi";
    private int money = 10_0000_0000;
    public void say(){
        System.out.println("说了句话");
    }

    public int getMoney() {
        return money;
    }

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

Teacher类

package com.Oop.Demo03;

//派生类
public class Teacher extends Person{
    public Teacher(){
        //隐藏代码：调用了父类的无参构造
        super();//调用父类的构造器，必须要在子类构造器第一行
        System.out.println("Teacher无参执行了");
    }
    private String name = "douzi";
    //属性访问，方法类似
    public void test(String name){
        System.out.println(name);//传入的参数
        System.out.println(this.name);//douzi
        System.out.println(super.name);//super访问父类；父类Person中的qiqi

    }
}

B类

package com.Oop.Demo03;

//重写都是方法的东西，与属性无关
public class B {
//    public static void test(){
//        System.out.println("B->test()");
//    }//静态方法是类的方法
    public void test(){
        System.out.println("B->test()非静态");
    }//非静态方法才是对象的方法
}

A类

package com.Oop.Demo03;

//继承关系
public class A extends B{
//    public static void test(){
//        System.out.println("A->test()");
//    }//静态方法是类的方法


    @Override//注解，有功能的注释
    public void test() {
//        super.test();
        System.out.println("A->test()非静态");
    }//非静态方法才是对象的方法

}

主方法

package com.Oop.Demo03;

public class Application {
    public static void main(String[] args) {
        /*
        * ctrl + h:显示类的继承路径
        * ctrl + f:全局搜索
        * Java中所有的类默认
        * 直接或间接继承Object
        * */
        Student s1 = new Student();
        s1.setName("qiqi");
        System.out.println(s1.getName());//println就是很多的方法重载（方法名相同，参数列表不同）
        s1.setAge(999);
        System.out.println(s1.getAge());//不合法  3

        Teacher teacher = new Teacher();
        teacher.say();//子类继承了父类就会继承了Person(父类)的全部方法
        System.out.println(teacher.getMoney());
        teacher.test("七七");
        /*
        * 快捷键：alt + insert :override
        * 方法重写（需要有继承关系，子类重写父类的方法）
        * 静态方法和非静态方法区别很大
        * 即 b 是A new出来的对象，因此调用了A的方法
        * 因为静态方法是类的方法，而非静态（才可以重写）是对象的方法(重点理解)
        * 有static时，b调用了B类的方法，因为 b 是用B类定义的
        * 没有static时，b调用的时对象的方法，而 b 时用类new的
        * 1.方法名，参数列表必须相同（重写）；方法名相同，参数列表不同（重载）；
        * 2.修饰符：范围可以扩大，但不能缩小 private->protected->default->public
        * 3.抛出的异常：可以被缩小，不能被扩大
        * 父类的功能不一定需要，或者不一定满足
        * */
        //静态方法的调用只和左边，定义的数据类型有关
        A a = new A();
        a.test();//有static时是A->test()，没有static时是A->test()非静态
        //父类的引用指向了子类
        B b = new A();//子类重写了父类的方法，重写只和非静态相关
        b.test();//有static时是B->test()，没有static时是A->test()非静态

    }
}