Abstract关键字通常被用于类和方法，用来把某些行为的实现委托给子类。由于Java不支持抽象属性，如果你试图将类属性标记为抽象，将会得到一个编译时错误。

在本教程中，我们将介绍两种定义抽象属性的方法，这些抽象属性可以由子类进行设置，而且不使用Abstract 关键字。

实用案例

假设我们想要实现一个记录事务的日志模块，用来记录特定事务的信息。我们希望这个模块是抽象的，这样我们可以实现不同的日志记录方式，例如：记录到文件或数据库中。

我们的引擎使用预定义的分隔符来连接日志中的信息，并存储在一个String中。具体应该使用哪个分隔符，这将取决于日志记录的规则，例如可以用字符“,”对日志记录中不同部分的信息进行分割。

因此，分隔符看起来对我们的引擎是抽象的，需要由每个日志记录规则明确定义。

下面我提供两种方式，来实现把分隔符的定义委托给子类。

在抽象类中定义带参数的构造函数

在抽象类中定义动态属性的第一种方法是：定义一个参数的构造函数。

所以我们可以这样实现这个引擎：

1. // TransactionManager.java 
2.  
3. public abstract class TransactionManager { 
4.     private String separator; 
5.      
6.     public TransactionManager(String separator) { 
7.         this.separator = separator; 
8.     } 
9.      
10.     public abstract void writeTransaction(String result); 
11.      
12.     public Transaction startTransaction() 
13.     { 
14.         Transaction transaction = new Transaction(System.currentTimeMillis()); 
15.         return transaction; 
16.     } 
17.      
18.     public void endTransaction(Transaction t) { 
19.         long processingTime = System.currentTimeMillis() - t.getStartTime(); 
20.   
21.         StringBuilder logBuilder = new StringBuilder(); 
22.         logBuilder.append(t.getStartTime()); 
23.         // Notice the use of this.separator 
24.         logBuilder.append(this.separator); 
25.         logBuilder.append(processingTime); 
26.         logBuilder.append(this.separator); 
27.         logBuilder.append(t.getData()); 
28.   
29.         String result = logBuilder.toString(); 
30.         writeTransaction(result); 
31.     } 
32. }  

在抽象类中定义带参数的构造函数时，子类将会被强制定义自己的构造函数并调用super()。 这样我们就能强制separator属性依赖于已使用的日志记录机制。

注意，我们的引擎实现了所有日志机制共有的静态行为：startTransaction(), endTransaction()，同时将动态行为writeTransaction()交给子类去实现。

现在，如果我们想要创建一个事务管理器，用它将日志内容记录到一个文件中，那么可以这样去定义:

1. public class TransactionManagerFS extends TransactionManager{ 
2.   
3.     // The IDE forces you to implement constructor. 
4.     public TransactionManagerFS(String separator) { 
5.         super(separator); 
6.     } 
7.         
8.     @Override 
9.     public void writeTransaction(String result) { 
10.         System.out.println("The following transaction has just finished: " ); 
11.         System.out.println(result); 
12.     } 
13. }  

接下来做一个测试，看看代码是怎样工作的

1. public static void main(String[] args) throws InterruptedException { 
2.         // we pass the separator explicitly in the constructor 
3.         TransactionManager transactionManager = new TransactionManagerFS(","); 
4.         Transaction transaction = transactionManager.startTransaction(); 
5.         transaction.setData("This is a test transaction !!"); 
6.         Thread.sleep(1500); 
7.         transactionManager.endTransaction(transaction); 
8.     }  

输出：

1. The following transaction has just finished:  
2. 1502179140689,1501,This is a test transaction !!  

通过getter方法传递分隔符

另外一种实现动态属性的方法是：通过定义一个抽象的getter方法，该方法根据当前的日志记录机制来检索所需的分隔符。在我们的引擎中，当需要要使用分隔符时，可以通过调用这个getter方法得到。

接下来我们将引擎修改成这样:

1. public abstract class TransactionManager { 
2.   
3.     public abstract String getSeperator(); 
4.     public abstract void writeTransaction(String result); 
5.      
6.     public Transaction startTransaction() 
7.     { 
8.         Transaction transaction = new Transaction(System.currentTimeMillis()); 
9.         return transaction; 
10.     } 
11.      
12.     public void endTransaction(Transaction t) { 
13.         long processingTime = System.currentTimeMillis() - t.getStartTime(); 
14.   
15.         StringBuilder logBuilder = new StringBuilder(); 
16.         logBuilder.append(t.getStartTime()); 
17.         // Notice the use of getSeparator() 
18.         logBuilder.append(getSeperator()); 
19.         logBuilder.append(processingTime); 
20.         logBuilder.append(getSeperator()); 
21.         logBuilder.append(t.getData()); 
22.   
23.         String result = logBuilder.toString(); 
24.         writeTransaction(result); 
25.     } 
26. }  

另外修改TransactionManagerFS如下：

1. public class TransactionManagerFS extends TransactionManager{ 
2.   
3.     @Override 
4.     public String getSeperator() { 
5.         return ","; 
6.     } 
7.         
8.     @Override 
9.     public void writeTransaction(String result) { 
10.         System.out.println("The following transaction has just finished: " ); 
11.         System.out.println(result); 
12.     } 
13. }  

然后，修改main以使用新的实现，并确保得到正确的结果。

1. public static void main(String[] args) throws InterruptedException { 
2.         // The separator is defined implicitly using getSeparator() method of the manager 
3.         TransactionManager transactionManager = new TransactionManagerFS(); 
4.         Transaction transaction = transactionManager.startTransaction(); 
5.         transaction.setData("This is a test transaction !!"); 
6.         Thread.sleep(1500); 
7.         transactionManager.endTransaction(transaction); 
8.     }  

输出：

1. The following transaction has just finished: 
2. 1502179140689,1501,This is a test transaction !!   

作者：疯狂的技术宅

来源：51CTO