继承和多态(上)

举一个简单的例子，我们可以认为动物是一个父类，然后猫猫狗狗，牛牛羊羊等是子类。这些猫狗牛羊都拥有一些相同的共性，比如：要睡觉，要吃饭，能跑等等，这些就是通用的属性或方法，然后子类继承父类，子类能够直接使用这些功能，也可以重写该功能(睡觉，吃饭，跑等等)，当然这些子类比如说狗，他可以在自己的类中拓展他自己本身有用的独一无二的技能，比如说狗叫汪汪汪等。

2.继承的语法

我们在java中如果想要表示类之间的继承关系的话，需要用到extends关键字，在想要成为子类的类名右旁加上extends 和父类类名。

修饰符 class 子类 extends 父类 {

// ...

}

举一个具体例子，按照上面的例子来写:

//Animal类

public class Animal {
    int age;
    String name;
    public void eat(){
        System.out.println(name+"正在吃饭...");
    }
    public void run(){
        System.out.println(name+"正在跑...");
    }
}

--------------------------------------------------
//Dog类

public class Dog extends Animal{
    //构造方法
    public Dog() {
        super();
        this.name="旺财";
        this.age=2;
    }

    public void bark(){
        System.out.println(name+"正在狗叫...");
    }
}

--------------------------------------------------
//Cat类
public class Cat extends Animal{
    //构造方法
    public Cat() {
        super();
        this.name="咪咪";
        this.age=1;
    }

    public void mew(){
        System.out.println(name+"正在猫叫...");
    }
}

---------------------------------------------------
//测试类
public class Test {
    public static void main(String[] args) {

        Dog dog=new Dog();
        System.out.println(dog.name);
        System.out.println(dog.age);
        dog.bark();
        dog.eat();
        dog.run();

        Cat cat=new Cat();
        System.out.println(cat.name);
        System.out.println(cat.age);
        cat.mew();
        cat.eat();
        cat.run();
    }
}

输出结果为:

在代码中测试类我们定义了一个Dog类型的dog对象,可以看到我们可以输出dog.name，dog.age，当然还有方法eat()，run()，这些成员变量和方法Dog类中都没有，但是继承了Animal类后就可以直接使用了，我们在构造方法那里其实就能看出来了。当然Cat类也是如此。

注意:

继承机制使得子类能够“继承”父类的属性和方法，即子类自动拥有父类中的变量和方法，不需要重新定义。

3.子类访问父类

(1)子类访问父类的成员变量

·当子类成员变量与父类成员变量同名时,优先访问自己的，也就是子类的。（无论类型相同与否）

·当子类和父类都没有定义某个成员变量时，就会编译错误。

·当子类成员变量与父类成员变量不同名时，则会根据情况访问子类或者父类的。

举个例子:

//父类Test
public class Test {
   static String name = "haha";
    static int a=66;
    static int b=77;
    static String d="父类d";
}



-------------------------------------
//子类Demo
public class Demo extends Test{
    static int a=67;  //与父类同名同类型
    static int c=88;  //父类没定义该变量

    static int d=10;  //与父类同名但是不同类型

    public static void main(String[] args) {
        System.out.println(a); //输出67  访问的子类
        System.out.println(b); //输出77  访问的父类
        System.out.println(name); //输出haha  //访问的父类
        System.out.println(c); //输出88  //访问的子类
        System.out.println(d); //输出10  //访问的子类
//        System.out.println(e); //编译错误:父类和子类都没定义d

    }
}

输出结果:

(2)子类访问的父类方法

子类访问父类的方法分两种情况：

1.方法有参数的情况。

(1)当子类和父类的方法同名但是参数一个有一个无时，如果子类调用有参数的方法，则系统就会自动识别执行有参数的方法，如果调用无参数的方法，那么系统就会执行无参数的方法（无论子类或者父类）。

(2)如果子类父类都有参数且方法同名，系统会根据参数的多少或者类别自动识别并且执行。

2.方法无参数的情况。

(1)子类和父类方法同名都无参时，则会优先执行子类的方法。

注意:成员方法没有同名时，在子类方法中或者通过子类对象访问方法时，则优先访问自己的，自己没有时再到父类中找，如果父类中也没有则报错。

举个例子:

//父类Test
public class Test {

