JAVA基础编程——继承

最新推荐文章于 2024-07-30 20:50:32 发布
最新推荐文章于 2024-07-30 20:50:32 发布
阅读量1k 收藏
点赞数
分类专栏： # JAVA基础编程 文章标签： java 基础编程 继承 final
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SAKURASANN/article/details/124599164
版权

面向对象的三大特性是封装、继承和多态。封装是将属性与外界隔离，同时由方法作为与外部的接口。而继承则是要解决代码重用的问题，利用继承可以从当前类派生出新的子类，也可以利用子类扩展更多的方法。

继承

继承实现

首先继承的语法为：

class Student extends Person {}

上面的语法能够从Person这个类中派生出Student这个类，也就是说JAVA中继承使用的是关键字extends。

看下边一段代码：

class Person {
    private String name;
	private int age;
	
	Person() {
	}
	
	Person(String name,int age) {
	    this.name = name;
		this.age = age;
	}
	
	void getInfo() {
	    System.out.println("Name is " + getName() + ",age is " + getAge());
	}
	
	public String getName() {
	    return name;
	}
	
	public int getAge() {
	    return age;
	}
	
	public void setName(String name) {
	    this.name = name;
	}
	
	public void setAge(int age) {
	    this.age = age;
	}
}

class Student extends Person{
	private int grade;
	
	Student() {
	}
	
	Student(String name,int age,int grade) {
	    super(name,age);
		this.grade = grade;
	}
	
	void getInfo() {
	    System.out.println("Name is " + getName() + ",age is " + getAge() + ",grade is " + getGrade());
	}
	
	public int getGrade() {
	    return grade;
	}
	
	public void setGrade(int grade) {
	    this.grade = grade;
	}
}

public class Demo {
    public static void main(String args[]) {
	    Student st = new Student();
		st.setName("wang");
		st.setAge(25);
		st.setGrade(5);
		st.getInfo();
	}
}

结果为：

Name is wang,age is 25,grade is 5

上面的代码可以看出：

  • 子类中可以添加父类中没有的属性和方法
  • 子类会继承父类中的属性和方法
  • 子类可以使用super方法调用父类的构造方法
  • 父类中的private属性，子类不能直接访问，只能通过getter方法访问，这点和C/C++不同
  • 子类会覆盖父类中不会产生重载的方法

继承限制

JAVA的语法区别于C/C++，在继承中也存在许多不同。这也就是JAVA对于继承所作的限制：

  • JAVA不允许多重继承，但是允许多层继承
  • 子类继承父类时，会继承父类中的全部操作，但是对于所有的私有操作属于隐式继承，而所有的非私有操作属于显示继承
  • 在子类对象构造前默认会调用父类的构造方法(默认使用无参构造)，以保证先实例化父类对象，再实例化子类对象

这里进行一一说明，首先是多层继承，这点区别于C/C++。C/C++中能够进行多重继承，但是JAVA却抛弃了这个特性：

class Person {
    private String name;
	private int age;
	
	Person() {
	}
	
	Person(String name,int age) {
	    this.name = name;
		this.age = age;
	}
	
	void getInfo() {
	    System.out.println("Name is " + getName() + ",age is " + getAge());
	}
	
	public String getName() {
	    return name;
	}
	
	public int getAge() {
	    return age;
	}
	
	public void setName(String name) {
	    this.name = name;
	}
	
	public void setAge(int age) {
	    this.age = age;
	}
}

class Student extends Person{
	private int grade;
	
	Student() {
	}
	
	Student(String name,int age,int grade) {
	    super(name,age);
		this.grade = grade;
	}
	
	void getInfo() {
	    System.out.println("Name is " + getName() + ",age is " + getAge() + ",grade is " + getGrade());
	}
	
	public int getGrade() {
	    return grade;
	}
	
	public void setGrade(int grade) {
	    this.grade = grade;
	}
}

class Undergraduate extends Student {
    private String major;
	
	Undergraduate() {
	}
	
	Undergraduate(String name,int age,int grade,String major) {
	    super(name,age,grade);
		this.major = major;
	}
	
	void getInfo() {
	    System.out.println("Name is " + getName() + ",age is " + getAge() + ",grade is " + getGrade() + ",major is " + getMajor());
	}
	
	public String getMajor() {
	    return major;
	}
	
	public void setMajor(String major) {
	    this.major = major;
	}
}

public class Demo {
    public static void main(String args[]) {
	    Undergraduate st = new Undergraduate();
		st.setName("wang");
		st.setAge(25);
		st.setGrade(5);
		st.setMajor("History");
		st.getInfo();
	}
}

