对任何一个父类调用__init__都不会改变类的继承结构，不。您只是在更改创建实例时除了C.__init__之外还运行什么初始化器方法。C同时继承{}和{}，并且由于继承顺序的不同，{}的所有方法都被{}上的方法所遮蔽。在
如果需要根据构造函数中的值更改类继承，请创建两个不同结构的独立类。然后提供另一个可调用的API来创建实例：class CA(A):
# just inherit __init__, no need to override
class CB(B):
# just inherit __init__, no need to override
def C(path):
# create an instance of a class based on the value of path
class_map = {'A': CA, 'B': CB}
return class_map[path](path)
API的用户仍然有名称C()来调用；C('A')从C('B')生成一个不同类的实例，但它们都实现了相同的接口，因此这对调用者来说并不重要。在
如果有一个公共的'C'类在isinstance()或issubclass()测试中使用，则可以混合使用一个，并使用^{} method重写返回的子类：
^{pr2}$
调用__new__来构造新的实例对象；如果__new__方法返回该类的实例(或其子类)，则将自动对该新实例对象调用__init__。这就是为什么C.__new__()返回CA.__new__()或CB.__new__()；__init__的结果。在
后者演示：>>> C('A').something()
Function A
>>> C('B').something()
B function with something
>>> isinstance(C('A'), C)
True
>>> isinstance(C('B'), C)
True
>>> isinstance(C('A'), A)
True
>>> isinstance(C('A'), B)
False
如果这两个选项都不适用于您的特定用例，则必须在C上的新somemethod()实现中添加更多路由，然后根据self.path调用A.something(self)或{}。当您必须对每个方法都执行此操作时，这会很快变得非常麻烦，但decorator可以在这方面提供帮助：from functools import wraps
def pathrouted(f):
@wraps
def wrapped(self, *args, **kwargs):
# call the wrapped version first, ignore return value, in case this
# sets self.path or has other side effects
f(self, *args, **kwargs)
# then pick the class from the MRO as named by path, and call the
# original version
cls = next(c for c in type(self).__mro__ if c.__name__ == self.path)
return getattr(cls, f.__name__)(self, *args, **kwargs)
return wrapped
然后在类的空方法上使用该方法：class C(A, B):
@pathrouted
def __init__(self, path):
self.path = path
# either A.__init__ or B.__init__ will be called next
@pathrouted
def something(self):
pass  # doesn't matter, A.something or B.something is called too
然而，这变得非常不和谐和丑陋。在

1、接口可以继承接口，抽象类不可以继承接口，但可以实现接口。

2、抽象类可以继承实体类。抽象类可以实现(implements)接口，抽象类是否可继承实体类，但前提是实体类必须有明确的构造函数。

3.抽象类可以继承实体类，就是因为抽象类的可以继承性和有方法。

4、一个接口可以继承多个接口. interface C extends A, B {}是可以的. 一个类可以实现多个接口: class D implements A,B,C{} 但是一个类只能继承一个类,不能继承多个类 class B extends A{} 在继承类的同时,也可以继承接口: class E extends D implements A,B,C{} 这也正是选择用接口而不是抽象类的原因。

前言

我一直在想一个事：Java只能继承一个类，那么C++为什么就能继承多个类呢

……不想了，打把吃鸡！See you!

……不行！还是自己研究下！

我对队友说：有队友逃跑或加入竞赛失败，你们可以在飞机起飞前安全退出，不影响任何屁事。只听见队友应了声：TM的老子差3分上王牌！

哼，差3分上王牌，不知道人家从王牌升到了星钻呢

1.我是来凑字数的

自己在Java写了一个程序，然后在C++写了一个程序

Java：
package XXX;

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class Abc extends JFrame {
	public static void main(String [] args){
		Abc a =new Abc();
	}
	
	public Abc(){
		this.setSize(350,240);
		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		this.setVisible(true);
	}
}

C++：
#include<iostream>
using namespace std;
class Abc
{
	public:
		Abc()
		{
			cout<<"I'm Talking now.";
		}
};
class aBC
{
	public:
		aBC()
		{
			cout<<"I'm also Talking now.";
		}
};
class AbC :public Abc,public aBC//继承
{
	//TODO
};
int main()
{
	AbC a();
	return 0;
}

2.看看两个程序的优缺点

Java程序：

优：容易实现、扩展

缺：只能单继承、父类修改后子类也要修改。

C++程序：

优：可以实现多继承、扩展性可提高、父类与子类相似但又不同

缺：灵活性降低

严重缺点：

1.程序猿其实根本用不上它

对于C++多继承，到现在还是有争议的，所谓C++之父云：“我创造了这门语言，可我还没有完全掌握它”

2.容易混淆

如果调用基类的基类中的方法，容易造成歧义

3.无用处

一般的Java都是一个继承完事，碰到相对复杂的也是使用大量的接口而不是多继承

所以C++的多继承实际不靠谱！

只不过画蛇添足而饮酒晚矣！

接口是常量值和方法定义的集合。接口是一种特殊的抽象类。
java类是单继承的。classB Extends classA
java接口可以多继承。Interface3 Extends Interface0, Interface1, interface……
不允许类多重继承的主要原因是，如果A同时继承B和C，而B和C同时有一个D方法，A如何决定该继承那一个呢？
但接口不存在这样的问题，接口全都是抽象方法继承谁都无所谓，所以接口可以继承多个接口。
注意：
1）一个类如果实现了一个接口，则要实现该接口的所有方法。
2）方法的名字、返回类型、参数必须与接口中完全一致。如果方法的返回类型不是void，则方法体必须至少有一条return语句。
3）因为接口的方法默认是public类型的，所以在实现的时候一定要用public来修饰（否则默认为protected类型，缩小了方法的使用范围）。


以上内容转自：http://blog.csdn.net/tiantiandjava/article/details/46514783
end
-----------------------------------------------------------------------------------------------------
注：作者 望穿秋水见伊人