Java的多接口实现到底有啥好处?

Posted

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java的多接口实现到底有啥好处?相关的知识，希望对你有一定的参考价值。

rt

如果你学过C++的话，就不难发现，接口就是变相的多继承
但是使用接口方式继承，继承了多继承方式的强大功能，降低了多继承的复杂性，有利于设计更加健壮的系统
更加便于维护、理解、其他程序员的阅读
java中的类是不允许多继承的，而接口可以多继承，算是一点弥补，然后就是使用接口可以封装具体的实现，不向外部暴露具体的实现细节，只将接口暴露出来，用户也只能够通过接口访问，这样也有一定的安全性。 参考技术A 我给你举个例子哈
比如我会炒菜。。也就是我有个炒菜的方法
但是每个人想吃的菜的口味并不一样。。
所以我这个方法接受一个。。恩。。叫调味的参数。。
意思就是我用你的调味将菜炒出来。。
因为每个人都不一样。。所以我并不能将调味类的内容具体写出来。。
于是我定义一个接口调味。。我接受的参数是这个接口。。
所以你想让我炒菜即想调用我的炒菜方法的话必须给我一个调味对象。。即你必须实现调味这个接口。。所以我的这个方法就能根据不同人的喜好炒出不同的菜了。。
这是我的理解吧。。
比如jdk里的Arrays类的sort方法 当然有很重构的。。其中一个就是接受一个数组和compareable（好像是这么写的）类型参数。。它是一个接口。。里面有个compareto方法。。sort方法是把你传给他的数组进行排序的。。你给他compareable具体实现。。它就可以根据你的要求来对数组里面的内容进行排序了。。你的要求也就是compareto方法的具体实现了。。
当然接口还有很多好处的。。要多用才能理解了。。 比如楼上说的变相多继承。。而又不让程序变得复杂。。多继承开销很大的。。

Serializable中的serialVersionUID到底有啥用

最近在研究跨进程通信的问题，于是又再一次研究了，我们熟悉而又陌生的Serializable接口。


那么好，做过Java开发的朋友肯定对这个接口不陌生吧，Java中就是通过这个接口，来实现了序列化和反序列化的，那么下面看看使用Serializable接口的小例子。

[java] view plain copy
 print?
  1. public class User implements Serializable{  
  2.     private String name;  
  3.     private int age;  
  4.     private float height;  
  5.     public String getName() {  
  6.         return name;  
  7.     }  
  8.     public void setName(String name) {  
  9.         this.name = name;  
  10.     }  
  11.     public int getAge() {  
  12.         return age;  
  13.     }  
  14.     public void setAge(int age) {  
  15.         this.age = age;  
  16.     }  
  17.     public float getHeight() {  
  18.         return height;  
  19.     }  
  20.     public void setHeight(float height) {  
  21.         this.height = height;  
  22.     }  
  23.     @Override  
  24.     public String toString() {  
  25.         return "User [name=" + name + ", age=" + age + ", height=" + height + "]";  
  26.     }  
  27.       
  28. }  


上面是我们常见写法的bean，不过呢，Eclipse就会有这个提示：The serializable class User does not declare a static final serialVersionUID field of type long，意思就是说让你添加一个serialVersionUID的值。

不过呢，我们就算不添加，那么也是可以正常序列化的。下面贴一下序列化和反序列化的代码。

