Java继承和多态

最新推荐文章于 2024-11-22 14:13:02 发布
最新推荐文章于 2024-11-22 14:13:02 发布
阅读量66 收藏
点赞数
分类专栏： Java 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_58843717/article/details/134551399
版权

文章目录

继承

成员继承
class Animal{
    public String name;
    public int age;

    public int a=10;
    public void doSomething(){
        System.out.println("Animal do something!");
    }
    public void eat(){
        System.out.println("Animal eat!");
    }
}
//java中只能是单继承,也就是说只能继承一个类
class Dog extends Animal{//继承关键字

    int a=20;
    public void func(){
        System.out.println("a:"+a);//当子类和父类的成员变量冲突时,优先访问自己的
        System.out.println("base a:"+super.a);//就是想访问基类的,用Super
        //super只是一个关键字,并不是父类的引用,因为并没有实例化对象
        //只是提供一种功能,就是在子类中访问父类的成员变量/方法
        //只能指代父类,不能指代爷爷类
    }
    //this 和super都是和对象相关的,所以无法在静态方法中使用
//    public static void func2(){
//        System.out.println(super.a);//error
//        System.out.println(this.a);//error
//    }
    @Override
    public void doSomething(){//子类对父类函数发生重写
        System.out.println("狗,汪汪叫!");
    }
    public void eat(){//构成对父类的隐藏:其实就是优先访问自己的
        System.out.println("Dog eat!");
    }
    public void eat(int x){//和eat参数列表不同构成重载.既和子类的构成重载,和父类的也构成重载.继承下来的也认为是一个作用域
        System.out.println(x+ "Dog eat!");
    }
}
class Cat extends Animal{

}
public class inherit {//继承

    public static void main(String[] args) {
        Dog dog =new Dog();
        dog.name="狗";
        dog.age=22;
        Cat cat=new Cat();
        cat.age=10;
        cat.name="猫";

        dog.eat();
        dog.eat(2);

        Animal a1= new Animal();
        a1.doSomething();
        //父类的引用调用子类发生重写的函数,构成多态
        Animal a2 =new Dog();
        a2.doSomething();

        dog.func();
    }
}
构造方法
class Base{
    public String name;
    public int age;
    public Base(){//提供默认构造函数之后才行
    }
    public Base(String name,int a ) {//当只提供这个构造函数时,子类无法创建
        this.name = name;
        this.age=a;
    }
}
class Derive extends Base{
}

class C{
    public String name;
    public int age;
    public C(String name,int a ) {//当只提供这个构造函数时,子类无法创建
        this.name = name;
        this.age=a;
    }
}
class D extends C{
    public D(String name,int age){
        super(name,age);//并没有在这里构造一个父类对象,只是将继承下来的成员变量进行初始化
//        super("yuanwei",22);//显示的调用父类构造函数,帮助父类成员完成初始化
    }
}

class E extends C{
    int e=0;
    public E(String name,int age){
        super(name,age);//一定要先帮助父类初始化
        e=20;
    }
    public E(String name,int age,int e){
        super(name,age);
//        this(name,age,e);//this 和super顺序无法确定,所以在调用构造方法时不能同时出现
    }
}

class G{
    
}
class H extends G{
    //什么都不写,编译器默认生成如下代码
    public H(){
        super();//调用父类自动生成的构造函数
    }
}
super和this的区别

super和this都可以在成员方法中用来访问,

成员变量和调用其他的成员函数都可以作为构造方法的第一条语句

  • 那他们之间有什么区别呢?

[相同点]

1.都是]ava中的关键字
2.只能在类的非静态方法中使用，用来访问非静态成员方法和字段
3.在构造方法中调用时，必须是构造方法中的第一条语句，并且不能同时存在

[不同点]

1.this是当前对象的引用，当前对象即调用实例方法的对象，super相当于是子类对象中从父类继承下来部分员的引用

2.在非静态成员方法中，this用来访问本类的方法和属性，super用来访问父类继承下来的方法和属性

3.在构造方法中: this(…)用于调用本类构造方法，super(…)用于调用父类构造方法，两种调用不能同时在构造方法中出现

4.构造方法中一定会存在super(…)的调用，用户没有写编译器也会增加，但是this(…)用户不写则没有.

代码块构造顺序
class Y{
    static{
        System.out.println("Y : static 静态代码块");
    }
    {
        System.out.println("Y: 非静态代码块");
    }
    Y() {
        System.out.println("Y : 不带参数的构造函数");
    }
}
class W extends Y{
    static{
        System.out.println("W : static 静态代码块");
    }
    {
        System.out.println("W: 非静态代码块");
    }
    W() {
        System.out.println("W : 不带参数的构造函数");
    }