结果为：

Name is wang,age is 25,grade is 5,major is History

虽然JAVA允许多层继承，但是也不要过度使用，否则会造成继承关系过于复杂。

再往下看，C/C++父类中的私有属性被子类继承后仍然可以在子类方法内部访问，但是JAVA中却并不是如此。JAVA并不希望子类直接访问父类的私有属性，因此才要统一构建setter和getter方法作为访问和设置其属性的接口。这点之前已经提到过了，因此才称私有操作为隐式继承，只能通过setter和getter进行间接访问，而非私有操作则为显式继承，可以直接在类中访问。

最后再看一下父类和子类的构造方法：

class A {
    public A() {
	    System.out.println("Constructor A");
	}
}

class B extends A {
    public B() {
	    System.out.println("Constructor B");
	}
}

public class Demo {
    public static void main(String args[]) {
	    B tmp = new B();
	}
}

结果为：

Constructor A
Constructor B

上面的执行结果和C/C++原理类似，先执行父类的构造方法，然后执行子类的构造方法。而如果父类只存在有参构造或者是在子类中想要调用父类的有参构造则需要：

class A {
    public A() {
	    System.out.println("Constructor A");
	}
	
	public A(String var) {
	    System.out.println("Constructor A " + var);
	}
}

class B extends A {
    public B() {
	    System.out.println("Constructor B");
	}
	
	public B(String var1,String var2) {
		//super(var1);
	    System.out.println("Constructor B " + var1 + " " + var2);
	}
}

public class Demo {
    public static void main(String args[]) {
	    B tmp = new B("Hello","world");
	}
}

结果为：

Constructor A
Constructor B Hello world

如果去掉上方的注释，结果为：

Constructor A Hello
Constructor B Hello world

也就是说，如果没有用super方法显式说明父类所调用的构造方法，那么就默认调用父类的无参构造方法，而如果想要显式调用父类的其它构造方法，就需要使用super方法显式进行调用。而由于super方法主要调用的是父类的构造方法，因此必须放在子类构造方法的首行。

比如上面的代码，如果是想要调用无参构造方法，那么子类构造方法首行的super()写与不写是没有区别的，而如果想要调用有参的构造方法，则需要显式调用super(var)。这样考虑的话，如果父类中存在自定义的构造方法，也就是自定义的构造方法覆盖了默认的无参构造方法，此时在子类中如果想要调用父类的构造方法就需要显式调用super(var)，因为父类并没有默认的构造方法，当然需要显式调用super方法。

因此为了避免程序出现错误，最好在每个类中都设定默认的无参构造方法。

覆写

继承是为了解决代码重用的问题，而继承同时也可以对父类进行功能扩展，功能扩展主要是借用覆写来实现的。

方法覆写

子类定义的方法和父类方法名称、返回值类型、参数类型和个数完全相同的情况时，称为方法覆写。否则该同名方法应该称为方法重载。

class A {
    public void fun() {
	    System.out.println("fun A");
	}
	
	public void func(String var) {
	    System.out.println("func A");
	}
}

class B extends A {
    public void fun() {
	    System.out.println("fun B");
	}
	
	public void func(String var1,String var2) {
	    System.out.println("func B");
	}
}

public class Demo {
    public static void main(String args[]) {
	    B tmp = new B();
		tmp.fun();
		tmp.func("Hello");
		tmp.func("Hello","world");
	}
}

结果为：

fun B
func A
func B

从上面的结果来看，子类的fun会覆盖父类的fun，也就是方法覆写，而子类的func和父类的func同时存在，也就是方法重载。对于子类来说，同时存在两个func方法，分别有一个和两个参数。

对于方法覆写来说，调用的一定是子类的方法，而方法重载则会根据参数情况不同而调用父类或者子类的同名方法。

但是子类所覆写的方法不能拥有比父类更为严格的访问控制权限。这里要先说明一下访问控制权限，这点和C/C++类似。C/C++中存在三种权限，分别是private/protected/public，而JAVA中也存在三种权限，从宽到严分别是public/default(默认，不写)/private。也就是说，父类的public方法被覆写后只能是public，而父类的default方法被覆写后可以是public或default。

class A {
    void fun() {
	    System.out.println("fun A");
	}
}

class B extends A {
    public void fun() {
	    System.out.println("fun B");
	}
}

public class Demo {
    public static void main(String args[]) {
	    B tmp = new B();
		tmp.fun();
	}
}

结果为：

fun B

