Java——OOP三大特性之继承（Inheritance）

最新推荐文章于 2023-02-22 10:57:13 发布
最新推荐文章于 2023-02-22 10:57:13 发布
阅读量961 收藏 7
点赞数 1
分类专栏： Java之核心应用 文章标签： Java 面向对象 三大特征 继承 详细易懂
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44551646/article/details/93747961
版权

文章目录

面向对象（Object Oriented Programming)三大特性

1.封装（Encapsulation）：提高代码安全性
2.继承（Inheritance）：提高代码复用性
3.多态（Polymorphism）：提高代码扩展性

一.继承的定义

Inheritance in Java is a mechanism in which one object acquires all the properties and behaviors of a parent object. It is an important part of OOPs (Object Oriented programming system).
Java中的继承是一种机制，其中一个对象获取父对象的所有属性和行为。它是面向对象编程系统的重要组成部分。[^1]

二.为什么需要继承

  1. For Method Overriding.
  2. For Code Reusability.[^2]

[^2]Reusability: As the name specifies, reusability is a mechanism which facilitates you to reuse the fields and methods of the existing class when you create a new class. You can use the same fields and methods already defined in the previous class.

1.没有用继承前

Class Animal{
	public String name;
	private int age;
	private int id;
	public String getAge(){
				return name；
				}
	 public void setAge(int age){
	 			this.age=age;
	 			}
	 public int getId(){
	 			return id;
	 			}
	 public void setId(int id){
	 			this.id=id;
	 			}
	 public void eat(){
	 			System.out.println(name+"正在吃");
	 			}
	 public void sleep(){
	             System.out.println(name+"正在睡");
}

Class Cat{
public String name;
	private int age;
	private int id;
	public String getAge(){
				return name；
				}
	 public void setAge(int age){
	 			this.age=age;
	 			}
	 public int getId(){
	 			return id;
	 			}
	 public void setId(int id){
	 			this.id=id;
	 			}
	 public void eat(){
	 			System.out.println(name+"正在吃");
	 			}
	 public void sleep(){
	             System.out.println(name+"正在睡");
}
	public void shout(){
					System.out.println(name+"正在叫");
					}
			}

在上述代码中出现了大量的重复代码，使得代码的编写效率大大降低，为了减少代码的重复使用，继承（inheritance）应运而生。

2.应用继承后的变化

继承的具体格式（syntax）：

class 子类名 extends 父类名

上述代码进行修改后：

Class Animal{
	public String name;
	private int age;
	private int id;
	public String getAge(){
				return name；
				}
	 public void setAge(int age){
	 			this.age=age;
	 			}
	 public int getId(){
	 			return id;
	 			}
	 public void setId(int id){
	 			this.id=id;
	 			}
	 public void eat(){
	 			System.out.println(name+"is eating");
	 			}
	 public void sleep(){
	             System.out.println(name+"is sleeping");
}

Class Cat extends Animal {
	public void shout(){
					System.out.println(name+"is shouting");
					}
}

public class Test {
    public static void main(String[] args) {
    			Cat cat = new Cat; // 实例化时，只能实例化子类对象Cat，而不能是父类Animal
    			cat.setName("Leo");
    			cat.setAge(2);
    			cat.setId(194122);
				System.out.println(“Name:” + cat.getName + ",Age:" + cat.getAge + ",Id:"+ cat.getId);
				cat.eat();
				cat.sleep();
				cat.shout();
    }
}
}

console:

Name:Leo,Age:2,Id:194122
Leo is eating
Leo is sleeping
Leo is shouting

减少了代码重复率，提高代码整洁度，体现了Code Reuseablity.
Animal与Cat的关系是Cat IS-A Animal

三. 继承的限制

1. 子类继承父类的成员变量

  • 能够继承父类的public和protected成员方法，不能够继承父类的private成员方法。注意：在上述代码中，父类出现了private的成员变量，子类可以通过set来修改，不是继承。
  • 对于父类的包访问权限成员变量，如果子类和父类在同一个包下，则子类能够继承，否则不能继承
  • 对于子类可以继承的父类成员变量，如果在子类中出现了同名的成员变量，则会发生隐藏现象，即子类的成员变量会屏蔽父类的同名成员变量。如果要在子类中访问父类的同名成员变量，需要使用super关键字来引用。

super关键字具体实例：

class Animal{
	String color= "white";
}

class Cat extends Animal{
	String color ="black";

	void printColor(){
			System.out.println(color);       //打印子类Cat的成员变量color
			System.out.println(super.color);  //打印父类Animal的成员变量color
			}
	}

class Test1{
		public static void main(String args[]){
			Cat cat =new Cat();
			cat.printColor();
			}
}

Console:

black
white

2.子类继承父类的方法

  • 子类能够继承父类的public和protected成员方法，不能够继承父类的private成员方法
  • 对于父类的包访问权限成员方法，如果子类和父类在同一个包下，则子类能够继承，否则不能继承
  • 对于子类可以继承的父类成员方法，如果在子类中出现了同名的成员方法，则称为覆盖，即子类的成员方法会覆盖父类的同名成员方法。如果要在子类中访问父类中的同名成员方法，需要使用super关键字来进行引用。

super关键字具体实例：

class Animal{
		void eat(){
				System.out.println("I'm eating now!);
				}
		}

class Dog extends Animal{
		void eat(){
				System.out.println("i'm eating apple!");
			}
		void bark(){
				System.out.println("wof..wof...");
			}
		 void together(){
		 		super.eat();   //调用父类的eat（）方法
		 		bark();       //调用子类bark（）方法
		 		}
		 }
class Test2{
		public static void main(String args[]){
				Dog dog =new dog();
				dog.together();
				}
		}

Console:

i'm eating apple!
wof..wof...

3.构造方法

  • 子类不能继承父类的构造方法
  • 子类可以使用super关键字调用父类构造方法
  • 子类必须调用父类的构造方法
  • super关键字只能放在第一行
  • 如果子类的构造方法中没有显示的调用父类的构造方法，则系统默认调用父类的无参数构造方法。
  • 如果子类构造方法中既没有显示调用父类构造方法，而父类又没有无参数的构造方法，则编译出错

super关键字具体实例：

public class Animal{
	protected String name;
	public Animal(){}    //无参构造
	public Animal(String name){
		this.name=name;
		}
	}
	
public class Cat extends Animal{
	private int id;
	public Cat(){}       //无参构造
	public Cat(String name){
		this.name=name;
		}
	public Cat(String name,int id){
		this.name=name;
		this.id=id;
		}
	}
}

上述代码没有问题，如果把父类的无参构造方法public Animal(){}去掉，则代码会报错。因为子类Cat的构造方法中既没有显示调用父类构造方法，而父类Animal又没有无参数的构造方法，所以编译出错。

如果删掉父类的无参构造方法，则上述代码可以用super关键字改为：

public class Animal{
	protected String name;
	public Animal(String name){
		this.name=name;
		}
	}
	
public class Cat extends Animal{
	private int id;
	public Cat(String name){
		super（“Leo”）；
		this.name=name;
		}
	public Cat(String name,int id){
		super（“Leo”）；
		this.name=name;
		this.id=id;
		}
	}
}