    public static void main(String[] args) {
        W w=new W();
        //Y : static 静态代码块
        //W : static 静态代码块
        //Y: 非静态代码块
        //Y : 不带参数的构造函数
        //W: 非静态代码块
        //W : 不带参数的构造函数
        System.out.println("==============");
        W w1=new W();
        //Y: 非静态代码块
        //Y : 不带参数的构造函数
        //W: 非静态代码块
        //W : 不带参数的构造函数
    }
}
  • 先静态,先父类静态再子类静态.再父类实例和构造函数,子类实例和构造函数
  • 静态每一个类,只会执行一次
限定修饰符

protected: 不同包的子类可以使用

default:同一包中不同的类可以使用

private: 修饰只能在同一个类中才能访问

image-20231020155538822

class V{
    private String name;
    public void func(){
        System.out.println(name);
    }
}
class N extends V{
    public static void main(String[] args) {
//        System.out.println(name);//error
        //private修饰的name已经被继承了,但是不可见. 因为private修饰只能在同一个类中才能访问
    }
}
final
//继承的深度可能很深,为了避免深度过深,当不想某一个类被继承时 ,使用final关键字
class a{
    public final int b=20;//成员变量定义为final一定要给定初始值
}
class b extends a{
    public static void main(String[] args) {
        final int[] array={1,2,3,4,5};
        
        array[0]=10;
//        array =new int[4]{2,3,4,5};//Cannot assign a value to final variable 'array'
        //array指向的对象是不能改变的
    }
}
final class c extends b{//不想让C被继承

    public static void main(String[] args) {
        final int A=10;
//        A=20;//error不想让A 被修改,那就是常量,建议大写变量名
        System.out.println(A);
    }
}
//class d extends c{//error
//
//}
继承和组合

是一种代码实现方式,设计思想. a part of ; has a 的关系.

降低不同类耦合度.

奔驰是一辆车

奔驰有轮胎,座椅,车架子这些类.

多态

同一件事情,发生在不同对象的身上,呈现出不同的状态.

  • 子类对父类对象中方法重写
  • 父类引用调用子类对象
向上转型
  • 子类对象给父类,使得父类引用指向了子类对象.
  • 因为父子类继承关系,所以可以实现不同类型对象之间的赋值.
  • 当发生向上转型之后,父类的引用,只能,访问父类自己的成员,不能访问子类所特有的成员.

class Animal {
    public String name;

    public void eat(){
        System.out.println(name+" 吃!");
    }
}
class Bird extends Animal {
    public String swing="翅膀";
    public void fly(){
        System.out.println(name+" 用 "+swing+" 飞 ");
    }
}
class Pig extends Animal{
    public int iq=1000;
    public void poll(){
        System.out.println(name + " 的iq是 "+iq);
    }
}

public class PolyCode {
    //返回值统一
        public static Animal func2(){
        Bird bird = new Bird();
        bird.name="鸟";
        Pig pig=new Pig();
        pig.name="猪";
        
        return pig;
    }
    //函数传参中的向上转型
    public static void  func(Animal animal){//使用父类引用进行接收子类对象,也是一种向上转型
        System.out.println(animal.name);
    }
    public static void main(String[] args) {
        Bird bird = new Bird();
        bird.name="鸟";
        func(bird);
        Pig pig=new Pig();
        pig.name="猪";
        func(pig);
        //鸟
        //猪
    }
    //直接接收
    public static void main1(String[] args) {
        Animal a=new Animal();
        a.name="动物基类";
        a.eat();
        System.out.println("=================");
        Animal a2=new Pig();
        a2.name="猪";
        a2.eat();

        ((Pig) a2).poll();//这么写可以,但是不建议
//        a2.poll();//error,子类中包含父类中没有的方法和属性
        
        System.out.println("=================");
        Animal a3 = new Bird();
        a3.name="鸟";
        a3.eat();

        ((Bird) a3).fly();
        //动物基类 吃!
        //=================
        //猪 吃!
        //猪 的iq是 1000
        //=================
        //鸟 吃!
        //鸟 用 翅膀 飞
    }
}
重写

需要满足三同: 函数名相同,参数列表相同,返回值相同.

class Animal {
    public String name;

    public void eat(){
        System.out.println(name+" 吃!");
    }
}
class Bird extends Animal {
    public String swing="翅膀";

