java的继承、多态、抽象类、接口

最新推荐文章于 2025-10-24 18:22:57 发布
原创 最新推荐文章于 2025-10-24 18:22:57 发布 · 467 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
收录于
java

当前文章被收录于：

java
14 篇文章 0 人学习
订阅专栏 查看详情
本文深入讲解Java中的继承、多态、抽象类与接口等核心概念，包括它们的基本定义、使用场景及注意事项。

java的继承、多态、抽象类、接口

文章目录

前言

最近在看java核心技术卷一。看到继承和接口，因为我感觉它们都差不多，只是在应用和特性上有差别，就想把它们和在一起写一篇笔记

提示：以下是本篇文章正文内容

一、继承 ( extends )

  1. 在数据设计的时候有一个简单的规则判断是否应该将数据设计为继承关系 —— is-a规则。 如
    男人是一个人，就可以考虑是否将数据设计为继承关系，这里人是父类，男人是子类
    反之，人是一个男人则要慎重考虑，因为可以很轻松举出反例，如：人是一个女人，人是一个中性人。这里人是子类，女人，中性人是父类
// 父类----人
class Person{		//人
	String name;	//名字
	String sexOrgans  // 性器官
}
// 子类----男人
class Man extends Person{		// 男人
	// 子类继承父类全部的字段(全局变量，类字段，属性)和方法 
}
  1. 使用final修饰符修饰类表示这个类不可被继承，并且这个类中的所有方法自动地成为final方法。字段则不会自动的被final自动修饰
  2. 使用final修饰符修饰方法表示这个方法表示这个方法不可被子类重写
  3. 子类继承父类的所有public修饰符修饰的字段和方法

方法的签名

方法的名字和参数列表称为方法的签名

// setName(String name)：就是方法的签名
public void setName(String name) {
		this.name = name;
	}

方法的重写/覆盖(Override)

重写也被称为覆写。对一个方法的重写必须发生在具有继承关系的两个类中，即子类对父类方法的重写。它要求两个方法的参数个数和类型以及返回值类型都必须一致，也就是方法的签名必须一致，这样才称为方法重写。
在Java SE 5.0 以前的版本中，覆盖父类的方法时，要求返回类型必须是一样的。现在子类覆盖父类的方法时，允许其返回类型定义为原始类型的子类型。

class A{
    public void fun(String data){
        System.out.println(data);
    }
}

class B extends A{
    // 方法的重写/覆盖
    public void fun(String data){
        System.out.println("XXXX" + data);
    }
}

同时子类对父类的方法覆写对权限有要求，子类方法的访问权限必须大于或等于父类方法的访问权限。也就是说如果父类方法的访问权限是default，那么子类必须是default或者public，如果父类方法是public访问权限，那么子类就只能是public访问权限了。然而，实际开发中，绝大多数的方法都是public访问权限，所以覆写方法也是public。

关于访问权限，还有一点需要注意的是，父类方法如果是private，根据JAVA的封装性原则，private是不让其它任何类访问的。那么，此时子类能否对父类的private方法进行覆写呢？

答案是否定的。

动态绑定与静态绑定

在运行时能够自动地选择适当的方法，称为动态绑定
动态绑定只是针对对象的方法，对于属性无效。因为属性不能被重写。

// 虚拟机在运行时能够自动地选择适当的方法,son类中没有定义method方法虚拟机会去查询父类的方法表
1 public class Son extends Father
2 Son son = new Son();
3 son.method();

方法表

动态绑定搜索调用方法事件开销巨大，所以，虚拟机预先为每一个类计算了一个方法表，其中列出了该类中的所有方法的签名和要调用的实际方法，
在真正调用的时候虚拟机仅查找这个表。在子类方法表中没有查到会查父类的方法表

动态绑定的过程

一、动态绑定的过程：

例子：

1 public class Son extends Father
2 Son son = new Son();
3 son.method();

1. 首先，编译器根据对象的声明类型和方法名，搜索相应类(Son)及其父类(Father)的“方法表”，找出所有访问属性为public的method方法。

