精华内容
下载资源
问答
  • 类与类之间单根继承 使Java语言变得易于使用和简单, 如果一个类可以继承多个类,那么这个类所有成员变量名和方法名必须要不同(C++就是这样要求的)...类与接口可以多重实现(接口与接口之间可以有相同的方法名), 接口中
    类与类之间单根继承
    使Java语言变得易于使用和简单,
    如果一个类可以继承多个类,那么这个类所有成员变量名和方法名必须要不同(C++就是这样要求的).这是前提,我们必须确定这个才能用多重继承,如果在类方法名或者成员变量名很多情况下,这是很复杂的事情.原因:要确定子类到底继承方法或属性是哪一父类的

    类与接口可以多重实现(接口与接口之间可以有相同的方法名),
    接口中没有成员变量(只有常量),而方法是抽象的,没有方法体,所以实现类只要实现这个些接口都必须重写,实现谁的接口方法最终的结果都是要重写

    接口与接口之间可以多重继承
    原因与上类似
    展开全文
  • 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());
    }
    

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

    展开全文
  • 多重栈的实现

    2017-11-09 19:29:20
    前面介绍的栈的实现可以用于实现单个栈,并且实现站得操作,接下来介绍多重栈的实现,也就是一次向创建N个栈用于模拟栈的功能,并且实现相关操作; 多重栈的实现最重要的实现实现通过下标对于各个栈的访问,也就是...
    • 前面介绍的栈的实现可以用于实现单个栈,并且实现栈的操作,接下来介绍多重栈的实现,也就是一次向创建N个栈用于模拟栈的功能,并且实现相关操作;
    • 多重栈的实现最重要的实现实现通过下标对于各个栈的访问,也就是需要通过数组下标的方式来随机性的访问各个栈;
    • 首先需要定义一个数组来进行栈的下标随机访问;
    StackNode top[MAX_SIZE] = {NULL};

    * 通过top的下标完成栈的随机访问工作;
    * 元素的添加操作,这里就需要指定添加栈元素的下标;

    void push(int i, elements item)
    {
        StackNode temp = (StackNode)malloc(sizeof(StackNode));
        if (temp == NULL)
        {
            fprintf(stderr, "malloc is error\n");
            exit(EXIT_FAILURE);
        }
        temp->data = item;
        temp->link = top[i];
        top[i] = temp;
    }
    • 元素的弹出操作,同样需要指定栈的下标;
    elements pop(int i)
    {
        StackNode temp = top[i];
        elements item;
        if (!temp)
            exit(EXIT_FAILURE);
        item = temp->data;
        top[i] = temp->link;
        free(temp);
        return item;
    }

    * 打印操作,用来检验栈里面的元素添加是否正常;

    void StackPrint(int i)
    {
        if (i < 0 || i > MAX_SIZE)
        {
            fprintf(stderr, "The number out of range\n");
            exit(EXIT_FAILURE);
        }
        printf("The Stack[%d] Contains:\n", i);
        StackNode temp = top[i];
        while (temp != NULL)
        {
            printf("[%d]\n", temp->data.key);
            temp = temp->link;
        }
    }
    • 访问栈顶指针操作
    elements stacktop(int i){
        StackNode temp=top[i];
        if(!temp)
            exit(EXIT_FAILURE);
        return temp->data;
    }
    • 弹出元素操作
    void pop(int i)
    {
        StackNode temp = top[i];
        elements item;
        if (!temp)
            exit(EXIT_FAILURE);
        item = temp->data;
        top[i] = temp->link;
        free(temp);
    }
    • 完整的程序代码
    #include<stdio.h>
    #include<stdlib.h>
    #define MAX_SIZE 10
    
    typedef struct
    {
        int key;
    } elements;
    typedef struct node *StackNode;
    
    struct node
    {
        elements data;
        StackNode link;
    };
    
    StackNode top[MAX_SIZE] = {NULL};
    
    void push(int i, elements item)
    {
        StackNode temp = (StackNode)malloc(sizeof(StackNode));
        if (temp == NULL)
        {
            fprintf(stderr, "malloc is error\n");
            exit(EXIT_FAILURE);
        }
        temp->data = item;
        temp->link = top[i];
        top[i] = temp;
    }
    void pop(int i)
    {
        StackNode temp = top[i];
        elements item;
        if (!temp)
            exit(EXIT_FAILURE);
        item = temp->data;
        top[i] = temp->link;
        free(temp);
    }
    elements stacktop(int i){
        StackNode temp=top[i];
        if(!temp)
            exit(EXIT_FAILURE);
        return temp->data;
    }
    
    void StackPrint(int i)
    {
        if (i < 0 || i > MAX_SIZE)
        {
            fprintf(stderr, "The number out of range\n");
            exit(EXIT_FAILURE);
        }
        printf("The Stack[%d] Contains:\n", i);
        StackNode temp = top[i];
        while (temp != NULL)
        {
            printf("[%d]\n", temp->data.key);
            temp = temp->link;
        }
    }
    
    int main()
    {
        elements item;
        item.key = 10;
        int num;
        num = 1;
        push(num, item);
        push(num, item);
        push(num, item);
        push(num, item);
        StackPrint(1);
        num = 2;
        push(num, item);
        StackPrint(2);
        return 0;
    }
    • 程序执行结果截图:
      这里写图片描述
    展开全文
  • 实现多重继承

    2014-04-19 22:22:40
    多重继承指的是一个类可以同时从多于一个的父类那里继承行为...但有时候我们确实是需要实现多重继承,而且现实生活中也真正地存在这样的情况,比如遗传:我们即继承了父亲的行为和特征也继承了母亲的行为和特征。可幸的

    多重继承指的是一个类可以同时从多于一个的父类那里继承行为和特征,然而我们知道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:

    1. public class Father {  
    2.     public int strong(){  
    3.         return 9;  
    4.     }  
    5. }  
    6.   
    7. public class Mother {  
    8.     public int kind(){  
    9.         return 8;  
    10.     }  
    11. }  

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

    1. public class Son {  
    2.       
    3.     /** 
    4.      * 内部类继承Father类 
    5.      */  
    6.     class Father_1 extends Father{  
    7.         public int strong(){  
    8.             return super.strong() + 1;  
    9.         }  
    10.     }  
    11.       
    12.     class Mother_1 extends  Mother{  
    13.         public int kind(){  
    14.             return super.kind() - 2;  
    15.         }  
    16.     }  
    17.       
    18.     public int getStrong(){  
    19.         return new Father_1().strong();  
    20.     }  
    21.       
    22.     public int getKind(){  
    23.         return new Mother_1().kind();  
    24.     }  
    25. }  

           测试程序:

    1. public class Test1 {  
    2.   
    3.     public static void main(String[] args) {  
    4.         Son son = new Son();  
    5.         System.out.println("Son 的Strong:" + son.getStrong());  
    6.         System.out.println("Son 的kind:" + son.getKind());  
    7.     }  
    8.   
    9. }  
    10. ----------------------------------------  
    11. Output:  
    12. Son 的Strong:10  
    13. Son 的kind:6  

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

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

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

    千次阅读 2018-05-07 14:59:07
    想到多重边框,我们可能会通过多个元素来模拟实现,但是如何在一个元素上实现多重边框呢?如下图: 1、box-shadow 我们可以通过box-shadow来实现。 box-shadow: h-shadow v-shadow blur spread color inset | ...
  • 上面使用接口实现多重继承是一种比较可行和普遍的方式,在介绍内部类的时候谈到内部类使的多继承的实现变得更加完美了,同时也明确了如果父类为抽象类或者具体类,那么我就仅能通过内部类来实现多重继承了。...
  • Java实现多重继承

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

    2017-05-28 10:36:08
    多重继承指的是一个类可以同时从多于一个的父类那里继承行为...但有时候我们确实是需要实现多重继承,而且现实生活中也真正地存在这样的情况,比如遗传:我们即继承了父亲的行为和特征也继承了母亲的行为和特征。可幸的
  • 内部类实现多重继承

    2016-06-15 10:33:30
    内部类实现多重继承
  • 多重背包 java实现

    千次阅读 2017-09-03 10:18:32
    * 多重和完全更接近,多了数量的限制,用一个count[n]计数数组来限制物品i的数量。 * 当放入第i个物品是较优值的时候,count[i]=count[j-weight[i]]+1(j 的含义:); * 这样做是因为,放入第i个物品的操作是基于...
  • Java中实现多重继承

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

    千次阅读 2018-05-31 17:33:48
    C#中是没有类的多重继承这个概念,要使用多重继承必须要通过接口Interface来完成 可是大家都知道Interface实际上就是一个虚函数列表指针.内部封装的只有函数和属性.而且接口(Interface)不能实力化只能通过派生(因为...
  • lua table索引无序 实现多重排序

    千次阅读 2017-07-28 18:00:04
    lua table索引无序 实现多重排序--lua table索引无序 实现多重排序 直接看代码 费话少说 --目标 优先级: chinese > english > historytable_score = { [1] = { chinese = 80, english = 76, history = ...
  • js实现多重继承

    千次阅读 2018-02-09 23:19:42
    原理: 将父类的实例,赋值给子类的原型和原型上一个属性superClass,将子类的实例赋值给孙类的原型和原型上一个属性superClass。 孙类实例继承了孙类,子类和父类原型上所有的属性和方法,并可以通过superClass向上...
  • 不定数量的多重循环简单实现

    千次阅读 2018-03-29 23:04:59
    不定数量的多重循环简单实现 要点概览 目的 实现不定数量的多重(层)循环 循环层数可以是1到n 不同层的循环数可以是不同的 运行环境 windows系统:64位win7 fotran编译器:mingw gfortran 注意/思路: 降维...
  • 面试题-实现多重继承

    2017-11-30 16:53:04
    多重继承指的是一个类可以同时从多于一个的父类那里继承...但有时候我们确实是需要实现多重继承,而且现实生活中也真正地存在这样的情况,比如遗传:我们即继承了父亲的行为和特征也继承了母亲的行为和特征。可幸的是
  • Python实现多重弹窗脚本 整蛊朋友

    千次阅读 2020-12-29 10:15:29
    使用多线程,每个线程挂载一个tk窗口,进而实现多重弹窗 用random库随机弹窗的位置 import tkinter as tk import random import threading import time def dow(): window = tk.Tk() window.title('你是憨憨')...
  • 7.2 图的存储结构7.2.3 邻接多重表(多重邻接表)Adjacency Multilist邻接多重表的类定义邻接多重表的顶点结点类模板邻接多重表的边结点类模板邻接多重表的类模板邻接多重表与邻接表的对比 7.2.3 邻接多重表(多重...
  • 由于 Cglib 本身的设计,无法实现在 Proxy 外面再包装一层 Proxy(JDK Proxy 可以),通常会报如下错误: Caused by: java.lang.ClassFormatError: Duplicate method name "newInstance" with signature ...
  • R语言实现常用多重比较方法

    万次阅读 2017-07-31 13:19:47
    最小显著差数检验法LSD法 Tukey氏固定差距检验法Tukey HSD在单因素方差分析ANOVA中,如果该因素影响比较...下面对R语言中,这两种多重比较方法的实现进行举例。前期数据如下,影响因素为group,指标为value:> head(ta
  • echarts实现多重环形图

    千次阅读 2020-01-22 10:57:04
    let echarts = require('echarts'); var BorderWidth = '10'; //反方向剩下部分的样式 var placeHolderStyle = { normal: { label: { show: false, position: "outside" ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 200,544
精华内容 80,217
关键字:

多重实现