继承

最新推荐文章于 2024-10-09 11:13:12 发布
最新推荐文章于 2024-10-09 11:13:12 发布
阅读量102 收藏
点赞数
分类专栏： java高级 文章标签： java 编程语言 类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/PIONEERRR/article/details/113047682
版权

1.继承

用继承来解决的问题的方法是共性抽取，意思就是解决重复代码
父类和子类，把公共的东西都抽到父类里面，子类直接继承就可以了。

1.1继承关系的特点：

1.子类可以拥有父类的内容
2.子类还可以拥有自己专有的内容
3.子类就是一个父类，子类可以当作父类看待。
4.当父类数组里面放了子类对象，但fu[1].子类方法啥错误了

1.2格式

定义父类的格式： 一个普通的类

定义子类的格式: public class 子类名称 extends 父类名称{ }

1.3父类与子类的方法继承
当我们在父类里面定义一个方法时，子类里面默认有了这个方法。

在父子类的继承关系中，如果成员变量重名，则创建子类对象时，访问有两种方式

            1.直接通过子类对象访问成员变量
              等号左边是谁，那就优先用谁,没有则向上找。（向上找的意思是子类没有的找父类）  用 .

           2. 间接通过成员方法访问成员变量
           该方法属于谁,就优先用谁.(定义在谁下的)，没有则向上找

//父类
public class fu {
    int numfu=100;
    int num=60;
    public void methodfu()
    {
        System.out.println(numfu);
    }
}

//子类
public class zi extends fu {
    int numzi=10;
    int num=50;
    public void methodzi()
    {
        System.out.println(num);
    }
}

//test 测试

public class test {
    public static void main(String[] args) {
        fu fu1=new fu();//父类的对象只能使用父类的东西，没有子类的内容
        System.out.println(fu1.numfu); //100
        zi zi1=new zi();
        System.out.println(zi1.numzi); //10

        System.out.println("============");
   

//等号左边是谁，那就优先用谁，这个等号是指创建对象的类 zi zi1=new zi(); 类是子类的 优先用子类的
        System.out.println(zi1.num);  //50
        
        System.out.println("============");
      //这个方法是子类的，优先用子类的，没有再向上找
        zi1.methodzi();   //50
        //这个方法是父类的当中定义的 ，你能继承使用
        zi1.methodfu();   //100
    }
}

总结：当子类成员方法的名字和父类相同时候，子类的对象优先调用子类同名方法。
在父子类的继承关系中，创建子类对象，访问成员方法的规则
创建的对象是谁，就优先用谁,如果没有则向上找。
无论是成员方法还是成员变量，如果没有都是向上找父类，绝对不会向下找子类的。

1.4
区分子类方法中重名的三种变量

本类的局部变量：直接写
本类的成员变量: this.成员变量名
父类的成员变量：super.成员变量名

public class Fu {
   int num=10;   //父类的成员变量

   public static void main(String[] args)
    {

   }
}

public class Zi extends Fu 
{
    int num=20;  //本类的成员变量
    public void method()
    {
        int num=30; //局部变量
        System.out.println(num);//30
        System.out.println(this.num);//20
        System.out.println(super.num);//10
    }
}
//test调用方法
public class test 
{
    public static void main(String[] args) 
    {
        new Zi().method(); //30 20 10
    }

}

1.5Override(重写)
覆盖重写和重载的区别

    override(重写)
    概念：
    在继承关系中，方法的名称一样，参数列表也一样。

   (override)  覆盖重写：重写方法体
   (overload) 重载： 方法的名称一样，参数列表不一样

1.5.1覆盖重写的注意事项

1.必须保证父子类方法的的名称相同,参数列表也相同。

