override

package com.Lucky.oop;


 /*
    构造器：   【和类名称相同，没有返回值，初始化对象值】
              1.创建完成一个类之后，会自动再创建一个无参构造器【不显示】
              2.一旦创建有参构造器，就无法使用new实例化一个无参数对象
              3.alt+insert  :快捷键
              4.一旦存在有参构造器，就必须显示无参构造器

     */

public class testCS {

    String name;
    int age;

    public testCS() {
        System.out.println("父类的无参构造器被调用了");
    }

    //一旦存在有参构造器，就必须显示无参构造器
    public testCS(String name, Integer age) {
        this.name = name;
        this.age = age;
    }


    /////继承方面：带有private关键字无法继承且调用

    private void CS(String name) {
        this.name = name;
    }

    //带有public键字可以继承且调用
    public void say() {
        System.out.println("父类中的say方法被调用了");
    }

    public String Hello(){
        System.out.println("我是没有重写之前的Hello");
        return "Hello可以重写";
    }

    //fu类特有的方法
    public void Father(){
        System.out.println("我是父类特有的方法");
    }
}

　　

package com.Lucky.oop.constructorClass;

import com.Lucky.oop.testCS;

import java.lang.ref.SoftReference;
import java.math.BigDecimal;

//测试类：用于作为java特性：封装，继承，多态 讲解
         /*
         封装作用：提高程序的安全性
                  隐藏代码细节
                  统一接口
                  系统可维护
          */
/*
         继承【extends】作用：  1子类拥有父类的所有公有的属性以及方法
                             2如果父类中存在private[私有的]属性以及方法则无法继承
                             3:ctrl+H :打开关系树
                             4.所有的类都间接或直接继承Object
                             5.只能单继承
                             6.想调用父类的属性以及方法采用super


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


         super与this
                 this：代表调用者本身【没有继承也可以使用】
                 super：代表父类对象【只有在继承条件下才能使用】
          */

//private  是私有的
//protected 受保护的
//public  公有的
//default  默认的
public class Users extends testCS {
    private String name;
    private int age;
    private String address;
    private BigDecimal money;

    public Users() {
        // super();这个是隐藏代码
        System.out.println("子类的无参构造器被调用了");

    }

    public Users(String name, int age, String address, BigDecimal money) {
        this.name = name;
        this.age = age;
        this.address = address;
        this.money = money;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    //封装例子：年龄大于150或小于0 都是不合法 加上条件
    public void setAge(int age) {
        if(age>150 || age<0){
            this.age=3;
        }
        this.age = age;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public BigDecimal getMoney() {
        return money;
    }

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

    @Override
    public String toString() {
        return "Users{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", address='" + address + '\'' +
                ", money=" + money +
                '}';
    }






    //继承：
    public void say() {
        System.out.println("子类中的say方法被调用了");
        super.say();  //调用父类的方法say
    }

    //重写
    @Override
    public String Hello() {
        System.out.println("我是重写的Hello");
        return "我是重写的Hello";
    }

    //子类特有的方法
    public void NB(){
        System.out.println("我是子类特有的方法");
    }
}

　　

Override效果展示：

package com.Lucky.oop;

import com.Lucky.oop.constructorClass.Users;

/*
    重写：需要有继承的关系
         1.什么都要相同，除了【修饰符】修饰符可以变大，但是不能变小
         public>protected>default>private
         2.方法体可以不同【这就是重写的意义】
         3.拓展：异常的范围是可以变小，但是不能变大

         注意点：为什么要重写？？？？
                 1。父类的功能在子类中不一定用的上或者不一定可以满足
                 2. 优化代码
                 3.static方法属于类，不能重写【不属于实例】
                   final方法，不能重写
                   private方法，不能重写


 */

public class OverrideClas {
    public static void main(String[] args) {
        //调用重写的方法
         /*
        能调用自身特有的方法以及继承父类中public的方法
         */
        Users users=new Users();
        users.Hello();

        //继承的原因：父类testCS指向子类Users
        /*
        不能调用子类特有的方法
         */
        testCS cs=new Users();
        cs.Hello();    //因为子类父类都存在该方法，所以指向的是子类的Hello方法
      //   cs.NB();   NB是子类特有的方法
        cs.Father();


       /*
       多态：
            1.是方法的多态，属性没有多态
            2.父类和子类的关系
            3.存在条件：继承关系，方法需要重写，就父类指向子类的运用就是多态  testCS是父类  Users是子类
              例如：testCS cs=new Users();

        */


        /**
         * instanceof  :判断是否
         */
        Object test=new Users();   //小知识：alt+enter：补充内容
        System.out.println(test instanceof Users);  //true
        System.out.println(test instanceof Object); //true
        System.out.println(test instanceof testCS); //true




    }
}