    @Override
    public void eat(){
        System.out.println(name+" 吃!");
    }
}
class Pig extends Animal{
    public int iq=1000;
    @Override
    public void eat(){
        System.out.println(name+" 吃!");
    }
}
public class PolyCode {

    public static void main(String[] args) {
        Animal a=new Animal();
        a.name="动物基类";
        a.eat();
        System.out.println("=================");
        Animal a2=new Pig();
        a2.name="猪";
        a2.eat();

        System.out.println("=================");
        Animal a3 = new Bird();
        a3.name="鸟";
        a3.eat();
        
        //动物基类 吃!
        //=================
        //猪 吃!
        //=================
        //鸟 吃!
    }
}
动态绑定

image-20231021201204625

在编译时发现是没有变化的,每个类的函数都会被确定执行地址.只有在运行时才会根据类型的不同,实现函数地址覆盖,然后调用.

import javafx.scene.image.PixelFormat;
class Animal {
    public String name;

    public void eat(){
        System.out.println(name+" 吃!");
    }
}
class Bird extends Animal {
    public String swing="翅膀";

    @Override
    public void eat(){
        System.out.println(name+" 吃!");
    }
}
class Pig extends Animal{
    public int iq=1000;
    @Override
    public void eat(){
        System.out.println(name+" 吃!");
    }
}
public class PolyCode {
    //多态: 当父类引用的对象不同时,表现出来的行为是不一样的
    public static void function(Animal animal){
        animal.eat();
    }

    public static void main(String[] args) {
        Animal a=new Animal();
        a.name="动物基类";
        function(a);

        System.out.println("=================");
        Animal a2=new Pig();
        a2.name="猪";
        function(a2);

        System.out.println("=================");
        Animal a3 = new Bird();
        a3.name="鸟";
        function(a3);
    }
重写注意事项

  1. private修饰的函数是不能被重写的

  2. static修饰的不能被重写.这个方法属于这个类不属于某个对象

  3. 子类的访问修饰限定权限要>=父类的.

    private<default<protected<public

  4. 被final修饰的方法是不能被重写的.此时这个方法被称为密封方法.

向下转型

子类引用指向父类对象.

非常的不安全,只能骗过编译器,但是运行时会出现问题

import javafx.scene.image.PixelFormat;
class Animal {
    public String name;

    public void eat(){
        System.out.println(name+" 吃!");
    }
}
class Bird extends Animal {
    public String swing="翅膀";

    @Override
    public void eat(){
        System.out.println(name+" 吃!");
    }
}
class Pig extends Animal{
    public int iq=1000;
    @Override
    public void eat(){
        System.out.println(name+" 吃!");
    }

    public void poll(){
        System.out.println(name + " 的iq是 "+iq);
    }
}
public class PolyCode {
    //向下转型: 所有的动物一定都是猪吗?
    public static void main(String[] args) {
        Animal animal =new Bird();
        //1.
        Pig pig =(Pig) animal;
        pig.poll();//terminal animal最开始是Bird的引用,又强转为pig,Bird中没有poll方法
        //2.
        //需要通过instanceof关键字判断animal是否真的引用一个pig对象
        if(animal instanceof Pig){
            Pig pig2 = (Pig)animal;
            pig2.poll();
        }
    }
}
多态优点
  1. 降低圈复杂度,避免使用大量的if-else判断语句.
  2. 父类类型数组可以存放子类的对象.
import javafx.scene.image.PixelFormat;
class Shape{
    public String name;
    public void drawShape(){
        System.out.println("画");
    }
}
class Circle extends Shape{
    public void drawShape(){
        System.out.println("画圆");
    }
}
class Rect extends Shape{
    public void drawShape(){
        System.out.println("画矩形");
    }
}
class Flower extends Shape{
    public void drawShape(){
        System.out.println("画花");
    }
}
public class PolyCode {
    public static void draw(){
        Rect rect=new Rect();
        Circle circle =new Circle();
        Flower flower =new Flower();
        
        //此处发生向上转型
        Shape[] shape = new Shape[]{rect,circle,flower};
        for(Shape e: shape){
            e.drawShape();
        }
        //画矩形
        //画圆
        //画花
    }
    public static void main(String[] args) {
        draw();
    }
}
注意
  1. 避免在构造方法中调用重写方法

当在父类中的构造方法中,调用父类和子类发生重写的 方法时,会调用子类的.

导致父类构造函数都没走完,父类对象都没有初始化完成,自然子类对象也没有初始化完成,所有的成员都是默认值.

import javafx.scene.image.PixelFormat;
//-------------避免在构造函数中调用重写函数
class B{
    public B(){
        func();
    }
    public void func(){
        System.out.println("B::func()");
    }
}
class D extends B{
    private int num=1;
    //默认调用B类的构造函数
//    D(){
//        super();
//    }
    
