第七章继承、多态、抽象类与接口

迟早会把头薅秃

已于 2023-04-07 13:37:40 修改

阅读量51

点赞数

文章标签： java servlet jvm

于 2023-04-04 20:14:53 首次发布

本文链接：https://blog.csdn.net/m0_74339463/article/details/129864455

版权

7.1 类的继承

Java语言每个类只能继承一个父类，叫做单继承。

extends 继承

父类写法与普通写法相同，关键词extends的使用方法如下：

public class 父类类名(){

}

子类

public class 子类类名 extends 父类类名(){

}

因为Java只支持单继承，即一个类只能有一个父类，所以类似下面的代码是错误的：

class 子类 extends 父类1，父类2{

}

例7.1

父类Parent和子类Child都各自有一个无参的构造方法，在main()方法中创建子类对象时，Java虚拟机会先执行父类的构造方法，然后再执行子类的构造方法。

运行结果：

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

public只能有一个，用public修饰的类就是类名(文件名)。

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

例7.2

Telephone电话类作为父类衍生Mobile手机类，手机类可以直接使用电话类的按键属性和拨打电话行为。

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

class Mobile extends Telephone{//手机类继承电话类
	String screen = "screen:液晶屏";//成员属性，液晶屏幕
	void call() {	//拨打电话功能
		System.out.println("拨打电话");//输出
	}
}

public class Demo2 {

	public static void main(String[] args) {
		Mobile motto = new Mobile();
		System.out.println(motto.button);//子类调用父类属性
		System.out.println(motto.screen);//子类调用父类没有的属性
		motto.call();//子类调用父类方法
		
	}
}

运行结果：

方法的重写(子类重写父类方法)：返回参数相同，方法名相同，传入参数相同，只有方法体不同

Java虽然不允许同时继承多个父类，但不代表没有多个继承，可以通过类似“祖父>父>儿子>孙子”的方式实现多代继承。

例如：

class Animal{ //父类：动物类

Eye eye;

Mouth mouth;

nose nose;

}

class Dog extends Animal{} //子类：犬类

class Husky extends Dog{} //孙子类：哈士奇类

7.2 Object类

在Java中所有的类都直接或间接继承了Java.lang.Object类。Object类是比较特殊的类，它是所有类的父类。

由于所有的类都是Object类的子类，所以任何类都可以重写Object类中的方法。下面是Object类中几种重要用法：

1、getClass()方法

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

getClass().getname();

2、toString()方法

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

例7.3

创建Student类，重写toString()方法，使该类的对象可以自定义输出自己的姓名和年龄。


public class Student { //创建类
	String name; //定义name变量
	int age; //定义age变量
	
	public Student( String name,int age) { //定义构造方法
		this.name = name; //传入参数
		this.age = age; 
	}
	
	public String toString() { //重写toString()
		return"我叫" +name +",今年"+age+"岁。"; //返回值
	}

	public static void main(String[] args) {
		Student s1 =new Student("张三",16); //新建对象s1
		System.out.println(s1); //输出s1
		Student s2 =new Student("李四",17); //新建对象s2
		System.out.println(s2); //输出s2

	}

}

运行结果：

3、equals()方法

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

public class People1{
	int id;//身份证
 String name;//名字
 public People1(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;
  People1 other=(People1) obj;//将参数强转成本类对象
  if(id!=other.id)//如果两者的身份证号不相等
   return false;
  return true;
 }
 public String toString() {//重写Object类的toString()方法
  return name;//只输出名字
 }
 public static void main(String[] args) {
  People1 p1=new People1(220,"tom");
  People1 p2=new People1(220,"汤姆");
  People1 p3=new People1(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));
 }
 }

运算结果：

7.3 对象类型的转换

向上转型

子类转父类，子类对象赋值给父类引用。子类类型的对象直接赋值给父类类型的对象。自动类型转换语法如下：

Animal a = new dog();

向下转型

父类转子类，父类对象赋值给子类引用。可以理解为将父类类型的对象转换为子类类型的对象。但是运用向下转换，如果把一个叫抽象的类的对象转换为一个较具体的类的对象，这样的转型通常会出现错误，这时就需要借助强制类型转换。

Dog a =(Dog)new Animal();

例7.6

class Bird {}
class Pigeon extends Bird{}
public class Demo4 {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Bird bird = new Pigeon();//某只鸽子是一只鸟
		Pigeon pigeon = (Pigeon) bird;//某只鸟是一只鸽子（要进行强制类型转换）

	}

}

7.4 使用instanceof关键词判断对象类型

语法如下：

对象名 instanceof 类名

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

例7.7

