Java | 继承、多态、抽象类与接口

目录

一、类的继承

二、Object类

2.1 getClass()方法

2.2 toString()方法

2.3 equals()方法

三 、对象类型的转换

3.1 向上转换

3.2 向下转型

四、使用instanceof关键字判断对象类型

五、方法的重载

六、final关键字

6.1 final变量

6.2 final方法

6.3 final类

七、多态

八、抽象类与接口

8.1 抽象类

8.2 接口

---

一、类的继承

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

class Child extends Parent{}

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

class Child entends Parent1,Parent2{}

子类在继承父类之后，创建子类对象的同时也会调用父类的构造方法。

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

package haha;

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();
	}
}

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

package haha;

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

class Mobile extends Telephone{      //手机类继承电话类
	String screen="screen:液晶屏";     //成员属性，液晶屏幕
}

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{}         //孙子类：哈士奇类

虽然Husky类没有直接继承Animal类，但是Husky可以调用Animal类提供的可被继承的成员变量和方法。

二、Object类

在Java中所有的类都直接或间接继承了java.lang.Object类。Object类是比较特殊的类，它是所有类的父类，是Java类层中最高层类。用户创建一个类时，除非已经指定要从其他类继承，否则它就是从java.lang.Object类继承而来的。由于所有的类都是Object类的子类，所以在定义时可省略extends Object。

在Object类中，主要包括clone()、finalize()、equals()、toString()等方法，其中常用的两个方法为equals()和toString()方法。由于所有的类都是Object类的子类，所以任何类都可以重写Object类中的方法。

Object类中的getClass()、notify()、notifyAll()、wait()等方法不能被重写，因为这些方法被定义为final类型。

2.1 getClass()方法

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

getClass().getName();

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

2.2 toString()方法

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

package haha;

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

2.3 equals()方法

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

package haha;

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类的equal()方法
		if(this==obj)                           //如果参数与本类是同一个对象
			return true;
		if(obj==null)
			return false;                       //如果参数是null
		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(330,"张三");
		Object o=new Object();
		
		System.out.println(p1+"与"+p2+"是否为同一人？");
		System.out.println("equal()方法的结果："+p1.equals(p2));
		System.out.println("==运算符的结果："+(p1==p2));
		
		System.out.println();
		System.out.print(p1+"与"+p3+"是否为同一人？");
		System.out.println(p1.equals(p3));
		System.out.print(p1+"与"+o+"是否为同一人？");
		System.out.println(p1.equals(o));
	}
}

三 、对象类型的转换

3.1 向上转换

向上转换可以理解为将子类类型的对象转换为父类类型的对象，即把子类类型的对象直接赋值给父类类型的对象，进而实现按照父类描述子类的效果。

class People {}
class Teacher extends People {}
public class Demo3{
    public static void main(String[] args){
    People tom=new Teacher();
}

进行向上转型，父类类型的对象二可以引用子类类型的对象。而且，向上转型是安全的，因为向上转型是将一个较具体的对象转换为一个较抽象的类的对象。

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

3.2 向下转型

向下转型可以理解为将父类类型的对象转换为子类类型得到对象。但是，运用向下转型，如果把一个较抽象的类的对象转换为一个较具体的类的对象。这样的转型通常会出现错误。

要想实现向下转型，需要借助强制类型转换。语法如下：

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

两个没有继承关系的对象不可以进行向上转型或者向下转型。

父类对象可以强制转换为子类对象，但是有一个前提：这个父类对象要先引用这个子类对象。

Bird bird=new Peigon()      //某只鸽子是一只鸟
Pigeon pigeon=(Pigeon) bird     //通过强制类型转换，告诉编译器“某只鸟就是一只鸽子”

四、使用instanceof关键字判断对象类型

当在程序中执行向下转型操作时，如果父类对象不是子类对象的实例，就会发生ClassCastException异常，所以在执行向下转型之前需要养成一个良好的习惯，就是判断父类对象是否为子类对象的实例。这个判断通常使用instanceof关键字来完成。可以使用instanceof关键字判断是否一个类实现了某个接口，也可以用它来判断一个实例对象是否属于一个类。

instanceof的语法格式如下：

myobject instanceof ExampleClass

• myobject：某类的对象引用。
• ExampleClass：某个类。

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

instanceof是Java语言的关键字，Java语言中的关键字都为小写。

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

package haha;

class Quadrangle{}
class Square extends Quadrangle{}
class Circular{}

public class Demo5{
	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);  //判断正方形是否为四边形的子类
	}
}

 

五、方法的重载

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

方法的重载就是在同一个类中允许存在一个以上的同名方法，只要这些方法的参数个数或类型不同即可。

package haha;

public class OverLoadTest{
	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) {
		return a;
	}
	public static int add(double a,int b) {       
		return b;
	}
	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));
	}
}