    public void func(){
        System.out.println("D::func()");
        System.out.println("B.num = "+num);
    }
}

public class PolyCode{
    public static void main(String[] args) {
        D d=new D();
        //D::func()
        //B.num = 0
    }
}
喜羊羊真聪明
关注
专栏目录
【Java基础知识 17】Java继承和多态
学Java，找哪吒
11-18 7375
关键字extends表明正在构造的新类派生于一个已存在的类。已存在的类称为超类(superclass)，新类称为子类（subclass)。超类和子类是 Java 程序员最常用的两个术语。在设计类的时候，应该将通用的方法放在超类中， 而将具有特殊用途的方法放在子类中。
JAVA继承和多态
Excuse_lighttime的博客
10-19 879
JAVA继承和多态
java继承和多态
m0_62520968的博客
04-28 515
Java 中子类继承父类的语法格式如下： 修饰符 class class_name extends extend_class { // 类的主体 } 其中，class_name 表示子类（派生类）的名称；extend_class 表示父类（基类）的名称 在 Java 中，所有的继承都是公有继承 类的继承不改变类成员的访问权限，也就是说，如果父类的成员是公有的、被保护的或默认的，它.
Java继承和多态（多态）
daweidi的博客
04-27 861
因此，在进行向下转型时，最好先使用instanceof运算符来判断对象是否是指定的子类类型，以避免异常的发生。当调用被重载的方法时，Java编译器会根据传入的参数类型或个数选择合适的方法进行调用。上述代码中，父类是Animal，子类是Cat，Cat中的eat方法对Animal中的eat方法进行了方法的重写。将一个子类对象经过向上转型之后当成父类方法使用，再无法调用子类的方法，但有时候可能需要调用子类特有的 方法，此时：将父类引用再还原为子类对象即可，即向下转换。向上转型的缺陷：不能调用到子类特有的方法。
学习-Java继承和多态之abstract类
千浔的博客
04-23 1914
本关任务：根据所学知识，完成抽象类的定义与使用。
Java继承和多态之final关键字
n9102的博客
05-11 1009
例如，Java 类库中的 String类，它对编译器和解释器的正常运行有着很重要的作用，不能轻易改变它，因此把它修饰为 final 类，使它不能被继承，这就保证了 String 类的惟一性。同时，如果你认为一个类的定义己经很完美，不需要再生成它的子类，这时也应把它修饰为 final 类。用 final 修饰的方法为最终方法，不能再被子类重写，可以被重载。2. final 关键字修饰类、成员变量和成员方法。变量被声明为 final 后，成为常值变量(即常量)，一旦被通过某种方式初始化或赋值，即不能再被修改。
Java继承和多态之方法重写
n9102的博客
05-11 342
在子类中如果创建了一个与父类中相同名称、相同返回值类型、相同参数列表的方法，只是方法体中的内容不同，以实现不同于父类的功能，这种方式被称为方法重写（override），又称为方法覆盖。返回的类型必须与被重写的方法的返回类型相同（Java1.5 版本之前返回值类型必须一样，之后的 Java 版本放宽了限制，返回值类型必须小于或者等于父类方法的返回值类型）；子类和父类在同一个包中时，子类可以重写父类的所有方法，除了声明为 private 和 final 的方法；父类的成员方法只能被它的子类重写；
JAVA继承和多态详细讲解
weixin_45536242的博客
07-08 3368
面向对象编程的重要知识：继承和多态。通过类的继承机制，可以使用已有的类为基础派生出新类，无需编写重复的程序代码，很好地实现程序代码复用。多态是面向对象编程中继封装和继承之后的另一大特征，它具体是指同一个行为具有多个不同表现形式或形态的能力。使用多态机制，可以提高程序的抽象程度和简洁性，最大程度地降低类和程序模块间的耦合性，并提高程序的可扩展性和可维护性。从Java语言的底层逻辑上看，封装和继承是为实现多态做准备的。6.1 类的继承继承描述了类的所属关系，多个类通过继承可形成一个关系体系，进而在原有类的基础上
练习-Java继承和多态之方法重载
千浔的博客
04-22 1050
第1关：练习-Java继承和多态之方法重载。
java继承和多态PPT教案学习.pptx
09-30
Java继承和多态PPT教案学习 本PPT教案主要讲解了Java中的继承和多态机制，包括继承、里式代换原则、多态和动态绑定、方法重载、重载构造函数和方法覆盖等概念。 继承是面向对象编程的基本机制之一，允许一个类继承...
Educoder题目：Java面向对象 - 封装、继承和多态的综合练习答案解析.md
11-09
Educoder题目：Java面向对象 - 封装、继承和多态的综合练习答案解析
java学习资料-Java继承和多态
06-14
在Java中，多态分为编译时多态和运行时多态。编译时多态主要通过方法重载实现，运行时多态主要通过方法重写（Override）和接口实现实现。 **2. 方法重写** 当子类继承父类并覆盖（Override）父类的某个方法时，这...
springboot基于大数据技术的电影推荐系统的设计与实现
qq_1744828575的博客
11-21 610
该系统综合运用了数据挖掘、机器学习和用户行为分析等先进技术，不仅能够实时监控用户的观影习惯和偏好，还能学习用户的历史互动，如评分、评论及搜索历史，以动态调整推荐算法。管理员通过强大的后台管理功能，维护电影信息库，优化用户体验，并保障系统的高效运行。这样的系统不仅极大地丰富了用户的娱乐体验，也为电影产业的市场营销提供了数据支持，开辟了新的商业价值途径。按照软件工程的流程来说，在系统的详细设计与实现阶段，要把模块、视图、模板进行相应的组合完成一个个所需的功能，此章将会把设计中模块一一说明如何设计和实现的。
JVM参数总结
Mr.W的博客
11-20 978
在本篇文章中，你将掌握最常用的 JVM 参数配置。
Java多线程简介
qq_45721579的博客
11-20 952
线程作为能够将服务器资源利用率发挥到极致的关键元素，对于现代 Java 开发而言，深入了解和掌握线程是不可或缺的技能之一。在本章节中，我们重点介绍了线程的基本使用方式、常用参数以及常用方法，并透过案例讨论了多线程可能导致的并发安全问题以及产生这些问题的原因。这一深入探讨为后续学习奠定了基础。虽然线程的使用可以提升服务器资源利用率，但若使用不当、控制不得当，就可能导致系统出现严重问题。在下一节中，我们将详细探讨如何合理、高效、安全地使用线程，以确保系统的稳定性和性能表现。
JavaSE——变量
qq_55890817的博客
11-21 389
在编程中，变量是存储数据值的容器，不管是那种高级语言，变量都是程序的基本组成单位。变量相当于内存中一个数据存储空间的表示，你可以把变量看做是一个房间的门牌号，通过门牌号可以找到房间，而通过变量名可以访问到这个存储空间中的数据。
ssm基于bs的企业合同管理系统
最新发布
wqq_992250277的博客
11-22 443
企业合同管理系统是一种旨在帮助企业高效管理各类合同的软件工具。该系统能够实现合同的电子化存储、快速检索和版本控制，简化审批流程。通过这一系统，企业能够确保合同执行的合规性，降低法律风险，同时提升工作效率和管理水平。系统利用Java语言和ssm框架，结合目前流行的 B/S架构，数据库使用免费的高性能MySQL数据库作为后端数据库，系统选择Windows操作系统。实现客户、公告信息、项目信息、合同信息、部门信息、合同类型、我的信息等功能。面向用户群体，分为管理员和员工两个角色，针对不同的用户划分不同的管理权限。
ubuntu22.04 android studio老卡
yudelian的博客
11-19 213
通过ubuntu软件中心安装android studio 2024.1.1版本的一直卡,设置的内存都到6M了。一搜代码，就卡死不动，查看top，java的cpu都占到了1100%还是卡，我这边一直是引入android系统源码来看代码的。然后暂时用的还行，top的java是112%，用用再看吧。猜想是版本太新的原因，现在是2024.11.15日。然后下载了2023.2.1的版本，安装后，发现我的。2、稍等会儿会出现下面的条例之类的，往下翻。4、然后就出现下面的版本列表了。1、刚看到是下面这样的。
Java继承和多态机制实验
Java继承与多态 Java编程语言中，继承和多态是两个重要的概念，它们是面向对象编程的基础。继承机制允许一个类继承另一个类的属性和方法，从而实现代码的重用和简化。多态则是指一个对象可以以不同的形式出现，例如...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值