java 在编译的时候就会检查 类是不是多继承，如果出现多继承编译不通过。但是在java语法中接口是可以多继承的。
目前创新互联已为千余家的企业提供了网站建设、域名、网页空间、网站托管、服务器托管、企业网站设计、椒江网站维护等服务，公司将坚持客户导向、应用为本的策略，正道将秉承"和谐、参与、激情"的文化，与客户和合作伙伴齐心协力一起成长，共同发展。
拓展阅读：
java 如果出现多继承、父类中都有相同的属性和name 值 子类如果使用父类的属性和name 值 无法确定是哪一个父类的是 属性和name值。
父类中如果相同的方法，并且子类并没有覆盖该方法。子类调用父类的时候 无法判断是那个父类的方法。
接口是可以多继承的。接口（jdk 1.7 以下版本）里面的方法并有实现,即使接口之间具有相同的方法仍然是可以的 几个接口可以有想通的实现类和实现方法。而且接口 接口里面的成员变量都是 static final的 有自己静态域 只能自己使用。
接口的实现类可以有多个 。（java bean 注解注入） 一个接口（用多个实现类）被注入进来。调用方法的时候。会先依据bean 查找那个 一样的bean 。调用该实现类的方法。其次如过 实现类上都没有注解的 bean 会按照加载的先后顺序去调用的。
多态
1.JAVA里没有多继承，一个类之能有一个父类。而继承的表现就是多态。一个父类可以有多个子类，而在子类里可以重写父类的方法（例如方法print()），这样每个子类里重写的代码不一样，自然表现形式就不一样。这样用父类的变量去引用不同的子类，在调用这个相同的方法print()的时候得到的结果和表现形式就不一样了，这就是多态，相同的消息（也就是调用相同的方法）会有不同的结果。举例说明：
//父类
public class Father{
//父类有一个打孩子方法
public void hitChild(){
}
}
//子类1
public class Son1 extends Father{
//重写父类打孩子方法
public void hitChild(){
System.out.println("为什么打我？我做错什么了！");
}
}
//子类2
public class Son2 extends Father{
//重写父类打孩子方法
public void hitChild(){
System.out.println("我知道错了，别打了！");
}
}
//子类3
public class Son3 extends Father{
//重写父类打孩子方法
public void hitChild(){
System.out.println("我跑，你打不着！");
}
}
//测试类
public class Test{
public static void main(String args[]){
Father father;
father = new Son1();
father.hitChild();
father = new Son2();
father.hitChild();
father = new Son3();
father.hitChild();
}
}
都调用了相同的方法，出现了不同的结果！这就是多态的表现！
2.JAVA中没有多继承，而用接口实现了多继承！一个类或是可以同时实现多个接口！（就相当于C++里一个类同时继承了多个类！）例如：
public class Son implements Father1,Father2,Father3{
}
接口有利于代码功能的扩展（增加新的功能）！而继承则有利于代码功能的修改（把旧的功能改成新的功能）！这里旧功能的修改和新功能的增加前提是不修改旧的功能，旧的功能仍然可以使用！旧类的代码也不做修改！
接着上面的继承举例：上面例子中的子类我们统称为一代子类
1.用继承修改旧的功能。
现在如果一代Son1的功能打孩子，也就是方法hitChild()里边的功能实现有问题，我们要把具体实现修改掉，那么我们可以重新写一个新的二代子类Son11继承自一代子类Son1，并重写其hitChild()方法。
//二代子类
public class Son11 extends Son1{
//重写父类打孩子方法
public void hitChild(){
System.out.println("我是二代子类对此方法的新实现");
}
}
2.用接口实现增加新的功能。
现在类Son1已经有了‘打孩子’功能（也就是方法），而我们有了新的需求，我们需要它还要有一个新的功能‘宠孩子’（新方法pet();）。而旧的代码不能动！那么我们可以定义一个新的接口（PetInterFace），接口里定义这个方法pet()的声明。再重新写一个二代子类Son11，让它先继承类Son1，同时实现接口 PetInterFace！并实现接口里的 pet()方法！
//新接口
public interface PetInterFace{
//新功能方法
public void pet();
}
//二代子类
public class Son11 extends Son1 implements PetInterFace{
//实现接口方法
public void pet(){
System.out.println("父亲很爱我！");
}
}
这样这个二代子类即有了老的方法，又有新的功能！
转至CSDN博客，如有侵权，联系删除。有问题可以追问。
接口(interface) 接口被用来建立类与类之间关联的标准 Java code public interface ITest{ public void test(); } public class TestImpl implements ITest{ public void test(){ System out println( test ); } }
抽象类(abstract class) 只要类中有一个抽象方法 此类就被标记为抽象类 实际上抽象类除了被继承之外没有任何意义
区别 接口是公开(public)的 里面不能有私有的方法或变量 是用于让别人使用的 实现接口的一定要实现接口里定义的所有方法 而抽象类是可以有私有方法或私有变量的 实现抽象类可以有选择地重写需要用到的方法 但是必须实现里面所有的抽象方法 抽象类在 Java 语言中表示的是一种继承关系 一个类只能使用一次继承关系 但是 一个类却可以实现多个interface(java中实现多重继承的方法之一) 抽象类中可以有自己的数据成员 也可以有非abstarct的成员方法 而在接口中 只能够有静态的不能被修改的数据成员（也就是必须是 static final的 不过在 interface中一般不定义数据成员） 而且所有的成员方法都是抽象的 抽象类和接口所反映出的设计理念不同 其实abstract class表示的是 is a 关系 interface表示的是 like a 关系 （组合是 has a 关系） 接口中定义的变量默认是public static final 型 且必须给其初值 所以实现类中不能重新定义 也不能改变其值 抽象类中的变量默认是 friendly 型 其值可以在子类中重新定义 也可以重新赋值
一般的应用里 最顶级的是接口 然后是抽象类实现接口 最后才到具体类实现 不是很建议具体类直接实现接口的 还有一种设计模式是面向接口编程 而非面向实现编程
其实接口是抽象类的延伸 可以将它看做是纯粹的抽象类 就是说接口比抽象类还抽象 还有设计接口的目的就是为了实现C++中的多重继承 不过java团队设计的一样更有趣的东西来实现这个功能 那就是内部类(inner class)
内部类(inner class) Java code public class OuterClass{//外部类 private class InnerClass{}//内部类 }
一 定义 放在一个类的内部的类我们就叫内部类 二 作用 内部类可以很好的实现隐藏 也就是封装性 一般的非内部类 是不允许有 private 与protected权限的 但内部类可以 内部类拥有外围类的所有元素的访问权限 可是实现多重继承(这个特点非常重要 个人认为它是内部类存在的最大理由之一) 可以避免修改接口而实现同一个类中两种同名方法的调用 三 多重继承的实现
类一 Java code public class Example {
public String getName() { return luffyke ; } }
类二 Java code public class Example {
public int getAge() { return ; } }
类三
Java code public class MainExample {
public class Test extends Example { public String getName() { return super getName(); } }
public class Test extends Example { public int getAge() { return super getAge(); } }
public String showName() { return new Test () getName(); }
public int showAge() { return new Test () getAge(); }
public static void main(String args[]) { MainExample example = new MainExample(); System out println( 姓名: + example showName()); System out println( 年龄: + example showAge()); } }
lishixinzhi/Article/program/Java/hx/201311/26594
java中没有多继承（就是不能继承多个父类），只有多重继承。。比如：\x0d\x0aclass A{\x0d\x0a}\x0d\x0a\x0d\x0aclass B extends A{\x0d\x0a}\x0d\x0a\x0d\x0aclass C extends B {\x0d\x0a}\x0d\x0a可以实现多个接口，比如：\x0d\x0ainterface A{\x0d\x0a}\x0d\x0a\x0d\x0ainterface B{\x0d\x0a\x0d\x0a}\x0d\x0a\x0d\x0aclass C implements A, B\x0d\x0a{\x0d\x0a}
使用内部类让Java实现 多继承
众所周知 Java没有像c++那样支持多继承 但是我们可以使用接口或内部类来模拟实现多继承
我们使用内部类来实现一个继承自消费者 又继承自生产者的派生类
实际上Java之所以设计出内部类这个概念 一方面是为了更好的封装性 另一方面就是借助内部类模拟实现多继承
首先我们定义一个消费者抽象基类
view plainprint？
/** * Consumer Class *@author androidyue *Last Modified 上午 */ public abstract class Consumer { protected float buyPrice protected abstract void buyGoods（） }
以下是生产者抽象基类
view plainprint？
/** * Producer Class *@author androidyue *Last Modified 上午 */ public abstract class Producer { protected float cost protected abstract void produce（） }
使用内部类实现 多继承 的派生子类
view plainprint？
/** *Java实现 多继承
*@author androidyue *Last Modified 上午 */ public class InnerClassDemo extends Producer { private ConsumerBuyer buyer
public void desribeMySelf（）{ System out println（ 使用Java模拟多继承 ） this produce（） this buyer=new ConsumerBuyer（） this buyer buyGoods（）
}
@Override protected void produce（） { st= f System out println（ 我是生产者 我以每件 +st+ RMB的成本生产一件产品 然后以 元价格对外出售 ） }
class ConsumerBuyer extends Consumer{
@Override protected void buyGoods（） { this buyPrice= f System out println（ 我是消费者 我以 +this buyPrice+ RMB 买了一件售价 元的商品 不信吧 因为我也是生产者！^_^ ）
}
}
}
在程序入口调用
view plainprint？
/** * the entrance of application *@author androidyue *Last Modified 上午 */ public class AppMain { public static void main（String[] args）{ InnerClassDemo demo=new InnerClassDemo（） demo desribeMySelf（） }
lishixinzhi/Article/program/Java/hx/201311/25912
Java对于多重继承是怎么实现的？
首先回答这个问题之前，我需要说明下什么是继承？什么是多重继承和单继承？java采用何种机制来实现多重继承：
1.1继承是面向对象编程的一种特性,是保留原有类功能的前提下拓展或改写部分功能，实现代码复用的方式.。
1.2单继承就是一个类只可以继承自一个父类，多继承是指一个类可以同时继承多个父类。
1.3java中使用的是单继承，也就是一个类有且只能有一个父类，java中可以使用接口实现来实现类似多继承的效果。
2.下面着重介绍Java中如何实现多继承:
如下是多重继承示例：
interface CanFight{
void fight();
}
interface CanSwim{
void swim();
}
interface CanFly{
void fly();
}
class ActionCharacter{
public void fight(){
System.out.println("I can fight!");
}
}
class Hero extends ActionCharacter implements CanFight,CanSwim,CanFly{
public void swim(){
System.out.println("I can swim!");
}
public void fly(){
System.out.println("I can fly!");
}
}
public class Adventure {
public static void t(CanFight x){x.fight();
}
public static void u(CanSwim x){x.swim();
}
public static void v(CanFly x){x.fly();
}
public static void w(ActionCharacter x){x.fight();
}
public static void main(String[] args){
Hero h=new Hero();
t(h);
u(h);
v(h);
w(h);
}
}
从这个实例中，不能看出Java对于多继承是如何实现的。
运行结果：
I can fight!
I can swim!
I can fly!
I can fight!
以上就是Java对于多继承是如何实现的说明
