13. 抽象类 & 接口

一、抽象类

// 抽象类Shape
public abstract class Shape
{
	// 1. 成员变量
	private String color;

	// 2. 初始化块
	{
		System.out.println("执行Shape的初始化块...");
	}

	// 3. 构造器
	public Shape() {}
	public Shape(String color)
	{
		System.out.println("执行Shape的构造器...");
		this.color = color;
	}

	// 4. 方法:抽象方法和普通方法都可以
	public abstract double calPerimeter();
	public void setter(String color)
	{
		this.color = color;
	}

	// 5. 内部类(接口、枚举)
}

1. 抽象方法

  • 抽象方法没有方法体(只有方法签名,没有方法实现),只能由子类提供实现(即重写)
  • 抽象方法必须能被其子类重写才有意义,即private和abstract不能同时修饰某个方法
  • final修饰的方法不能被重写,因此final和abstract不能同时修饰某个方法
  • 类方法不能被定义成抽象方法,即static和abstract不能同时修饰某个方法
  • 含有抽象方法的类只能被定义成抽象类

2. 抽象类

  • 抽象类不能被实例化(不能创建抽象类的实例),只能当作父类被其他子类继承
  • final修饰的类不能被继承,因此final和abstract永远不能同时使用
  • 子类只有实现抽象父类里的所有抽象方法,才能被定义成普通类

3. 抽象类的成员:成员变量、方法、初始化块、构造器、内部类(接口、枚举)

  • 抽象类里可以没有抽象方法
  • 抽象类中的初始化块和构造器都不是在创建该类对象时被调用的(抽象类的构造器不能用于创建实例),而是在创建其子类的实例时被调用

4. 利用抽象类可以发挥多态的优势,使程序更加灵活

// 下面定义一个Circle普通类,其必须实现Shape里的抽象方法
public class Circle extends Shape
{
	private double radius;
	public Circle(String color, double radius)
	{
		super(color);
		this.radius = radius;
	}

	public void setRadius(double radius)
	{
		this.radius = radius;
	}

	// 重写Shape类的计算周长的抽象方法
	public double calPerimeter()
	{
		return 2 * Math.PI * radius;
	}

	public static void main(String[] args)
	{
		// 定义Shape类型的引用变量s,s指向Circle对象
		Shape s = new Circle("黄色", 3);

		// 由于在Shape类中定义了calPerimeter()方法,所以程序可以直接调用变量s的calPerimeter()方法
		// 无须将变量s强制转换为其子类类型
		System.out.println(s.calPerimeter());
	}
}

5. 抽象类的作用

  不同Shape子类对周长的计算方法是不一样的,即Shape类无法准确地知道其子类计算周长的方法,故Shpe类不知道如何实现calPerimeter()方法。此时若不在Shape类中定义calPerimeter()方法,则Shape引用变量s虽然可以引用到Shape子类的实例,但该变量s却无法调用calPerimeter()方法,必须将其强制转换为其子类类型才行,这就降低了程序的灵活性。这种情况下,我们可以在Shape类中将calPerimeter()方法定义为抽象方法,其具体实现交给子类来完成。也就是说,抽象父类把不能实现的方法定义为抽象方法,留给其子类去实现

  • 从语义的角度来看,抽象类是从多个具体类中抽象出来的父类,它具有更高层次的抽象
  • 从多个具有相同特征的类中抽象出一个抽象类,以这个抽象类作为其子类的模板,从而避免了子类设计的随意性
  • 抽象类体现的是一种模板模式的设计,抽象类作为多个子类的通用模板,子类在抽象类的基础上进行扩展、改造,但子类总体上会大致保留抽象类的行为方式

二、接口

/*
 * 示例:定义一个接口
 */
[修饰符] interface 接口名 extends 父接口1, 父接口2...
{
	// 成员1:静态常量
	[public static final int] MAX_SIZE = 50;
	
	// 成员2:抽象方法
	[public abstract] void getData(String msg);

	// 成员3:默认方法
	[public] default void test()
	{
		System.out.println("默认的test()方法");
	}

	// 成员4:类方法
	[public] String staticTest()
	{
		return "接口里的类方法";
	}

	// 成员5:私有方法
	private void foo()
	{
		System.out.println("foo私有方法");
	}
	private static void bar()
	{
		System.out.println("bar私有静态方法");
	}

	// 成员6:内部类、内部接口、内部枚举
}

1. 定义接口概述

  • 定义接口使用interface关键字
  • 修饰符可以是public或省略,如果省略了public访问控制符,则默认采用包权限访问控制符
  • 接口名应与类名采用相同的命名规则,通常使用形容词
  • 接口只能继承接口,且接口支持多继承(可以有多个直接父接口)
  • 一个Java源文件里最多只能有一个public接口,且如果某Java源文件里定义了一个public接口,则该文件名必须与public接口名相同

2. 接口的成员

由于接口里定义的是多个类共同的公共行为规范,因此接口里的成员(除了私有方法)都是public访问权限。

定义接口成员(除了私有方法)时,既可以显式使用public修饰符,也可以省略不写(此时系统会自动添加public修饰符)。