   public void methodA(){
       System.out.println("调用父类的方法A");
   }
   public void methodB(String str){
       System.out.println("调用父类的方法B:"+str);
   }
   public void methodC(){
       System.out.println("调用父类的方法C");
   }
}

------------------------------------------------------

//子类Demo
public class Demo extends Test{
    //跟父类的方法A同名且无参数
    public void methodA(){
        System.out.println("调用子类的方法A");
    }
    //跟父类的方法B同名但是参数不同
    public void methodB(int a){
        System.out.println("调用子类的方法B:"+a);
    }
    //跟父类的方法C同名但是参数一个有一个无
    public void methodC(int c){
        System.out.println("调用子类的方法C:"+c);
    }

    public static void main(String[] args) {
        Demo demo=new Demo();
        demo.methodA();  //调用子类的方法A
        demo.methodB("hello");  //调用父类的方法B:hello
        demo.methodB(10);  //调用子类的方法AB:10
        demo.methodC();  //调用父类的方法C
        demo.methodC(12);  //调用子类的方法C:12

    }
}

输出结果:

二.super关键字

在子类中，super提供了一种方式，能够直接访问父类被重写的方法、父类的属性，以及父类的构造方法。

注意事项：

必须在子类构造方法的第一行调用父类构造方法：如果需要使用super调用父类的构造方法，它必须是子类构造方法的第一个语句。如果子类构造方法没有显式调用super()，则默认调用父类的无参构造方法。
不能在静态上下文中使用super：super关键字仅用于实例方法或构造方法中，不能在静态方法或静态代码块中使用，因为静态方法不属于任何实例对象。

`1.super`用于调用父类的构造方法

在子类的构造方法中，可以通过super关键字来调用父类的构造方法。这在需要初始化父类部分的属性或做一些父类构造的工作时非常有用。如果没有明确使用super调用父类构造方法，系统会默认调用父类的无参构造方法（如果存在）。

class Animal {
    Animal(String name) {
        System.out.println("Animal构造方法: " + name);
    }
}

class Dog extends Animal {
    Dog(String name) {
        super(name); // 调用父类构造方法
        System.out.println("Dog构造方法");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog("Buddy");
    }
}

输出结果:

代码解释:在这个例子中，super(name);调用了Animal类的构造方法，从而完成了父类的初始化工作。

2.`super`用于调用父类的实例方法

在子类中，可以使用super关键字来调用父类的实例方法，尤其是在子类中重写了该方法的情况下。此时super关键字帮助子类调用到父类版本的实现，避免因方法重写而无法访问原方法。

class Animal {
    void sound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    @Override
    void sound() {
        super.sound(); // 调用父类的 sound 方法
        System.out.println("Dog barks");
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.sound();
    }
}

输出结果:

代码解释:在这个例子中，super.sound()调用了Animal类的sound方法，而后才执行子类Dog的sound方法。这种情况在需要在重写方法中保留父类的一部分行为时非常有用。

3.`super`用于访问父类的实例变量

当子类中有与父类同名的实例变量时，可以使用super来区分和访问父类中的变量。这样做可以避免子类中覆盖父类的变量。

class Animal {
    String name = "Animal";
}

class Dog extends Animal {
    String name = "Dog";

    void printNames() {
        System.out.println(super.name); // 输出父类的 name 属性
        System.out.println(this.name);  // 输出子类的 name 属性
    }
}

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.printNames();
    }
}

输出结果：

代码解释:在这个例子中，super.name用于访问父类Animal中的name属性，而this.name访问的是子类Dog中的name属性。

三.子父类构造方法和代码块的执行优先顺序

直接上例子，简单记一下就行:

//1、父类静态代码块优先于子类静态代码块执行，且是最早执行
//2、父类实例代码块和父类构造方法紧接着执行
//3、子类的实例代码块和子类构造方法紧接着再执行
//4、第二次实例化子类对象时，父类和子类的静态代码块都将不会再执行
class Person{
    public Person(){
        System.out.println("Person父类构造方法执行");
    }
    {
        System.out.println("Person父类实例代码块执行");
    }
    static {
        System.out.println("Person父类静态代码块执行");
    }
}
public class Student extends Person{
    public Student(){
        System.out.println("Student子类构造方法执行");
    }
    {
        System.out.println("Student子类实例代码块执行");
    }
    static {
        System.out.println("Student子类静态代码块执行");
    }

