接口和抽象类比较

1 相同点：

1）都不能实例化，就是类不能new一个对象。

2）接口的实现类或抽象类的的子类都只有实现接口或抽象中      的方法才能被实例化

1不同点

1）接口里只有定义，方法体不能在接口里实现   /   抽象类可以有定义与实现，被声明为抽象的方法不能有方法体，没有声明为抽象的方法可以有方法体。

2）接口需要实现（implements）,抽象类只能被继承（extends）

3)接口里的方法都是抽象的，抽象类只要有一个抽象类的方法就可以。

4)总的来说，接口被运用于实现比较常用的功能，便于日后维护或者删除方法/ 而抽象类更倾向充当公共类的角色，不适于日对里面代码进行修改。

我们看一个银行借款的领子，中国人民银行管理并监督所有的银行，它制定了一个规范，所有的银行在进行借款时都必须遵守这个规范（基本接口）；

Version~0.1.0:

中国人民银行定义了一个操作接口：

1. package GoodDesignPattern;
3. import java.util.Map;
5. public interface BankLoan {
7. /**
8. * 银行借款操作
9. * 每个公司都需要实现该方法，并针对自己公司员工的情况进行特殊操作，
10. * 比如判断该员工是否有资格，能借款多少等等
11. * @return
12. */
13. public Map<String, String> loanOperation(String userId);
15. }

所有的银行都必须遵守这个接口，进行具体的实现：

1. package GoodDesignPattern;
3. import java.util.HashMap;
4. import java.util.Map;
6. public class ABC implements BankLoan {
8. @Override
9. public Map<String, String> loanOperation(String userId) {
11. //所有银行借款必须的校验
12. if(userId== null || userId.isEmpty()){
13. System.out.println( "userId为空！");
14. return null;
15. }
16. //所有银行借款必须的校验
17. if(userId.length()!= 32){
18. System.out.println( "userId格式错误，应该为32位！"+userId);
19. return null;
20. }
21. //所有银行借款必须的校验
22. if(!queryUserExist(userId)){
23. System.out.println( "用户不存在："+userId);
24. return null;
25. }
26. //所有银行借款必须的校验
27. if(!queryUserIllegal(userId)){
28. System.out.println( "用户没有资格进行借款："+userId);
29. return null;
30. }
32. //业务逻辑
33. Map<String, String> map = getResultMap(userId);
34. return map;
36. }
38. //根据数据库查询是否存在，根据自己公司的用户表查询
39. public boolean queryUserExist(String userId){
40. return true; //return false;
41. }
43. //根据数据库查询数据查询判断
44. public boolean queryUserIllegal(String userId){
45. return true; //return false;
46. }
48. //根据数据库查询相关信息
49. public Map<String, String> getResultMap(String userId){
50. Map<String, String> map = new HashMap<String, String>();
52. map.put( "name", "詹姆斯"); //此处为了方便直接写死
53. map.put( "amount", "100000"); //应根据userId，在系统进行一系列判断计算，得出能借款金额，此处为了方便直接写死
54. map.put( "rankLevel", "A"); //应根据userId，在系统进行一系列判断计算，得出用户等级，此处为了方便直接写死
55. //.....其它一些列操作
57. return map;
59. }
62. }

