精华内容
下载资源
问答
  • 多继承,多重继承,多层继承Inheritance is one of the most popular ways to reuse code in Angular. It has been used very frequently to build components. Yet, not many developers will apply inheritance to ...

    多继承,多重继承,多层继承

    Inheritance is one of the most popular ways to reuse code in Angular. It has been used very frequently to build components. Yet, not many developers will apply inheritance to service. In fact, service inheritance is much cleaner and easier to maintain comparing with component inheritance. It can be a good alternative of component inheritance in some cases.

    继承是在Angular中重用代码的最流行方法之一。 它已非常频繁地用于构建组件。 但是,没有多少开发人员会将继承应用于服务。 实际上,与组件继承相比,服务继承要干净得多且易于维护。 在某些情况下,它可以很好地替代组件继承。

    入门 (Getting started)

    Inheritance can be applied either on an abstract class or a concrete class. However, the best practice is to always create an abstract class to encapsulate the logic and reduce noise for other developers working together. Here is an example:

    继承既可以应用于抽象类,也可以应用于具体类。 但是,最佳实践是始终创建一个抽象类来封装逻辑并为其他开发人员一起工作减少噪音。 这是一个例子:

    @Injectable()
    abstract class BankingService {
    abstract getAccountType(): string;
    abstract transferCredit(amount: number): void;
    }

    All concrete child services with business logic should extend the base abstract service:

    所有具有业务逻辑的具体子服务都应扩展基本抽象服务:

    @Injectable()
    class InternationalBankingService extends BankingService {
    getAccountType(): string {
    return 'international-account';
    }
    transferCredit(amount: number): void {console.log(`Transferred ${amount} from international account`);
    }
    }
    @Injectable()
    class DomesticBankingService extends BankingService {
    getAccountType(): string {
    return 'domestic-account';
    }
    transferCredit(amount: number): void {console.log(`Transferred ${amount} from domestic account`);
    }
    }

    The @Injectable decorator for child services is optional as the direct injection of child services is discouraged, which will be explained in next section. Yet, it is still recommended to add that for the sake of readability.

    子服务的@Injectable装饰器是可选的,因为不建议直接注入子服务,这将在下一部分中进行说明。 但是,出于可读性考虑,仍建议添加它。

    注入服务 (Injecting the service)

    Ideally, the injection of the child services should be avoided as it makes the component less generic and so, less reusable, which contradicts to the purpose of applying inheritance — code reuse. Components should not concern which child services to use as this is what the Angular dependency injection engine is supposed to handle.

    理想情况下,应避免注入子服务,因为子服务会使组件的通用性降低,因此可重用性降低,这与应用继承的目的(代码重用)相矛盾。 组件不应该担心要使用哪个子服务,因为这应该是Angular依赖项注入引擎要处理的。

    @Component({
    selector: 'app-banking',
    template: `
    The account type is {{ accountType }}
    <button (click)="confirm()">Confirm</button>
    `
    })
    export class BankingComponent implements OnInit {
    accountType: string;
    constructor(
    private bankingService: BankingService
    ) {}
    ngOnInit(): void {
    this.accountType = this.bankingService.getAccountType();
    }
    confirm() {
    this.bankingService.transferCredit(Math.random() * 10000);
    }
    }

    提供服务 (Providing the service)

    The last step is to provide the required child service based on the context via the Angular dependency injection engine. Some may not know how to do this as this is a relatively unpopular feature of Angular. However, it is actually very straight forward and easy to understand.

    最后一步是通过Angular依赖项注入引擎基于上下文提供所需的子服务。 有些人可能不知道该怎么做,因为这是Angular相对不受欢迎的功能。 但是,它实际上非常简单,易于理解。

    Normally, a service can be provided in this way:

    通常,可以通过以下方式提供服务:

    ...({
    ...
    providers: [
    BankingService
    ]
    })

    However, it doesn’t work in this case as BankingService is just an abstract base class. This can be solved simply by adding provide options:

    但是,由于BankingService只是一个抽象基类,因此在这种情况下BankingService 。 只需添加提供选项即可解决此问题:

    @Component({
    selector: 'app-root',
    providers: [
    {
    provide: BankingService,
    useClass: InternationalBankingService
    }
    ],
    template: `
    <app-banking></app-banking>
    `
    })
    export class AppComponent {}

    优于组件继承 (Advantage over component inheritance)

    One of the major weakness of component inheritance is that it cannot inherit HTML or CSS. It creates strong coupling between the parent and child class, as the change of these non-inheritable elements can break the children very easily. Here I have written another article for a more detailed explanation:

    组件继承的主要缺点之一是它不能继承HTML或CSS。 由于这些不可继承的元素的更改很容易破坏子级,因此它在父级和子级之间建立了强大的耦合。 在这里,我写了另一篇文章以获得更详细的解释:

    Unlike component, service is a pure Typescript class, which is fully inheritable. It doesn’t create tight coupling when being inherited. It makes the long term maintenance much easier.

    与component不同,service是一个纯Typescript类,可以完全继承。 继承时不会产生紧密耦合。 这使长期维护变得更加容易。

    Thanks for reading! Hope you find this article helpful. Any comments would be highly appreciated. :D

    谢谢阅读! 希望本文对您有所帮助。 任何意见将不胜感激。 :D

    翻译自: https://medium.com/@liutingchun_95744/angular-introduction-to-service-inheritance-aead1a8e1f0c

    多继承,多重继承,多层继承

    展开全文
  • JAVA中的多层继承

    2018-02-18 19:16:06
    类的继承格式、继承的关系表示图、访问限制、子类对象的实例化过程、方法的覆写、属性的覆盖、Super关键字、this与super的区别
  • 多继承:一个子类拥有很多父类 多重继承 : 一层一层的继承父类 转载于:https://www.cnblogs.com/liunx1109/p/9439424.html

     

    多继承:一个子类拥有很多父类

    多重继承 : 一层一层的继承父类

     

    转载于:https://www.cnblogs.com/liunx1109/p/9439424.html

    展开全文
  • Python中类的继承、多层继承和多继承 Python中,一个类可以通过继承的方式来获得父类中的非私有属性和非私有方法。 一、继承、重写、和调用重写的父类方法 继承的语法为在类名后的小括号()中写入要继承的父类名,...

    Python中类的继承、多层继承和多继承

    Python中,一个类可以通过继承的方式来获得父类中的非私有属性和非私有方法。

    一、继承、重写、和调用重写的父类方法

    继承的语法为在类名后的小括号()中写入要继承的父类名,如果要继承多个类则中间用逗号分隔。

    class Electrical(object):
    
        def __init__(self, name):
            self.name = name
    
        def watch_movie(self):
            print('Watch movie!')
    
        def game(self):
            print('Play game!')
    
        def chat(self):
            print('Chat with friend!')
    
    
    class Phone(Electrical, object):
    
        def send_message(self):
            print('Send message!')
    
        def game(self):
            print('Play game in phone!')
    
        def chat(self):
            super(Phone, self).chat()
            print('Chat with anyone!')
    
    
    p = Phone('VIVO')
    # 继承父类的属性
    print(p.name)
    # 继承父类的方法
    p.watch_movie()
    # 子类自己实现的方法
    p.send_message()
    # 重写了父类的方法
    p.game()
    # 先继承父类的方法,在对父类方法的功能进行扩展
    p.chat()

    运行结果:

    VIVO
    Watch movie!
    Send message!
    Play game in phone!
    Chat with friend!
    Chat with anyone!

    1.父类的非私有属性和非私有方法子类可以直接继承,子类对象可以直接使用。如果子类要调用父类的私有属性和私有方法,只能通过间接的方法来获取。

    2.子类可以实现父类没有的属性和方法,与继承的属性和方法互不干扰。

    3.如果在子类中有跟父类同名的方法,但方法中执行的内容不同,则子类可以重写父类方法。

    当子类实现一个和父类同名的方法时,叫做重写父类方法直接在子类中定义与父类同名的方法,然后在方法中实现子类的业务逻辑,子类方法就会覆盖父类的同名方法。子类重写了父类方法,子类再调用该方法将不会执行父类的方法。

    4.如果在子类重写父类的方法中,需要使用父类同名方法中的功能,在父类功能基础上做扩展,则子类可以在重写的方法中调用父类被重写的方法,使用super()来调用。

    二、类的多层继承

    类可以多层继承。

    class Mi(Phone):
        pass
    
    
    m = Mi('Redmi')
    print(m.name)
    m.chat()

    运行结果:

    Redmi
    Chat with friend!
    Chat with anyone!

    继续上面的类,我们定义的类Mi继承自Phone类,Phone类继承自Electrical类,这样就构成了多层继承。

    Mi类对象可以使用Phone中的方法和属性,也可以使用Electrical中的方法和属性,如果Phone重写了Electrical的方法,则继承的是Phone中的方法。

    当Mi类对象调用属性和方法时,优先在自己的内部查找是否有该属性和方法,如果没有会到它的父类Phone中查找该属性和方法,如果没有会继续往上在Phone的父类Electrical中查找,一直查找到object类中。到最后也没有找到,就说明对象没有该属性和方法,程序报错,如果找到就会返回找到的属性和方法,不再继续往上查找。

    三、类的多继承

    class Computer(Electrical):
    
        def coding(self):
            print('Coding something!')
    
    
    class HuaWei(Phone, Computer):
        pass
    
    
    h = HuaWei('huawei')
    h.send_message()
    h.coding()
    print(h.name)
    h.watch_movie()

    运行结果:

    Send message!
    Coding something!
    huawei
    Watch movie!

    同一个类可以继承多个类,如上面的HuaWei类同时继承了Phone和Computer两个类。这时,两个父类中的方法和属性子类都可以使用,两个父类的父类中的属性和方法子类也可以使用。

     

     

     

    展开全文
  • 谈面向对象语言不能不谈继承,这也是面向对象语言天生的优势,大大提高了代码的复用,在c语言中我们也可以通过结构体嵌套的方式,来实现继承,倘若看本c++的书,一个继承都能来来回回讲个几十回合。我们通过反汇编来...

    谈面向对象语言不能不谈继承,这也是面向对象语言天生的优势,大大提高了代码的复用,在c语言中我们也可以通过结构体嵌套的方式,来实现继承,倘若看本c++的书,一个继承都能来来回回讲个几十回合。我们通过反汇编来看看继承的本质究竟是什么?

    一:继承                                                                    

        1、不继承的写法                                

                                         
        struct Person                                    
        {                                    
            int age;                                
            int sex;                                
        };                                    
        struct Teacher                                    
        {                                    
            int age;                                
            int sex;                                
            int level;                                
            int classId;                                
        };                                    
        struct Student                                    
        {                                    
            int age;                                
            int sex;                                
            int code;                                
            int score;                                
        };                                    
                                            
                                            
        Teacher t;                观察反汇编:                    
                                            
        t.age = 1;                  mov dword ptr [ebp-10h],1                    
        t.sex = 2;                  mov dword ptr [ebp-0Ch],2                    
        t.level = 3;                mov dword ptr [ebp-8],3                    
        t.classId = 4;              mov dword ptr [ebp-4],4                    
                                    push 10h                    
        printf("%d\n",sizeof(t));                push offset string "%d\n" (0042201c)                    
                                    call printf (004010e0)                    
                                    add esp,8        
     
                                            
        Student s;                mov dword ptr [ebp-10h],1                    
                                  mov dword ptr [ebp-0Ch],2                    
        s.age = 1;                mov dword ptr [ebp-8],3                    
        s.sex = 2;                mov dword ptr [ebp-4],4                    
        s.code = 3;               push 10h                    
        s.score = 4;              push offset string "%d\n" (0042201c)                    
                                  call printf (004010e0)                    
        printf("%d\n",sizeof(s));                add esp,8    

     

                                        

        2、改变写法:        继承方式                            

       

     struct Person                                    
        {                                    
            int age;                                
            int sex;                                
        };                                    
        struct Teacher:Person                                    
        {                                    
            int level;                                
            int classId;                                
        };                                    
        struct Student:Person                                    
        {                                    
            int code;                                
            int score;                                
        };    
                                    
    反汇编:                                                        
        Teacher t;                mov dword ptr [ebp-10h],1                    
                                  mov dword ptr [ebp-0Ch],2                    
        t.age = 1;                mov dword ptr [ebp-8],3                    
        t.sex = 2;                mov dword ptr [ebp-4],4                    
        t.level = 3;              push 10h                    
        t.classId = 4;            push offset string "%d\n" (0042201c)                    
                                 call printf (004010e0)                    
        printf("%d\n",sizeof(t));                add esp,8                    
             
                 
                                            
        Student s;                mov dword ptr [ebp-10h],1                    
                                  mov dword ptr [ebp-0Ch],2                    
        s.age = 1;                mov dword ptr [ebp-8],3                    
        s.sex = 2;                mov dword ptr [ebp-4],4                    
        s.code = 3;               push 10h                    
        s.score = 4;              push offset string "%d\n" (0042201c)                    
                        call printf (004010e0)                    
        printf("%d\n",sizeof(s));                add esp,8          

     

        总结:                                                             

        1、什么是继承?                                    

                                            

        继承就是数据的复制,从汇编的角度看是,完全一样的,但是从编写的角度看,显然继承的方式编写大大提高了代码的复用

    其实本质上,就是继承的时候,那部分继承代码会由编译器帮我们生成而不用我们自己编写,这也是为什么说,继承的本质就是数据的复制,其实就是将父类的拷贝到子类。                                    

                                       

       2、为什么要用继承?                                                                        

        减少重复代码的编写                                                       

        3、Person 称为父类或者基类                                                                    

        4、Teacher、Student称为子类或者派生类                                    

                                            

        5、t和s可以称为对象或者实例.                                    

                                            

        6、可以用父类指针指向子类的对象.    

    这是我们要讨论的一个核心问题,那就是类指针,其实上面的东西明白了,类指针也就非常明白了。下面的代码实现了父类指针指向子类

    而且可以访问修改,这其实就是源于继承的本质,从内存的角度来看,继承的父类成员放在了对象的开始,低地址处,父类指针和子类指针的区别

    最为明显的就是指针步长的不同,而把父类指针指向开始,恰好是父类的成员,符合父类的指针步长,也就恰好可以访问。当然世间没有那么多的恰好

    这必然是源于语言设计者的心血。那么可否用父类指针访问子类成员,编译器是不允许的,这还是源于指针步长的合理性,当然从底层的角度来看,没有什么不能访问,我们可以通过一些手段来实现访问。反过来,子类指针访问父类,其实是没有什么价值的,源于父类里面没有子类的成员。而且编译器肯定是不允许的。

     

     

     

     

     

     

      

     

     

    #include <iostream>
     
    using namespace std ;
     
        struct Person        
        {        
            int age;    
            int sex;    
        };        
        struct Teacher:Person        
        {        
            int level;    
            int classId;    
        };        
        struct Student:Person        
        {        
            int code;    
            int score;    
        };        
                
     
        
    int main (void)
    {
     
        Teacher *point, t;            
        point=&t;
     
        point->age=1;
        point->classId=2;
        point->level=3;
        point->sex=4;
                
        printf("%d %d %d %d\n",t.age,t.classId,t.level,t.sex);    
        
        Person * point_test; // 父类指针
        point_test=&t; // 子类对象地址
     
        point_test->age=5;
        point_test->sex=6;
        
        printf("%d %d\n",t.age,t.sex);    
            
    return 0;
    }

     

     

    二:      多层继承

     

    多层继承比较简单,那就是你可以继承你父亲的遗产,也可以继承你爷爷的遗产。其实都可以想到,还是数据的拷贝。

                                

      

     

     

     

     

     

     

     

     

     

     

        多层继承:                观察反汇编:            
        1)无相同成员                            
        struct X                            
        {                 mov dword ptr [ebp-18h],1            
            int a;            mov dword ptr [ebp-14h],2            
            int b;            mov dword ptr [ebp-10h],3            
        };                 mov dword ptr [ebp-0Ch],4            
        struct Y:X            mov dword ptr [ebp-8],5            
        {                 mov dword ptr [ebp-4],6            
            int c;            push 18h            
            int d;            push offset string "%d\n" (0042201c)            
        };                 call printf (004010e0)            
        struct Z:Y                add esp,8            
        {                            
            int e;                        
            int f;                        
        };                            
                                    
                                    
        Z z;                            
                                    
        z.a = 1;                            
        z.b = 2;                            
        z.c = 3;                            
        z.d = 4;                            
        z.e = 5;                            
        z.f = 6;                            
                                    
        printf("%d\n",sizeof(z));                            
                                     
                                     
        2)有相同成员 ,二异性问题 ,但是编译器不一定会报错,默认是使用当前类的成员                                                      
                                    
        struct X                            
        {                            
            int a;                        
            int b;                        
        };                            
        struct Y:X                            
        {                            
            int a;                        
            int d;                        
        };                            
        struct Z:Y                            
        {                            
            int e;                        
            int f;                        
        };                            
                                    
                                    
                                    
        Z z;                            
                                    
        z.X::a = 1;    //通过::区分了a,但是对于底层来说和上面的完全一样,
                       //这里的区分仅仅是让编译器明白。                
        z.b = 2;                            
        z.Y::a = 3;                            
        z.d = 4;                            
        z.e = 5;                            
        z.f = 6;                            
                                    
        printf("%d\n",sizeof(z));                            
        printf("%d\n",z.X::a);                            
        printf("%d\n",z.b);                            
        printf("%d\n",z.Y::a);                            
        printf("%d\n",z.d);                            
        printf("%d\n",z.e);                            
        printf("%d\n",z.f);                            
     

     

     

     对于二义性问题,其本质是不存在任何问题的,从汇编看,和正常的成员完全一样,关键的就是让编译器可以区分。

     

    三:多重继承

    何为多重继承,就是有多个爹,在java 中是没有多重继承的,但是在c++中是支持多重继承的。也就是一个父类有多个子类。

     

     

     

     

     

     

     

     

     

     

     

     

     

     

     

       3、继承的特性        
        struct X        
        {        
            int a;    
            int b;    
        };        
        struct Y        
        {        
            int c;    
            int d;    
        };        
        struct Z:X,Y        
        {        
            int e;    
            int f;    
        };        
     
    

    多态:

    我们看到了父类指针指向子类对象,可以实现继承的父类区域的访问,其实这是完全正常的逻辑,但是如果我们把父类的某个函数变成虚函数,这个时候父类指针接着访问这个函数还会访问父类的吗?

    情况一般是这样的,你已经搞成了虚函数,那就意味着不希望被访问,如果这个时候子类又有实现,那就可以实现父类指针访问子类空间,而非继承过来的空间。这其实就是多态。

     

     

     

     

    展开全文
  • 继承允许我们依据另一个类来定义一个类,这使得创建维护一个应用程序变得更容易。这样做,也达到了重用代码功能提高执行效率的效果。 当创建一个类时,您不需要重新编写新的数据成员成员函数,只需指定新建的...
  • Java多重继承的两种方式

    万次阅读 2019-01-30 17:00:57
    /*内部类使的多继承的实现变得更加完美了,同时也明确了如果父类为抽象类或者具体类,那么我就仅能通过内部类来实现多重继承了。*/ public class UseInnerClassHandleMultiExtendsTest { public static void main...
  • # 继承 重用代码 提高软件的可扩展性 class Animal(): def __init__(self, name): print(1) self.name = name pass def eat(self, food): print(self.name + "吃" + food) pass ...
  • 多层继承和多继承同时使用的情况下,就会出现复杂的继承关系,多重多继承。 其中,就会出现菱形继承。如下图所示。mark 在这种结构中,在调用顺序上就出现了疑惑,调用顺序究竟是以下哪一种顺序呢 D->B->A->C...
  • 多重继承中调用1 多层继承1.1 介绍1.2 示例2 多重继承 1 多层继承 1.1 介绍 在一个类中的虚函数说明,只对派生类中重定义的函数有影响,对它的基类中的函数不起作用。 1.2 示例 class A { public: virtual ...
  • java可以多重继承吗 有时我写了几篇有关Java继承,接口组成的文章。 在这篇文章中,我们将研究多重继承,然后了解组成优于继承的好处。 Java中的多重继承 多重继承是创建具有多个超类的单个类的能力。 与其他一些...
  • 多重继承javaToday we will look into Multiple Inheritance in Java. Sometime back I wrote few posts about inheritance, interface and composition in java. In this post, we will look into java multiple ...
  • 多继承与多重继承

    千次阅读 2017-04-22 17:35:59
    什莫是多重继承? 一个类不仅仅有父类还有祖父类 什莫是虚继承? 虚继承是为了解决多继承的问题.经过这样的声明后,当基类通过多条派生路径被一个派生类继承时,该派生类只继承该基类一次,也就是说,基类成员只保留...
  • 多继承又分为多级继承与多重继承,同时又演化出了 多级多重继承。因此在多级多重继承上,衍生出了虚基类的问题。(假设现在有五个类,分别为A,B,C,D,E) 多级继承:A是基类,B继承A,C继承B,D继承C,E继承D.这种继承...
  • ES6 实现类的多重继承

    2020-04-01 11:32:38
    const copyProperties = function(target, source) { for (let key of Reflect.ownKeys(source)) { if (key !== 'constructor' && key !== 'prototype' && key !== 'name') { ...
  • 然后a12又多重继承了a1a2。同样,a12获得了b方法的定义。 但是假设上述代码中的接口都换成类,假如a12没有对b方法作覆盖,那么再假如a1对b方法作了实现,然后a2也对b方法作了实现,那么a12继承的b方法究竟来自...
  • Python的多重继承和super

    万次阅读 2016-05-22 00:10:35
    多重继承: super: 不要一说到 super 就想到父类!super 指的是 MRO 表中的下一个类!super 其实干的是这件事: def super(cls, inst): mro = inst.__class__.mro() # Always the most derived class ...
  • C++多继承(多重继承)

    千次阅读 2020-09-18 09:25:12
    例如已声明了类A、类B类C,那么可以这样来声明派生类D: class D: public A, private B, protected C { //类D新增加的成员 } D 是多继承形式的派生类,它以公有的方式继承 A 类,以私有的方式继承 B 类,以保护...
  • 多重继承和多继承 这个我们来讲讲这两个的概念问题,一字之差,千差万别。 多重继承,比如有三个类,人类-士兵类-步兵类,三个依次继承,这样的继承称为多重继承。class Person {};class Soldier :public Person {...
  • Python中多重继承

    千次阅读 2019-12-29 21:54:20
    多重继承和方法解析顺序 python支持多继承的,下面看一个多继承的例子: class A: def ping(self): print('ping:',self) class B(A): def pong(self): print('pong:',self) class C(A): def pong(self): ...
  • python中新定义一个类称为子类,被继承的类称为父类;子类继承父类后就拥有了父类的所有特性。 #语法格式 class 子类名(父类名): pass 如下:定义了Person类,一个Student类,但是Student类完全可以使用Person类...
  • 下面讲讲多重继承,lua的单继承如果说是在别的表中查找自己没有的东西,那么多重继承就是查找多个表,即在多个表中找到自己需要的。 在介绍多重继承之前,我们先看一幅图,然后分享一个小故事 小故事 ...
  • 多继承对父类的个数没有限制,继承方式可以是公共继承、保护继承和私有继承, 不写继承方式,默认是private继承 多继承举例: #include <iostream> #include <stdlib.h> #include <string> ...
  • C++习题 多重继承

    2016-07-07 12:59:31
    c++多重继承的一个习题
  • Lua的多重继承实现

    2020-11-29 20:51:51
    其实多重继承没什么特别的,除非两个将要被继承的类有相同的函数名属性,否则,处理起来很简单。 无非就是在多个table中查找某个字段而已,不简单吗?Lua里的继承就是在别人的table里查找自己不存在的字段罢了。 ...
  • 上面使用接口实现多重继承是一种比较可行普遍的方式,在介绍内部类的时候谈到内部类使的多继承的实现变得更加完美了,同时也明确了如果父类为抽象类或者具体类,那么我就仅能通过内部类来实现多重继承了。...
  • JAVA 单继承 与 接口 多重继承

    千次阅读 2017-10-11 18:30:42
    又是一个牛角尖,只是语言不够严谨而已,Java中只支持类的单继承,接口之间的继承同样也是使用extends关键字,但是接口之间是支持多继承的,如下面的例子: [java] view plaincopy interface IP1 {  }...
  • 2.类的多层继承 3.类的多重继承 4.类的定制 1.类的继承 继承这个词很好理解,比如你继承了亿万家产,什么都没干一夜暴富。类的继承也是如此,子类继承父类,什么都没干就有了父类所有的属性方法。 class ...
  • Java中的多重继承

    2020-02-16 11:46:15
    在C++中组合多个类接口的行为称之为多重继承。它可能会是你背上沉重的包袱,因为每一个类都有一个具体的实现。在Java中,你可以执行相同的行为,但是只有一个类可以有具体的实现,因此通过组合多个接口,...
  • package interfacetest;... * 继承组合接口方法名字冲突 */ public class InterfaceCollision { public static void main(String[] args) { C1 c1 = new C1(); C2 c2 = new C2(); C3 c3 = new

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,541
精华内容 3,416
关键字:

多重继承和多层继承