Java 继承

雨点打透心脏的1/2处 2024-03-27 15:05 2阅读 0赞

### 继承 ###

#### 用 final 关键字修饰的类，不能被继承 ####

*  继承的本质是对某一批类的抽象，从而实现对现实世界的更好的建模
 *  **extends** “扩展”。子类是父类的扩展
 *  Java只有单继承，没有多继承
 *  继承：**类与类之间的关系**。除此之外，还有 依赖、组合、聚合等
 *  继承关系的两个类，一个为子类（派生类），一个为父类（基类）。
 *  子类继承父类，使用关键字 **extends**
 *  Java 中，所有的类，都默认直接或间接 继承Object类
 *  子类继承父类，就会拥有该父类的全部方法

package com.oop.demo05;
    //Java 中，所有的类，都默认直接或间接 继承Object类
    //人：父类
    public class Person /* extends Object */{
        
    
        private int money = 1_0000_0000;
        public void say(){
        
            System.out.println("说话");
        }
    
        public Person(int money) {
        
            this.money = money;
        }
    
        public Person() {
        
        }
    
        public int getMoney() {
        
            return money;
        }
    
        public void setMoney(int money) {
        
            this.money = money;
        }
    }

package com.oop.demo05;
    //学生 也是 人
    //子类继承父类，就会拥有该父类的全部方法
    public class Student extends Person{
        
    }

package com.oop.demo05;
    
    //派生类，子类
    public class Teacher extends Person{
        
    
    }

public class Application {
        
        public static void main(String[] args) {
        
    
            Student student = new Student();
            student.say();
            System.out.println(student.getMoney());
    
        }
    }

#### **私有的东西，无法被继承** ####

*  super 注意点：
    
    1.  super 调用父类的构造方法，必须在构造方法的第一行
    2.  super 必须只能出现在子类的方法或构造方法中
    3.  super 和 this 不能同时调用构造方法（调用时，都需要在第一个）
 *  VS this
    
     *  代表的对象不同：
        
         *  this ： 本身调用者这个对象
         *  super ： 代表父类对象 的 引用
     *  前提：
        
         *  this ： 没有继承也可以用
         *  super ： 只能在继承条件下才可以使用
     *  构造方法：
        
         *  this() ：本类的构造
         *  super() ：父类的构造

public class Application {
        
        public static void main(String[] args) {
        
    
    
            Student student = new Student();
            student.print("print-wangc");
    
        }
    }

public class Person /* extends Object */{
        
    
        protected String name = "Person-wangc";
    
        private int money = 1_0000_0000;
        public void say(){
        
            System.out.println("说话");
        }
    
        public Person(int money) {
        
            this.money = money;
        }
    
        public Person() {
        
            System.out.println("Person 无参构造");
        }
    
        public int getMoney() {
        
            return money;
        }
    
        public void setMoney(int money) {
        
            this.money = money;
        }
    }

public class Student extends Person{
        
        public Student() {
        
            //默认调用父类，无参构造   super();
            super();//假如父类没有无参构造，报错！    显示调用时，必须放在第一行
            System.out.println("Student 无参构造");
        }
    
        public String name = "Student-wangc";
        public void print(String name){
        
            System.out.println(name);//print-wangc
            System.out.println(this.name);//Student-wangc
            System.out.println(super.name);//Person-wangc
        }
    
    }

#### 方法的重写 ####

*  静态的方法，和非静态的方法区别很大
 *  静态方法：方法的调用，只和定义的数据类型有关（左边）
 *  非静态：重写,关键字只能用 **public**

#### 重写：需要有继承关系，子类重写父类方法 ####

*  Ctrl + O 自动重写

1.  方法名必须相同
2.  参数列表必须相同
3.  修饰符：范围可以扩大，但是不能缩小
4.  **Public > Protected > Default > Private**
5.  抛出的异常：范围，可以被缩小，但不能扩大

package com.oop;
    
    import com.oop.demo05.A;
    import com.oop.demo05.B;
    
    //一个项目，应该只存在一个main方法
    public class Application {
        
        public static void main(String[] args) {
        
    
    
            A a = new A();
            a.test();//A-->test
    
            //父类的 引用 指向子类
            B b = new A();//子类重写了父类的方法
            b.test();//A-->test		如果test()方法是静态的，则结果：B-->test
    
        }
    }

package com.oop.demo05;
    
    public class B{
        
        public void test(){
        
            System.out.println("B-->test");
        }
    }

package com.oop.demo05;
    
    public class A extends B{
        
    
        //Override 重写
        @Override//注解:有功能的注释
        public void test() {
        
            System.out.println("A-->test");
        }
    }

##### 为什么要重写 #####

1.  父类的方法，子类不一定需要
2.  父类的方法，子类不一定满足