第七章：继承性、多态性

哪错了？

已于 2023-04-07 12:09:15 修改

阅读量73

点赞数

文章标签： java jvm 开发语言

于 2023-04-05 00:01:43 首次发布

本文链接：https://blog.csdn.net/m0_75052101/article/details/129864475

版权

继承

Java语言里只能继承一个父类：这个叫单继承；

父类写法与普通类写法相同

public class 父类类名（）{

}

子类写法

public class 子类类名 extends 父类类名（）{

}

在执行过程中会先调用父类再调用子类

所有类的构造方法第一行都有一个隐藏的super();

super()作用：在执行该构造方法之前调用其父类构造方法

子类调用成员方法遵行就近原则，先看一下自己有没有在去执行父类的

例题7.1

package c;



class p{//定义一个p类
	public p() {
		System.out.println("调用父类构造方法");//输出调用父类构造方法
	}
}
	class c extends p{//定义c类，继承父类p
		public c() {
			System.out.println("调用子类构造方法");//输出调用子类构造方法
		}
	}


public class Q4 {

	public static void main(String[] args) {
		
		// TODO Auto-generated method stub
		new c();//调用c方法
	}

}

结果

例题7.2

public class telephone {//电话类
	
	String button ="button:0~9";//成员属性，10个按键
	void call() {//拨打电话功能
		System.out.println("开始拨打电话");
		
	}
}
public class telephone {//电话类
	
	String button ="button:0~9";//成员属性，10个按键
	void call() {//拨打电话功能
		System.out.println("开始拨打电话");
		
	}
}
public class demo2 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		mobile motto=new mobile();
		System.out.println(motto.button);//子类调用父类属性
		System.out.println(motto.screen);//子类调用父类没用的属性
		motto.call();//调用父类方法
	}

}

结果

方法的重写

返回参数相同方法名相同传入参数相同只有方法体不同

只有父子关系关系的时候能用，子类重写父类的方法

object

object是所有类的父类，不论是直接继承还是间接继承都或多或少继承了它；

可以省略extends Object

任何类都可以重写Object类的方法

clone 克隆的涵义

toString()方法

是将一个对象返回为字符型形式，它会返回String实例。

在实际的应用中通常重写to String()方法，为对象提供一个特定的输出模式

public String toStrin() {

} 重写

当这个类型转换为字符串或字符串连接时，将自动调用重写的toString()方法。

equals()方法

在Java中，有两种比较对象的方式，分别为==和equals（）方法

两种的区别是：

== 是比较两个对象引用内存地址相同

equals 是比较两个对象的实际内容

对象类型的转换

父类animal a=new animal ();

子类dog a=new dog();

向上转型

子类转父类

子类对象赋值给父类引用

animal a=new dog();

向下转型

父类对象赋值给子类引用

dog a=（dog）new animal();

强制类型转换，例题7.3

package c;

class bird{}//定义鸟类
class pigeon extends  bird{}//定义鸽子类，是鸟类的子类
public class E4 {
	public static  void mian(String []args) {//主函数
		bird bird=new pigeon();//某鸽子是一只鸟
		pigeon pigeon=(pigeon) bird;//某一只鸟是一只鸽子
		
	}
}

bird bird=new pigeon(); 是向上转型，子类转父类，可以进行转换

pigeon pigeon=bird; 是向下转型，父类转子类，这样无法转换

pigeon pigeon=(pigeon) bird; 我们这样写才能完成转换，运用强制类型转换

重载

方法名相同参数不同（返回，传入，或者参数顺序不同，都叫不同）

在编译器的底层逻辑，如果传入参数和返回参数类型一样，那么编译器不会认为是重载，但是在父子关系中是重写

重载用在父子关系中也是重载；

如果方法名相同，参数也相同，那就是重写；

例题7.8

ublic class E4 {
	public static int add(int a,int b) {//定义一个方法
		return a+b;
	}
	public static double add(double a,double b) {//与第一个方法名相同，参数不同
		return a+b;
		
	}
	public static int add(int a) {//参数数量不同
		return a;
		
	}
	public static int add(int a,double b) {//先int参数，后double参数
		return a;//输出int参数
		
	}
	public static int add(double a,int b) {//先double参数，后int参数
		return b;//输出int参数
	}
public static void main(String[]args) {
	
		System.out.println("调用add(int,int)方法："+add(1,2));
		System.out.println("调用add(double,double)方法："+add(2.1,3.3));
		System.out.println("调用add(int)方法："+add(1));
		System.out.println("调用add(int,double)方法："+add(5,8.0));
		System.out.println("调用add(double,int)方法："+add(5.0,8));
		}
}

结果

不定长参数

语法如下

返回值方法名（参数数据类型...参数名称）

参数长度不定但参数类型定了；

其底层逻辑就是运用数组

例题7.9

public class E4 {
	public static int add(int a,int b) {//定义一个方法
		return a+b;
	}
	public static double add(double a,double b) {//与第一个方法名相同，参数不同
		return a+b;
		
	}
	public static int add(int a) {//参数数量不同
		return a;
		
	}
	public static int add(int a,double b) {//先int参数，后double参数
		return a;//输出int参数
		
	}
	public static int add(double a,int b) {//先double参数，后int参数
		return b;//输出int参数
	}
	public static  int add(int...a) {//定义不定长参数方法
		int s=0;
		for(int i=0;i<a.length;i++) {//根据参数个数做循环操作
			s+=a[i];//将每个参数累加
		}
		return s;//将计算结果返回
	}
	public static void main(String[]args) {
	
		System.out.println("调用add(int,int)方法："+add(1,2));
		System.out.println("调用add(double,double)方法："+add(2.1,3.3));
		System.out.println("调用add(int)方法："+add(1));
		System.out.println("调用add(int,double)方法："+add(5,8.0));
		System.out.println("调用add(double,int)方法："+add(5.0,8));
		
		//不定长参数
		System.out.println("调用不定长参数方法："+add(1,2,3,4,5,6,7,8,9));
		System.out.println("调用不定长参数方法："+add(1));
		
		
	}
}