可能存在多个方法名为method的方法，只是参数类型或数量不同。

2. 然后，根据方法的“签名”找出完全匹配的方法。

方法的名称和参数列表称为方法的签名。

在Java SE 5.0 以前的版本中，覆盖父类的方法时，要求返回类型必须是一样的。现在子类覆盖父类的方法时，允许其返回类型定义为原始类型的子类型。

1 public Father getFather(){...}  //父类中的方法
2 public Son getFather(){...}     //子类覆盖父类中的getFather()方法

3. 如果是private、static、final 方法或者是构造器，则编译器明确地知道要调用哪儿个方法，这种调用方式成为“静态调用”。

4. 调用方法。

如果子类Son中定义了 method() 的方法，则直接调用子类中的相应方法；如果子类Son中没有定义相应的方法，则到其父类中寻找method()方法。

二、Demo

1. 子类重写父类中的方法，调用子类中的方法

 1 public class Father{
 2     public void method(){
 3         System.out.println("父类方法："+this.getClass());
 4     }
 5 }
 6 public class Son extends Father{
 7     public void method(){
 8        System.out.println("子类方法"+this.getClass());
 9     }
10     public static void main(String[] args){
11         Father instance = new Son();
12         instance.method();
13     }
14 }
15 //结果：子类方法：class Son

2. 子类没有重写父类中的方法，所以到父类中寻找相应的方法

public class Father{
    public void method(){
        System.out.println("父类方法："+this.getClass());
    }
}
public class Son extends Father{
    public static void main(String[] args){
        Father instance = new Son();
        instance.method();
    }
}
//结果：父类方法：class Son

三、动态绑定只是针对对象的方法，对于属性无效。因为属性不能被重写。

1 public class Father{
 2     public String name = "父亲属性";
 3 }
 4 public class Son extends Father{
 5     public String name = "孩子属性";
 6 
 7     public static void main(String[] args){
 8         Father instance = new Son();
 9         System.out.println(instance.name);
10     }
11 }
12 //结果：父亲属性

二、java 中，对象变量是多态的

  • 一个对象变量可以指示多种实际类型的现象称为多态
    • 在继承关系中，父类对象变量可以引用自身，也可以引用任何它的子类的对象
    • 抽象类中，父类对象变量可以指向非抽象对象
    • 接口中，接口的对象变量可以指向实现接口的对象
  • 父类对象变量可以指向子类称为向上转型
  • 子类对象变量可以通过强转父类从而达成子类对象变量指向父类，但有一个前提，这个父类变量本身就是子类
public class Test_1 {
	public static void main(String[] args) {
		// 父类对象变量可以引用自身，也可以引用任何它的子类的对象  ----多态
		Human hm = new Man();  // 父类对象变量指向子类  向上转型
		hm.output1();  // 输出：多态1
		// Man m = new Human();  //编译不通过  子类指向父类----向下转型
		//Man m = (Man)new Human();  // 编译通过，运行时异常(java.lang.ClassCastException)。强制向下转型 
		// m.output1();
		// hm对象变量本身指向的就是Man子类
		// Man m2 = hm;   // 直接指向编译不通过
		Man m2 = (Man)hm;
		m2.output2();     // 输出：多态2
	}
}
// 父类
class Human{
	public void output1() {	
		System.out.println("多态1");
	}
}
// 子类
class Man extends Human{
	public void output2() {
		System.out.println("多态2");
	}
}

三、抽象类(abstract)

1、什么是抽象类？

  1. 类和类之间具有共同特征，将这些共同特征提取出来，形成的就是抽象类
  2. 类本身是不存在的，所以抽象类无法创建对象<无法实例化>

2、抽象类属于什么类型？

  • 抽象类也是属于引用数据类型

3、抽象类怎么定义？

语法：
[修饰符列表]  abstract  class 类名{
		类体;
  }

4、抽象类是无法实例化的，无法创建对象的，所以抽象类是用来被子类继承的

5、final和abstract不能联合使用，这两个关键字是对立的