由于父类没有无参构造方法，所以子类的构造方法必须先使用super方法调用父类的有参构造方法，这样十分麻烦，因此父类在设计构造方法时应该含有一个无参构造方法

四.继承的方式

在这里插入图片描述

1. 单继承Single

上述代码都为单继承

2.多级继承Multilevel

class Animal{  
	void eat(){
		System.out.println("eating...");
		}  
}  

class Dog extends Animal{  
	void bark(){
		System.out.println("barking...");
		}  
}  

class BabyDog extends Dog{  
	void weep(){
		System.out.println("weeping...");
		}  
}  
class TestInheritance2{  
	public static void main(String args[]){  
		BabyDog d=new BabyDog();  
		d.weep();  
		d.bark();  
		d.eat();  
	}
}

Output：

weeping...
barking...
eating...

3.层级继承Hierarchial

class Animal{  
void eat(){System.out.println("eating...");}  
}  
class Dog extends Animal{  
void bark(){System.out.println("barking...");}  
}  
class Cat extends Animal{  
void meow(){System.out.println("meowing...");}  
}  
class TestInheritance3{  
public static void main(String args[]){  
Cat c=new Cat();  
c.meow();  
c.eat();  
//c.bark();//C.T.Error  
}}

Output:

meowing...
eating...

4.在Java中没有多继承!!!

为什么没有多继承？？

