精华内容
下载资源
问答
  • java内部类实现多重继承

    千次阅读 2010-06-30 14:55:00
    java内部类实现多重继承

     

     

     

     

    原文地址http://topic.csdn.net/u/20100312/10/822b0e94-8d2f-4bf0-9746-3424eaea40ce.html?10780

    展开全文
  • 本文的标题可能有一定的误导性,并不是说一般内部类就能实现多继承,显然这是不可能的。真正的意思是通过多继承实现我们期望中的多继承的功能。 这里就拿人类来举例吧,人(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的,那么就只有包含此内部类的外部类能够访问他。这样在我们希望只给某一个类提供服务,拒绝其它不相干的的类的访问的时候,我们可以通过内部类来达到目的。



    展开全文
  • Java中可实现多继承的三种方法 多层继承 内部类 接口 多层继承 我们知道,如果要直接继承类,子类不可直接多继承,但可通过多层继承实现多继承。但多层继承一般建议不超过三次,且代码较冗余。 //多层继承实现多...

    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内部类模拟实现多继承

    千次阅读 2012-07-20 14:14:53
    package com.test; /**  * 橡皮  * */ public abstract class Eraser {  public abstract void erase(); } package com.test; /**  * 铅笔  * */ public abstract class Pencil {

    package com.test;

    /**
     *  橡皮类
     * */
    public abstract class Eraser {
                public abstract void erase();
    }
    package com.test;
    /**
     *  铅笔类
     * */
    public abstract class Pencil {
                 public abstract void wirte();
    }

    package com.test;
    /**
     *  做一个既有铅笔功能又有橡皮擦功能类
     *  (用接口完全可以实现,这里只是假设这种情况,模拟多继承)
     * */
    public class PencilWithEraser{


     private MyPencil pencil = new MyPencil();
     private MyEraser eraser = new MyEraser();


     /**
      *
      * 继承了铅笔的功能
      *
      * */ 
     private class MyPencil extends Pencil{

      @Override
      public void wirte() {
       System.out.println("use to wirte");
      }
      
      
     }
    /*写一个既有笔功能又有橡皮侧功能的类

    **/

     private class MyEraser extends Eraser {

      @Override
      public void erase() {
                System.out.println("use to erase");
      }
      
     }
     /*
      * 本类自己的方法
      * */
     public void wirte(){
                   pencil.wirte();
     }


     public void eraser(){
                    eraser.erase();
       }
    }

    测试类

    package com.test;

    public class Test {

     /**
      * @param args
      */
     public static void main(String[] args) {
      // TODO Auto-generated method stub
      PencilWithEraser pencilWithEraser = new PencilWithEraser();
                       pencilWithEraser.wirte();
                       pencilWithEraser.eraser();
     }

    }

    这个类既有笔又有橡皮擦功能了。模拟实现了Java多继承。

     

    展开全文
  • 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实现多继承

    千次阅读 2011-12-13 11:38:45
    使用内部类Java实现多继承” 众所周知,Java没有像c++那样支持多继承,但是我们可以使用接口或内部类来模拟实现多继承。 我们使用内部类实现一个继承自消费者,又继承自生产者的派生。 实际上Java之所以...
  • Java:使用内部类实现类的多重继承

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

    千次阅读 2011-04-17 13:21:00
    java中不允许一个类继承多个父类,但是可以使用java内部类的来达到多继承的效果,同时也避免了多继承中不好的地方。
  • java实现多继承

    千次阅读 2015-03-13 12:17:09
    使用内部类就可以多继承,严格来说,还不是实现多继承,但是这种方法可以实现多继承所需的功能,所以把它称为实现多继承。 下面就举个例子: 假如有一个打电话Call,里面实现了一个可以打电话的功能的方法...
  • java如何实现多继承

    万次阅读 热门讨论 2018-09-03 16:26:00
    使用内部类就可以多继承,严格来说,还不是实现多继承,但是这种方法可以实现多继承所需的功能,所以把它称为实现多继承。 下面就举个例子: 假如有一个打电话Call,里面实现了一个可以打电话的功能的方法...
  • 1. 匿名内部类总是默认实现某个接口或继承某个抽象。 2.不能有构造方法,只能有一个实例。 3. 不能定义在任何静态成员、静态方法。 4. 不能是public.protected.private static. 5. 匿名内部类为局部的,所以...
  • 详解 Java 内部类

    万次阅读 多人点赞 2018-09-04 00:17:56
    内部类Java 里面算是非常常见的一个功能了,在日常开发中我们肯定多少少都用过,这里总结一下关于 Java内部类的相关知识点和一些使用内部类时需要注意的点。 从种类上说,内部类可以分为四类:普通内部类...
  • java 不支持多继承,但可以实现多个接口,间接的实现多继承,也可以通过内部类。 参考代码:MultiExtendsTest // 测试间接的实现多继承 public class MultiExtendsTest extends D implements A, B, C { @...
  • 内部类实现多重继承

    千次阅读 2014-08-22 16:23:24
    多重继承指的是一个可以同时从多于一个的父类那里继承行为和特征,然而我们知道Java为了保证数据安全,它只允许单继承。有些时候我们会认为如果系统中需要使用多重继承往往都是糟糕的设计,这个时候我们往往需要...
  • 匿名内部类也就是没有名字的内部类 ...但使用匿名内部类还有个前提条件:必须继承一个父类或实现一个接口   实例1:不使用匿名内部类实现抽象方法 1 2 3 4 5 6 7 8 9 10 11 12 13
  • Java内部类和匿名内部的用法

    万次阅读 多人点赞 2016-07-21 15:46:41
    Java内部类和匿名内部的用法 【尊重原创,转载请注明出处】http://blog.csdn.net/guyuealian/article/details/51981163一、内部: (1)内部的同名方法 内部可以调用外部的方法,如果内部有同名方法...
  • 本文主要介绍了Java内部类的基本原理,使用方法和各种细节。 有关内部类实现回调,事件驱动和委托机制的文章将在后面发布。 具体代码在我的GitHub中可以找到 https://github.com/h2pl/MyTech 文章首发于我的个人...
  • Java内部类(三)—内部类继承

    万次阅读 多人点赞 2016-12-14 14:23:50
    内部类继承内部类和其他普通一样,同样可以被继承,这样给本来就十分灵活的内部类增加了更好的结构性和代码复用性。只是内部类继承和普通有一些不同之处,是在使用时需要多加注意的。因为内部类在创建时需要...
  • Java内部类

    千次阅读 2018-12-28 11:21:17
    Java内部类真的很难理解,但有必要搞懂,因为内部让外部更丰富多彩了,就好像一个人的心中还可以住着另外一个人。
  • 文章目录1 内部类的基本概念1.1 内部类的定义1.2 内部类的优缺点2 创建内部类2.1 在外部外部创建非静态内部类2.2 在外部外部创建静态内部类2.3 在外部类内部创建内部类语法3 内部类的分类3.1 成员内部类3.2 静态...
  • package 匿名内部类实现多线程; public class Demo { public static void main(String[] args) { // 继承Thread类实现多线程 new Thread() { public void run() { for (int i = 0; i...
  • java内部类及四种内部实现方式

    千次阅读 2013-08-21 09:29:19
    java内部类及四种内部实现方式 一、内部定义: 内部分为: 成员内部、静态嵌套、方法内部、匿名内部。 二、为何要内部? a、内部提供了某种进入外围的窗户。 b、也是最吸引人的原因,每个内部...
  • Java 内部类综述

    千次阅读 多人点赞 2016-11-20 22:07:18
    可幸的是,Java 提供了两种方式让我们曲折地来实现多重继承:接口和内部类。其中,内部类的一个及其重要的作用就是实现多重继承。除此之外,内部类还可以很好的实现隐藏(私有成员内部类)。内部类共有四种类型,即...
  • Java里如何实现多继承

    千次阅读 2012-05-08 12:55:21
    1.接口(interface),接口被用来建立之间关联的标准。  Javacode  public interface ITest{  public void test();  }  public class TestImpl implements ITest{  public void test(){
  • Java 抽象 接口 继承 实现

    千次阅读 2016-07-23 17:21:14
    接口和抽象的概念不一样。...人可以吃东西,狗也可以吃东西,你可以把“吃东西”定义成一个接口,然后让这些实现它(类实现多个接口,实现多个动作). 所以,在高级语言上,一个只能继承一个(抽象,jav
  • 回答:匿名内部类实现时必须借助一个借口或者一个抽象或者一个普通来构造,从这过层次上讲匿名内部类实现了接口或者继承,但是不能通过extends或implement关键词来继承类实现接口。 匿名内部类即...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 388,895
精华内容 155,558
热门标签
关键字:

java内部类实现多继承

java 订阅