override

<br><br>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("我是父类特有的方法");
    }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

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效果展示：

 1 package com.Lucky.oop;
 2 
 3 import com.Lucky.oop.constructorClass.Users;
 4 
 5 /*
 6     重写：需要有继承的关系
 7          1.什么都要相同，除了【修饰符】修饰符可以变大，但是不能变小
 8          public>protected>default>private
 9          2.方法体可以不同【这就是重写的意义】
10          3.拓展：异常的范围是可以变小，但是不能变大
11 
12          注意点：为什么要重写？？？？
13                  1。父类的功能在子类中不一定用的上或者不一定可以满足
14                  2. 优化代码
15                  3.static方法属于类，不能重写【不属于实例】
16                    final方法，不能重写
17                    private方法，不能重写
18 
19 
20  */
21 
22 public class OverrideClas {
23     public static void main(String[] args) {
24         //调用重写的方法
25          /*
26         能调用自身特有的方法以及继承父类中public的方法
27          */
28         Users users=new Users();
29         users.Hello();
30 
31         //继承的原因：父类testCS指向子类Users
32         /*
33         不能调用子类特有的方法
34          */
35         testCS cs=new Users();
36         cs.Hello();    //因为子类父类都存在该方法，所以指向的是子类的Hello方法
37       //   cs.NB();   NB是子类特有的方法
38         cs.Father();
39 
40 
41        /*
42        多态：
43             1.是方法的多态，属性没有多态
44             2.父类和子类的关系
45             3.存在条件：继承关系，方法需要重写，就父类指向子类的运用就是多态  testCS是父类  Users是子类
46               例如：testCS cs=new Users();
47 
48         */
49 
50 
51         /**
52          * instanceof  :判断是否
53          */
54         Object test=new Users();   //小知识：alt+enter：补充内容
55         System.out.println(test instanceof Users);  //true
56         System.out.println(test instanceof Object); //true
57         System.out.println(test instanceof testCS); //true
58 
59 
60 
61 
62     }
63 }