6、抽象类的子类可以是抽象类

7、抽象类虽然无法实例化，但是抽象类有构造方法，这个构造方法是供子类使用的

8、抽象类关联到一个观念：抽象方法。什么是抽象方法呢？

  • 抽象方法表示没有实现的方法，没有方法体的方法。
  • 如：public abstract void doSome( );
  • 抽象方法的特点是：
  • 特点1：没有方法体，以分号结尾
  • 特点2：前面修饰符列表中有abstract关键字

9、抽象类中不一定有抽象方法，抽象方法必须出现在抽象类中

10、非抽象类继承抽象类必须将抽象类中的抽象方法重写

//抽象类的子类可以不实现继承的方法，但是这个子类也要声明为abstract。一种是子类实现抽象类的全部方法
abstract class Person{
	int age;
	public int getAge(int age) {
		return age;
	}
	public abstract String fun();
}

abstract class Student extends Person{

}

class Worker extends Person{
	public String fun() {
		return null;
	}
}

四、接口( interface )

  1. 接口是一种"引用数据类型"
  2. 接口是完全抽象的
  3. 接口的语法：[修饰符列表] interface 接口名{ }
  4. 接口支持多继承
  5. 接口中只有常量+抽象方法
    1. java8中允许在接口增加静态方法
  6. 接口中所有的元素都是public修饰的
    1. java9中接口可以是private修饰符修饰，可以是静态方法和实例方法，私有方法只能在接口本身的方法中使用，所以它们的用法有限，只能作为接口中其它方法的辅助方法
  7. 接口中抽象方法的public abstract可以省略
  8. 接口中常量的public static final可以省略
  9. 接口中方法不能有方法体
  10. 一个非抽象的类，实现接口的时候，必须将接口中所有方法加以实现
  11. 一个类可以实现多个接口
  12. extends和implements可以一起使用，extends在前，implements在后,implements是一个类实现一个接口用的关键字，是用来实现接口中定义的抽象方法
  13. 使用接口，写代码的时候，可以使用多态（父类型引用指向子类型对象）

接口的实现

  1. 类和类之间叫做继承，类和接口之间叫做实现，继承使用extends关键字；实现使用implements关键字完成
  2. 当一个非抽象的类实现接口的话，必须将接口中所有的抽象方法全部实现(重写)
public class Test02{
    public static void main(String[] args){
        //抽象方法无法实例化
        //使用多态，子类型引用指向子类型的对象
        MyMath mm = new MyMathImpl();
        //调用接口里面的方法（面向接口编程）
        int result_1 = mm.sum(10,20);
        int result_2 = mm.sub(20,13);
        System.out.println("加：" + result_1 + "，减法：" + result_2);
    }
}

//接口：特殊的抽象类，完全抽象的
interface MyMath{
    //常量，public static final省略
    double PI = 3.1415;
    //抽象方法;没有方法体
    int sum(int a,int b);
    int sub(int a,int b);
}

//实现MyMath接口
class MyMathImpl implements MyMath{
    //要写上public ,不写系统会自动写上比public 权限低的关键字
    public int sum(int a,int b){
        return a+b;
    }
    public int sub(int a,int b){
        return a-b;
    }
}

接口是为了弥补Java中类与类只支持单继承带来的缺陷。单继承是为了简单出现的，现实世界中存在多继承

public class Text03{
	public static void main(String[] args){
        R r = new R();
        M m = (R)m;
        //编译不会报错
        //运行时可能会出现ClassCastException异常
        //继承是向下转型，两者必须要有继承关系，但是接口不一样，编译不会报错，运行可能会报错
        //向下转型养成好习惯，转型前用if + instanceof进行判断
        m.mm_1();
    }
}

interface R{
    void mm_1();
}

interface M{
    void mm_2();
}

exdents和implements

public class Text04{
    public static void main(String[] args){
        Flyable f1 = new Cat();
        f1.fly();
        //同一个接口
        Flyable f2 = new Pig();
        //调用同一个fly()方法，最后的执行效果不同
        f2.fly();
    }
}