上面的方法覆写中，权限关系是合理的，而反过来则是错误的。而虽然方法覆写扩展方法的访问控制权限从语法上讲是合理的，但是从原则上讲，如果private方法覆写为了public方法，似乎并不合理。因此最好还是要保证类属性是private，方法是public的为好。

这里再看一段代码：

class A {
    public void fun() {
	    this.func();
	}
	
	public void func() {
	    System.out.println("func A");
	}
}

class B extends A {
	public void func() {
	    System.out.println("func B");
	}
}

public class Demo {
    public static void main(String args[]) {
	    B tmp = new B();
		tmp.fun();
	}
}

结果为：

func B

上面实例化了类B，然后调用fun方法，此时会执行this.func()，而此时的func由于存在方法覆写，因此调用的是子类的func方法。而如果将父类的func方法修改为private：

class A {
    public void fun() {
	    this.func();
	}
	
	private void func() {
	    System.out.println("func A");
	}
}

class B extends A {
	public void func() {
	    System.out.println("func B");
	}
}

public class Demo {
    public static void main(String args[]) {
	    B tmp = new B();
		tmp.fun();
	}
}

此时的结果为：

func A

这样解释的话，之前将private方法用覆写的形式扩展访问权限为public就不能称之为方法覆写了，因为如果这样的形式存在的话，上面的代码结果就不应该是func A了，也就是说private权限的方法无法覆写。此时对于子类而言，就相当于定义了一个新的同名方法，不过从形式上看是覆写的形式罢了。这点可以通过下面一段代码来说明：

class A {
    public void fun() {
	    this.func();
	}
	
	public void func() {
	    System.out.println("func A");
	}
}

class B extends A {
	public void func() {
		super.func();
	    System.out.println("func B");
	}
}

public class Demo {
    public static void main(String args[]) {
	    B tmp = new B();
		tmp.fun();
	}
}

结果为：

func A
func B

上面的代码是合理的，而如果将父类的func方法修改为private则是错误的，这也说明了两点：

  • super类似于this，不过this指代当前对象，super指向父对象
  • private方法不能覆写，因为super.func()的执行结果是错误的，也正说明了当前类对象的父类中不存在public的func，不能够直接访问

属性覆盖

和方法覆写类似，如果子类定义了和父类完全相同的属性名称时，就称为属性覆盖。

  • 子类属性会覆盖父类的同名属性
  • 子类中可以使用super来访问父类的同名属性

不过总的来说，属性覆盖并没有什么用，通常也不会使用到。

final

上面提到了继承，可以从父类中派生出子类。而如果不想要该类继续被派生，就可以使用final修饰。JAVA中可以使用final定义类、方法和属性。

  • final定义的类不能被继承，也就不能有子类
  • final定义的方法不能被子类所覆写
  • 使用final定义的变量就成了常量，常量必须在定义的时候进行赋值，并且不能修改

final定义常量有点类似C/C++中的const用法，而由于final修饰的变量不能够被修改，因此多用大写。除此之外还存在“全局常量”的概念，所谓全局常量就是用“public”、“static”、“final”联合修饰的变量。之前提到的String类就是final修饰的，因此不能够被继承。

