java的三大特性：继承/多态/封装

继承：

 1 package com.Lucky.oop;
 2 
 3 import com.Lucky.oop.constructorClass.Users;
 4 
 5 public class extendClass {
 6     public static void main(String[] args) {
 7           //实例化继承对象
 8 
 9         //步骤： 1.先调用父类的无参构造器
10         //      2.在调用子类本身的无参构造器
11         Users users=new Users();
12 
13         //调用say方法：只会调用实例化对象Users中的say方法
14         //           如果要调用父类的say方法，要在子类方法中采用super
15         users.say();
16 
17     }
18 }

多态/封装：

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
 
 
 
 
    }
}

　　子类与父类：

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

 1 package com.Lucky.oop;
 2 
 3 
 4  /*
 5     构造器：   【和类名称相同，没有返回值，初始化对象值】
 6               1.创建完成一个类之后，会自动再创建一个无参构造器【不显示】
 7               2.一旦创建有参构造器，就无法使用new实例化一个无参数对象
 8               3.alt+insert  :快捷键
 9               4.一旦存在有参构造器，就必须显示无参构造器
10 
11      */
12 
13 public class testCS {
14 
15     String name;
16     int age;
17 
18     public testCS() {
19         System.out.println("父类的无参构造器被调用了");
20     }
21 
22     //一旦存在有参构造器，就必须显示无参构造器
23     public testCS(String name, Integer age) {
24         this.name = name;
25         this.age = age;
26     }
27 
28 
29     /////继承方面：带有private关键字无法继承且调用
30 
31     private void CS(String name) {
32         this.name = name;
33     }
34 
35     //带有public键字可以继承且调用
36     public void say() {
37         System.out.println("父类中的say方法被调用了");
38     }
39 
40     public String Hello(){
41         System.out.println("我是没有重写之前的Hello");
42         return "Hello可以重写";
43     }
44 
45     //fu类特有的方法
46     public void Father(){
47         System.out.println("我是父类特有的方法");
48     }
49 }