//动物类：父类
class Animal{
    
}
//接口通常提取的是行为动作
//能插拔的是接口
//接口：飞翔的接口
interface Flyable{
    void fly();
}

//动物子类：猫类
class Cat extends Animal implements Flyable{
    public void fly(){
        System.out.println("有了翅膀会飞的猫！！！");
    }
}

//飞猪
class Pig extends Animal implements Flyable{
    public void fly(){
        System.out.println("会飞的猪");
    }
}

//蛇类，不想实现飞的功能，就可以不实现Flyable接口
//这样蛇就不会有翅膀了
calss Snake extends Animal{
    
}

//没写也是有继承的，默认继承Object
class Fish extends Object implements Flyable{
    
}

默认方法和静态方法

java8中接口提供了静态方法和默认方法(default)
默认方法可以调用其他方法，实现类可以直接调用默认方法,在接口中抽象方法不用实现，默认方法必须实现
为什么需要静态方法和默认方法
当一个接口需要扩展一个功能(方法)时，所有的实现类也要实现这个这个功能
默认方法的最典型用法是逐步为接口提供附加功能，而不破坏实现类。
此外，它们还可以用来为现有的抽象方法提供额外的功能
默认方法冲突
1、超类优先 一个接口继承一个超类，超类中有和接口中同名同参的方法，接口中的默认方法会被忽略
2、一个类实现两个接口，这个两个接口有同名同参的默认方法 T1.super.cpu();
3、一个类实现两个接口，一个接口为默认方法，一个接口为抽象方法，同名同参。程序保存，程序员必须解决这个二义性，保持程序的一致性

interface Phone{
	// 接口没有字段，有常量
	String NAME = "phone";
	// 默认方法
	default int price() {
		return 2000;
	}
	// 静态方法
	static String defaultName() {
		return "黑色";
	}
	String name();
	String colour();
}

interface T1 extends Phone{
	default String cpu(){
		return "晓龙";
	}
}

interface T2 extends Phone{
	default String cpu() {
		return "联发科";
	};
}

class SelectParameter implements T1,T2{

	@Override
	public String name() {
		// TODO Auto-generated method stub
		return null;
	}

	@Override
	public String colour() {
		// TODO Auto-generated method stub
		return null;
	}

	// 解决一个类实现两个接口，这个两个接口有同名同参的默认方法
	@Override
	public String cpu() {
		// TODO Auto-generated method stub
		return T1.super.cpu();
	}
	
}

声明

部分内容转载自
https://www.cnblogs.com/kuillldan/p/5905572.html
https://www.cnblogs.com/ericdream/archive/2012/01/07/2315697.html

《java核心技术卷一》