止步听风
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java基础编程——基础语法及介绍
Box_sir的博客
08-24 3720
Java基础编程——基础语法及介绍 介绍 Java是由Sun Microsystems公司于1995年5月推出的Java面向对象程序设计语言和Java平台的总称。由James Gosling和同事们共同研发，并在1995年正式推出。 Java分为三个体系： JavaSE（J2SE）（Java2 Platform Standard Edition，java平台标准版） JavaEE(J2EE)(Java 2 Platform,Enterprise Edition，java平台企业版) JavaME
Java基础知识——JavaIO
weixin_45680007的博客
02-01 1万+
Java io IO的基本分类 同步和异步的区别：同步是线程去查看是否完成，异步是完成的数据去提醒线程已经完成 参考资料 data = socket.read();socket本意为套接字，为ip+端口，我理解为一个数据载体 (BIO)阻塞io：未请求到数据即让出cpu (NIO not block io)非阻塞io：在 while 循环中不断地去询问内核数据是否就绪，这样会导致 CPU 占用率非...
JAVA基础面试题——继承
qq_44395617的博客
03-18 928
文章目录一、继承概念二、继承面试题答案 一、继承概念 Java继承是使用已存在的类的定义作为基础建立新类的技术,新类的定义可以增加新的数据或新的功能,也可以用父类的功能,但不能选择性地继承父类。 二、继承面试题 代码如下（示例）： 父类： public class Fu { int a = 10; } 子类： public class Zi extends Fu { int a = 20; public void method() { int a = 30; System.out.p
Java面向对象编程——继承和多态
qq_70030815的博客
04-26 664
Java面向对象编程——继承和多态
Java基础编程——异常处理之finally语句块
Best_Basic的博客
10-08 2048
Java 异常处理： 异常是程序中的一些错误，但并不是所有的错误都是异常，并且错误有时候是可以避免的。 比如说，你的代码少了一个分号，那么运行出来结果是提示是错误 java.lang.Error；如果你用System.out.println(11/0)，那么你是因为你用0做了除数，会抛出 java.lang.ArithmeticException 的异常。
Java基础篇——三大特性（继承）
自我总结，分享所有，快乐每一天
05-01 3121
Java是一门面向对象的语言：“对象这种观念本身就是十分方便的工具，使得你可以通过概念将数据和功能封装到一起，因此可以对问题空间的观念给出恰当的表示，而不用受制于必须使用底层及其语言。这些概念用关键字class来表示，它们形成了编程语言中的基本单位”；“复用代码是Java众多引人注目的功能之一”-------这段话引用《Think in Java》。继承的本体就是一个class，而继承的最根...
C++编程——继承
professor_tao的博客
04-25 3791
文章目录1. 继承的基本语法2. 继承方式 继承的知识点结构： 继承是面向对象三大特性之一，例如动物类下可以有猫类、狗类。显然猫类、狗类都具有动物类的属性，于此同时，也就有自己独特的属性。这个时候，猫类、狗类就是继承于动物类，采用继承的技术，可以减少重复的代码。 1. 继承的基本语法 语法：class 子类：继承方式 基类 继承示例： 一般网页都有很多部分相似的，我们可以将这些相似的部分抽象出来，作为一个基类。然后子类只需要继承基类，在基类的基础上添加自身其他的属性或者方法就可以实现基本的功能，同时减少
Java基础语法——Java语言介绍
qq_52519008的博客
04-11 9086
1. Java语言简介 1.1 Java故事 Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程。 Java具有简单性、面向对象、分布式、健壮性、安全性、平台独立与可移植性、多线程、动态性等特点。Java可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等。 Java
Java基础学习——代码复用
pyq012的博客
03-13 2882
Java基础学习——代码的复用。通过代码复用可以使项目代码更加精炼
JAVA基础——接口（全网最详细教程）
热门推荐
扬俊的小屋
05-10 37万+
Java基础——接口 接口概念 官方解释：Java接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。 我的解释：接口可以理解为一种特殊的类，里面全部是由全局常量和公共的抽象方法所组...
尚硅谷Java基础实战——Bank项目下载地址
12-29
"尚硅谷Java基础实战——Bank项目"是一个旨在帮助初学者深入理解Java编程概念并实践应用的项目。这个项目以银行系统为背景，涵盖了诸多Java基础知识点，包括类与对象、数据类型、控制结构、异常处理、集合框架、IO流...
JAVA实验报告——简单绘图程序.doc
06-28
根据提供的文档信息，本次实验的主要目标是通过Java编程语言实现一个简单的绘图程序。下面将对实验的目的、内容以及部分...通过本次实验，不仅可以加深对Java基础知识的理解，还能够增强实际编程能力和项目开发经验。
Java实验报告——用户登录系统
02-21
【Java实验报告——用户登录系统】的实验主要围绕Java异常处理机制展开，旨在让学生深入理解和掌握Java中的异常处理。在用户登录系统这个实际场景中，实验者需要运用异常处理来确保程序的健壮性。 首先，实验的核心...
java基础之面向对象编程
02-20
Java是一种广泛使用的面向对象编程语言，其面向对象的特性使得代码更加模块化、易于...以上只是Java面向对象编程的基础知识概览，实际上，每个主题都包含了更深入的概念和实践技巧，需要通过不断的学习和实践来掌握。
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
qq_43700885的博客
07-29 446
1.导入hutool的maven依赖。2.复制一下代码执行。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 244
1.导入hutool的maven依赖。2.直接复制一下代码运行。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 620
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
花几千上万学习Java，真没必要！（三十五）
最新发布
wehpd的博客
07-30 278
集合之Map
面向对象编程——Java基础与学习笔记
"这是一份关于Java基础的笔记总结，涵盖了面向对象编程的概念，以及类、对象、变量等核心概念的讲解。" Java是一种强大的面向对象编程语言，面向对象编程（Object-Oriented Programming，OOP）是其核心特性。与面向...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值