Java继承与多态的理解

1413-南同学

发表文章数:13

热门标签

, , ,
首页 » Java » 正文

继承


概述

多个类中存在相同的属性和行为时,将这些内容抽取到单独一个类中,那么多个类无需在定义这些属性和行为,只要继承那个类即可
单独的这个类称为父类,基类或者叫超类,多个类可以称为子类或者派生类
有了继承以后,我们定义一个类的时候,可以在一个已经存在的类的基础上,还可以定义自己的新成员

实现方式

通过extends关键字可以实现类与类的继承

格式:
public class 子类名 extends 父类名{}

代码

public class Person {//学生和老师类都有name,age属性
	private String name;
	private int age;
	
	public Person() {}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}
	
}

public class Student extends Person {
	public void study() {
		System.out.println("学生要好好学习");
	}
}

public class Teacher extends Person {
	public void teach() {
		System.out.println("老师要好好讲课");
	}
}

继承的好处和弊端


继承的好处

  • 提高了代码的复用性
    多个类相同的成员可以放到同一个类中
  • 提高了代码得到维护性
    如果功能的代码需要修改,修改一处即可
  • 让类与类之间产生了关系,是多态的前提

继承的弊端

由于类与类之间产生了关系,让类的耦合性增强了,而程序设计的原则是:高内聚低耦合。

继承的特点

Java中单继承以及多级继承

  1. Java中只支持单继承,不支持多继承
  2. Java中类支持多层继承

继承中成员变量的特点

1.成员变量名称不同,那就正常使用了

2.父类与子类成员变量一样:

在子类中访问变量:(就近原则)

  • 在方法的局部范围找,如果有就使用
  • 在子类的成员范围找,如果有就使用
  • 在父类的成员范围找,如果有就使用
  • 如果还找不到 就报错

继承中成员方法的特点

同样的就近原则:先在子类中找,再去父类中找

继承中构造方法的特点

1.由于子类会继承父类中的数据,还可能会使用父类中的数据,所以在子类初始化之前,一定要先完成对父的初始化。子类中每一个构造方法的第一条默认语句都是super。

2.子类中的所有构造方法默认都会访问父类中无参数的构造方法。

3.那如果父类中没有构造函数怎么办?

  • 他没有那就给他加一个呗
  • 通过使用super关键字去访问父类的带参构造方法
  • 在平常使用中建议直接每次都自己建一个无参构造方法

super关键字

1.概述
super代表父类存储空间的标识(可以理解为父类对象引用),可以用此去访问父类的属性,方法,构造,但是私有属性和方法不能被访问,用法与this相似

2.使用格式
使用父类成员变量

super.成员变量名;

使用父类的方法

super.成员方法名();

使用父类的构造方法

super(…);

3.好处
当子类与父类的成员重名时,由于访问成员时会遵循就近原则,要想使用父类的成员,那么就是我们使用super的时候了,区分子类与父类的成员

4.代码

public class Father {//父类
	public int age = 45;
}

public class Son extends Father {//子类
	public int age = 20;
	
	public void printAge() {
		int age = 10;
		//根据继承中成员变量的访问方法--就近原则,会先访问局部变量
		System.out.println(age);
		//我要访问成员范围的age?
		System.out.println(this.age);
		//我要访问父类成员范围的age?
		System.out.println(super.age);
	}
}

public class ExtendsTest {//测试
	public static void main(String[] args) {
		Son s = new Son();
		s.printAge();
	}
}

方法重写


概述

子类中出现了和父类中一摸一样的方法声明

使用

当子类需要父类的功能,而功能主体子类有自己特有的内容时,可以重写父中的方法,这样重写父类中的方法,既沿袭了父类的功能,又定义了子类特有的内容

注意事项

  • 注解
@Override
表明该方法的重写父类的方法
  • 方法重写的注意事项
-	父类中私有方法不能被重写
-	子类重写父类方法时,访问权限不能更低(父类的私有方法,可理解为被子类继承,但是不被子类可见,不可访问)
-	子类重写父类方法时,建议访问权限一摸一样
-	父类的成员方法只能被它的子类重写。
-	声明为 final 的方法不能被重写。
-	声明为 static 的方法不能被重写,但是能够被再次声明。
-	构造方法不能被重写。
-	如果一个方法不能被继承,那么它一定不能被重写