1. package GoodDesignPattern;
3. import java.util.HashMap;
4. import java.util.Map;
6. public class ICBC implements BankLoan {
8. @Override
9. public Map<String, String> loanOperation(String userId) {
11. //所有银行借款必须的校验
12. if(userId== null || userId.isEmpty()){
13. System.out.println( "userId为空！");
14. return null;
15. }
16. //所有银行借款必须的校验
17. if(userId.length()!= 32){
18. System.out.println( "userId格式错误，应该为32位！"+userId);
19. return null;
20. }
21. //所有银行借款必须的校验
22. if(!queryUserExist(userId)){
23. System.out.println( "用户不存在："+userId);
24. return null;
25. }
26. //所有银行借款必须的校验
27. if(!queryUserIllegal(userId)){
28. System.out.println( "用户没有资格进行借款："+userId);
29. return null;
30. }
32. //业务逻辑
33. Map<String, String> map = getResultMap(userId);
34. return map;
36. }
38. //根据数据库查询是否存在，根据自己公司的用户表查询
39. public boolean queryUserExist(String userId){
40. return true; //return false;
41. }
43. //根据数据库查询数据查询判断
44. public boolean queryUserIllegal(String userId){
45. return true; //return false;
46. }
48. //根据数据库查询相关信息
49. public Map<String, String> getResultMap(String userId){
50. Map<String, String> map = new HashMap<String, String>();
52. map.put( "amount", "100000"); //应根据userId，在系统进行一系列判断计算，得出能借款金额，此处为了方便直接写死
53. map.put( "rankLevel", "A"); //应根据userId，在系统进行一系列判断计算，得出用户等级，此处为了方便直接写死
54. //.....其它一些列操作
56. return map;
58. }
61. }

我们发现，每当一家银行做此操作时，都会做一些校验，并且他们都是类似的，这不仅繁琐，而且有些银行容易遗漏一些校验操作；虽然校验的逻辑大同小异，但是每个银行都可能自己定义自己的方法名、判断自己的业务逻辑，这样的开发低效且中国人民银行不方便管理，为此，人行需要调整自己的规范，统一各个银行的行为；

Version~0.2.0:

中国人民银行修改自己的规范：

之前的接口不变，新增一个抽象类：

1. package GoodDesignPattern;
3. import java.util.Map;
5. public abstract class CommonOpretion {
7. public Map<String, String> loanOperation(String userId) {
9. //所有银行借款必须的校验
10. if(userId== null || userId.isEmpty()){
11. System.out.println( "userId为空！");
12. return null;
13. }
14. //所有银行借款必须的校验
15. if(userId.length()!= 32){
16. System.out.println( "userId格式错误，应该为32位！"+userId);
17. return null;
18. }
19. //所有银行借款必须的校验
20. if(!queryUserExist(userId)){
21. System.out.println( "用户不存在："+userId);
22. return null;
23. }
24. //所有银行借款必须的校验
25. if(!queryUserIllegal(userId)){
26. System.out.println( "用户没有资格进行借款："+userId);
27. return null;
28. }
30. //业务逻辑
31. Map<String, String> map = getResultMap(userId);
32. return map;
34. }
36. //根据数据库查询是否存在，根据自己公司的用户表查询
37. protected abstract boolean queryUserExist(String userId);
39. //根据数据库查询数据查询判断
40. protected abstract boolean queryUserIllegal(String userId);
42. //根据数据库查询相关信息
43. protected abstract Map<String, String> getResultMap(String userId);
48. }

看看这个抽象类的逻辑，你可以看出来，把所有的公共逻辑都写在里面，具体的业务操作方法是抽象的，由具体的银行去实现即可，看下银行的实现：

1. package GoodDesignPattern;
3. import java.util.HashMap;
4. import java.util.Map;
6. public class ABC extends CommonOpretion implements BankLoan {
8. //根据数据库查询是否存在，根据自己公司的用户表查询
9. @Override
10. public boolean queryUserExist(String userId){
11. return true; //return false;
12. }
14. //根据数据库查询数据查询判断
15. @Override
16. public boolean queryUserIllegal(String userId){
17. return true; //return false;
18. }
20. //根据数据库查询相关信息
21. @Override
22. public Map<String, String> getResultMap(String userId){
23. Map<String, String> map = new HashMap<String, String>();
25. map.put( "name", "詹姆斯"); //此处为了方便直接写死
26. map.put( "amount", "100000"); //应根据userId，在系统进行一系列判断计算，得出能借款金额，此处为了方便直接写死
27. map.put( "rankLevel", "A"); //应根据userId，在系统进行一系列判断计算，得出用户等级，此处为了方便直接写死
28. //.....其它一些列操作
30. return map;
32. }
35. }