class A{  
	void msg(){
		System.out.println("Hello");
		}  
}  
class B{  
	void msg(){
		System.out.println("Welcome");
		}  
}  
class C extends A,B{                 //suppose if it were  
   
 public static void main(String args[]){  
   C obj=new C();  
   obj.msg();                  //Now which msg() method would be invoked?  
	}  
}

重载（Method Overloading）

在Java中，同一个类中的多个方法可以有相同的名字，只要它们的参数列表不同即可，这被称为方法重载（Method Overloading）。参数列表包括参数的类型，参数的个数，参数的顺序，只要有一个不用就叫参数列表不同。因此，重载是面向对象的一个基本特征

public class Test{
		void test(){
			System.out.println("test1");
			}
		void test(int a){
			System.out.println("test2");
			}
		void test(int a, int b){
			System.out.println(test3);
			}
			void test(double a){
			System.out.println(test4);
			}

但是，以下集中情况不是重载
在这里插入图片描述
在这里插入图片描述
更多精彩尽在Blog主页

Reference:
1.https://www.javatpoint.com/inheritance-in-java

66Kevin
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java 面向对象特征：继承(Inheritance)（概念、代码、图示）
m0_54140879的博客
01-22 1065
绿化：前人栽树，后人乘凉“绿水青山，就是金山银山”样貌：继承之外，是不是还可以""： 角度一：从上而下为描述和处理个人信息，定义类Person： 为描述和处理学生信息，定义类Student： 角度二：从下而上 多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类中无需再定义这些属性和行为，只需要和抽取出来的类构成。如图所示： 再举例： 继承的出现减少了代码冗余，提高了代码的复用性。继承的出现，更有利于功能的扩展。继承的出现让类与类之间产生了的关系，为多态的使用提供了前提。继承描述事物之
Java面向对象程序设计(OOP)
记录学习历程
08-21 6130
1、面向对象程序设计(OOP) 1.1、面向过程&面向对象 面向过程思想 步骤清晰简单,第一步做什么，第二步做什么…（线性思维） 面向过程适合处理一些较为简单的问题 面向对象编程 物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类,然后对这些分类进行单独思考。最后,才对某个分类下的细节进行面向过程的思索。 面向对象适合处理复杂的问题，适合处理需要多人协作的问题！ 对于描述复杂的事物，为了从宏观上把握、从整体上合理分析,我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作
Java详细讲解OOP面向对象
github_67177094的博客
06-20 2251
类中的static代码块的特点：常见的异常
动物类Animal
qq_45941400的博客
11-19 7769
动物类Animal 编写动物类Animal，要求如下： 属性：颜色color，年龄age，性别gender。 方法：各属性的set和get方法，玩耍play（），奔跑（），休息（），显示全部属性showAll 编写测试类AnimalText进行测试，为Animal对象属性赋予初始值，并调用对象的各个方法 class Animal { //全局变量 private String color; private int age; private String gender;
Java OOP的理解
一只程序菜鸡的博客
09-19 2657
Java-面向对象编程思想
JavaOOP三大特性复习课——第二次小班辅导.pptx
04-20
【原创作者田超凡，未经许可请勿转发，侵权仿冒必究】
JAVA基础之继承（inheritance）详解
08-31
在Java面向对象编程（OOP）中，继承（Inheritance）是实现代码重用和抽象化的重要机制。它允许一个类（子类）从另一个类（超类、基类、父类）继承特性，包括方法和字段。继承使得子类能够获取父类的功能，同时还能...
Java面向对象之继承练习题.doc
08-04
刚开始学，需要简单题目加深对概念的理解
自学笔记记录之OOP三大特征
10-18
自学笔记记录
JavaOOP02 第二章 继承.pdf|02 第二章 继承.pdf
09-04
JavaOOP02 第二章 继承.pdf,JavaOOP02 第二章 继承.pdf JavaOOP02 第二章 继承.pdf,JavaOOP02 第二章 继承.pdf
java继承
adaixiaoxiao的专栏
01-28 716
Java 继承 继承是java面向对象编程技术的一块基石，因为它允许创建分等级层次的类。继承可以理解为一个对象从另一个对象获取属性的过程。 如果类A是类B的父类，而类B是类C的父类，我们也称C是A的子类，类C是从类A继承而来的。在Java中，类的继承是单一继承，也就是说，一个子类只能拥有一个父类 继承中最常使用的两个关键字是extends和implements。 这两个关键
Java(基础) - 继承（inheritance）
Yolandera的博客
10-02 645
一 封装 作为一个保护屏障，将类中的具体代码实现细节进行包装盒隐藏，防止该类的代码和数据在外部调用时被访问。 封装的思想保证了类内部数据结构的完整性，提高了程序的安全性和可维护性。 往往将类中某个字段私有化(private)，再提供公有方法(getter/setter)。setter方法可以对数据进行合法性判断。 Java 访问修饰符有4种 public protected friendly pr...
JAVA基础的interface与inheritance实例
dead man
07-21 3365
rugby还算成功,但这1个星期的体力恢复还不行,昨天打了一半就有点累了,不过昨天避开了Shean和Rock的冲击,这2个家伙可比我要重25KG以上,简直不敢正面对抗~~~很奇怪的是昨天球场旁边有一栋楼的避雷针在5秒内被闪电击中2次,有点爽哈...第4讲是OOP的第2部分,主要讲解了class,inheritance和Polymorphism.以及一些JAVA的新特性,Java里没有多重继承,但可
要点Java13 继承Inheritance
赤山岛
03-20 3093
继承Inheritance Java中继承允许你重用另外一个类的代码, 你可以从现有的类 派生 出新类。这个新类叫做 子类 他继承了父类的所有的成员和方法（私有排外）. 你可以像使用普通属性一样使用继承的属性. 你也可以定义与父类相同名字的属性名, 它会隐藏父类的属性(不推荐使用). 你可以定义一个新的属性，父类中没有的. 方法也是如此. 你还可以在子类中写一个同名的方法，覆盖父类的方法
面向对象的三大特征
Hvitur的博客
02-22 779
面向对象（OOP）的三大特征：继承、封装、多态
动物类的继承
热门推荐
AI_QS_CSDN的博客
04-24 1万+
动物类的继承 要求： 1.在一个名为Test.java的文件中定义四个类：动物类Animal，狗类Dog和猫类Cat继承Animal，测试类Test，要求编写代码的同时编写简单注释。 2.动物类Animal要求体现以下内容： （1） 私有成员变量：姓名name，年龄age （2） 构造方法：无参构造、带参构造 （3） 成员方法：s...
Java中OOP的理解
qq_50864729的博客
05-15 2081
目录 1. 什么是OOP 2. 面向对象的三大特性： 2.1 封装 2.2 继承 2.3 多态 3. OOP的优缺点 3.1 优点 3.2 缺点 4. OOP设计模式六大原则 1. 什么是OOP 什么是OOP，Object Oriented(面向) Programming，即面向对象编程。很早很早以前的编程是面向过程的，我们提到的面向对象编程的优点，一般是和面向过程编程POP(procedure oriented Programming) 对比的。 2. 面向对象的三大特性： 2.
java面向对象9经典程序
mike_jun的博客
12-17 1600
转载自：http://blog.csdn.net/u010793590/article/details/28898923 1 Hello world例子 [java]view plaincopy packageExample;//定义自己的包名 publicclassExample1
JavaOOP 从初识到掌握
只有登上山顶，才能看到那边的风光
05-17 2175
😹 作者: 爱摸鱼的小凯 😻爱摸鱼的小凯的博客 😽 觉得博主文章写的不错的话，希望大家三连（✌关注，✌点赞，✌评论），多多支持一下！！！
OOP的三大特性包括哪些
最新发布
07-17
OOP（面向对象编程）的三大特性包括： 1. 封装（Encapsulation）：封装是指将数据和对数据的操作封装在一个单元中，即类。通过封装，类可以控制对其内部数据的访问，提供公共的方法来操作数据，同时隐藏了内部实现细节，提高了代码的安全性和可维护性。 2. 继承（Inheritance）：继承是指一个类可以继承另一个类的属性和方法。通过继承，子类可以继承父类的特性，并且可以在此基础上添加新的属性和方法。继承实现了代码的重用，提高了代码的可扩展性和可维护性。 3. 多态（Polymorphism）：多态是指同一类型的对象，在不同情境下可以表现出不同的行为。多态通过方法的重写和重载实现。通过多态，可以提高代码的灵活性和可读性，使得代码更加通用和易于扩展。 这三个特性共同构成了面向对象编程的基础，并且能够提供更加灵活、可维护和可扩展的代码结构。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值