精华内容
下载资源
问答
  • 在java中一个可以多重实现,但不能多重继承,也就是说一个能够同时实现多个接口,但不能同时继承多。但有时候我们确实需要继承多,比如希望拥有两个的行为功能,就很难使用单继承来解决问题了(当然...
    
    

    在java中一个类可以多重实现,但不能多重继承,也就是说一个类能够同时实现多个接口,但不能同时继承多个类。但有时候我们确实需要继承多个类,比如希望拥有两个类的行为功能,就很难使用单继承来解决问题了(当然多层继承是可以解决的),那么我们还可以用什么办法来解决多重继承的问题呢?没错!用内部类!下面介绍一个案例。假设有一个父亲和母亲,他们的儿子继承了他们两个的优点,那么怎么来写呢?

    1. public interface Father {

      //定义父亲的强壮指数的接口

      public int strong();

      }

    2. public interface Mother {

      //定义母亲的善良指数的接口

      public int kind();

      }

    3. public class FatherImpl implements Father {

      //实现父亲接口,定义父亲强壮指数为8

      @Override

      public int strong() {

      return 8;

      }

      }

    4. public class MotherImpl implements Mother {

      //实现母亲接口,定义母亲善良指数为8

      @Override

      public int kind() {

      return 8;

      }

      }

    5. 下面儿子类来了~~

    儿子类

    可以看到儿子继承父亲,并且覆写了父类的strong方法,同时呢儿子也具有母亲的优点,覆写了母亲的kind方法。这里构造了一个MotherSpecial类继承于母亲类,也就是获得了母亲类的行为方法,这也是内部类的一个重要特征:内部类可以继承一个与外部类无关的类,保证了内部类的独立性,正是基于这一点,多重继承才能成为可能~~

    在现实生活中,也确实存在多重继承的问题,比如我国的“四不像”(学名麋鹿),其外形“似鹿非鹿,似马非马,似牛非牛,似驴非驴”,这要是用单继承就麻烦了,如果用多继承的话就可以很好的解决问题了,定义鹿、马、牛、驴四个类,再建立麋鹿类的多个内部类,继承他们即可~~~


    内部类实现一个接口与外围类实现这个接口的区别


    在java中,外围类只能继承一个基类,要实现多继承,只有继承多个接口类型。有时,你需要与接口的实现进行交互,所以使用内部类最重要的一个原因是:每个内部类都能独立的继承自一个(接口的)实现,内部类允许你继承多个非接口类型。正是因为内部类的这种能力,有效的实现了“多重继承”。

    内部类的其他特性:

    1.内部类可以有多个实例,每个实例都有自己的状态信息,并且与其外围类对象的信息相互独立;

    2.在单个外围类中,你可以让多个内部类以不同的方式实现一个接口,或继承同以一个类;

    3.创建内部类对象的时候并不依赖外围类对象的创建;

    4.内部类与外围类之间没有另人迷惑的“is-a”关系,它就是一个独立的实体



    展开全文
  • 本文的标题可能有一定的误导性,并不是说一般内部类就能实现多继承,显然这是不可能的。真正的意思是通过多继承实现我们期望中的多继承的功能。 这里就拿人类来举例吧,人(Person)是一种生物(biology),而且是...

    本文的标题可能有一定的误导性,并不是说一般内部类就能实现多继承,显然这是不可能的。真正的意思是通过多继承来实现我们期望中的多继承的功能。

    这里就拿人类来举例吧,人(Person)是一种生物(biology),而且是可移动(Moveable)的生物。我们可以定义如下两个类:

    public class Biology {
    
    	
    	public void die(){
    		System.out.println("生命是有限的,都有死亡的一天");
    	}
    	
    	
    }


     
    

    package com.pht.inner;
    
    public class Moveable {
    
    	public void move(){
    		System.out.println("运动是永恒的,静止是想对的");
    	}
    	
    }


    人要同时具有以上的两种特性,那么就需要定义一个人(Human)如下:

    package com.pht.inner;
    
    import com.pht.inner.Outer.Inner;
    
    public class Human {
    
    	
    	public void MoveableBiology(){
    		InnerHuman1 innerHuman1=new InnerHuman1();
    		InnerHuman2 innerHuman2=new InnerHuman2();
    		
    		innerHuman2.move();
    		innerHuman1.die();
    	}
    	
    	
    	class InnerHuman1 extends Biology{
    	
    		
    		
    	}
    	class InnerHuman2 extends Moveable{
    		
    	}
    	
    }

    测试类main如下

    package com.pht.inner;
    
    public class Humantest {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    
    		Human human=new  Human();
    		human.MoveableBiology();
    		
    	}
    
    }
    
    可以看出,我们是通过内部类分别继承来实现多继承的功能,这对于在一些情况下提高代码的灵活性和复用是很有帮助的。当然,我们也可以外部类继承一个模块,剩下的由内部类来继承来实现。在此不需要赘述。

    内部类的封装性:

    加入我们把内部类定义为private的,那么就只有包含此内部类的外部类能够访问他。这样在我们希望只给某一个类提供服务,拒绝其它不相干的的类的访问的时候,我们可以通过内部类来达到目的。



    展开全文
  • 内部类实现多重继承

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

            感谢‘chenssy’提供生动的例子,自己受益匪浅    

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

           如何利用内部类实现多重继承,请看下面实例:儿子是如何利用多重继承来继承父亲和母亲的优良基因。

           首先是父亲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类,且都可以非常自然地获取各自父类的行为,这是内部类一个重要的特性:内部类可以继承一个与外部类无关的类,保证了内部类的独立性,正是基于这一点,多重继承才会成为可能。



    展开全文
  • 我们知道,如果要直接继承类,子类不可直接多继承,但可通过多层继承实现多继承。但多层继承一般建议不超过三次,且代码较冗余。 //多层继承实现多继承 class A{//父类A private int num=10; public int getNum...

    Java中可实现多继承的三种方法

    多层继承

    内部类

    接口

    多层继承

    我们知道,如果要直接继承类,子类不可直接多继承,但可通过多层继承实现多继承。但多层继承一般建议不超过三次,且代码较冗余。

    //多层继承实现多继承
    class A{//父类A类
        private int num=10;
        public int getNum(){
            return this.num;
        }
        public void fun(){
            System.out.println("你今天真好看!");
        }
    }
    class B extends A{//B类继承A类
        private String name="张三";
        public String getName(){
            return this.name;
        }
        public void fun(){//方法覆写
            System.out.println(this.getNum());
            //父类私有域被继承但不可直接使用,需通过getter方法间接获得私有域的内容
        }
    }
    class C extends B{//C类继承B类,相当于间接继承A类
        private String name="刘能";
        public String getName(){
            return this.name;
        }
        public void fun(){//方法覆写(结果为覆写后的内容)
            System.out.println(this.getName());
            System.out.println(this.name);
        }
    }
    public class Test{
        public static void main(String[] args){
            A a=new A();
            a.fun();
            print(new B());//向上转型(优点在于子类可自动进行向上转型,可实现参数的统一)
            print(new C());
        }
        public static void print(A a){
            a.fun();
        }
    }

    内部类

    第二种方法就是成员内部类可直接实现多继承。

    //内部类实现多继承
    class A{//A类
        private int num=10;
        public int getNum(){
            return this.num;
        }
        public void fun(){
            System.out.println("你今天真好看!");
        }
    }
    class B {//B类(与A类无关)
        private String name="张三";
        public String getName(){
            return this.name;
        }
        public void fun(){
            System.out.println("昨天的你也很好看!");
        }
    }
    class C {//C类
        // private String name="刘能";
        class OneA extends A{//C中内部类继承A类
            public void printA(){
                System.out.println(this.getNum());
                fun();
            }
        }
        class OneB extends B{//C类内部类继承B类
            public void printB(){
                System.out.println(this.getName());
                fun();
            }
        }
        public void print(){//在C类中生成普通方法print()
            new OneA().printA();//匿名实例化OneA类对象并调用printA方法
            new OneB().printB();
        }
    }
    public class Test{
        public static void main(String[] args){
            C c=new C();//实例化C类对象
            c.print();//调用C中print方法
        }
    }

    接口

    第三种实现多继承的方法是接口,在同时可用内部类和接口时,优先使用接口。因内部类需要应用于继承关系,接口可用于继承也可用于其他,比较灵活。

    //接口实现多继承
    interface IA{//父接口A(接口为更纯粹的抽象类,结构组成只含全局常量和抽象方法)
        void funA();
    }
    interface IB {//父接口B(接口前添加I用以区分接口)
        void funB();
    }
    interface CImpl extends A,B{//接口可继承多个父接口,用,分隔开即可,子接口的命名可选择较为重要的父接口进行命名或自行命名,一般子接口后添加Impl用以区分
        void funC();
    }
    class Impl implements CImpl{//定义类实现接口(也可直接实现父接口(多个))
        public void funC(){//抽象方法的实现
            System.out.println("你昨天真好看!");
        }
        public void funA(){
            System.out.println("你今天真好看!");
        }
        public void funB(){
            System.out.println("你明天真好看!");
        }
    }
    public class Test{
        public static void main(String[] args){
            Impl im=new Impl();//实例化对象
            im.funA();
            im.funB();
            im.funC();
        }
    }

    展开全文
  • java利用内部类实现多重继承

    千次阅读 2011-08-07 15:45:23
    利用内部类可以实现多重继承关系 : 如下: class D {} abstract class E{} class Z extends D { E makeE(){ return new E() {}; } } public class MultiImpleme
  • 可以。而且必须实现接口或继承其他
  • Java内部类模拟实现多继承

    千次阅读 2012-07-20 14:14:53
    package com.test; /**  * 橡皮  * */ public abstract class Eraser {  public abstract void erase(); } package com.test; /**  * 铅笔  * */ public abstract class Pencil {
  • 匿名内部类: 可以继承其他,但不能用extends。 可以实现某接口,但不能用implements。匿名内部类,就是没有名字的内部类。故没有构造器,必须调用基类的构造器。所以是继承基类的。匿名内部类经常被用来覆盖...
  • Java:使用内部类实现类的多重继承

    千次阅读 2012-03-06 22:42:12
    Java不支持的多重继承,但可以使用内部类继承实现。 下面的例子,目标需要继承两个抽象(A和B)。目标C本身继承类A,并使用一个匿名内部类继承另一个B。 MultiImplementation.java abstract ...
  • 使用内部类让Java实现多继承

    千次阅读 2011-12-13 11:38:45
    使用内部类让Java实现多继承” 众所周知,Java没有像c++那样支持多继承,但是我们可以使用接口或内部类来模拟实现多继承。 我们使用内部类实现一个继承自消费者,又继承自生产者的派生。 实际上Java之所以...
  • 1. 匿名内部类总是默认实现某个接口或继承某个抽象。 2.不能有构造方法,只能有一个实例。 3. 不能定义在任何静态成员、静态方法。 4. 不能是public.protected.private static. 5. 匿名内部类为局部的,所以...
  • 匿名内部类必须继承一个父类或实现一个接口;不能继承其他的,别的博文中一直写匿名内部类可以作为一个接口,由另一个内部类实现,完全不明白是什么意思,本人也没有实现这个功能,欢迎大神评论解答。...
  • 匿名的内部类是没有名字的内部类。不能继承其它,但一个内部类可以作为一个接口,由另一个内部类实现
  • 匿名内部类也就是没有名字的内部类 ...但使用匿名内部类还有个前提条件:必须继承一个父类或实现一个接口   实例1:不使用匿名内部类实现抽象方法 1 2 3 4 5 6 7 8 9 10 11 12 13
  • java实现多继承

    千次阅读 2015-03-13 12:17:09
    使用内部类就可以多继承,严格来说,还不是实现多继承,但是这种方法可以实现多继承所需的功能,所以把它称为实现多继承。 下面就举个例子: 假如有一个打电话Call,里面实现了一个可以打电话的功能的方法...
  • 一个关于匿名内部类的两个问题:匿名内部类能否继承其他的 ?又能否实现接口?
  • 一个匿名内部类一定是继承一个或者实现一个接口,new了这个父类或接口名的内部类还带内容,我就想问能不能还能不能继承其他实现其他接口。 如果我表达不好,不好理解, 那问题简化就是 匿名内部类能不能...
  • 1.为什么需要内部类 内部类继承自某个或者实现某个接口,内部类可以访问创建它...下面的代码体现内部类实现多重继承实现多个接口 interface A{} interface B{} //实现两个接口的单一 class X implements A,B{}
  • 但使用匿名内部类还有个前提条件:必须继承一个父类或实现一个接口 实例1:不使用匿名内部类实现抽象方法 abstract class Person { public abstract void eat(); } class Child extends Person
  • Inner Class(内部类)定义在中的。 Nested Class(嵌套)是静态(static)内部类。1. 要创建嵌套的对象,并不需要其外围...匿名的内部类不能extends(继承)其它,但一个内部类可以作为一个接口,由另一个
  • Java 内部类的作用,实现多重继承

    千次阅读 2014-03-14 11:09:48
    1.内部类可以很好的实现隐藏  一般的非内部类,是不允许有 private 与protected权限的,但内部类可以 2.内部类拥有外围的所有元素的访问权限 3.可是实现多重继承 4.可以避免修改接口而实现同一个...
  • java 不支持多继承,但可以实现多个接口,间接的实现多继承,也可以通过内部类。 参考代码:MultiExtendsTest // 测试间接的实现多继承 public class MultiExtendsTest extends D implements A, B, C { @...
  • java如何实现多继承

    万次阅读 热门讨论 2018-09-03 16:26:00
    使用内部类就可以多继承,严格来说,还不是实现多继承,但是这种方法可以实现多继承所需的功能,所以把它称为实现多继承。 下面就举个例子: 假如有一个打电话Call,里面实现了一个可以打电话的功能的方法...
  • Java—内部类(三)—内部类继承

    万次阅读 多人点赞 2016-12-14 14:23:50
    内部类继承内部类和其他普通一样,同样可以被继承,这样给本来就十分灵活的内部类增加了更好的结构性和代码复用性。只是内部类继承和普通有一些不同之处,是在使用时需要多加注意的。因为内部类在创建时需要...
  • 回答:匿名内部类实现时必须借助一个借口或者一个抽象或者一个普通来构造,从这过层次上讲匿名内部类实现了接口或者继承,但是不能通过extends或implement关键词来继承类实现接口。 匿名内部类即...
  • package 匿名内部类实现多线程; public class Demo { public static void main(String[] args) { // 继承Thread类实现多线程 new Thread() { public void run() { for (int i = 0; i...
  • //异步任务处理 ... //新建内部类 继承 AsyncTask @SuppressLint("StaticFieldLeak") class RequestNetworkDataTask extends AsyncTask<String,Integer,String> { @Overrid...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 636,797
精华内容 254,718
关键字:

内部类怎么实现多继承