final方法

修饰变量——不可改变的量（常量）

final double PI=3.14;

修饰方法——不能被重写

一个定义为private的方法隐式被指定为final类型，因此无需将一个定义为private的方法再定义为final类型（private的意思是私有）

private final voidtest（）{

........//省略代码

}

例题7.11

package c;

public class A4 {
	class Dad{
		public final void turnOntheTV() {
			System.out.println("爸爸打开了电视");
			
		}
	}

	class Baby extends Dad{
		public final void turnOntheTV() {
			System.out.println("宝宝也要打开电视");
			
		}
	}
}

我们会发现报错，意思是无法覆盖最终方法

修饰类——不能被继承

final 类名{}

例题

package c;
final class FinalClass{//被final修饰的类
	
}

public class A4 extends FinalClass {//强行继承
	
}

意思是不能成为最终态类的子类

instanceof关键字

对象名 instanceof 类名

判断对象是否属于该类或其子类

属于是输出真，不属于就输出假

例题7.7

package c;
class Quadrangle{}//创建四边形类
class Square extends Quadrangle{}//创建正方形类
class Circular{}//创建圆形类

public class A3 {//
	public static void main(String[]args) {
			Quadrangle q=new Quadrangle();//四边形对象
			Square s=new Square();//正方形对象
			System.out.println(q instanceof Square);//判断四边形是否为正方形的子类
			System.out.println(s instanceof Quadrangle);//判断正方形是否为四边形的子类
			System.out.println(q instanceof Circular);//判断正方形是否为圆形的子类
		}
	}
}

没有输出结果，因为最后一句代码会报错。

圆形和正方形没有父子关系，它们不能进行判断

对象名 instanceof 接口名

判断对象是否属于该接口的实现类

多态

子类继承父类，所形成的多种形态。就叫多态

继承父类所形成的多种结果，使用多个方法、变量、类，只要结果不同就是多态

使用多态节省了开发和维护时间，避免编写大量重复的代码

例题

package zy;

class SH{}//图形类
class sq extends SH{}//正方形类继承图形类
class q extends SH{}//圆形类继承图形类
public class Q{
	public static void dr(SH s) {//绘制方法dr
		if(s instanceof sq) {//如果是正方形
			System.out.println("绘制正方形");
		}else if(s instanceof q) {//如果是圆形
			System.out.println("绘制圆形");
		}else {//如果是其他类型
			System.out.println("绘制父类图形");
		}
	}
public static void main(String []args) {
		
		dr(new SH());//调用方法dr
		dr(new sq());
		dr(new q());
}
	
}

抽象方法

修饰符 abstract 返回参数方法名（传入参数）；

public abstract void st();

用abstract修饰，没有方法体，；结尾

抽象方法只能用抽象类定义

抽象类有抽象方法的类一定是抽象类

修饰符 abstract class 类名{
}

public abstract class 类名{

}

子类继承父类，如果父类是抽象类，有抽象方法，子类是普通类，不能有抽象方法，子类要继承父

类，但是子类不能有抽象方法，那么重写就可以继承抽象类父类，同时子类维持是普通类。

因为子类继承父类，所以父类的抽象方法已经在子类里，但是子类不能有抽象方法，不然要不报错

要不变成抽象类，只有重写才能够达到普通类子类继承抽象类父类的结果（这样就会形成一个规则，遇到抽象方法就重写）

接口

所有方法都是抽象方法就是接口（不能有普通方法）

修饰符 interface 接口名{

}

Java是单继承，它的缺点就是无法多继承，但是我们有解决办法，就是接口

Java语言每个类可以实现多个接口

实现接口 implements

修饰符 class 类名 implements 接口1，接口2，.......{

}

接口的目的是为了实现多个结果

一个子类要继承父类还要实现接口，要先继承后实现

接口的实现类必须重写接口的抽象方法（这是接口制定的规则），不然会报错，或者变成抽象类

如果接口的实现类是抽象类，那么可以不重写一些抽象方法

例题7.13

package b;

interface p{//绘制图形接口
	public void dr();//方法
}
class Q{//平行四边形类
	public void doA(){//重写方法
		System.out.println("四边形提供的方法");
		
	}
}
class Pare extends Q implements p{//平行四边形类继承正方形类，实现接口
	public void dr() {
		System.out.println("绘制平行四边形");
	}
}
class s extends Q implements p{//正方形类继承平行四边形类，实现接口
	public void dr() {
		System.out.println("绘制正方形");
		
	}
}
class C implements p{//圆形类实现接口
	public void dr() {
		System.out.println("绘制圆形");
	}
}


public class demo{
	public static void main(String[]args) {
		s s1=new s();//创建对象，s1
		s1.dr();//调用方法dr
		s1.doA();//调用方法doA
		Pare p1=new Pare();
		p1.dr();
		p1.doA();
		C c1=new C();
		c1.dr();
	}
	}

哪错了？

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
第七章：继承性、多态性

一个定义为private的方法隐式被指定为final类型，因此无需将一个定义为private的方法再定义为final类型（private的意思是私有）在编译器的底层逻辑，如果传入参数和返回参数类型一样，那么编译器不会认为是重载，但是在父子关系中是重写。因为子类继承父类，所以父类的抽象方法已经在子类里，但是子类不能有抽象方法，不然要不报错。Java是单继承，它的缺点就是无法多继承，但是我们有解决办法，就是接口。在Java中，有两种比较对象的方式，分别为==和equals（）方法。
复制链接

扫一扫