在本例中分别定义了5个方法，在这5个方法中，前两个方法的参数类型不同，并且方法的返回值类型也不同，所以这两个方法构成重载关系；前两个方法与第3个方法相比，第3个方法的参数个数少于前两个方法，所以这3个方法也构成重载关系；最后两个方法相比，发现除了参数的出现顺序不同，其他都相同，同样构成重载关系。

虽然在方法重载中可以使两个方法的返回类型不同， 但只有返回类型不同并不足以区分两个方法的重载，还需要通过参数的个数以及参数的类型来设置。

 编译器是利用方法名、方法各参数类型和参数的个数、参数的顺序来确定类中的方法是否唯一。

不定长方法的语法如下：

返回值 方法名(参数数据类型...参数名称)

package haha;

public class OverLoadTest{
	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) {
		return a;
	}
	public static int add(double a,int b) {       
		return b;
	}
	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关键字修饰过的内容都是不可改变的。

6.1 final变量

如果在程序中再次对定义为final的常量赋值，编译器将不会接受。

final关键字定义的变量必须在声明时对其进行赋值操作。final除了可以修饰基本数据类型的常量，还可以修饰对象引用。由于数组也可以被看作一个对象来引用，所以final可以修饰数组。一旦一个对象引用被修饰为final后，它就只能恒定指向一个对象，无法将其改变以指向另一个对象。一个既是static又是final的字段只占据一段不能改变的存储空间。

6.2 final方法

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

在修饰权限中曾经提到过final修饰符，如果一个父类的某个方法被设置为private，子类将无法访问该方法，自然无法覆盖该方法。也就是说，一个定义为private的方法隐式被指定为final类型。因此无须将一个定义为private的方法再定义为final类型。

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

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

本实例运行前会报错，因为打开电视这个方法是由final修饰，子类无法打开，所以Baby想要打开电视，就只能找爸爸打开。

6.3 final类

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

final 类名{}

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

七、多态

package haha;

class Shape{}         //图形类
class Square extends Shape{}      //正方形类继承图形类
class Circular extends Shape{}    //圆形类继承图形类

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

八、抽象类与接口

仅用来描述特征切极具抽象性类，在Java中被定义为抽象类。

8.1 抽象类

在Java语言中 设置抽象类不可以实例化为对象。

使用abstrct关键字定义的类称为抽象类，而使用这个关键字定义的方法称为抽象方法。抽象方法没有方法体，这个方法本身没有任何意义，除非它被重写，而承载这个抽象方法的抽象类必须被继承，实际上抽象类除了被继承没有任何意义。

public abstract class Parent{
    abstract void testAbstract()；     //定义抽象方法
}

反过来讲，如果声明一个抽象方法，就必须将承载这个抽象方法的类称为抽象类，不能在非抽象类中获取抽象方法。换句话说，只有类中有一个抽象方法，此类就被标记为抽象类。

抽象类被继承后需要实现其中所有的抽象方法，也就是保证以相同的方法名称。参数列表和返回值类型创建出非抽象方法，当然也可以是抽象方法。

继承抽象类的所有子类需要将抽象类的抽象方法进行覆盖。

Java中规定不能同时继承多个父类。

8.2 接口

接口是抽象类的延伸，可以将它看作是纯粹的抽象类，接口中的所有方法都没有方法体。

接口使用interface关键字进行定义，其语法如下：

public interface Paintable{
    void draw();              //定义接口方法可省略public abstract
}

• public：接口可以像类一样被权限修饰符修饰，但public关键字仅限用于接口在与其同名的文件中被定义。
• interface：定义接口关键字。
• Paintable：接口名称。

一个类继承一个父类的同时再实现一个接口，可以写成如下形式：

public class Parallelogram extends Quadrangle implements Paintable{
    ...
}

在接口中，方法必须被定义为public或abstract形式，其他修饰权限不被Java编译器认可。或者说，即使不将该方法声明为public形式，它也是public形式。

在接口中定义的任何字段都自动是static和final的。

package haha;

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

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

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

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

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

public class Demo7{
	public static void main(String[] args) {
		Square s=new Square();
		s.draw();
		s.doAnything();
		Parallelogram p=new Parallelogram();
		p.draw();
		p.doAnything();
		Circular c=new Circular();
		c.draw();
	}
}

Java中不允许出现多重继承，但使用接口就可以实现多重继承。一个类可以同时实现多个接口，因此可以将所有需要继承的接口放置在implements关键字后并使用逗号隔开。实现多个接口的语法如下：

class 类名 implements 接口1,接口2,...,接口n

但这可能会在一个类中产生庞大的代码量，因为继承一个接口时需要实现接口中的所有方法。一个接口可以继承另一个接口，其语法如下：

interface intf1 {}
interface intf2 extends intf1 {}  //接口继承接口