Thinking in Java,Fourth Edition(Java 编程思想,第四版)学习笔记(九)之Interfaces
Interfaces and abstract classes provide more structured way to separate interface from implementation.
the abstract class, which is a kind of midway step between an ordinary class and an interface.
Abstract classes and methods
abstract void f();
A class containing abstract methods is called an abstract class. If a class contains one or more abstract methods, the class itself must be qualified as abstract.
It's possible to make a class abstract without including any abstract methods. This is useful when you've got a class in which it doesn't make sense to have any abstract methods, and yet you want to prevent any instances of that class.
Abstract classes are also useful refactoring tools, since they allow you to easily move common methods up the inheritance hierarchy.
Interfaces
The interface keyword produces a completely abstract class, one that provides no implementation at all.
An interface says, "All classes that implement this particular interface will look like this."
The interface is used to establish a "protocol" between classes.
interface allowed multiple inheritance
An interface can also contain fields, but these are implicitly static and final.
You can choose to explicitly declare the methods in an interface as public, but they are public even if you don't say it. So wnen you implement an interface, the methods from the interface must be defined as public.
Complete decoupling
Creating a method that behaves differently depending on the argument object that you pass it is called the Strategy design pattern. The method contains the fixed part of the algorithm to be performed, and the Strategy contains the part that varies
The Strategy is the object that you pass in, and it contains code to be executed.
public static void process(Processor p, Object s) {
p.process(s);
}
public static void main (String[] args) {
process(new Upcase(),s);
process(new Downcase(),s);
}
However, you are often in the situation of not being able to modify the classes that you want to use. In these cases, you can use the Adapter design pattern.
class FilterAdapter implements Processor {
Filter filter;
public FilterAdapter (Filter filter) {
this.filter = filter;
}
public String name () { return filter.name();}
public Waveform process (Object input) {
return filter.process((Waveform)input);
}
"Multiple inheritance" in Java
A class can only extends one class, and can implements one or more interface
When you combine a concrets class with interfaces this way, the concrete class must come first, then the interfaces.
The resons for interfaces:
1. to upcast to more than one base type.
2. (the same as using an abstract base class) to prevent the client programmer from makig an object of this class and to establish that it is only an interface.
In fact, if you know somethins is going to be a base class, you can consider making it an interface.
Extending an interface with inheritance
You can easily add new method declarations to an interface by using inheritance, and you can also combine several interfaces into a new interface with inheritance.
Name collisions when combining interfaces
overloaded methods cannot differ only by return type.
Using the same method names in different interfaces that are intended to be combined generally causes confusion in the readability of the code, as well. Strive to avoid it.
Adapting to an interface
A common use for interfaces is the Strategy design pattern.
Fields in interfaces
Because any fields you put into an interface are automatically static and final, the interface is a convenient tool for creating groups of constant values. Before Java SE5, this was the only way to produce the same effect as an enum.
The fields in an interface are automatically public.
Initializing fields in interfaces
Fields defined in interfaces cannot be "blank finals", but they can be initialized with non-constant expressions.
the fields, of course, are not part of the interface. The values are stored in the static storage area for that interface.
Nesting interfaces
nesting an interface, these can have public 、package-access or private visibility.
Implementing a private interface is a way to force the definition of the methods in that interface without adding any type information.
package interfaces.nesting;
class A {
interface B {
void f();
}
public class BImp implements B {
public void f() {
}
}
private class BImp2 implements B {
public void f() {
}
}
public interface C {
void f();
}
class CImp implements C {
public void f() {
}
}
private class CImp2 implements C {
public void f() {
}
}
private interface D {
void f();
}
private class DImp implements D {
public void f() {
}
}
public class DImp2 implements D {
public void f() {
}
}
public D getD() {
return new DImp2();
}
private D dRef;
public void receiveD(D d) {
dRef = d;
dRef.f();
}
}
interface E {
interface G {
void f();
}
// Redundant "public":
public interface H {
void f();
}
void g();
// Cannot be private within an interface:
// ! private interface I {}
}
public class NestingInterfaces {
public class BImp implements A.B {
public void f() {
}
}
class CImp implements A.C {
public void f() {
}
}
// Cannot implement a private interface except
// within that interface’s defining class:
// ! class DImp implements A.D {
// ! public void f() {}
// ! }
class EImp implements E {
public void g() {
}
}
class EGImp implements E.G {
public void f() {
}
}
class EImp2 implements E {
public void g() {
}
class EG implements E.G {
public void f() {
}
}
}
public static void main(String[] args) {
A a = new A();
// Can’t access A.D:
// ! A.D ad = a.getD();
// Doesn’t return anything but A.D:
// ! A.DImp2 di2 = a.getD();
// Cannot access a member of the interface:
// ! a.getD().f();
// Only another A can do anything with getD():
A a2 = new A();
a2.receiveD(a.getD());
}
}
The rules about interfaces-- that all interfaces elements must be public--are strictly enforces here, so an interface nested within another interface is automatically public and cannot be made private.
Notice that when you implement an interface, you are not required to implement any interfaces nested within. Also, private interfaces cannot be implemented outside of their defining classes.
Interfaces and factories
An interfaces is intended to be a gateway to multiple implementations, and a typical way to produce objects that fit the interface is the Factory Method design pattern.
You call a creation method on a factory object which produces an implementation of the interface--this way, in theory, your code is completely isolated from the implementation of the interface.
Summary
Almost anytime you create a class, you could instead create an interface and a factory.
Interfaces should be something you refactor to when necessary, rather than installing the extra level of indirection everywhere, along with the extra complexity.
An appropriate guideline is to prefer classes to interfaces. Start with classes, and if it becomes clear that interfaces are necessary, then refactor. Interfaces are a great tool, but they can easily be overused.
Thinking in Java,Fourth Edition(Java 编程思想,第四版)学习笔记(九)之Interfaces的更多相关文章
- Thinking in Java,Fourth Edition(Java 编程思想,第四版)学习笔记(七)之Access Control
Access control ( or implementation hiding) is about "not getting it right the first time." ...
- Thinking in Java,Fourth Edition(Java 编程思想,第四版)学习笔记(六)之Initialization & Cleanup
Two of these safety issues are initialization and cleanup. initialization -> bug cleanup -> ru ...
- Thinking in Java,Fourth Edition(Java 编程思想,第四版)学习笔记(十三)之Strings
Immutable Strings Objects of the String class are immutable. If you examine the JDK documentation fo ...
- Thinking in Java,Fourth Edition(Java 编程思想,第四版)学习笔记(二)之Introduction to Objects
The genesis of the computer revolution was a machine. The genesis of out programming languages thus ...
- Thinking in Java,Fourth Edition(Java 编程思想,第四版)学习笔记(十四)之Type Information
Runtime type information (RTTI) allow you to discover and use type information while a program is ru ...
- Thinking in Java,Fourth Edition(Java 编程思想,第四版)学习笔记(十二)之Error Handling with Exceptions
The ideal time to catch an error is at compile time, before you even try to run the program. However ...
- Thinking in Java,Fourth Edition(Java 编程思想,第四版)学习笔记(十一)之Holding Your Objects
To solve the general programming problem, you need to create any number of objects, anytime, anywher ...
- Thinking in Java,Fourth Edition(Java 编程思想,第四版)学习笔记(十)之Inner Classes
The inner class is a valuable feature because it allows you to group classes that logically belong t ...
- Thinking in Java,Fourth Edition(Java 编程思想,第四版)学习笔记(八)之Polymorphism
Polymorphism is the third essential feature of an object-oriented programming language,after data ab ...
随机推荐
- 理解Go语言组件flag
作用 主要用来实现命令行的参数解析,以达到实现以下效果的目的 $ cmd -flagname 123 使用方式 flag是Go语言的内置包,能接收的参数类型主要有字符串.布尔和数值类型. 方式一 fu ...
- [极客大挑战 2019]PHP1
知识点:PHP序列化与反序列化,最下方有几个扩展可以看一下 他说备份了,就肯定扫目录,把源文件备份扫出来 dirsearch扫目录扫到www.zip压缩包
- 洛谷1972 HH的项链 树状数组查询区间内不同的数的数量
题目链接:https://www.luogu.com.cn/problem/P1972 题意大致是:给定一个序列长度为n,给出m个查询区间,要求响应是区间内不同的数的个数.为此我们考虑到树状数组的区间 ...
- JSP(三)----EL表达式
## EL表达式 1.概念:Expression alnguage 表达式语言 2.作用:替换和简化JSP页面中java代码的编写 3.语法:${表达式} 4.注意: * jsp默认支持EL表 ...
- 【HDU5934】Bomb——有向图强连通分量+重建图
题目大意 二维平面上有 n 个爆炸桶,i−thi-thi−th爆炸桶位置为 (xi,yi)(x_i, y_i)(xi,yi) 爆炸范围为 rir_iri ,且需要 cic_ici 的价格引爆, ...
- 2020年最新版Web前端学习路线图-前端小白入门必读-pink老师推荐
Hello,大家好,相信很多学习前端的小伙伴,会有很多的疑惑: 我要学习那些技术? 我要到哪里去学习这些技术呢? 学习这些技术的目的对就业有什么帮助呢? 我学到什么程度可以胜任工作? ... 这里,p ...
- Linux环境下部署项目时的步骤和一些要注意的点
SQL的导出和导入 sql的导出 首先选中要导出的数据库 然后点击左下角的administration选项,进入导出界面. 点击Data Export 然后勾选图中的几个选项即可导出一个sql,如果需 ...
- Python学习前端之JavaScript
JavaScript介绍 1992年Nombas开发出C-minus-minus(C--)的嵌入式脚本语言(最初绑定在CEnvi软件中),后将其改名ScriptEase(客户端执行的语言). Nets ...
- Blazor入门笔记(4)-组件的生命周期
1.环境 VS2019 16.5.1.NET Core SDK 3.1.200Blazor WebAssembly Templates 3.2.0-preview2.20160.5 2.简介 Blaz ...
- Azure多因素认证
什么是多重身份验证? 双重验证是需要多种验证方法的身份验证方法,可为用户登录和事务额外提供一层重要的安全保障. 它的工作原理是需要以下两种或多种验证方法: 用户知道的某样东西(通常为密码) 用户具有的 ...