精华内容
下载资源
问答
  • Java多重继承实现方法

    2019-10-16 09:41:22
    我们都知道,在Java中一个类可以多重实现,但是不能多重继承。也就是说一个类可以同时实现多个接口,但不能同时继承多个类。有时候我们需要让一个类同时拥有多个类的行为功能。这时候使用单继承特性就很难解决问题了...

    我们都知道,在Java中一个类可以多重实现,但是不能多重继承。也就是说一个类可以同时实现多个接口,但不能同时继承多个类。有时候我们需要让一个类同时拥有多个类的行为功能。这时候使用单继承特性就很难解决问题了。幸运的是Java提供的内部类可以用来解决此问题。

    内部类的一个重要特性:内部类可以继承一个与外部类无关的类,保证了内部类的独立性,正是基于这一点, 多重继承才会成为可能。这种内部类叫做成员内部类(也叫做实例内部类,Instance Inner Class)。

    明白了一些简单的原理,下面来看一个案例:在游戏人物设定中,通常子女的属性值受父亲和母亲的属性值影响。其中父亲为敏捷值突出,母亲恢复值突出。定义一个父亲、母亲接口,用于描述父亲敏捷值和母亲恢复值。代码如下:

    // 父亲
    public interface Father {
    	// 敏捷
        int agile();
    }
    // 母亲
    public interface Mother {
    	// 恢复
        int recover();
    }
    

    再定义父亲、母亲的实现:

    // 父亲实现
    public class FatherImpl implements Father {
        // 父亲敏捷值为8
        @Override
        public int agile() {
            return 8;
        }
    }
    // 母亲实现
    public class MotherImpl implements Mother {
        // 母亲恢复值为8
        @Override
        public int recover() {
            return 8;
        }
    }
    

    下面我们来定义儿子类,儿子需要同时继承父亲的敏捷和母亲的恢复功能,代码如下:

    public class Son extends FatherImpl implements Mother {
        // 儿子敏捷值在父亲基础上+1
        public int agile() {
            return super.agile() + 1;
        }
    
        @Override
        public int recover() {
            return new MotherImplAttr().recover();
        }
    
        private class MotherImplAttr extends MotherImpl {
            public int recover() {
                // 儿子恢复值在母亲基础上-1
                return super.recover() - 1;
            }
        }
    }
    

    同样我们可以用匿名内部类来覆写父类方法,继承父类行为。再来定义个女儿类:

    public class Daughter extends MotherImpl implements Father {
    	// 女儿恢复值在母亲基础上+1
        public int recover() {
            return super.recover() + 1;
        }
    
        @Override
        public int agile() {
            return new FatherImpl() {
                public int agile() {
                	// 女儿敏捷值在父亲基础上-1
                    return super.agile() - 1;
                }
            }.agile();
        }
    }
    

    测试:

    public static void main(String[] args) {
        Son son = new Son();
        System.out.println("儿子敏捷值:" + son.agile());
        System.out.println("儿子恢复值:" + son.recover());
        System.out.println("************");
        Daughter daughter = new Daughter();
        System.out.println("女儿敏捷值:" + daughter.agile());
        System.out.println("女儿恢复值:" + daughter.recover());
    }
    

    结果:
    结果截图
    于是在面对麋鹿(四不像)其外形“似鹿非鹿,似马非马,似牛非牛,似驴非驴”的情形你就能很好的解决问题了,只需定义鹿、马、牛、驴四个类,建立麋鹿类的多个内部类,继承他们即可。

    展开全文
  • Java多重继承的两种方式

    万次阅读 2019-01-30 17:00:57
    /*内部类使的多继承的实现变得更加完美了,同时也明确了如果父类为抽象类或者具体类,那么我就仅能通过内部类来实现多重继承了。*/ public class UseInnerClassHandleMultiExtendsTest { public static void main...

    参考网址: https://www.cnblogs.com/chenssy/p/3389027.html
    1.使用接口

    
    public class Superhero extends ActionCharacter implements FlyAbility,SwimAbility{
    
        @Override
        void fight() {
            System.out.print("会打架");
        }
    
        @Override
        public void canFly() {
            System.out.print("会飞");
        }
    
        @Override
        public void canSwim() {
            System.out.print("会游泳");
        }
    }
    
    abstract class ActionCharacter{
        abstract void fight();
    }
    
    interface FlyAbility{
        void canFly();
    }
    
    interface SwimAbility{
        void canSwim();
    }
    
    

    2.使用内部类

    /*内部类使的多继承的实现变得更加完美了,同时也明确了如果父类为抽象类或者具体类,那么我就仅能通过内部类来实现多重继承了。*/
    public class UseInnerClassHandleMultiExtendsTest {
    
        public static void main(String[] args) {
    
            Son son = new Son();
            Son.LikeMother motherLike = son.getKind();
            motherLike.display();
    
            Son.LikeFather fatherLike = son.getStrong();
            fatherLike.display();
        }
    }
    
    /*这里定义了两个内部类,他们分别继承父亲Father类、母亲类Mother类,且都可以非常自然地获取各自父类的行为,
        这是内部类一个重要的特性:内部类可以继承一个与外部类无关的类,保证了内部类的独立性,正是基于这一点,多重继承才会成为可能。*/
    class Father{
        public void getStrong(){
            System.out.println("像父亲一样强壮");
        }
    }
    
    class Mother{
        public void getKind(){
            System.out.println("像母亲一样和蔼");
        }
    }
    
    class Son{
    
        class LikeMother extends Mother{
            public void display(){
                getKind();
            }
        }
    
        class LikeFather extends Father{
            public void display(){
                getStrong();
            }
        }
    
        LikeFather getStrong(){
            return new LikeFather();
        }
    
        LikeMother getKind(){
            return new LikeMother();
        }
    
    }
    
    展开全文
  • java可以多重继承吗 有时我写了几篇有关Java继承,接口和组成的文章。 在这篇文章中,我们将研究多重继承,然后了解组成优于继承的好处。 Java中的多重继承 多重继承是创建具有多个超类的单个类的能力。 与其他一些...
    java可以多重继承吗

    java可以多重继承吗

    有时我写了几篇有关Java继承接口组成的文章。 在这篇文章中,我们将研究多重继承,然后了解组成优于继承的好处。

    Java中的多重继承

    多重继承是创建具有多个超类的单个类的能力。 与其他一些流行的面向对象的编程语言(例如C ++)不同, java不提供对类中多重继承的支持。 Java不支持类中的多重继承,因为它可能导致钻石问题,而不是提供一些复杂的方法来解决它,而是有更好的方法来实现与多重继承相同的结果。

    钻石问题

    为了轻松理解钻石问题,我们假定Java中支持多重继承。 在这种情况下,我们可以像下面的图像那样有一个类层次结构。

    钻石问题多重继承

    假设SuperClass是一个抽象类,声明了一些方法,而ClassA,ClassB是具体类。

    超类.java

    package com.journaldev.inheritance;
    
    public abstract class SuperClass {
    
    	public abstract void doSomething();
    }

    ClassA.java

    package com.journaldev.inheritance;
    
    public class ClassA extends SuperClass{
    
    	@Override
    	public void doSomething(){
    		System.out.println("doSomething implementation of A");
    	}
    
    	//ClassA own method
    	public void methodA(){
    
    	}
    }

    ClassB.java

    package com.journaldev.inheritance;
    
    public class ClassB extends SuperClass{
    
    	@Override
    	public void doSomething(){
    		System.out.println("doSomething implementation of B");
    	}
    
    	//ClassB specific method
    	public void methodB(){
    
    	}
    }

    现在,让我们说ClassC的实现如下所示,它扩展了ClassA和ClassB。

    ClassC.java

    package com.journaldev.inheritance;
    
    public class ClassC extends ClassA, ClassB{
    
    	public void test(){
    		//calling super class method
    		doSomething();
    	}
    
    }

    注意, test()方法正在调用超类doSomething()方法,这导致歧义,因为编译器不知道要执行哪个超类方法,并且由于菱形类图,它被称为Diamond Problem,这是Java不支持类中的多重继承的主要原因。

    请注意,具有多个类继承的上述问题也可能只出现在三个类中,它们全部具有至少一个通用方法。

    接口中的多重继承

    您可能已经注意到,我一直在说类不支持多重继承,但是接口支持多重继承,并且单个接口可以扩展多个接口,下面是一个简单的示例。

    接口A.java

    package com.journaldev.inheritance;
    
    public interface InterfaceA {
    
    	public void doSomething();
    }

    接口B.java

    package com.journaldev.inheritance;
    
    public interface InterfaceB {
    
    	public void doSomething();
    }

    注意,两个接口都声明了相同的方法,现在我们可以拥有一个扩展这两个接口的接口,如下所示。

    接口C.java

    package com.journaldev.inheritance;
    
    public interface InterfaceC extends InterfaceA, InterfaceB {
    
    	//same method is declared in InterfaceA and InterfaceB both
    	public void doSomething();
    
    }

    这样做非常好,因为接口仅声明方法,并且实际实现将由实现接口的具体类完成,因此在接口的多重继承中不存在任何歧义的可能性。

    这就是为什么Java类可以实现多重继承的原因,例如下面的示例。

    接口Impl.java

    package com.journaldev.inheritance;
    
    public class InterfacesImpl implements InterfaceA, InterfaceB, InterfaceC {
    
    	@Override
    	public void doSomething() {
    		System.out.println("doSomething implementation of concrete class");
    	}
    
    	public static void main(String[] args) {
    		InterfaceA objA = new InterfacesImpl();
    		InterfaceB objB = new InterfacesImpl();
    		InterfaceC objC = new InterfacesImpl();
    
    		//all the method calls below are going to same concrete implementation
    		objA.doSomething();
    		objB.doSomething();
    		objC.doSomething();
    	}
    
    }

    您是否注意到,每当我覆盖任何超类方法或实现任何接口方法时,我都使用@Override注释,它是三个内置的Java注释之一,并且 在覆盖任何方法时都应 始终使用覆盖注释

    救援人员组成

    因此,如果我们想在ClassC使用ClassA函数methodA()ClassB函数methodB() ,该解决方案在于使用composition ,这是ClassC的重构版本,该版本使用了composition来利用这两种类方法以及doSomething ()方法来自其中一个对象。

    ClassC.java

    package com.journaldev.inheritance;
    
    public class ClassC{
    
    	ClassA objA = new ClassA();
    	ClassB objB = new ClassB();
    
    	public void test(){
    		objA.doSomething();
    	}
    
    	public void methodA(){
    		objA.methodA();
    	}
    
    	public void methodB(){
    		objB.methodB();
    	}
    }

    组合与继承

    Java编程的最佳实践之一是“通过接口支持组合”,我们将研究一些偏爱这种方法的方面。

    1. 假设我们有一个超类和子类,如下所示:

      ClassC.java

      package com.journaldev.inheritance;
      
      public class ClassC{
      
      	public void methodC(){
      	}
      }

      ClassD.java

      package com.journaldev.inheritance;
      
      public class ClassD extends ClassC{
      
      	public int test(){
      		return 0;
      	}
      }

      上面的代码可以编译并正常工作,但是如果ClassC实现更改如下:

      ClassC.java

      package com.journaldev.inheritance;
      
      public class ClassC{
      
      	public void methodC(){
      	}
      
      	public void test(){
      	}
      }

      请注意,子类中已经存在test()方法,但返回类型有所不同,现在ClassD将无法编译,并且如果您使用的是任何IDE,它将建议您更改超类或子类中的返回类型。

      现在想象一下这样的情况:我们具有多个级别的类继承,并且超类不受我们控制,我们别无选择,只能更改我们的子类方法签名或名称以消除编译错误,我们还必须在所有方面进行更改子类方法被调用的地方,因此继承使我们的代码易碎。

      组合永远不会发生上述问题,这使其比继承更有利。

    2. 继承的另一个问题是,我们将所有超类方法公开给客户端,并且如果我们的超类设计不当且存在安全漏洞,那么即使我们在实现类时全神贯注,我们也会受到不良实现的影响。超类。组合可以帮助我们提供对超类方法的受控访问,而继承不提供对超类方法的任何控制,这也是组合优于继承的主要优势之一。
    3. 组合的另一个好处是它提供了方法调用的灵活性。 我们上ClassC实现不是最佳的,它提供了与将要调用的方法的编译时绑定,只需进行最小的更改,我们就可以使方法调用变得灵活并使其动态。

      ClassC.java

      package com.journaldev.inheritance;
      
      public class ClassC{
      
      	SuperClass obj = null;
      
      	public ClassC(SuperClass o){
      		this.obj = o;
      	}
      	public void test(){
      		obj.doSomething();
      	}
      
      	public static void main(String args[]){
      		ClassC obj1 = new ClassC(new ClassA());
      		ClassC obj2 = new ClassC(new ClassB());
      
      		obj1.test();
      		obj2.test();
      	}
      }

      上面程序的输出是:

      doSomething implementation of A
      doSomething implementation of B

      方法调用的这种灵活性在继承中不可用,并且提倡了最佳做法,即在继承方面偏向于组合。

    4. 单元测试很容易组合,因为我们知道超类中正在使用的所有方法,并且可以对其进行模拟,而在继承中,我们很大程度上依赖于超类,并且不知道将使用所有超类方法,因此我们需要要测试超类的所有方法,这是一项额外的工作,由于继承,我们不需要这样做。

    理想情况下,仅当在所有情况下父类和子类的“ is-a ”关系均成立时才应使用继承,否则我们应该继续进行组合。

    翻译自: https://www.javacodegeeks.com/2013/08/multiple-inheritance-in-java-and-composition-vs-inheritance.html

    java可以多重继承吗

    展开全文
  • Java实现多重继承技巧

    千次阅读 2017-02-14 10:16:13
    Java实现多重继承

    多重继承指的是一个类可以同时从多于一个的父类那里继承行为和特征,然而我们知道Java为了保证数据安全,它只允许单继承。有些时候我们会认为如果系统中需要使用多重继承往往都是糟糕的设计,这个时候我们往往需要思考的不是怎么使用多重继承,而是您的设计是否存在问题.但有时候我们确实是需要实现多重继承,而且现实生活中也真正地存在这样的情况,比如遗传:我们即继承了父亲的行为和特征也继承了母亲的行为和特征。可幸的是Java是非常和善和理解我们的,它提供了两种方式让我们曲折来实现多重继承:接口内部类

     


    一、 接口

      在介绍接口和抽象类的时候了解到子类只能继承一个父类,也就是说只能存在单一继承,但是却可以实现多个接口,这就为我们实现多重继承做了铺垫。

          对于接口而已,有时候它所表现的不仅仅只是一个更纯粹的抽象类,接口是没有任何具体实现的,也就是说,没有任何与接口相关的存储,因此也就无法阻止多个接口的组合了。

     

    复制代码
     1 interface CanFight {
     2     void fight();
     3 }
     4 
     5 interface CanSwim {
     6     void swim();
     7 }
     8 
     9 
    10 interface CanFly {
    11     void fly();
    12 }
    13 
    14 public class ActionCharacter {
    15     public void fight(){
    16         
    17     }
    18 }
    19 
    20 public class Hero extends ActionCharacter implements CanFight,CanFly,CanSwim{
    21 
    22     public void fly() {
    23     }
    24 
    25     public void swim() {
    26     }
    27 
    28     /**
    29      * 对于fight()方法,继承父类的,所以不需要显示声明
    30      */
    31 }
    复制代码

     

    二、内部类

      上面使用接口实现多重继承是一种比较可行和普遍的方式,在介绍内部类的时候谈到内部类使的多继承的实现变得更加完美了,同时也明确了如果父类为抽象类或者具体类,那么我就仅能通过内部类来实现多重继承了。如何利用内部类实现多重继承,请看下面实例:儿子是如何利用多重继承来继承父亲和母亲的优良基因。

    首先是父亲Father和母亲Mother:

     

    复制代码
    public class Father {
        public int strong(){
            return 9;
        }
    }
    
    public class Mother {
        public int kind(){
            return 8;
        }
    }
    复制代码

     

      重头戏在这里,儿子类Son:

    复制代码
    public class Son {
        
        /**
         * 内部类继承Father类
         */
        class Father_1 extends Father{
            public int strong(){
                return super.strong() + 1;
            }
        }
        
        class Mother_1 extends  Mother{
            public int kind(){
                return super.kind() - 2;
            }
        }
        
        public int getStrong(){
            return new Father_1().strong();
        }
        
        public int getKind(){
            return new Mother_1().kind();
        }
    }
    复制代码

       测试程序:

    复制代码
    public class Test1 {
    
        public static void main(String[] args) {
            Son son = new Son();
            System.out.println("Son 的Strong:" + son.getStrong());
            System.out.println("Son 的kind:" + son.getKind());
        }
    
    }
    ----------------------------------------
    Output:
    Son 的Strong:10
    Son 的kind:6
    复制代码

     儿子继承了父亲,变得比父亲更加强壮,同时也继承了母亲,只不过温柔指数下降了。这里定义了两个内部类,他们分别继承父亲Father类、母亲类Mother类,且都可以非常自然地获取各自父类的行为,这是内部类一个重要的特性:内部类可以继承一个与外部类无关的类,保证了内部类的独立性,正是基于这一点,多重继承才会成为可能。


    展开全文
  • 主要介绍了java为什么不允许类多重继承却允许接口多重继承,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • Java实现多重继承

    千次阅读 2018-06-07 16:14:13
    Java提供了两种方式让我们曲折来实现多重继承:接口和内部类。①接口和内部类的应用场景区别??一、接口 在介绍接口和抽象类的时候了解到子类只能继承一个父类,也就是说只能存在单一继承,但是却可以实现多个接口...
  • java多重继承

    2018-05-11 16:51:51
    多重继承指的是一个类可以同时从多于一个的父类那里继承行为和特征,然而我们知道Java为了保证数据安全,它只允许单继承。有些时候我们会认为如果系统中需要使用多重继承往往都是糟糕的设计,这个时候我们往往...
  • 浅谈 Java多重继承

    2017-12-09 22:22:17
    浅谈 Java多重继承 James Gosling在1995年2月发表了一篇名为”Java概览”的Java白皮书,文章解释了Java不支持多重继承的原因。 Java去除了一些C++中很少用、而且被经常误解而错用的功能...
  • java实现多重继承

    2017-05-28 10:36:08
    多重继承指的是一个类可以同时从多于一个的父类那里继承行为和特征,然而我们知道Java为了保证数据安全,它只允许单继承。有些时候我们会认为如果系统中需要使用多重继承往往都是糟糕的设计,这个时候我们往往需要...
  • JAVA 单继承 与 接口 多重继承

    千次阅读 2017-10-11 18:30:42
    又是一个牛角尖,只是语言不够严谨而已,Java中只支持类的单继承,接口之间的继承同样也是使用extends关键字,但是接口之间是支持多继承的,如下面的例子: [java] view plaincopy interface IP1 {  }...
  • Java中实现多重继承

    千次阅读 2016-06-08 21:51:22
    常常使用继承单个类和集成多个接口的方式实现类的多重继承。 如下是多重继承示例:interface CanFight{ void fight(); } interface CanSwim{ void swim(); } interface CanFly{ void fly(); } class ...
  • Java中的多重继承

    千次阅读 2015-11-07 10:00:22
    多重继承指的是一个类可以同时从多于一个的父类那里继承行为和特征,然而我们知道Java为了保证数据安全,它只允许单继承。 有些时候我们会认为如果系统中需要使用多重继承往往都是糟糕的设计,这个时候我们往往需要...
  • Java中关于多重继承的问题标签(空格分隔): Java多重继承的含义 多重继承指的是一个类可以同时从多于一个的父类那里继承行为和特征,然而Java为了保证数据安全,它只允许单继承。 有时候我们确实是需要实现多重...
  • java 实现多重继承

    2016-12-02 15:56:40
    //多重继承类 public class ClassTestylll extends Person1 { class inner extends Machine1{ @Override void run() { // TODO Auto-generated method stub System.out.println("Machin
  • Java - 为什么Java中不支持多重继承

    万次阅读 2019-08-13 11:28:44
    为什么Java不支持多重继承,可以考虑以下两点: 1.第一个原因是围绕钻石GEM形继承问题产生的歧义。考虑一个类A有foo()方法,然后B和C派生自A,并且有自己的foo()实现,现在D类使用多个继承派生自B和C,如果我们只...
  • 多重继承指的是一个类可以同时从多于一个的父类那里继承行为和特征,然而我们知道Java为了保证数据安全,它只允许单继承。有些时候我们会认为如果系统中需要使用多重继承往往都是糟糕的设计,这个时候我们往往需要...
  • 众所周知,java是一门不支持多重继承的语言,每当在java中谈及多重继承,人们都会说起接口。 然而一般理解之下,既然是接口,里面的方法是不能有具体实现的,顶多也就起到一个规范的作用嘛,这样岂不是还会造成代码...
  • Python的多重继承Java的单继承

    千次阅读 2015-01-30 16:12:27
    最近在学习Python,了解到Python是允许使用多重继承的,与Java的单继承不同。 仔细思考之后觉得Python的这种多重继承的设计更为合理些,更接近现实世界。因为我觉得一个物体不能严格的把它归为确定的某一类,拿动物...
  • 不管是Java的interface或是C++的多重继承﹐在物件导向的理论里﹐都算是蛮新颖的概念。所以这里我们谈的﹐是以程式语言的角度﹐看看Java interface的所有意义与功能﹐是否C++的多重继承能全部诠释?或是相反地以Java...
  • Java基础篇:多重继承的实现.pdf
  • 为什么Java不支持多重继承?

    千次阅读 2013-11-27 08:42:42
    James Gosling在1995年2月发表了一篇名为”Java概览”的Java白皮书,文章解释了Java不支持多重继承的原因。 Java去除了一些C++中很少用、而且被经常误解而错用的功能,如操作符的重载(operator overloading)...
  • Java为什么不支持多重继承

    千次阅读 2019-06-22 14:57:22
    熟悉 Java 的小伙伴应该知道 Java 有个很重要的特性就是它不支持多重继承。但是使用过其他面向对象编程语言的童鞋会知道,有的语言是支持多重继承的,比如 C++,Python. 我们来看看 ”Java 之父“:James Gosling ...
  • 然后a12又多重继承了a1和a2。同样,a12获得了b方法的定义。 但是假设上述代码中的接口都换成类,假如a12没有对b方法作覆盖,那么再假如a1对b方法作了实现,然后a2也对b方法作了实现,那么a12继承的b方法究竟来自...
  • 主要介绍了C++中的多态与多重继承实现与Java的区别,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • java内部类实现多重继承

    千次阅读 2010-06-30 14:55:00
    java内部类实现多重继承
  • C++的多重继承功能较广,Java的interface功能只是其中的一个子集。因为C++的虚拟函数可以有纯虚拟函数,也可有非纯虚拟函数,而Java只有抽象函数,所以功能模式少一种,自然能达到的效果较少一些。 但这并不代表Java...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 62,359
精华内容 24,943
关键字:

java多重继承方式

java 订阅