    public static void main(String[] args) {
        Student stu=new Student();
        System.out.println("===================");
        Student stu1=new Student();
    }
}

输出结果：

三.继承总结

1. 单继承

Java中一个类只能直接继承自一个父类，这种机制称为单继承。

如下:

class Animal {
    // 父类代码
}

class Dog extends Animal {
    // Dog类继承了Animal类
}

2. 多层继承

Java支持多层继承，即一个类可以继承另一个类，而这个类本身又可以继承另一个类。

如下:

class Animal {
    // 父类代码
}

class Mammal extends Animal {
    // Mammal继承Animal
}

class Dog extends Mammal {
    // Dog继承Mammal，也间接继承了Animal
}

3.多个子类继承同一个父类

Java中允许多个不同的类继承同一个父类，这称为多对一继承。

class Animal {
    // 父类代码
}

class Mammal extends Animal {
    // Mammal继承Animal
}

class Dog extends Animal {
    // Dog继承Animal
}

Java中不支持的继承类型：多重继承

Java明确不支持类的多重继承，即一个类不能继承多个父类。

class Animal {}
class Mammal {}
class Dog extends Animal, Mammal {} // 错误

原文地址：https://blog.csdn.net/2202_75357702/article/details/143746554

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：stm32使用cJSON_Print返回空
下一篇：不用来回切换，一个界面管理多个微信

[产品管理-85]：《产品经理从入门到精通》- 创业公司的产品经理
目录一、概述1、创业公司产品经理的角色与定位2、创业公司产品经理的核心能力3、创业公司产品经理的实战技巧4、创业公司产品经理的挑战与应对策略二、创业公司的产品经理与大公司产品经理的比较1、工作环境与资
阅读更多2024-11-18
《TCP/IP网络编程》学习笔记 | Chapter 13：多种 I/O 函数
《TCP/IP网络编程》学习笔记 | Chapter 13：多种 I/O 函数
阅读更多2024-11-18
解决IntelliJ IDEA的Plugins无法访问Marketplace去下载插件
勾选并填入代理URL，可以先做检查连接：
阅读更多2024-11-18
STM32读写内部FLASH
本文是学习野火的指南针开发板过程的学习笔记，可能有误，详细请看B站野火官方配套视频教程（这个教程真的讲的很详细，请给官方三连吧）在STM32芯片内部有一个FLASH存储器，它主要用于存储代码，我们在电
阅读更多2024-11-18
【STM32】基于SPI协议读写SD，详解！
因为项目需要，使用stm32读写sd卡，这一块网上的资料很多，但是比较杂乱。有些是不能跑，有些是代码可以跑，但是相关的注释或者配置方法、流程不够清晰明确，于是花了几天时间，研究了几个成功案例之后，总结
阅读更多2024-11-18
Java基础（9）本地API
哈喽大家好啊，Java基础的学习马上就要告一段落了，今儿分享的是一些Java常用的本地API，让我们开始吧。
阅读更多2024-11-18
Spring gateway 路由配置在数据库
#spring gateway ServerRoute实体类。##spring gateway 查询动态路由mapper。##Spring gateway 动态路由Service。##spring g
阅读更多2024-11-18
i春秋-FUZZ（python模板注入、base64编码命令执行）
i春秋-FUZZ（python模板注入、base64编码命令执行）
阅读更多2024-11-18
Spring 4.3 源码导读
Spring 4 是一个功能强大的 Java 应用程序框架，广泛用于企业级应用开发。理解其核心代码有助于开发者更好地使用和优化 Spring 框架。
阅读更多2024-11-18
【Rabbitmq篇】RabbitMQ⾼级特性----消息确认
介绍RabbitMQ⾼级特性----消息确认
阅读更多2024-11-18

继承和多态(上)

一.继承

1.何为继承

2.继承的语法

3.子类访问父类

(1)子类访问父类的成员变量

(2)子类访问的父类方法

二.super关键字

1.super用于调用父类的构造方法

2.super用于调用父类的实例方法

3.super用于访问父类的实例变量

三.子父类构造方法 和代码块的执行优先顺序

三.继承总结

1. 单继承

2. 多层继承

3.多个子类继承同一个父类

相关文章

`1.super`用于调用父类的构造方法

2.`super`用于调用父类的实例方法

3.`super`用于访问父类的实例变量

三.子父类构造方法和代码块的执行优先顺序