Java之继承&重写与重载

苏-言

于 2024-10-09 16:15:56 发布

阅读量613

点赞数 18

CC 4.0 BY-SA版权

文章标签： java 开发语言

本文链接：https://blog.youkuaiyun.com/SOS_suyan/article/details/142786872

继承：extends

本质：
1. 子类能够调用父类的方法和变量
2. 类只能单击成，不可多继承，但是可以间接继承
作用：
1. 减少代码量，定义简单化
2. 已经在一个类当中写过的代码不需要在另一个类中重复写这些代码，继承该类即可
静态代码块：static{}
1. 优先级比 main 方法高
2. 目的：修饰 main 方法
缺点：
1. java 只支持单继承，父类的代码不一定完全适合子类，这时子类就会对父类的方法重写
类的加载顺序：
1. 先加载继承的父类，再加载子类，先创建父类的对象，再创建子类的对象
2. 加载子类构造器时，先加父类的构造器
  1. 在任何一个类当中都有一个默认的不显示的无参构造器
  2. 一旦这个类定义了其他构造器，则默认不显示的无参构造器就会被覆盖
3. 当父类构造器需要接收值时，需要使用 super() 关键字给父类构造器传参
  1. super 关键字只能在构造器中使用
  2. super 关键字必须在构造器的第一行
  3. 如果父类有多个构造器，子类需要在父类中选择一个执行

public class Test extends Animal {

    static {
        System.out.println("子类静态代码块");
    }
    public Test(){
        super("猫");
        System.out.println("测试类");
    }

    public static void main(String[] args) {
        Test t = new Test();
        t.run();
    }

}
class Animal{
    
    static {
        System.out.println("父类静态代码块");
    }
    public Animal(String name){
        System.out.println("名称:" + name);
    }

    public void run(){
        System.out.println("我会跑");
    }
}

/*** 步骤:
 * 1.Base 先进入方法区，然后发现 Base 类中有 static代码块,首先执行 static 代码块
 * 2.Test 类被加载进方法区,然后发现 Test 类有 static 代码块，执行 static 代码块
 * 3.main 方法入栈,执行 Test() 构造器创建对象,但是 Test 类创建对象之前必须先创建父类对象,Test() 构造器优先调用了 Base() 类中的构造器
 * 4.父类对象创建完毕，然后创建子类对象，子类对象就可以调用父类中的方法和变量
 */

方法的重载和重写：

重写：

在父类中，子类重写了父类的方法(方法返回值和签名一致)
子类重写父类的方法
子类对象最终调用的也是子类重写后的方法

public class Test extends Animal {

    public Test(){
        super("猫");
    }
    
    public void run(){        //方法的重写：子类中方法会覆盖父类中的同名方法
        System.out.println("都会跑");
    }

    public static void main(String[] args) {
        Test t = new Test();
        t.run();
    }

}
class Animal{
    
    public Animal(String name){
        System.out.println("名称:" + name);
    }

    public void run(){
        System.out.println("跑");
    }
}

重载：

在同一个类当中，方法的名称和形参不能一致(签名不一致)，返回值可不同

public class Test{
    public void run(){
    
    }


    public int run(int a){    //方法的重载:签名不能一致
         return a;
    }
    
    public void run(String  a,int b){    //签名不能一致
       
    }
}

多态：

父类的引用指向了子类的对象

多态实现条件：

必须有继承

class Animal {

    public void run(){
        System.out.println("动物都会跑");
    }
}

class Cat extends Animal{
    
    Animal a = new Cat();  //多态形式创建对象
}

当父类中的方法被子类从写时，父类的方法会被子类的方法覆盖，执行的是被重写后的逻辑

public class Test {
    public static void main(String[] args) {
        Animal a = new Cat();   //多态创建对象


        a.run();    // run() 方法被子类重写,调用父类中的 run() 方法执行的是子类逻辑
        //输出：猫会跑
    }

}


class Animal {

    public void run(){
        System.out.println("动物都会跑");
    }
}

class Cat extends Animal{
    public void run(){
        System.out.println("猫会跑");
    }
}

向上转型：子类的对象可以当成参数转为父类

public class Test {
    public static void main(String[] args) {
        A a = new A();
        B b = new B();

        a.show(b);
        /***
         *   在 a 对象里传入一个 B 类型对象，就会在 a 对象里寻找 show 方法的形参为 B 类型的 show方法
         *   第一次在 a 对象里没有找到对应的方法, 此时实参 B 类型数据向自己父类转型 转为 A 类型数据继续从 a 对象里寻找匹配的方法
         *   此时匹配到第二个 show 方法，输出: A and A
         */
    }
}

class A{
    public void show(D obj){
        System.out.println("A and D");
    }
    public void show(A obj){
        System.out.println("A and A");
    }
}

class B extends A{
    @Override
    public void show(A obj) {
        super.show(obj);
    }
}

class D extends B{

}

位运算和移位运算：

数值类型的数据：
1. byte：1bit 符号位 7bit 数值位
2. short：1bit 符号位 15bit 数值位
3. int：1 bit 符号位 31bit 数值为
4. long：1bit 符号位 63bit 数值位
5. float：1bit 符号位 8bit 数值位 23bit 数值位
6. double：1bit 符号位 11bit 阶位 52bit 数值位
数据的存储：
1. 计算机中不会存储源码，因为两个相反数相加不是 0
2. 计算机中也不会存储反码，因为两个相反数相加存在正负 0 的问题
3. 计算机中存储的是补码
反码：
1. 正数：原反补码一致
2. 负数：符号位不变，其余位按位取反
补码：
1. 正数：原反补码一致
2. 负数：源码取反加一即可