怎么用接口实现多继承？？

interface A{}
interface B{}
interface C extends A,B{}
class A1 implements A{}
class B1 implements B{}
class C1 implements C{}
C1类就继承了A1，B1了吗？ 
使用A1对象的地方，也就可以使用C1的对象吗？ 
这个问题解决不了么？？

32 个解决方案

#1

C1类就继承了A1，B1了吗？ 错
使用A1对象的地方，也就可以使用C1的对象吗？ 错

#2

那 这个问题解决不了嘛？

#3

--这个问题解决不了么？
你希望的结果是什么？

#4

就是想在使用A1，B1对象的地方，也就可以使用C1的对象

#5

那就这样吧
interface A1 extends A{} 
interface B1 extends B{} 
class C1 implements A1,B1{}

#6

http://hi.baidu.com/linux_zss/blog/item/dd632a9bdd7a35b4c9eaf4ff.html
我在这看的       没看懂，
他说的是不是能够通过接口能实现C1类 同时继承 没有关系的 A1和B1两个类，实现使用父类A1或B1对象的地方  也可以使用子类C1的对象

#7

引用 5 楼 lovecj6185 的回复:

那就这样吧
interface A1 extends A{}
interface B1 extends B{}
class C1 implements A1,B1{}

哈哈哈哈哈哈哈。。。。。
楼主去看看java基础吧，只有有了一定的基础，再来问自己不明白的东西，这样才能更快的学习，提高自己。

#8

是说接口可以多继承，java糊弄人的说法，lz当真了

#9

理论上接口是可以实现多继承的

#10

看你上面的描述,A1类实现了A接口,B1类实现了B接口,C1类实现了A,B,C接口,但C1并没有继承A1类,也没有继承B1类,所以C1类和A1类,C1类和B1类之间没有继承关系,C1类和A1类的关系是他们都是A接口的实现类,C1类和B1类的关系是他们都是B接口的实现类.使用A1,B1对象的地方不可以使用C1对象.

#11

你哈利波特系列啊？？ 我正看着呢！！！
没看懂，
interface A1 extends A{} 
interface B1 extends B{} 
class C1 implements A1,B1{} 
这样写  在使用A1对象的方法中不允许使用C1的对象啊！！

#12

看书

#13

C1 extends A1 implements C

#14

lovecj6185
理论上可以
能给个例子吗？

#15

interface A{} 
interface B{} 
interface C extends A,B{}

你这个C接口不就是同时继承了接口A和接口B吗
这就是多继承阿

#16

这是接口的多继承啊 
也不是类啊 ！！！

你能看看我贴的那个网址吗
我没看懂

#17

不好意思
你那个网址的东东太长了，呵呵

简单的说吧
只有接口可以多继承
比如
interface C extends A,B{} 

类只能单继承
（排除其他变相的多继承）
class c extends A{}

但是类可以实现多个接口
比如
class C1 implements A1,B1{} 

#18

谢谢了！！！
看来是没法实现了

#19

JAVA中没有多继承，而用接口“实现了多继承”！一个类或是可以同时实现多个接口！（就相当于C++里一个类同时继承了多个类！）
指的是这个（伪代码）：
public class 你 implements 妈妈的好儿子,单位的好同事,党的好儿女
{

}

反过来一个接口可以有多个实现（伪代码）：
public class 你 implements 人
{

}
public class 我 implements 人
{

}
public class 他 implements 人
{

}

#20

public class MyDaoImpl  extends BaseDao implements IMyBiz,IMyBaseDao(){}

#21

类中单独定义的方法你是没法调用了。接口中的方法是可以的。。

#22

Java不支持多继承，接口只是一个类似机制，楼主是从学C++转过来的吧？那你就要认真理解Java的机制，否则，总用C++的思路使用Java，你会很痛苦.........

#23

谢谢大家了  ！！我在理解理解吧
不过我一分都没有，不能分给大家了
抱歉抱歉！！

#24

用策略模式，又叫算法簇模式，就是定义了不同的算法族，并且之间可以互相替换，此模式让算法的变化独立于使用算法的客户。 

策略模式的好处在于你可以动态的改变对象的行为。 
设计原则是把一个类中经常改变或者将来可能改变的部分提取出来，作为一个接口（c++z中可以用虚类），然后在类中包含这个对象的实例，这样类的实例在运行时就可以随意调用实现了这个接口的类的行为。下面是一个例子。 


