JAVA只要掌握内部类，多继承和单继承都不是问题

转x33g5p2x  于2022-03-05 转载在 Java  
字(7.3k)|赞(0)|评价(0)|浏览(536)

本文分享自华为云社区《【JAVA冷知识】JAVA居然支持多继承？让我们用内部类去吧!》，作者：山河已无恙 。

众多周知，对于面向对象语言来讲，JAVA是不支持多继承的，只支持单继承，但是提供了接口来补偿。

在实际的项目中，接口更多的用于行为的委托，把类本身一些是共性但又是特定的行为委托给一个接口的具体实现，当然接口也可以用于属性的委托，对象结构型的设计模式大都采用接口的方式来实现对对象内部组成的注册和操作

如果实现java的多继承，其实很简单，关键是对于内部类的特征的掌握，内部类可以继承一个与外部类无关的类，保证了内部类天然独立性，根据这个特性从而实现一个类可以继承多个类的效果
下面我们看一个Demo，声明父母两个接口，实现父母两个类，看如何通过内部类来继承父母类，而不是通过，接口委托的方式，

一个Demo

父亲接口

  1. package com.liruilong;
  3. /**
  4.  * @Project_name: workspack
  5.  * @Package: com.liruilong
  6.  * @Description: 父亲接口
  7.  * @Author: 1224965096@qq.com
  8.  * @WeChat_Official_Accounts: 山河已无恙
  9.  * @blog: https://liruilong.blog.csdn.net/
  10.  * @Date: 2022/2/12  2:48
  11.  */
  12. public interface Father {
  13.     /**
  14.      * @return: int
  15.      * @Description 强壮的行为
  16.      * @author LiRuilong
  17.      * @date  2022/2/12  2:49
  18.      **/
  19.      int strong();
  20. }

父亲实现类

  1. package com.liruilong;
  3. /**
  4.  * @Project_name: workspack
  5.  * @Package: com.liruilong
  6.  * @Description: 父亲类
  7.  * @Author: 1224965096@qq.com
  8.  * @WeChat_Official_Accounts: 山河已无恙
  9.  * @blog: https://liruilong.blog.csdn.net/
  10.  * @Date: 2022/2/12  2:51
  11.  */
  12. public class FatherImpl implements Father {
  14.     static  public   String height = "身体超高";
  16.    /**
  17.     * @return: int
  18.     * @Description  强壮值
  19.     * @author LiRuilong
  20.     * @date  2022/2/12  2:51
  21.     **/
  22.     @Override
  23.     public int strong() {
  24.         return 8;
  25.     }
  26. }

母亲接口

  1. package com.liruilong;
  3. /**
  4.  * @Project_name: workspack
  5.  * @Package: com.liruilong
  6.  * @Description: 母亲接口
  7.  * @Author: 1224965096@qq.com
  8.  * @WeChat_Official_Accounts: 山河已无恙
  9.  * @blog: https://liruilong.blog.csdn.net/
  10.  * @Date: 2022/2/12  2:50
  11.  */
  12. public interface Mother {
  13.    /**
  14.     * @return: int
  15.     * @Description 温柔的行为
  16.     * @author LiRuilong
  17.     * @date  2022/2/12  2:50
  18.     **/
  19.    int Kind();
  20. }

母亲实现类

  1. package com.liruilong;
  3. /**
  4.  * @Project_name: workspack
  5.  * @Package: com.liruilong
  6.  * @Description: 母亲类
  7.  * @Author: 1224965096@qq.com
  8.  * @WeChat_Official_Accounts: 山河已无恙
  9.  * @blog: https://liruilong.blog.csdn.net/
  10.  * @Date: 2022/2/12  2:51
  11.  */
  12. public class MotherImpl implements Mother{
  13.     static   public  String pretty = "脸蛋特别漂亮";
  14.    /**
  15.     * @return: int
  16.     * @Description 温柔值
  17.     * @author LiRuilong
  18.     * @date  2022/2/12  2:51
  19.     **/
  20.     @Override
  21.     public int Kind() {
  22.         return 8;
  23.     }
  24. }