[java] view plain copy
 print?
  1. public class Test {  
  2.   
  3.     private static String FILE_PATH = "cache.txt";  
  4.   
  5.     /** 
  6.      * 测试SerialVersionUID和不同是否能发序列化成功 
  7.      *  
  8.      * @param args 
  9.      */  
  10.     public static void main(String[] args) {  
  11.         // 创建一个对象  
  12.         User user = new User();  
  13.         user.setAge(10);  
  14.         user.setName("小可爱");  
  15.         user.setHeight(175.6f);  
  16.         // 开始序列化  
  17.         ObjToFile(user);  
  18.         // 开始反序列化  
  19.         Object o = FileToObj();  
  20.         System.out.println("=====================");  
  21.         System.out.println(o.toString());  
  22.     }  
  23.   
  24.     /** 
  25.      * 序列化 
  26.      */<del>  
  27. </del>    public static void ObjToFile(Serializable s) {  
  28.         ObjectOutputStream _Oos = null;  
  29.         try {  
  30.             _Oos = new ObjectOutputStream(new FileOutputStream(FILE_PATH));  
  31.             _Oos.writeObject(s);  
  32.             _Oos.flush();  
  33.             System.out.println("序列化成功！");  
  34.         } catch (FileNotFoundException e) {  
  35.             e.printStackTrace();  
  36.         } catch (IOException e) {  
  37.             e.printStackTrace();  
  38.         } finally {  
  39.             if (_Oos != null) {  
  40.                 try {  
  41.                     _Oos.close();  
  42.                 } catch (IOException e) {  
  43.                     e.printStackTrace();  
  44.                 }  
  45.             }  
  46.         }  
  47.     }  
  48.   
  49.     /** 
  50.      * 反序列化 
  51.      */  
  52.     public static Serializable FileToObj() {  
  53.         ObjectInputStream _Ois = null;  
  54.         try {  
  55.             _Ois = new ObjectInputStream(new FileInputStream(FILE_PATH));  
  56.             Serializable s = (Serializable) _Ois.readObject();  
  57.             System.out.println("反序列化成功");  
  58.             return s;  
  59.         } catch (FileNotFoundException e) {  
  60.             e.printStackTrace();  
  61.         } catch (IOException e) {  
  62.             e.printStackTrace();  
  63.         } catch (ClassNotFoundException e) {  
  64.             e.printStackTrace();  
  65.         } finally {  
  66.             if (_Ois != null) {  
  67.                 try {  
  68.                     _Ois.close();  
  69.                 } catch (IOException e) {  
  70.                     e.printStackTrace();  
  71.                 }  
  72.             }  
  73.         }  
  74.         return null;  
  75.     }  
  76.   
  77. }  

先说第一种情况：

其实，如果你不添加serialVersionUID，那么Eclipse在会根据这个类的结构（成员变量，成员变量的个数等），生成一个hash值，然后将这个值作为serialVersionUID。

告诉大家实验步骤：

1、序列化User对象的时候，不要添加serialVersionUID。

2、然后给User对象添加serialVersionUID = 2L,可以随便是个long值。

3、开始对新添加的User对象，进行反序列化。

接着大家就可以看到控制台打印的报错了。

我这边的报错是这样的：

java.io.InvalidClassException: com.peng.test.User; local class incompatible: stream classdesc serialVersionUID = -2110639933710420778, local class serialVersionUID = 2

看到上面的这个serialVersionUID = -2110639933710420778了吗,我们序列化的时候，不是没有添加serialVersionUID的值吗。
当然了，这种方式只能说明serialVersionUID这个值会自己生成，那么就这样确定是Eclipse生成的，仿佛证据不是很确凿，不过呢，还有一种方法，来证明一下，那就是不使用Eclipse，直接使用文本编辑器，如果根本不能序列化，那么就是Eclipse的问题了。

第二种情况：
如果你没有添加serialVersionUID，进行了序列化，而你在反序列化的时候，修改了User对象的结构（添加或删除成员变量，修改成员变量的命名），那么这个时候，就会出现上面的报错。

第三种情况：

如果你添加了serialVersionUID，进行了序列化，而你在反序列化的时候，修改了User对象的结构（添加或删除成员变量，修改成员变量的命名），那么就不见的报错了，不过反序列化，它只能恢复部分数据，或者恢复不了数据。

总结一下：
序列化的时候，系统会把序列化的类的serialVersionUID写入到序列化文件中（有可能其他地方）,当去反序列化的时候，系统会去检测文件中的serialVersionUID，如果类中的值和文件的值一致，那么就可以反序列化成功，反之失败。








以上是关于Java的多接口实现到底有啥好处?的主要内容，如果未能解决你的问题，请参考以下文章

Serializable中的serialVersionUID到底有啥用

java中接口和类有啥区别 java中接口和类有啥区别

java接口和类有啥区别？

标记接口有啥好处？

java 实现接口和继承有啥区别

java中接口和类有啥区别java中接口和类有啥区别