1. package GoodDesignPattern;
3. import java.util.HashMap;
4. import java.util.Map;
6. public class ICBC extends CommonOpretion implements BankLoan {
8. //根据数据库查询是否存在，根据自己公司的用户表查询
9. @Override
10. public boolean queryUserExist(String userId){
11. return true; //return false;
12. }
14. //根据数据库查询数据查询判断
15. @Override
16. public boolean queryUserIllegal(String userId){
17. return true; //return false;
18. }
20. //根据数据库查询相关信息
21. @Override
22. public Map<String, String> getResultMap(String userId){
23. Map<String, String> map = new HashMap<String, String>();
25. map.put( "amount", "100000"); //应根据userId，在系统进行一系列判断计算，得出能借款金额，此处为了方便直接写死
26. map.put( "rankLevel", "A"); //应根据userId，在系统进行一系列判断计算，得出用户等级，此处为了方便直接写死
27. //.....其它一些列操作
29. return map;
31. }
34. }

每个银行只要继承这个抽象类，并实现对应的业务逻辑方法即可，一些校验都统一放入抽象类中判断，这样，每个银行的实现逻辑清晰、规范、不会遗漏校验，当然如果抽象类中的某些抽象方法，有些银行不想做具体实现，可以默认返回，当然这是一个缺陷，欢迎读者提出更好的解决方案。

这个时候每个银行又要实现抽象类，又要实现接口，他们感觉很麻烦且没有必要，这个时候中国银行又进行调整：

Version~0.3.0:
顶层接口还是不变，抽象类修改：由抽象类实现接口

1. package GoodDesignPattern;
3. import java.util.Map;
5. public abstract class CommonOpretion implements BankLoan{
7. @Override
8. public Map<String, String> loanOperation(String userId) {
10. //所有银行借款必须的校验
11. if(userId== null || userId.isEmpty()){
12. System.out.println( "userId为空！");
13. return null;
14. }
15. //所有银行借款必须的校验
16. if(userId.length()!= 32){
17. System.out.println( "userId格式错误，应该为32位！"+userId);
18. return null;
19. }
20. //所有银行借款必须的校验
21. if(!queryUserExist(userId)){
22. System.out.println( "用户不存在："+userId);
23. return null;
24. }
25. //所有银行借款必须的校验
26. if(!queryUserIllegal(userId)){
27. System.out.println( "用户没有资格进行借款："+userId);
28. return null;
29. }
31. //业务逻辑
32. Map<String, String> map = getResultMap(userId);
33. return map;
35. }
37. //根据数据库查询是否存在，根据自己公司的用户表查询
38. protected abstract boolean queryUserExist(String userId);
40. //根据数据库查询数据查询判断
41. protected abstract boolean queryUserIllegal(String userId);
43. //根据数据库查询相关信息
44. protected abstract Map<String, String> getResultMap(String userId);
49. }

具体银行不再需要实现接口：

1. package GoodDesignPattern;
3. import java.util.HashMap;
4. import java.util.Map;
6. public class ABC extends CommonOpretion {
8. //根据数据库查询是否存在，根据自己公司的用户表查询
9. @Override
10. public boolean queryUserExist(String userId){
11. return true; //return false;
12. }
14. //根据数据库查询数据查询判断
15. @Override
16. public boolean queryUserIllegal(String userId){
17. return true; //return false;
18. }
20. //根据数据库查询相关信息
21. @Override
22. public Map<String, String> getResultMap(String userId){
23. Map<String, String> map = new HashMap<String, String>();
25. map.put( "name", "詹姆斯"); //此处为了方便直接写死
26. map.put( "amount", "100000"); //应根据userId，在系统进行一系列判断计算，得出能借款金额，此处为了方便直接写死
27. map.put( "rankLevel", "A"); //应根据userId，在系统进行一系列判断计算，得出用户等级，此处为了方便直接写死
28. //.....其它一些列操作
30. return map;
32. }
35. }

到此一个体现接口和抽象类结合使用的简单例子就说完了，谢谢～