代码

public class Phone {	
	public void call(String name) {
		System.out.println("给"+name+"打电话");
	}
}
/*
 * 方法重写:子类中出现了和父类中一模一样的方法声明的情况
 * 方法重写的应用:
 * 当子类需要父类的功能,而功能主体子类又有自己的特有内容的时候,就考虑使用方法重写,
 * 这样即保证了父类的功能,还添加了子类的特有内容。
 */
public class NewPhone extends Phone {	
	public void call(String name) {
		System.out.println("打开微信");
		//System.out.println("给"+name+"打视频电话");
		super.call(name);
	}
}

public class PhoneTest {
	public static void main(String[] args) {
		Phone p = new Phone();
		p.call("刘诗诗");
		System.out.println("-----------");
		NewPhone np = new NewPhone();
		np.call("刘诗诗");
	}
}

多态


概述

多态是同一个行为具有多个不同表现形式或形态的能力(多个子类对同一方法的重写可以表现出不同的行为),父类的引用指向哪个子类的实例,就调用哪个类中的重写方法。

类型

  • 静态多态(编译时多态):程序在编译时就知道调用哪个方法,表现为方法重载
  • 动态多态(运行时多态):程序在运行时才知道调用哪个方法,表现为方法重写

产生动态多态的条件:

a.有继承
b.有方法重写
c.父类的引用指向子类的实例(向上转型)

本质

多态的本质就是将子类对象赋值给父类变量,在运行时期会表现出具体的子类特征(调用子类的重写方法)

成员访问特点

  • 成员变量访问特点
    编译看左边(基类),运行看左边(基类)

  • 成员方法访问特点
    编译看左边(基类),运行在右边(派生类)

动态的好处

  • 应用程序不必为每一个派生类编写调用功能,只需对抽象类进行处理即可。大大提高程序的可复用性,这是由于继承。

  • 派生类的功能可以被基类的方法或引用变量所调用,这叫向后兼容,可以提高扩容性和可维护性。

  • 具体体现:定义方法的时候,使用父类型作为参数,将来在使用的时候,使用具体的子类型参与操作。

多态的弊端:不能使用子类的特有功能

代码

public class DuoTaiDemo {
	public static void main(String[] args) {
		//多态
		Animal a = new Cat(); //向上转型
		a.eat();
		System.out.println(a.age);
		//a.playGame();
		//多态的弊端:无法访问子类特有方法
		//如何使用子类的特有方法
		//创建子类对象就可以了
		/*
		Cat c = new Cat();
		c.eat();
		c.playGame();
		*/
		//现在的代码虽然可以访问子类的特有功能,但是不合理
		//因为我们发现内存中有两个猫类的对象
		//这个时候,我们得想办法把多态中的猫对象还原
		//这个时候,就要使用多态中的转型了
		//父类引用转为子类对象
		Cat c = (Cat)a;//向下转换
		c.eat();
		c.play();
		
	}
}

public class Cat extends Animal {
	public int age = 20;
	@Override
	public void eat() {
		System.out.println("猫吃鱼");
	}
	
	public void play() {
		System.out.println("猫玩皮球");
	}
}

public class Animal {
	public int age = 18;
	public void eat() {
		System.out.println("吃东西");
	}
}

结果

18
猫吃鱼
猫吃鱼
猫玩皮球

未经允许不得转载:作者:1413-南同学, 转载或复制请以 超链接形式 并注明出处 拜师资源博客
原文地址:《Java继承与多态的理解》 发布于2020-11-22

分享到:
赞(0) 打赏

评论 抢沙发

评论前必须登录!

  注册



长按图片转发给朋友

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

微信扫一扫打赏

Vieu3.3主题
专业打造轻量级个人企业风格博客主题!专注于前端开发,全站响应式布局自适应模板。

登录

忘记密码 ?

您也可以使用第三方帐号快捷登录

Q Q 登 录
微 博 登 录