①静态常量

  • 接口里的成员变量只能是静态常量,它们是接口相关的
  • 在接口中定义成员变量时,不管是否使用public static final修饰符,接口里的成员变量总是使用这三个修饰符来修饰(系统自动添加)
  • 由于接口里没有初始化块和构造器,因此接口里的静态常量只能在定义时指定默认值

②抽象方法(无方法体)

  • 由于接口里定义的方法只能是抽象方法、类方法、默认方法和私有方法,因此如果不是定义后三种方法,系统将自动为普通方法增加abstract修饰符
  • 定义接口里的普通方法时,不管是否使用public abstract修饰符,接口里的普通方法总是使用public abstract来修饰(系统自动添加)

③默认方法(带方法体)

  • 默认方法必须使用default修饰,且不能使用static修饰,故不能直接使用接口来调用
  • 定义接口里的默认方法时,不管是否使用public修饰符,接口里的默认方法总是使用public来修饰(系统自动添加)
  • 接口的默认方法其实就是实例方法,只是多了个default修饰符而已

④类方法(带方法体)

  • 类方法必须使用static修饰,且不能使用default修饰,可以直接使用接口来调用
  • 定义接口里的类方法时,不管是否使用public修饰符,接口里的默认方法总是使用public来修饰(系统自动添加)

⑤私有方法(带方法体)

  • Java9增加了私有方法,这是因为:Java8允许在接口中定义带方法体的默认方法和类方法,那么当两个默认方法(或类方法)中包含一段相同的实现逻辑时,程序必然考虑将这段实现逻辑抽取成工具方法,而工具方法时应该被隐藏的,故Java9增加了私有方法。

⑥内部类、内部接口、内部枚举

  • 接口里的内部类、内部接口、内部枚举默认采用public static来修饰(系统自动添加)

3. 接口的作用

  • 抽象类是从多个类中抽象出来的模板,如果将这种抽象进行得更彻底,那就得到了“接口”
  • 接口定义了某一批类所需要遵守的规范,接口不关心这些类的内部状态数据和方法实现细节,它只规定这些类里必须提供哪些方法
  • 接口是从多个相似类中抽象出来的规范,接口不提供任何实现,它体现的是规范和实现分离的设计哲学
  • 接口作为系统与外界交互的窗口,它规定了实现者必须向外提供哪些服务,还规定了调用者可以调用哪些服务以及如何调用这些服务
  • 当在一个程序中使用接口时,接口是多个模块间的耦合标准;当在多个程序之间使用接口时,接口是多个程序之间的通信标准

4. 抽象类 & 接口

  • 抽象类体现的是一种模板式设计,它作为系统中多个子类的抽象父类,已经实现了系统的部分功能(那些已经提供实现的方法)
  • 接口体现的是一种规范,它是系统的“总纲”,制定了系统各模块应该遵循的标准,故一个系统的接口不应该经常改变

三、面向接口编程

1. 接口的三大用途

  • 定义引用类型变量,该变量必须引用到接口实现类的对象,该变量也可进行强制类型转换
  • 调用接口中定义的常量
  • 被实现类实现

2. 类实现接口

// 类实现接口的语法格式
[修饰符] class 类名 extends 父类 implements 接口1, 接口2...
{
}
  • 类实现接口使用implements关键字
  • 一个类可以继承一个父类,并同时实现一个或多个接口,implements部分必须放在extends部分之后
  • 类实现接口时,该类将获得接口中定义的静态常量、方法等,故可以把实现接口理解为一种特殊的继承
  • 类实现接口时,必须完全实现接口里所定义的全部抽象方法,否则,该类将保留从父接口那里继承到的抽象方法,该类也必须定义成抽象类
  • 实现接口方法时,必须使用public访问控制修饰符,因为接口里的方法都是public的,故实现类实现接口里的方法时只能使用public访问权限

3. 模拟多继承

interface Output
{
	// 静态常量,系统自动添加public static final修饰符
	int MAX_CACHE_LINE = 50;
}

interface Product
{
	// 抽象方法,系统自动添加public abstract修饰符
	int getProduceTime();
}

// 让Printer类实现Output和Product接口
public class Printer implements Output, Product
{
	public int getProduceTime()
	{
		return 45;
	}

	public static void main(String[] args)
	{
		// ex1:创建一个Printer对象,当成Output使用
		Output o = new Printer();

		// ex2:创建一个Printer对象,当成Product使用
		Product p = new Printer();
		System.out.println(p.getProduceTime());

		// ex3:所有接口类型的引用变量都可直接赋给Object类型的变量
		Object obj = p;
	}
}
  • Printer类实现了Output接口和Product接口,故Printer对象既可直接赋给Output变量,也可直接赋给Product变量
  • 彷佛Printer类既是Output类的子类,也是Product类的子类,这就是Java提供的模拟多继承,通过实现多个接口可以弥补单继承的不足
  • 虽然接口不能显式继承任何类,但所有接口类型的引用变量都可直接赋给Object类型的引用变量
原文地址:https://www.cnblogs.com/xzxl/p/11178111.html