public class Fu {
@Override
public String method()
{
return null;
}

public class Zi extends Fu {
     @Override
    public Object method()
    {
      return null;
    }
}
//这是错误的。

2.@override,写在方法的前面，用来检测是不是有效的正确覆盖重写。最好每一个覆盖重写方法前面都写一个@Overload

3.子类方法的返回值必须小于等于父类方法的返回值范围。
object类是所有类的公共最高父类(祖宗类) java.lang.String是Object的子类

4.子类方法的权限必须大于等于父类方法的权限修饰符。
public>protected>(default)>private

备注:(default) 不是关键字default，而是什么都不写

1.5.2方法覆盖重写的应用

例子：新手机和旧手机

在这里插入图片描述

//旧手机
public class Phone {
    public void call()
    {
        System.out.println("打电话");
    }
    public void sendmessage()
    {
        System.out.println("发短信 ");
    }
    public  void show()
    {
        System.out.println("显示号码");
    }
}

//新手机
public class Newphone extends Phone {
    @Override
    public void show() {
      super.show();//把父类的show方法拿过来重复利用,然后自己子类再来添加更多内容
        System.out.println("显示姓名");
        System.out.println("显示头像");
    }
}


public class test
{
    public static void main(String[] args)
    {

        Phone phone=new Phone();
        phone.call();//打电话
        phone.sendmessage();//发短信
        phone.show();//显示号码
        System.out.println("====================");

        Newphone newphone=new Newphone();
        newphone.call();//打电话
        newphone.sendmessage();//发短信
        newphone.show();//显示号码
                        //显示姓名
                        //显示头像
    }

}

总结：如果你要添加一个新的功能，不要去修改老的类，在新的类中继承老的类，然后覆盖重写，然后添加一些新的功能。其中super.类名称就是继承旧的方法。

1.6继承中构造方法的访问特点

1.6.1子类的对象在创建时，是先调用的父类的构造方法还是子类的构造方法？

//父类
public class Fu
{
public Fu()
{
      System.out.println("父类构造方法！");
}
 public static void main(String[] args)
      {
      }
}
//子类
public class Zi extends Fu {
public Zi()
{
    System.out.println("子类构造方法!");
}
}

//调用
public class constructor {
    
    public static void main(String[] args) {

        Zi zi= new Zi();//父类构造方法！
                        //子类构造方法!

    }
}

1.6.2子类构造可以通过super关键字来调用父类重载构造

//父类
public class Fu
{
public Fu(int num)
{

      System.out.println("有参构造方法！");
}
public  Fu()
{
      System.out.println("无参构造方法！");
}
      public static void main(String[] args)
      {

      }
}

//子类
public class Zi extends Fu
{
public Zi()
  {    super(10); //调用父类重载的构造方法
    System.out.println("子类构造方法!");
  }

}

//测试
public class constructor {
   
    public static void main(String[] args) {

        Zi zi= new Zi();
      //有参构造方法！
      //子类构造方法!

    }
}

1.6.3.super父类构造调用，必须是子类构造方法的第一个语句，不能是一个子类构造调用多次super构造,只能调用一次。

1.6.4 子类必须调用父类构造方法，不写则赠送super(); 写了则用写的指定的参数super调用（写一个有参数的来重载），super只能有一个，还必须是第行的第一个。

//父类
public class Fu
{
public Fu(int num)
{

      System.out.println("有参构造方法！");
}
public  Fu()
{
      System.out.println("无参构造方法！");
}
      public static void main(String[] args)
      {

      }
}

//子类
public class Zi extends Fu
{
public Zi()
  {    super(10); //调用父类重载的构造方法

  }
  //普通的成员方法是不能调用super();
 public void method()
  {
     // super(); //错误写法！ 只有子类构造方法才能调用父类构造方法。
  }
}

1.7super关键字的用法

super关键字的用法有三种

 1.在子类成员方法中，访问父类的成员变量。

//父类
public class Fu
{
      int num=10;

      public static void main(String[] args)
      {

      }
}
//子类
public class Zi extends Fu
{
public void methodzi()
{
    System.out.println(super.num); //访问父类中的num  10
}

}

 2.在子类的成员方法中，访问父类的成员方法。

//父类
public class Fu
{
public void method()
{
      System.out.println("父类的method");
}
      public static void main(String[] args)
      {

      }
}
//子类
public class Zi extends Fu
{
public void method()
{
    super.method();//访问父类的method

}

}


