Java接口和抽象类_java的抽象类和接口

---

1️⃣接口

接口中不可以创建对象
在Java中，抽象类可以包含非抽象方法。抽象类是一个没有具体实现其所有抽象方法的类，但是这并不意味着它不能包含非抽象方法。非抽象方法提供具体的实现，可以由子类继承或重写。

提示：这里可以添加本文要记录的大概内容：

Java接口是一种特殊的抽象类
接口是一种能力的描述

Java中的接口是一种抽象的类型，用于定义一组方法。接口只有方法的定义，没有方法的实现。
类可以实现一个或多个接口，实现接口的类必须实现接口中定义的所有方法。

提示：接口的定义使用关键字interface

---

下面详细讲解Java接口的特点和使用方法：
手机能接打电话

一、定义接口

接口中只能定义静态常量属性和抽象的方法
抽象方法是具体描述这种能力的

可以使用interface关键字定义接口，如下所示：

public interface Callable {
    public abstract void call();
	void answer();
}
1
2
3
4

在上面的代码中，Callable接口定义了一个名为call的抽象方法（没有方法体）。

再定义一个接口Audio

public interface Audio {
//播放声音
	void playSound();
}
1
2
3
4

二、实现接口

接口必须要有对应的实现类
必须实现这些接口中定义的抽象方法
实现之后具备了这种能力

可以使用implements关键字来实现某些接口，如下所示：

public class Iphone12Pro implements Callable,Audio{
//添加未实现的方法
	@Override
	public void call() {
		System.out.println("Iphone12Pro可以拨打电话");
		
	}

	@Override
	public void answer() {
		System.out.println("Iphone12Pro可以接听电话");
		
	}

	@Override
	public void playSound() {
		System.out.println("Iphone12Pro可以播放声音");
		
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

在上面的代码中，Iphone12Pro类实现了MyInterface接口，并实现了Callable,Audio方法。
注意，实现接口的类必须实现接口中定义的所有抽象方法。

如果某个类没有实现接口中的所有方法，那么该类必须声明为抽象类。

三、接口测试

public static void main(String[] args) {
		Iphone12Pro  iphone12Pro = new Iphone12Pro();
		iphone12Pro.call();
		iphone12Pro.answer();
		iphone12Pro.playSound();
	}
1
2
3
4
5
6

如果某个类即需要继承又需要实现，要先继承再实现
接口可以多继承，类只能单继承

public class Iphone12Pro extends Thread implements Callable,Audio{

}
1
2
3

---

2️⃣抽象类

抽象类 不能创建对象
抽象类 需要子类继承才有意义
抽象类中能定义抽象方法也可以定义非抽象方法
抽象类实际应用中当做模板来使用
抽象类中要包含非抽象的方法，可以让子类继承后直接使用
抽象类要包含抽象方法，让子类继承后去重写

抽象方法，里面不写具体逻辑，只是abstract修饰方法 calclate()

一个类里如果有抽象方法就是一个抽象类，也用abstract修饰

【例】矩形面积计算

public abstract class Shape {
//图形类的实现
	private String color;

	public Shape() {
		super();
		// TODO 自动生成的构造函数存根
	}

	public Shape(String color) {
		super();
		this.color = color;
	}
	
	public void showColor() {
		System.out.println("颜色是"+color);
	}
	//抽象方法
	//定义时在返回值类型前使用abstract关键字
	//没有方法体
	public abstract double getArea() ;
	
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

再写一个Shape的子类

非抽象的子类继承抽象类后，必须重写抽象类中定义的所有抽象方法

public class Rectangle extends Shape{
//他是矩形类，Shape的子类
	private double length;
	private double width;
	

	@Override
	public double getArea() {
		return length*width;
    //添加未实现的方法
	}


	public Rectangle() {
		super();
		// TODO 自动生成的构造函数存根
	}


	public Rectangle(String color, double length, double width) {
		super(color);
		this.length = length;
		this.width = width;
	}


	public double getLength() {
		return length;
	}


	public void setLength(double length) {
		this.length = length;
	}


	public double getWidth() {
		return width;
	}


	public void setWidth(double width) {
		this.width = width;
	}
	
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

再来个子类圆形

public class Circle extends Shape{
	private double radius;//半径
	
	public Circle(String color, double radius) {
		super(color);
		this.radius = radius;
	}

	public Circle() {
		super();
		// TODO 自动生成的构造函数存根
	}

	public double getRadius() {
		return radius;
	}

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

	@Override
	public double getArea() {
		return 3.14*radius*radius;
	}
	
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

需要注意的是上面的无参方法是自动生成的：

有参的调用有参的

测试类实现

public class 抽象类测试 {
	public static void main(String[] args) {
		//Shape x = new Shape();
		Rectangle rectangle = new Rectangle("蓝",15,6);
		rectangle.showColor(); //继承的图形的这个父类
		System.out.println(rectangle.getArea()); //getArea()方法是继承后重写的
		
		
		Circle circle = new Circle("黑",6);
		circle.showColor();
		System.out.println(circle.getArea());
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

*️⃣接口和抽象类区别

不同点

1、定义

接口是抽象方法和全局常量的集合

抽象类是包含一个抽象方法的类

2、组成

接口由常量和抽象方法组成

抽象类由构造方法、普通方法、抽象方法、常量、变量组成

3、关键字

接口：interface

抽象类：abstract class

4、使用

子类实现接口（implements）

子类继承抽象类（extends）

5、关系

接口不允许继承抽象类，但允许继承多个接口

抽象类可以实现多个接口

6、设计模式

接口：工厂设计模式、代理设计模式

抽象类：模板设计

7、实际

接口作为一个标准、表示一种能力

抽象类作为一个模板

8、局限性

接口没有此局限性

抽象类有单继承的局限性

9、访问修饰符

接口默认的访问修饰符是public

抽象方法的访问修饰符可以是public、protected、default

10、速度

接口稍微慢，因为它要寻找在类中实现的方法

抽象类比接口速度快

11、与普通Java类的区别

不是同一个类型的东西

抽象类除了不能实例化对象外，和普通Java类没有区别

12、main方法

接口没有main方法。因此不能运行(jdk8以后接口可以有default和static方法，所以可以运行main方法)

抽象类中可以有main方法，并且可以运行。

13、构造方法

接口没有构造方法

抽象类可以有构造方法，用于子类实例化使用

相同点

14、对象

都要通过对象的多态性来实例化对象

15、选择

如果抽象类和接口都可以使用的话，优先使用接口，因为可以避免单继承的局限性

16、特殊性

一个抽象类中可以包含多个接口，一个接口中可以包含多个抽象类