Python 官方文档:入门教程 => 点击学习
目录什么是抽象类和接口? 区别在哪里?抽象类接口抽象类和接口解决了什么问题?如何模拟抽象类和接口如何决定该用抽象还是接口?什么是抽象类和接口? 区别在哪里? 不同的编程语言对接口和
不同的编程语言对接口和抽象类的定义方式可能有些差别,但是差别并不大。本文使用 Java 语言。
下面我们通过一个例子来看一个典型的抽象类的使用场景。
Logger 是一个记录日志的抽象类,FileLogger 和 MessageQueueLogger 继承Logger,分别实现两种不同的日志记录方式:
FileLogger 和 MessageQueuLogger 两个子类复用了父类 Logger 中的name、enabled 以及 minPermittedLevel 属性和 log 方法,但是因为两个子类写日志的方式不同,他们又各自重写了父类中的doLog方法。
父类
import java.util.logging.Level;
public abstract class Logger {
private String name;
private boolean enabled;
private Level minPermittedLevel;
public Logger(String name, boolean enabled, Level minPermittedLevel) {
this.name = name;
this.enabled = enabled;
this.minPermittedLevel = minPermittedLevel;
}
public void log(Level level, String message) {
boolean loggable = enabled && (minPermittedLevel.intValue() <= level.intValue());
if(!loggable) return;
doLog(level, message);
}
protected abstract void doLog(Level level, String message);
}
FileLogger
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
import java.util.logging.Level;
public class FileLogger extends Logger {
private Writer fileWriter;
public FileLogger(String name, boolean enabled, Level minPermittedLevel, String filePath) throws IOException {
super(name, enabled, minPermittedLevel);
this.fileWriter = new FileWriter(filePath);
}
@Override
protected void doLog(Level level, String message) {
// 格式化level 和 message,输出到日志文件
fileWriter.write(...);
}
}
MessageQueuLogger
import java.util.logging.Level;
public class MessageQueueLogger extends Logger {
private MessageQueueClient messageQueueClient;
public MessageQueueLogger(String name, boolean enabled, Level minPermittedLevel, MessageQueueClient messageQueueClient) {
super(name, enabled, minPermittedLevel);
this.messageQueueClient = messageQueueClient;
}
@Override
protected void doLog(Level level, String message) {
// 格式化level 和 message,输出到消息队列中
messageQueueClient.send(...)
}
}
通过上面的例子,我们来看下抽象类有哪些特性。
同样的,下面我们通过一个例子来看下接口的使用场景。
public interface Filter {
void doFilter(rpcRequest req) throws RpcException;
}
public class AuthencationFilter implements Filter {
@Override
public void doFilter(RpcRequest req) throws RpcException {
// 鉴权逻辑
}
}
public class RateLimitFilter implements Filter{
@Override
public void doFilter(RpcRequest req) throws RpcException {
// 限流逻辑
}
}
public class Application {
// 过滤器列表
private List<Filter> filters = new ArrayList<>();
filters.add(new AuthencationFilter());
filters.add(new RateLimitFilter());
public void handleRpcRequest(RpcRequest req) {
try {
for (Filter filter : filters) {
filter.doFilter(req);
}
} catch (RpcException e) {
// 处理过滤结果
}
// ...
}
}
上面的案例是一个典型的接口使用场景。通过Java中的 interface 关键字定义了一个Filter 接口,AuthencationFilter 和 RetaLimitFilter 是接口的两个实现类,分别实现了对Rpc请求的鉴权和限流的过滤功能。
下面我们来看下接口的特性:
综上,从语法上对比,这两者有比较大的区别,比如抽象类中可以定义属性、方法的实现,而接口中不能定义属性,方法也不能包含实现等。
除了语法特性的不同外,从设计的角度,这两者也有较大区别。抽象类本质上就是类,只不过是一种特殊的类,这种类不能被实例化,只能被子类继承。属于is-a的关系。接口则是 has-a 的关系,表示具有某些功能。对于接口,有一个更形象的叫法:协议(contract)
下面我们先来思考一个问题~
抽象类的存在意义是为了解决代码复用的问题(多个子类可以继承抽象类中定义的属性哈方法,避免在子类中,重复编写相同的代码)。
那么,既然继承本身就能达到代码复用的目的,而且继承也不一定非要求是抽象类。我们不适用抽象类,貌似也可以实现继承和复用。从这个角度上讲,我们好像并不需要抽象类这种语法呀。那抽象类除了解决代码复用的问题,还有其他存在的意义吗?
这里大家可以先思考一下哈~
我们还是借用上面Logger的例子,首先对上面的案例实现做一些改造。在改造之后的实现中,Logger不再是抽象类,只是一个普通的父类,删除了Logger中的两个方法,新增了 isLoggable()方法。FileLogger 和 MessageQueueLogger 还是继承Logger父类已达到代码复用的目的。具体代码如下:
public class Logger {
private String name;
private boolean enabled;
private Level minPermittedLevel;
public Logger(String name, boolean enabled, Level minPermittedLevel) {
this.name = name;
this.enabled = enabled;
this.minPermittedLevel = minPermittedLevel;
}
public boolean isLoggable(Level level) {
return enabled && (minPermittedLevel.intValue() <= level.intValue());
}
}
public class FileLogger extends Logger {
private Writer fileWriter;
public FileLogger(String name, boolean enabled, Level minPermittedLevel, String filePath) throws IOException {
super(name, enabled, minPermittedLevel);
this.fileWriter = new FileWriter(filePath);
}
protected void log(Level level, String message) {
if (!isLoggable(level)) return ;
// 格式化level 和 message,输出到日志文件
fileWriter.write(...);
}
}
package com.yanliang.note.java.abstract_demo;
import java.util.logging.Level;
public class MessageQueueLogger extends Logger {
private MessageQueueClient messageQueueClient;
public MessageQueueLogger(String name, boolean enabled, Level minPermittedLevel, MessageQueueClient messageQueueClient) {
super(name, enabled, minPermittedLevel);
this.messageQueueClient = messageQueueClient;
}
protected void log(Level level, String message) {
if (!isLoggable(level)) return ;
// 格式化level 和 message,输出到消息队列中
messageQueueClient.send(...)
}
}
以上实现虽然达到了代码复用的目的(复用了父类中的属性),但是却无法使用多态的特性了。
像下面这样编写代码就会出现编译错误,因为Logger中并没有定义log()方法。
Logger logger = new FileLogger("access-log", true, Level.WARN, "/user/log");
logger.log(Level.ERROR, "This is a test log message.");
如果我们在父类中,定义一个空的log()方法,让子类重写父类的log()方法,实现自己的记录日志逻辑。使用这种方式是否能够解决上面的问题呢? 大家可以先思考下~
这个思路可以用使用,但是并不优雅,主要有一下几点原因:
抽象类更多是为了代码复用,而接口更侧重于解耦。接口是对行为的一种抽象,相当于一组协议或者契约(可类比api接口)。调用者只需要关心抽象的接口,不需要了解具体的实现,具体的实现代码对调用者透明。接口实现了约定和实现相分离,可以降低代码间的耦合,提高代码的可扩展性。
实际上,接口是一个比抽象类应用更加广泛、更加重要的知识点。比如,我们经常提到的 ”基于接口而非实现编程“ ,就是一条几乎天天会用到的,并且能极大的提高代码的灵活性、扩展性的设计思想。
在前面列举的例子中,我们使用Java的接口实现了Filter过滤器。不过,在 c++ 中只提供了抽象类,并没有提供接口,那从代码的角度上说,是不是就无法实现 Filter 的设计思路了呢? 大家可以先思考下 🤔 ~
我们先会议下接口的定义:接口中没有成员变量,只有方法声明,没有方法实现,实现接口的类必须实现接口中的所有方法。主要满足以上几点从设计的角度上来说,我们就可以把他叫做接口。
实际上,要满足接口的这些特性并不难。下面我们来看下实现:
class Strategy {
public:
-Strategy();
virtual void alGorithm()=0;
protected:
Strategy();
}
抽象类 Strategy 没有定义任何属性,并且所有的方法都声明为 virtual 类型(等同于Java中的abstract关键字),这样,所有的方法都不能有代码实现,并且所有继承了这个抽象类的子类,都要实现这些方法。从语法特性上看,这个抽象类就相当于一个接口。
处理用抽象类来模拟接口外,我们还可以用普通类来模拟接口。具体的Java实现如下所示:
public class MockInterface {
protected MockInteface();
public void funcA() {
throw new MethodUnSupportedException();
}
}
我们知道类中的方法必须包含实现,这个不符合接口的定义。但是,我们可以让类中的方法抛出 MethodUnSupportedException 异常,来模拟不包含实现的接口,并且强迫子类来继承这个父类的时候,都主动实现父类的方法,否则就会在运行时抛出异常。
那又如何避免这个类被实例化呢? 实际上很简单,我们只需要将这个类的构造函数声明为 protected 访问权限就可以了。
上面的讲解可能偏理论,现在我们就从真实项目开发的角度来看下。在代码设计/编程时,什么时候该用接口?什么时候该用抽象类?
实际上,判断的标准很简单。如果我们需要一种is-a关系,并且是为了解决代码复用的问题,就用抽象类。如果我们需要的是一种has-a关系,并且是为了解决抽象而非代码复用问题,我们就用接口。
从类的继承层次来看,抽象类是一种自下而上的设计思路,先有子类的代码复用,然后再抽象成上层的父类(也就是抽象类)。而接口则相反,它是一种自上而下的设计思路,我们在编程的时候,一般都是先设计接口,再去思考具体实现。
好了,你是否掌握了上面的内容呢。你可以通过一下几个维度来回顾自检一下:
以上就是Java 接口和抽象类的区别的详细内容,更多关于Java 接口和抽象类的资料请关注编程网其它相关文章!
--结束END--
本文标题: Java 接口和抽象类的区别详解
本文链接: https://www.lsjlt.com/news/126485.html(转载时请注明来源链接)
有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341
下载Word文档到电脑,方便收藏和打印~
2024-03-01
2024-03-01
2024-03-01
2024-02-29
2024-02-29
2024-02-29
2024-02-29
2024-02-29
2024-02-29
2024-02-29
回答
回答
回答
回答
回答
回答
回答
回答
回答
回答
0