OK，准备工作做好了， 看我们如何实现。

  1. package com.liruilong;
  3. import java.util.logging.Logger;
  5. /**
  6.  * @Project_name: workspack
  7.  * @Package: com.liruilong
  8.  * @Description: 孩子类
  9.  * @Author: 1224965096@qq.com
  10.  * @WeChat_Official_Accounts: 山河已无恙
  11.  * @blog: https://liruilong.blog.csdn.net/
  12.  * @Date: 2022/2/12  13:16
  13.  */
  14. public class Son extends FatherImpl implements Mother {
  15.     static Logger logger = Logger.getAnonymousLogger();
  17.     MotherSpecial motherSpecial = new MotherSpecial();
  18.     @Override
  19.     public int strong() {
  20.         return super.strong() + 1;
  21.     }
  23.     @Override
  24.     public int Kind() {
  25.         return motherSpecial.Kind();
  26.     }
  27.     @Override
  28.     public String toString() {
  29.         return "Son{" +
  30.                 "height=" + height +"," +
  31.                 "pretty=" + MotherSpecial.pretty +
  32.                 '}';
  33.     }
  34.     public class MotherSpecial extends MotherImpl {
  35.         @Override
  36.         public int Kind() {
  37.             return super.Kind() - 1;
  38.         }
  39.     }
  41.     public static void main(String[] args) {
  42.         Son son = new Son();
  43.         logger.info(son.toString());
  44.         logger.info(son.strong()+"");
  45.         logger.info(son.Kind()+"");
  46.     }
  48. }

我们用内部类继承一个外部类无关的类，实现了Son类的多继承

  1. Bad level value for property: .level
  2. Bad level value for property: java.util.logging.ConsoleHandler.level
  3. Can''t set level for java.util.logging.ConsoleHandler
  4. 二月 12, 2022 2:02:06 下午 com.liruilong.Son main
  5. 信息: Son{height=身体超高,pretty=脸蛋特别漂亮}
  6. 二月 12, 2022 2:02:06 下午 com.liruilong.Son main
  7. 信息: 9
  8. 二月 12, 2022 2:02:06 下午 com.liruilong.Son main
  9. 信息: 7
  11. Process finished with exit code 0

这里只是讨论这样的写法，我个人认为，这种方法有些鸡肋。这种方式实现的多继承，完全可以通组合的方式来实现，我们简单分析一下优缺点

优缺点分析

优点：

通过内部类的方式，把继承关系控制在类的内部，理论上比通过组合的方式更加安全，代码可读性要好一点。

更符合设计原则中的迪米特法则，又称最少知道原则（Demeter Principle），一个实体应当尽量少地与其他实体之间发生相互作用，使得系统功能模块相对独立。

缺点：

首先通过继承的方式实现，打破了类的封装性，子类依赖于其超类中特定功能的实现细节。 超类的实现有可能会随着发行版本的不同而有所变化，如果真的发生了变化，即使子类的代码完全没有改变，但是子类可能会遭到破坏因而，子类必须要跟着其超类的更新而演变，除非超类是专门为了扩展而设计的，并且具有很好的文挡说明。

其次，通过这样的方式实现的，不符合常态思想，尤其内部类同名的情况，容易被忽略某些特性(见JDK源码)。

JDK源码中的运用

关于通过内部类来实现java多继承的JDK场景，我们简单分析一下

asList

  1. List<Integer> integers = Arrays.asList(1, 2, 3);