/* 
这是一个表现僧人和道士的程序，僧人光头，使用棍子做武器，道士长小胡子，使用拂尘作武器 
*/ 
package strategy; 


//处理长相接口 
interface LooksBehavier 
{ 
public void display(); 
} 

//处理所使用的武器接口 
interface WeaponBehavier 
{ 
public void useWeapon(); 
} 
//角色基类 
class Role { 
public int heght; //身高 
public int sex; //性别 
public WeaponBehavier weapon; //处理武器接口的实例 
public LooksBehavier looks; //处理长相的接口的实例 
public void display() //显示长相 
{ 
looks.display(); 
} 
public void weapon() //设置所使用的武器 
{ 
weapon.useWeapon(); 
} 
} 

//道士长相类，实现了长相接口 
class TaoistBehavier implements LooksBehavier 
{ 
public void display() //实现接口函数 
{ 
System.out.println("I''m a taolist with long white goatee"); 
} 

} 

//和尚长相类，实现了长相接口 
class BonzeBehavier implements LooksBehavier 
{ 
public void display() //实现接口函数 
{ 
System.out.println("I''m a Bonze with no hair"); 
} 

} 

//道士武器类，实现了处理武器接口 
class TaoistWeapon implements WeaponBehavier 
{ 
public void useWeapon() //实现了处理武器接口函数 
{ 
System.out.println("My weapon is horsetail whisk");; 
} 
} 

//和尚武器类，实现了处理武器接口 
class BonzeWeapon implements WeaponBehavier 
{ 
public void useWeapon() //实现了处理武器接口函数 
{ 
System.out.println("My weapon is truncheon");; 
} 
} 

//道士 
class Taoist extends Role 
{ 
public Taoist() 
{ 
looks = new TaoistBehavier(); 
weapon = new TaoistWeapon(); 
} 
} 

//和尚 
class Bonze extends Role 
{ 
public Bonze() 
{ 
looks = new BonzeBehavier(); 
weapon = new BonzeWeapon(); 
} 
public void changeWeapon() 
{ 
weapon = new TaoistWeapon(); 
System.out.println("change weapon"); 
} 
} 
public class RoleBase{ 
public static void main(String [] arg) 
{ 
Taoist taoistObj = new Taoist(); 
Bonze bonzeObj = new Bonze(); 
taoistObj.display(); 
taoistObj.weapon(); 
bonzeObj.display(); 
bonzeObj.weapon(); 
bonzeObj.changeWeapon(); //改变和尚使用的武器 
bonzeObj.weapon(); 
} 
} 

成功执行后的输出为： 
I''m a taolist with long white goatee 
My weapon is horsetail whisk 
I''m a Bonze with no hair 
My weapon is truncheon 
change weapon 
My weapon is horsetail whisk  
文章出处：http://www.diybl.com/course/3_program/java/javajs/200838/103114.html

#25

该回复于2009-07-29 15:43:00被版主删除

#26

class Test implements A,B,C 就是多继承的表现

#27

实现接口就是变相的多继承. 一个类只能继承于一个基类,但是一个类可以同时实现多个接口. 继承是提高代码重用性,并且规范子类的行为,  而接口正是规范类的行为的.  就好比,一种人既是数学家又是物理学家. 能让这个人去继承那两个类吗? 显然不行, 只能说这种人具有数学家和物理学家的功能,也就是说要去实现数学家这个接口和物理学家这个接口

#28

楼主没有真正理解 java 多继承意义

java 通过接口达到多继承，是为了让一个类同时具有多种类型，从而达到多态的效果；而不是让类继承其父类已经实现的方法。


interface A{} 
interface B{} 
interface C extends A,B{} 
class A1 implements A{} 
class B1 implements B{} 
class C1 implements C{} 

如果创建一个 C1 类型的对象：
C1 obj = new C1();

则 obj 同时也是C类型，而接口C继承了接口A、B，因此它又是A和B接口的一个对象，可以这样写：
C1 obj = new C1();
C c = obj;
A a = obj;
B b = obj



再次强调一下，多继承的根本目的不是为了可以调用父类已经实现的方法而少写几行代码，而是为了多态而增强系统的灵活性

#29

顶28楼，楼上滴。
严重赞同。

#30

顶28楼，讲解的很详细~~~

#31

非常赞同28楼的说法！
要理解接口的真正用途啊！
实现多态，使程序的扩展性达到极致

#32

谢谢大家了   ！！！
就到这里吧
不过我一分都没有             抱歉了！！