原文出处：http://www.blogjava.net/vcycyv/archive/2011/02/20/344716.ht
ml先说说interface和abstract method语法中需要注意的地方。
Interface:
1. An interface can contain fields, but these are implicitly static and final.
2. You can choose to explicitly declare the methods in an interface as public, but they are public even if you don’t say it.
3. Interface cannot define static method
Abstract:
1. 一个类中如果所有的方法都有实现，我们仍然可以定义这个类为abstract class
2. abstract和static不能放在一起定义方法。
Interface和Abstract class的实践
1. interface适合定义mixins（不知道mixin怎么翻译，它指窄接口，只定义specific contract）.
java不能多重继承。如果想达到多重继承的效果，需要借助“多重实现”interface. interface的一个典型用法是定义小接口。比如Comparable。这样它的实现成本比较小，一个class比较容易mixin多个interface。
2. 如果interface不是mixin, 而是大一点的接口。
effective java, 2nd edition有精彩的阐述，对于大接口，我们往往使用skeletal implementation class. 举个例子：
// Concrete implementation built atop skeletal implementation
static List<Integer> intArrayAsList(final int[] a) {
if (a == null)
throw new NullPointerException();
return new AbstractList<Integer>() {
public Integer get(int i) {
return a[i]; // Autoboxing (Item 5)
}
@Override public Integer set(int i, Integer val) {
int oldVal = a[i];
a[i] = val; // Auto-unboxing
return oldVal; // Autoboxing
}
public int size() {
return a.length;
}
};
}new AbstractList<Integer>就是在应用Skeletal implementation. 有两个好处：
a) 它使实现接口更方便了
b) If, in a subsequent release, you want to add a new method to an abstract class, you can always add a concrete method containing a reasonable default implementation. All existing implementations of the abstract class will then provide the new method. This does not work for interfaces.
跟interface相关的还有一个话题是wrapper class，也很精彩，它是把继承转成合成的方式，应用了decorater模式的思想. 在书里的第16章介绍。
// Wrapper class - uses composition in place of inheritance
public class InstrumentedSet<E> extends ForwardingSet<E> {
private int addCount = 0;
public InstrumentedSet(Set<E> s) {
super(s);
}
@Override public boolean add(E e) {
addCount++;
return super.add(e);
}
@Override public boolean addAll(Collection<? extends E> c) {
addCount += c.size();
return super.addAll(c);
}
public int getAddCount() {
return addCount;
}
}
// Reusable forwarding class
public class ForwardingSet<E> implements Set<E> {
private final Set<E> s;
public ForwardingSet(Set<E> s) { this.s = s; }
public void clear() { s.clear(); }
public boolean contains(Object o) { return s.contains(o); }
public boolean isEmpty() { return s.isEmpty(); }
public int size() { return s.size(); }
public Iterator<E> iterator() { return s.iterator(); }
public boolean add(E e) { return s.add(e); }
public boolean remove(Object o) { return s.remove(o); }
public boolean containsAll(Collection<?> c)
{ return s.containsAll(c); }
public boolean addAll(Collection<? extends E> c)
{ return s.addAll(c); }
public boolean removeAll(Collection<?> c)
{ return s.removeAll(c); }
public boolean retainAll(Collection<?> c)
{ return s.retainAll(c); }
public Object[] toArray() { return s.toArray(); }
public <T> T[] toArray(T[] a) { return s.toArray(a); }
@Override public boolean equals(Object o)
{ return s.equals(o); }
@Override public int hashCode() { return s.hashCode(); }
@Override public String toString() { return s.toString(); }
}使用它的客户端程序：
Set<Date> s = new InstrumentedSet<Date>(new TreeSet<Date>(cmp));
Set<E> s2 = new InstrumentedSet<E>(new HashSet<E>(capacity));
3. 人人都说 面向接口编程，很多时候矫枉过正了， 搞得接口漫天飞。interface常常是重构出来的，而不总是设计出来的。程序分层中，越是靠近底层的程序，越倾向于需要接口，越靠近顶层的程序，对接口的需求倾向于越小。如果你明知道以后不太可能提供另一套实现，提前写个接口摆那里也没啥意义，尽管定义接口的成本很低。如果你担心一旦有一天确实提供了另一套实现，重构code也不会很麻烦。只要遵守了单一职责原则和迪米特法则。迪米特法则的一种表述方式是：talk only to your immediate friends
分享到：
相关推荐
abstract class和interface是Java语言中对于抽象类定义进行支持的两种机制，正是由于这两种机制的存在，才赋予了Java强大的面向对象能力。abstract class和interface之间在对于抽象类定义的支持方面具有很大的相似性...
`abstract class`和`interface`都是Java面向对象编程中不可或缺的组成部分。理解它们之间的区别对于编写高质量、可维护性强的代码至关重要。在实际开发中，灵活运用这两种机制可以帮助我们更好地组织代码结构，提高...
### abstract class和interface有什么区别? 在面向对象编程中，`abstract class` 和 `interface` 都是用来实现抽象化的工具，但它们之间存在着重要的差异。理解这些差异有助于开发者更有效地设计和实现软件系统。 ...
在面向对象编程语言中，如Java，接口（Interface）和抽象类（Abstract Class）是两种非常重要的概念，它们都被用来实现代码的复用性和扩展性。但它们之间存在一些根本性的区别，这些差异对于正确地设计类结构至关...
在Java编程语言中，抽象类（abstract class）和接口（interface）都是用于实现抽象化的重要工具，它们可以帮助程序员更好地组织代码，提高代码的可复用性和扩展性。尽管二者在功能上有一些相似之处，但在实际使用中...
在编程领域，`abstract class`（抽象类）和`interface`是两种重要的设计模式，它们在构建可扩展和模块化的软件系统中起着至关重要的作用。这篇文章将深入探讨这两个概念，以及它们在实际开发中的应用。 首先，让...
在Java编程语言中，`abstract class`（抽象类）和`interface`是两种重要的机制，它们用于实现多态性和抽象性。虽然它们都可以用来定义抽象方法，但它们之间存在显著的差异，这些差异影响了开发者在设计软件时的选择...
在Java编程语言中，`abstract class`（抽象类）和`interface`都是用来定义抽象类的概念，它们在面向对象设计中扮演着重要的角色。抽象类主要用于表示一系列具有共同特征但又各自具有独特行为的具体类的抽象，而接口...
Java设计模式是面向对象编程中的重要概念，它们是解决常见问题的经验总结，为代码的可重用性、可维护性和可扩展性提供了指导。这里我们将深入探讨三种常见的Java设计模式：单例（Singleton）、工厂方法（Factory ...
在Java编程语言中，接口（Interface）是一种定义行为规范的关键元素，它允许我们实现多继承。接口是完全抽象的，不包含任何方法的实现，只有方法的声明、常量定义以及默认方法。Java中的接口提供了以下核心知识点： ...
在Java编程语言中，`interface`接口和`abstract class`抽象类是两种重要的面向对象设计概念，它们都用于实现多态性，但有着显著的区别。理解这些差异对于编写可扩展和可维护的代码至关重要。 首先，接口是完全抽象...
abstract class和interface都是Java语言中支持抽象类定义的机制，但它们之间有很大的区别。选择合适的机制需要根据问题领域的特点和设计理念，正确地理解和使用abstract class和interface是软件设计和开发的关键。
在Java编程语言中，`abstract class`和`interface`是两种用于定义抽象类的重要机制。这两种机制不仅支持了Java的强大面向对象特性，而且也在实际开发过程中发挥了重要作用。尽管两者在表面上看起来非常相似，但它们...
在Java语言中，abstract class和interface 是支持抽象类定义的两种机制。正是由于这两种机制的存在，才赋予了Java强大的面向对象能力。abstract class和interface之间在对于抽象类定义的支持方面具有很大的相似性，...
### 上机练习四大特性总结Java #### 一、封装 **封装**是面向对象编程中的一个核心概念，指的是将数据（属性）与操作这些数据的方法（行为）包装在一起，形成一个独立的对象。封装的主要目的是提高代码的安全性和...
Java 接口的定义与普通类的定义类似，区别在于使用关键字 `interface` 而不是 `class`。接口的定义格式如下： ```java public interface 接口名 { // 抽象方法和默认方法的定义 } ``` 二、Java 接口的抽象方法 ...
在Java编程语言中，`static`、`final`、`abstract`和`interface`是四个非常重要的关键字，它们分别代表不同的特性，用于定义类、变量和方法的行为。下面是对这些关键字的详细解释： 1. **static（静态）** - **...