标签
#java #开发语言 #后端
Java - 包、继承、组合、多态、抽象类、接口
旧时言的博客
11-13 2321
面向对象编程 本节目标 包 继承 组合 多态 抽象类 接口 包 包 (package) 是组织类的一种方式. 使用包的主要目的是保证类的唯一性. //例如, 你在代码中写了一个 Test 类. 然后你的同事也可能写一个 //Test 类. 如果出现两个同名的类, 就会冲突, 导致代码不能编译通过. 导入包中的类 Java 中已经提供了很多现成的类供我们使用. 例如 public class Test { public static void main(String[] args) {
S4 Hana SD -信贷管理 - 03
weixin_46525734的博客
03-16 2825
自动信用控制将针对同一信用控制范围的不同的客户风险类别和信贷组执行不同的信用控制政策。对于ECC系统而言，无需单独设置检查规则，可在自动信贷控制进行设置即可，如图1-5-2。在S4 HANA版本中，自动信贷控制和检查规则是分离的。S4系统需要在定义自动信贷控制的时候，给字段“SAP信用管理”打钩，激活检查规则，然后需要单独在检查规则页签设置检查规则。接下来，我们分别介绍ECC和S4 HANA系统中两种不同配置方式.6.2SPRO。
【Java语法】包 继承 多态 抽象类 接口
耀的博客
03-20 9912
一、包 包 (package) 是组织类的一种方式. 使用包的主要目的是保证类的唯一性 将类将放到包中 基本规则 在文件的最上方加上一个 package 语句指定该代码在哪个包中. 如果一个类没有 package 语句, 则该类被放到一个默认包中 包的访问权限控制 如果某个成员不包含 public 和 private 关键字, 此时这个成员可以在包内部的其他类使用, 但是不能在包外部的类使用. 二、继承 继承 对共性的抽取，使用extends关键字进行处理，可以对代码重复使用 语
ABAP RAP 行为建模深入学习：从 Behavior Definition 到 Behavior Implementation 的完整实践指南
最新发布
2007 年 ~ 2025 年，深耕 SAP 技术 18 年
10-24 361
ABAP RAP开发指南：业务行为定义与实现 本文介绍SAP RAP框架中业务对象行为的开发方法： 分层设计 Behavior Definition声明业务能力（增删改查、校验、动作等） Behavior Implementation在ABAP类中编写具体逻辑 核心组件 使用BDL定义业务行为 通过FOR BEHAVIOR OF绑定行为池类(ABP) 在本地类实现校验/确定/动作逻辑 关键特性 支持managed/unmanaged两种实现模式 提供草稿表、并发控制等企业级功能 通过EML以别名访问实体 开
JAVA 学习之extens和implements的用法
Michae的博客
04-22 968
理解继承是理解面向对象程序设计的关键。在Java中，通过关键字extends继承一个已有的类，被继承的类称为父类(超类，基类)，新的类称为子类(派生类)。在Java中不允许多继承。 （1）继承 [java] view plain copy   class Animal{       void eat(){           System.out.p
extends和implements的区别
废了
06-28 535
1.extends后面跟的是类，表示继承关系，只能继承一个2.implements后面跟的是接口，表示实现接口，可以实现多个。实现接口就是实现接口中定义的方法， 接口可以看作一个标准，比如定义了一个人的接口，那么人有吃饭，睡觉这个办法，你就可以用implements实现这个方法。
java抽象类的继承
fsky的博客
12-14 8404
java基础 抽象类的继承
extends 与 implements 的区别 ！
热门推荐
zzz897089046的博客
07-28 1万+
JAVA中extends 与implements有啥区别？ 在类的声明中，通过关键字extends来创建一个类的子类。一个类通过关键字implements声明自己使用一个或者多个接口。 extends 是继承某个类, 继承之后可以使用父类的方法, 也可以重写父类的方法; implements 是实现多个接口, 接口的方法一般为空的, 必须重写才能使用 extends是继承父类，只要那个类不是声明为final或者那个类定义为abstract的就能继承，JAVA中不支持多重继承，但是可以用接口 来实现，这样就
Java implements和extends的区别
weixin_41924879的博客
03-30 6103
Java implements和extends的区别 implements 关键字implements是一个类，实现一个接口用的关键字，它是用来实现接口中定义的抽象方法。实现一个接口，必须实现接口中的所有方法。使用 implements 关键字可以变相地使java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口跟接口之间采用逗号分隔） 注意点： 接口可以被多重实现（i...
Java基础 | 继承，多态，抽象类与接口
zszq111的博客
01-12 2312
继承，多态，抽象类和接口
Java继承、super、this、抽象类、接口、多态
m0_55597999的博客
04-07 1014
Java的继承，super、this、抽象类、接口、多态
Java第三周：继承和多态，抽象类和接口
一些知识和经验
10-24 1545
两个代码学会继承和多态，抽象类和接口，它允许一个类（子类或派生类）继承另一个类（父类或基类）的属性和方法。子类可以在父类的基础上进行扩展，添加新的属性和方法，或者重写父类的方法。例如，在Java中，使用extends关键字来实现继承关系。DogAnimalDogAnimalnamegetNamebarksuper二、多态多态是指同一个操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。在面向对象编程中，多态主要通过方法重写和接口实现来体现。例如，继续以上面的Animal和Dog。
Java的继承、抽象类、接口、多态
Hrgge的博客
11-15 589
一，抽象方法将共性的行为（方法）抽取到父类之后，发现该方法的实现逻辑无法在父类中具体明确地表示出来，该方法就可以定义为抽象方法。1.abstract不能与final并列修饰同一个类2.abstract不能与private， static， final或native并列修饰同一方法3.abstract方法必须位于abstract类中二，抽象类如果一个类中存在抽象方法，那么该类就必须声明为抽象类三，抽象类的注意事项1，抽象类不能实例化（不能创建对象 new）
Java——继承与多态、抽象类、抽象方法、接口
qq_63179750的博客
06-18 1019
这篇文章将重点介绍面向对象编程中的继承、重写、多态、抽象类和接口。首先，我们将探讨什么是继承，以及在哪些应用场景中可以使用。接下来，我们将了解继承的格式和特点，以及子类能够继承哪些东西。随后，我们将讨论在继承中成员变量的访问特点和如何进行重写。最后，我们将深入探讨多态、抽象类和抽象方法、接口等概念，以及它们在实际开发中的应用。无论你是刚入门的初学者还是有一定编程经验的开发者，相信这篇文章都能够对你有所帮助，欢迎阅读！
Java中的继承和多态以及抽象类、接口的理解
modi000的博客
12-24 448
多态性，可以用父类引用指向子类对象。例2：形参是父类对象（实现解耦）方法的重载：重载与多态毫无关系。
【JAVA系列】Java中的包、类的继承、多态、抽象类与接口
weixin_46913665的博客
11-16 2430
文章目录前言一、包及访问权限1.什么是包？2.如何导入包？3.JDK中常见的包4.包的访问控制权限二、继承1.继承的基本概念2.继承时方法调用顺序3.super和this关键字。总结 前言 一、包及访问权限 1.什么是包？ 要理解什么是包，我们需要先设想一个情境——当我们在开发一个大型程序时，不同的开发人员都可能会写一个Test类，那么在这种情况下，就会发生冲突导致代码不能编译通过。这个时候就需要通过package来帮忙，而package就是包。 package时在使用多个类或接口时，为了避免名.
初始Java Java SE 包,继承,组合,多态,抽象类,接口
wwzzzzzzzzzzzzz的博客
11-14 1870
目录 包 1.静态导入 2.将类放到包中 3.包的访问权限控制 继承 基本语法: 注意事项: protected 关键字 final 关键字 组合 多态 向上转型: 动态绑定 方法重写 重写的规则: 注意事项 : 重载和重写的区别: 向下转型 super 关键字 1.使用了 super 来调用父类的构造器 2.使用 super 来调用父类的普通方法 super和this的区别 理解多态: 抽象类 语法规则 注意事项: 1.包含抽象方法的类,叫做抽...
Java继承、多态接口和抽象类总结
weixin_45923633的博客
04-29 646
一、继承（extends） 继承的理解：当我们定义很多部分具有相同属性和行为的类时，如果使用之前我们所讲类的定义方式进行定义，那么是不是发现有大量的代码重复书写，为了允许使用现有的类的功能，并在无须改写原来的类的情况下，引入了继承的概念。我们把允许重用现有类称为基类（或超类，父类），由基类派生出来的类称为派生类(子类)。 Java类的继承主要通过extends关键字来完成的。一旦继承后，子类将获...
浅谈Java面向对象编程之多态、继承、抽象类、接口
na 小子叫坚强的博客
07-24 1532
1. 包 包 (package) 是组织类的一种方式。 使用包的主要目的是保证类的唯一性。 1.1 导入包中的类 java中提供了很多现成的类供我们使用 public class Test { public static void main(String[] args) { java.util.Date date = new java.util.Date(); // 得到一个毫秒级别的时间戳 System.out.println(date.getT
Java第七章继承、多态、抽象类和接口
2302_76537296的博客
04-04 1587
总结
GNSSdata_广播星历_广播星历计算_rinex3.04_星_RINEX_
数据为Rinex 3.03的多系统混合导航星历（截取部分）广播星历计算
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值