因为四边形类与圆形类没有继承关系，因此两者不能使用instanceof关键词进行比较，否则会发生”不兼容“错误。如果删除或注释掉这一行代码，运行结果如下：

第二种使用方法：

对象名 instanceof 接口名

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

7.5 方法的重载

方法名相同，参数不同（返回参数不同，传入参数不同）

构造方法的名称由类名决定，所以构造方法只有一个名称。如果希望以不同的方式来实例化对象，就需要使用多个构造方法来完成。由于这些构造方法都需要根据类名进行命名，为了方法名相同而形参不同的构造方法同时存在，必须用到方法重载。虽然方法存在起源于构造方法，但它也可以应用到其他方法中。

例7.8

public class Demo4{
	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 double add(int a,double b) {//先int参数，后double参数
		return a;    //输出int参数值
	}
	public static double 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 Demo4{
	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 double add(int a,double b) {//先int参数，后double参数
		return a;    //输出int参数值
	}
	public static double 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));
		
	}
}

运行结果：

在参数列表中使用“...”形式定义不定长参数，其实这个不定长参数a就是一个数组，编译器会将“int…a”这种形式看作是“int[]a”，所以在add()方法体作累加操作时使用到了for循环语句，在循环中是根据数组a的长度作为循环条件的，最后将累加结果返回。

7.6 final关键词

final被译为”最后的“”最终的“，凡是被final关键词修饰过的内容都是不可改变的。

1、final变量

修饰变量——不能被改变（常量）

例如，在类中定义PI值，可以使用如下语句：

final double PI = 3.14;

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

2、final方法

修饰方法——不能被重写

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

因为打开电视这个方法是由final修饰的，子类无法重写。

3、final类

修饰类——不能被继承

如果将某个类设置为final类，则该类中的所有方法都被隐式设置为final方法，但是final类中的成员变量可以被定义为final或非final形式。

报错原因：类型Dad不能将最终类Baby子类化。

7.7 多态

利用多态可以使程序具有良好的扩展性，并可以对所有类对象进行通用的处理。

下面代码中的这种将子类对象视为父类对象的做法称为“向上转型”。

class Shape{}	//图形类
class Square extends Shape{}	//正方形类继承图形类
class Circular extends Shape{}	//圆形类继承图形类
public class Demo5 {
	public static void draw(Shape s) {	//绘制方法
		if(s instanceof Square) {	//如果是正方形
			System.out.println("绘制正方形");
		}else if(s instanceof Circular) {	//如果是圆形
			System.out.println("绘制圆形");
		}else {	//	如果是其他类型
			System.out.println("绘制父类图形");
		}
	}
	public static void main(String[] args) {
		draw(new Shape());
		draw(new Square());
		draw(new Circular());

	}

}

运行结果：

7.8 抽象类与接口

1.抽象类

如果声明一个抽象方法，就必须将承载这个抽象方法的类定义为抽象类，不能在非抽象类中获取抽象方法。只要类中有一个抽象方法，此类就被标记为抽象类。

使用abstract关键字定义的类称为抽象类，使用这个关键字的方法称为抽象方法。

抽象方法：

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

抽象方法没有方法体

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

public abstract void methodName();

假设父类是抽象类，子类是普通类，子类继承父类就需要被重写，如果不重写就会报错。

承载这个抽象方法的抽象类必须被继承，抽象类除了被继承没有任何意义。

作用：继承，制定规则。

2.接口

所有方法都是抽象方法

修饰符 interface 接口名{

}

实现 implements

Java语言每个类可以实现多个接口，可以单继承，多实现。

Java中不允许出现多重继承，但使用接口就可以实现多重继承。一个类可以同时实现对各接口。

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

}



interface Paintable{	//可绘制接口
 public void draw();	//绘制抽象方法
}

class Quadrangle2{ 	//四边形类
 public void doAnything() {
  System.out.println("四边形提供的方法");
 }
}

//平行四边形，继承四边形类，并实现了可绘制接口
class Parallelogram extends Quadrangle2 implements Paintable{
 public void draw() {
  System.out.println("绘制平行四边形");
 }
}

//正方形类，继承四边形类，并实现了可绘制接口
class Square2 extends Quadrangle2 implements Paintable{
 public void draw() {	//由于该类实现了接口，所以需要覆盖draw()方法
  System.out.println("绘制正方形");
 }
}

//圆形类，仅实现了可绘制接口
class Circular2 extends Quadrangle2 implements Paintable{
 public void draw() {
  System.out.println("绘制圆形");
 }
}

public class Dome7 {
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  Square2 s = new Square2();
  s.draw();
  s.doAnything();
  Parallelogram p = new Parallelogram();
  p.draw();
  p.doAnything();
  Circular2 c = new Circular2();
  c.draw();
 }
}

运行结果：