 3.在子类的构造方法中访问父类的构造方法
 具体看1.6.3

1.8
this关键字的三种用法

super关键字用来访问父类内容，而this关键字用来访问本类内容，用法有三种
1.在本类的成员方法中，访问本类的成员变量

2.在本类的成员方法中，访问另一个成员方法。

3.在本类的构造方法中，访问本类的另一个构造方法
this();必须是构造方法的第一个语句，调用本类的有参构造
super 和this这两种构造调用，不能同时使用;
本类一个参数的构造方法调用两个参数的构造方法。

public class Zi extends Fu {
/*super关键字用来访问父类内容，而this关键字用来访问本类内容，用法有三种
1.在本类的成员方法中，访问本类的成员变量

。*/
int num=20;
    public void shownum() {
        int num = 10;
        System.out.println(num); //局部变量
        System.out.println(this.num);//本类中的成员变量
        System.out.println(super.num);//父类中的成员变量
    }
    //2.在本类的成员方法中，访问另一个成员方法。
        public void methodA()
        {
            System.out.println("AAA");
        }
        public void methodB()
        {
          this.methodA();   //AAA
            System.out.println("BBB");
        }
//3.在本类的构造方法中，访问本类的另一个构造方法
// this();必须是构造方法的第一个语句，调用本类的有参构造
// super 和this这两种构造调用，不能同时使用;

public  Zi()   //本类的无参构造方法调用本类的有参构造方法。
  {
    this(100); //用了this调用后，这一行不再赠送super();(父类构造方法)
   }
    public  Zi(int num)
    {
        this(10,20);      //本类一个参数的构造方法调用两个参数的构造方法。
        System.out.println(num);
    }

public Zi(int m,int n)
{
}
}

1.9
java继承的三个特点

1.java是单继承的，一个类的直接父类只能有唯一一个 .

2.java语言可以多级继承，我有一个父亲，我父亲还有一个父亲。（称为间接父类）
而java语言中最顶级的父类 java.lang.Object;

3.一个子类的直接父亲是唯一的，但是一个父类可以拥有很多个子类

在这里插入图片描述

【C++】继承
HenryBlog
02-24 1149
一、继承的概念及定义 二、父类和子类对象赋值转换 三、继承的作用域 四、派生类的默认成员函数 五、继承和友元 六、继承与静态成员 七、菱形继承和菱形虚拟继承
Java面向对象之继承练习题.doc
08-04
【Java面向对象之继承练习题】的解析与详解： 1. **类的继承**：在Java中，继承是面向对象编程的重要特性，允许一个类（子类）继承另一个类（父类）的属性和方法。例如，我们可以创建一个`Music`类作为其他音乐相关...
18、继承以及继承中成员变量和成员方法的重名问题
pray1996的博客
12-04 506
继承 继承类别写法： 定义父类格式： public class 父类名称{ ​ //… } 定义子类格式：//extends 扩大；扩展 public class 子类名称 extends 父类名称{ ​ //… } 父类子类中访问成员变量的规则：（父类子类中变量重名问题） 在父子类的继承关系中，如果成员变量重名，则创建子类对象时，访问有两种方式： 直接通过子类对象访问成员变量 规则：等号左边时谁，就优先用谁，没有则向上找 间接通过成员方法访问成员变量 规则：该方
C++——继承
2301_80401288的博客
10-05 1609
《C++——继承》 求点赞收藏评论关注！！！ 感谢各位大佬的支持！！！
Java继承
m0_61130325的博客
06-07 1977
继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。继承的作用：通过继承可以快速创建新的类，实现代码的重用，提高程序的可维护性，节省大量创建新类的时间，提高开发效率和开发质量。相关代码: 最后输出:继承过来的字段和方法，可以像任何其他字段和方法一样被直接使用； 在子类中可以声明一个与父类中同名的新字段或静态方法，从而“隐藏”父类中的字段或方法； 可以在子类中声明一个在父类中没有的新字段和方法； 可以在子类中编写一个父类当中具有相同名
继承与多态
热门推荐
Lucky_mzc的博客
01-05 1万+
一.概述 面向对象程序设计的三大原则是封装性，继承性和多态性。继承性是子类自动共享父类的数据和方法的机制，它是由类的派生功能体现的。继承具有传递性，使得一个类可以继承另一个类的属性和方法，这样通过抽象出共同的属性和方法组件新的类，便于代码的重用。而多态是指不同类型的对象接收相同的消息时产生不同的行为，这里的消息主要是对类成员函数的调用，而不同的行为是指类成员函数的不同实现。当对象接收到发送给它的消息时，根据该对象所属的类，动态选用在该类中定义的实现算法。 二.继承 2.1 继承的概述 ...
c++继承
分享学习过程中的知识和感悟
02-27 1439
切片，虚继承，菱形继承，虚继承内存，虚继承原理，隐藏，先继承先声明，继承中默认成员函数调用顺序
C++继承的使用
JayceSun的博客
04-17 1906
定义 继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特 性的基础上进行扩展，增加功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构， 体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的复用。 ...
多重继承
weixin_51958878的博客
05-17 3398
多重继承 多重继承派生类 除去一个类从一个基类派生，C++还支持一个派生类同时继承多个基类 1.多重继承派生类的定义 如果已经定义了多个基类，那么定义多重继承的派生类的形式为： class 派生类名:访问标号1 基类名1，访问标号2 基类名2，... { //类体 成员列表 }; class A { }; class B : public A { }; //A-B class C : public A { }; //A-C class D : public B,public C { }; //B-D,C
java继承
weixin_45847691的博客
06-18 6543
继承是面向对象程序设计语言的基石之一。 只需在新的类中产生现有类的对象 的方式叫做组合，按照现有类的类型来创建新类的方式为继承。 1、在java中使用 extends关键字实现类的继承机制类Parent为父类，Child为子类。2、通过继承子类会自动拥有基类（父类）所有的成员变量和方法。3、一个子类只能有一个基类，一个基类可以有多个子类。就像一个儿子只能有一个父亲，但一个父亲可能会有多个儿子。故java只支持单继承，不支持多继承。，终极基类（父类）为java标准类Obiect。 举例： 运行结果：为了便于理
Scala进阶_继承
01-07
继承 scala语言是支持面向对象编程的，我们也可以使用scala来实现继承，通过继承来减少重复代码。 定义语法 scala和Java一样，使用extends关键字来实现继承 可以在子类中定义父类中没有的字段和方法，或者重写父类的...
图解Java继承内存分配
01-20
继承的基本概念： 　（1）Java不支持多继承，也是说子类至多只能有一个父类。 　（2）子类继承了其父类中不是私有的成员变量和成员方法，作为自己的成员变量和方法。 　（3）子类中定义的成员变量和父类中定义...
C语言 | 第十章 | 函数 作用域
ZJC744575的博客
10-05 1287
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
JDK1.0主要特性
FoolRabbit的专栏
10-06 381
JDK1.0主要特性。
Puppeteer自动化：使用JavaScript定制PDF下载
ip16yun的博客
10-08 797
Puppeteer 是一个强大的Node.js库，提供了对无头Chrome或Chromium的控制，可以用于生成网页快照、抓取数据、自动化测试等任务。其中，生成PDF文件是一个常见的需求，本文将通过使用Puppeteer展示如何自动化生成定制的PDF，并使用代理IP、设置user-agent、cookie等技术来增强自动化过程的灵活性与稳定性。为了更好地理解如何定制Puppeteer生成的PDF文件，我们提供一个生成A4纸张格式的网页PDF的实例。用户可以根据需求自定义输出的PDF格式或内容。
Netty 相比原生IO模型的优势
最新发布
lssffy的博客
10-09 611
Java提供了多种I/O模型，每种模型都有其适用的场景和特点，随着网络应用需求的变化，I/O模型也在不断发展。阻塞I/O（BIO，Blocking I/O）传统的I/O模型，使用简单，但每次I/O操作都会阻塞线程。每个请求需要独立的线程来处理，这在并发请求较少时问题不大，但在高并发情况下，线程资源将成为瓶颈。非阻塞I/O（NIO，Non-Blocking I/O）引入了多路复用技术，一个线程可以处理多个连接，避免了BIO中每个连接占用一个线程的问题。通过Selector。
2024Java最新面试题总结（针对于一些小厂、中厂）
weixin_62375676的博客
10-07 1140
2024最新Java面试题，针对一些小厂，中厂
C++继承详解：单继承与多继承
"C++继承是面向对象编程中的一个重要概念，它允许一个类（子类、派生类）从另一个类（基类、父类）那里继承特性与行为。这种机制使得代码重用变得简单，同时支持多态性。C++支持两种主要的继承方式：单一继承和多重...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值