这个代码小伙伴们一定不陌生，这里通过Arrays工具类来生成一个List，但是这里的List并不是真正的ArrayList，而是在Arrays工具类内部定义的一个继承了AbstractList的静态内部类ArrayList,这里java通过内部类的方式巧妙的实现了。

  1. .......
  2.     @SafeVarargs
  3.     @SuppressWarnings("varargs")
  4.     public static <T> List<T> asList(T... a) {
  5.         return new ArrayList<>(a);
  6.     }
  8.     /**
  9.      * @serial include
  10.      */
  11.     private static class ArrayList<E> extends AbstractList<E>
  12.         implements RandomAccess, java.io.Serializable
  13.     {
  14.         private static final long serialVersionUID = -2764017481108945198L;
  15.         private final E[] a;
  17.         ArrayList(E[] array) {
  18.             a = Objects.requireNonNull(array);
  19.         }
  20.     .................

但是这里同样需要注意的是通过内部类实现多继承要考虑其类的特殊性：

这样生成的List调用add方法会抛不支持的操作的异常，基于Arrays的ArrayList是一个静态私有内部类，除了Arrays能访问以外，其他类都不能访问，正常的ArrayList中add方法是ArrayList父类提供，Arrays的内部类ArrayList没有覆写add方法。

下面源码为ArrayList静态内部类实现的个方法。

  1. /**
  2.      * @serial include
  3.      */
  4.     private static class ArrayList<E> extends AbstractList<E>
  5.         implements RandomAccess, java.io.Serializable
  6.     {
  7.         private static final long serialVersionUID = -2764017481108945198L;
  8.         private final E[] a;
  10.         ArrayList(E[] array) {
  11.             a = Objects.requireNonNull(array);
  12.         }
  14.         @Override
  15.         public int size() {
  16.             return a.length;
  17.         }
  19.         @Override
  20.         public Object[] toArray() {
  21.             return a.clone();
  22.         }
  24.         @Override
  25.         @SuppressWarnings("unchecked")
  26.         public <T> T[] toArray(T[] a) {
  27.             int size = size();
  28.             if (a.length < size)
  29.                 return Arrays.copyOf(this.a, size,
  30.                                      (Class<? extends T[]>) a.getClass());
  31.             System.arraycopy(this.a, 0, a, 0, size);
  32.             if (a.length > size)
  33.                 a[size] = null;
  34.             return a;
  35.         }
  37.         @Override
  38.         public E get(int index) {
  39.             return a[index];
  40.         }
  42.         @Override
  43.         public E set(int index, E element) {
  44.             E oldValue = a[index];
  45.             a[index] = element;
  46.             return oldValue;
  47.         }
  49.         @Override
  50.         public int indexOf(Object o) {
  51.             E[] a = this.a;
  52.             if (o == null) {
  53.                 for (int i = 0; i < a.length; i++)
  54.                     if (a[i] == null)
  55.                         return i;
  56.             } else {
  57.                 for (int i = 0; i < a.length; i++)
  58.                     if (o.equals(a[i]))
  59.                         return i;
  60.             }
  61.             return -1;
  62.         }
  64.         @Override
  65.         public boolean contains(Object o) {
  66.             return indexOf(o) != -1;
  67.         }
  69.         @Override
  70.         public Spliterator<E> spliterator() {
  71.             return Spliterators.spliterator(a, Spliterator.ORDERED);
  72.         }
  74.         @Override
  75.         public void forEach(Consumer<? super E> action) {
  76.             Objects.requireNonNull(action);
  77.             for (E e : a) {
  78.                 action.accept(e);
  79.             }
  80.         }
  82.         @Override
  83.         public void replaceAll(UnaryOperator<E> operator) {
  84.             Objects.requireNonNull(operator);
  85.             E[] a = this.a;
  86.             for (int i = 0; i < a.length; i++) {
  87.                 a[i] = operator.apply(a[i]);
  88.             }
  89.         }
  91.         @Override
  92.         public void sort(Comparator<? super E> c) {
  93.             Arrays.sort(a, c);
  94.         }
  95.     }

即没有实现add和remove方法，所以asList返回的为一个长度不可变的列表，数组为多长转换为列表为多长，即不在保持列表动态变长的特性。

subList

嗯，不多讲，直接上代码

  1. ArrayList arrayList = new ArrayList();
  2.         LinkedList linkedList = new LinkedList();
  3.         Vector vector = new Vector();
  4.         linkedList.subList(2,3);
  5.         arrayList.subList(2,3);
  6.         vector.subList(2,3);

List提供一个subList方法,与String的subString有点类似,这里的List通过subList生成子list方式也是通过内部类继承方式的多继承实现的。

当然这里，具体需要分析，ArrayList和其他List的实现的方式略有不同

ArrayList是自己定义的内部类SubList继承AbstractList实现的

  1. public class ArrayList<E> extends AbstractList<E>
  2.         implements List<E>, RandomAccess, Cloneable, java.io.Serializable
  3. {
  4.   .......
  5.     public List<E> subList(int fromIndex, int toIndex) {
  6.         subListRangeCheck(fromIndex, toIndex, size);
  7.         return new SubList(this, 0, fromIndex, toIndex);
  8.     }
  9. .....
  10.     private class SubList extends AbstractList<E> implements RandomAccess {
  11.         private final AbstractList<E> parent;
  12.         private final int parentOffset;
  13.         private final int offset;
  14.         int size;
  15.     .........

LinkedList的subList方法是由AbstractList实现的，它会根据是不是随机存储提供不同的实现方法，subList返回的类也是AbstractList的子类SubList。

  1. public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {
  2.   ........
  3.    public List<E> subList(int fromIndex, int toIndex) {
  4.         return (this instanceof RandomAccess ?
  5.                 new RandomAccessSubList<>(this, fromIndex, toIndex) :
  6.                 new SubList<>(this, fromIndex, toIndex));
  7.     }
  8.    class SubList<E> extends AbstractList<E> {
  9.      ...
  10.     }
  11.    class RandomAccessSubList<E> extends SubList<E> implements RandomAccess{
  12.     .......
  13.     }
  14.     ........ 
  15. }

这里需要注意的是，不管是ArrayList还是LinkedList等其他List，通过SubList内部类生成的List，其所有的方法(get,add,set,remove等)都是在原始列表上操作的，它自身并没有生成一个数组或是链表，也就是子列表只是原列表的一个视图(View）,所有的修改都反映在原列表上。

点击关注，第一时间了解华为云新鲜技术~​

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://huaweicloud.blog.csdn.net/article/details/123275953

内容来源于网络，如有侵权，请联系作者删除！

Java后端开发语言技术交流内部类多继承

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com