第七章总结：继承、多态类与接口

马虎小丸子

已于 2023-04-07 12:32:42 修改

阅读量211

点赞数

文章标签： html servlet 前端

于 2023-04-04 17:24:04 首次发布

本文链接：https://blog.csdn.net/z1314zppl/article/details/129957526

版权

类的继承

继承在程序中复用一些已经定义完善的类，不仅可以减少软件开发周期，也可以提高软件的可维护性和可扩展性。

子类重写父类的方法：返回参数相同，方法名相同，传入参数相同，只有方法体不同，前提是具有父子关系。

所有类的构造方法，第一行都有一个隐藏的“super();" 作用是在执行该构造方法之前调用其父类的构造方法。

在Java语言中，一个类继承另一个类需要使用关键字extrends,关键字extrends的使用方法如下

class Child extrends Parent{}

创建子类对象，观察构造方法执行顺序，代码如下：

class Parent{
	public Parent() {
		System.out.println("调用父类构造方法");
	}
}
 
class Child extends Parent{
	public Child() {
		System.out.println("调用子类构造方法");
	}
}
 
public class Demo {
	public static void main(String[] args) {
		new Child();
	}
 
}

运行结果：

子类继承父类之后可以调用父类创建好的属性和方法。

在电话基础上衍生出手机类，代码如下：

class Parent{//父类电话
String button="button:0~9";//成员属性，10个按键
void call() {//拨打电话功能
	System.out.println("开始拨打电话");
}
}
 
class Child extends Parent{//子类手机继承电父类电话
	String screen="screen:液晶屏";//成员属性，液晶屏幕
 
}
 
public class Demo2 {
	public static void main(String[] args) {
		Child motto=new Child();
		System.out.println(motto.button);//子类调用父类属性
		System.out.println(motto.screen);//子类调用父类没有的属性
		motto.call();//子类调用父类方法
	}
}

运行结果：

Object类

在开始学习使用class关键字定义类时，就应用到了继承原理，因为在Java中所有的类都直接或间接继承了java.lang.Object类是比较特殊的类，它是所有类的父类，是Java类层中的最高层类。

1、getClass()方法

getClass()方法是Object类定义的方法，它会返回对象执行时的Class实例，然后使用此实例调用getName()方法可以取得类的名称。语法如下：

getClass().getname();r

可以将getClass()方法与toString()方法联合使用。

2、toString()方法

toString()方法的功能是将一个对象返回为字符串形式，它会返回一String实例。在实际的应用中通常重写toString（）方法，为对象提供一个特定的输出模式。当这个类转换为字符串或与字符串连接时，将自动调用重写的toString()方法。

让学生自我介绍，创建Child类，重写toString()方法，使该类的对象可以自定义输出自己的姓名和年龄，代码如下：

public class Child{
	String name;
	int age;
	public Child(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public String toString() {
	return"我叫"+name+",今年"+age+"岁。";
	}
	public static void main(String[] args) {
		Child s1=new Child("张三",16);
		System.out.println(s1);
		Child s2=new Child("李四",19);
		System.out.println(s2);
	}
}

运行结果：

3、equals()方法
在Java语言中，有两种比较对象的方式，分别为”==“运算符与equals()方法。两者的区别在于：”==“比较的是两个对象引用内存地址是否相等，而equals()方法比较的是两个对象的实际内容。

根据身份证号判断是否为同一人，用equals()方法和”==“运算符来判断是否存在多个对象代表同一个人，代码如下：

public class People{
	int id;//身份证
	String name;//名字
	public People(int id,String name) {
		this.id=id;
		this.name=name;
	}
	public boolean equals(Object obj) {//重写Object类的equals()方法
		if(this==obj)//如果参数与本类同一个对象
			return true;
		if(obj==null)//如果参数是null
			return false;
		if(getClass()!=obj.getClass())//如果参数与本类类型不同
			return false;
		People other=(People) obj;//将参数强转成本类对象
		if(id!=other.id)//如果两者的身份证号不相等
			return false;
		return true;
	}
	public String toString() {//重写Object类的toString()方法
		return name;//只输出名字
	}
	public static void main(String[] args) {
		People p1=new People(220,"tom");
		People p2=new People(220,"汤姆");
		People p3=new People(220,"张三");
		Object o=new Object();
		System.out.println(p1+"与"+p2+"是否为同一人？");
		System.out.println("equals()方法的结果："+p1.equals(p2));
		System.out.println("==运算符的结果："+(p1==p2));
		System.out.println();
		System.out.print(p1+"与"+p3+"是否为同一人？");
		System.out.println(p1.equals(3));
		System.out.print(p1+"与"+o+"是否为同一人？");
		System.out.println(p1.equals(o));
	}
	}

运行结果：

对象类型的转换

1、向上转型

子类转父类，即子类赋值给父类，用自动类型转换

Bird bird=new Pigeon(); //用向上转换，借助自动类型转换，将鸽子类转换为鸟类，告诉编译器：“某只鸽子是一只鸟”

在运行向上转换的过程中，父类的对象无法调用子类独有的属性或者方法。

2、向下转型

父类转子类，即父类赋值给子类，用强制类型转换。语法如下：

子类类型子类对象=（子类类型）父类对象；

class Bird{}
class Pigeon extends Bird{}
public class Demo2{
	public static void main (String[] args) {
		Bird bird=new Pigeon();//用向上转换，借助自动类型转换，将鸽子类转换为鸟类，告诉编译器：“某只鸽子是一只鸟”
		Pigeon pigeon=(Pigeon) bird;//用向下转换，借助强制类型转换，将鸟类转换为鸽子类，告诉编译器：“某只鸟是一只鸽子”
	}
}

方法的重载

方法名相同，参数类型（返回参数、传入参数）不同，参数个数不同，参数顺序不同，都能构成重载。

编写不同形式的加法运算方法。代码如下：

public class Parent{
	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));
	}
}

运行结果：

在谈到参数个数可以确定两个方法是否具有重载关系时，会想到定义不定义长参数方法。不定长方法的语法如下：

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

使用不定长参数重载加法运算方法。代码如下：

public class Parent{
	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关键字

1、final变量

用final修饰方法的不能被重写

public class Child{
	static final double PI=3.1415926;
	public static void main(String[] args) {
		System.out.println("圆周率的值为："+PI);
		System.out.println("半径为3的圆的周长为："+(2*3*PI));
       //尝试修改PI的值
		PI=3.1415927;
 
	}
	}

会报错，错误如下（常量PI不允许被修改

当在程序中使用到PI这个常量时，它的值就是3.1415926。如果在程序中再次对定义为final的常量赋值，编译器将不会接受。

2、final方法
用final修饰变量不能被改变

将方法定义为final类型，可以防止子类修改父类的定义与现实方式，同时定义为final的方法的执行效果要高于非final方法。

3、final类
用final修饰类不能被继承

final class FinalClass{//被FinalClass修饰的类
 
}
public class FinalTest extends FinalClass{//行继承FinalClass
 
}

错误；

定义为final的类不能被继承。如果希望一个类不被任何类继承，并且不允许其他人对这个类进行任何改动，可以将这个类设置为final类。final类的语法如下：

final 类名{}

使用instanceof关键字判断对象类型
instanceof的语法格式如下：

对象名 instanceof 类名

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

使用instanceof关键字的表达式返回值为布尔类值。如果返回值为true，说明对象为类的实例对象；如果返回值为false，说明对象不是类的实例对象。

分析几何图形之间的继承关系，代码如下：

public class Child{
	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();
	}
	}