Java为什么没有多继承，还多了一接口概念？

因为多继承容易带来安全隐患:当多个父类中定义了相同功能，
当功能内容不同时，子类对象不确定要运行哪一个。

接口：是不可以创建对象的，因为有抽象方法。
需要被子类实现，子类对接口中的抽象方法全都覆盖后，子类才可以实例化。
否则子类是一个抽象类。
接口可以被类多实现，也是对多继承不支持的转换形式。java支持多实现。

多继承之所以没提出，是因为，如果子类的父类们中的方法一样，子类怎么继承，该用谁的？你考虑过吗。用接口就不同了，可以变向的做到C++多继承的特性，当然，各个接口的方法也不同。

java是对多继承进行了优化(接口实现),给你段代码理解下;
class A
{ void method1(){
  内容;
}
}

class B
{ void method1(){
  内容;
}
}

C这个类只能继承A或者继承B。不能同时继承。
class C extend A ,B
{
        C里面如果使用method1()，就不能够确定到底使用的是谁的。就会出问题。
}

使用接口就不同了,接口不能被实例化,接口中定义的方法都必须是抽象的,必须得实现接口,并且覆盖了接口中的方法了才能使用;
哥们,估计你没好好看视频...

当然多个接口如果其中的抽象方法，有相同的，子类实现时，也只会实现一份。我做了个例子。

1. package test;
   
2. 
   
3. import java.lang.reflect.Method;
   
4. 
   
5. public class A implements C,D{
   
6. 
   
7. public static void main(String[] args) {
   
8. A a = new A();
   
9. a.method1();
   
10. a.method2();
    
11. a.method3();
    
12. }
    
13. 
    
14. @Override
    
15. public void method1() {
    
16. System.out.println("method1");
    
17. 
    
18. }
    
19. 
    
20. @Override
    
21. public void method2() {
    
22. try {
    
23. System.out.println(Class.forName("test.A").getMethod("method2", null).toString());
    
24. } catch (SecurityException e) {
    
25. e.printStackTrace();
    
26. } catch (NoSuchMethodException e) {
    
27. e.printStackTrace();
    
28. } catch (ClassNotFoundException e) {
    
29. e.printStackTrace();
    
30. }
    
31. }
    
32. 
    
33. @Override
    
34. public void method3() {
    
35. System.out.println("method3");
    
36. 
    
37. }
    
38. 
    
39. }
    
40. 
    
41. interface C {
    
42. public abstract void method1();
    
43. public abstract void method2();
    
44. public abstract void method3();
    
45. 
    
46. }
    
47. 
    
48. interface D {
    
49. public abstract void method1();
    
50. public abstract void method2();
    
51. 
    
52. }
    

复制代码

结果：
method1
public void test.A.method2()
method3

说明：
如果超类和接口具有相同的方法，调用的是接口的。因为接口的方法必须在该类中实现，实现后相当于子类覆盖了超类的方法

多个接口具有相同的方法，调用的是任意一个接口的方法，因为他们本来就一样，不管多少个接口，方法都必须实现，既然方法一样，实现时代码会是同一段

java里面继承是单继承，也就是说一个父类可以有多个子类，但一个子类却不能有多个父类。
为什么java要单继承呢？那是因为如果多继承会导致类的各种继承关系混乱，不利于程序阅读和维护。
但是这样在编写程序的时候就会有点问题。
比如说现在有猫类，狗类，他们都继承动物类，具有年龄，名字，毛发颜色的属性，我现在又想让他们继承一个宠物类，能实现和主人散步的方法，但很明显这在java里面是不允许的。这个就出现一个很神奇的东西叫做接口！~！，interfere的出现犹如平地一声雷，所有烦恼统统消失掉，我们可以接口来解决上面的问题了。把宠物定义为一个接口，就可以搞定了。
这个下面写了一段演示的代码，没什么实际意义，只是演示接口继承，希望能有用。

1. /**
   
2. * 作者：于陈
   
3. * 功能：演示接口和继承
   
4. * 时间：二〇一二年五月十一日 20:42:42
   
5. */
   
6. package com.paixu;
   
7. 
   
8. //定义Pet接口
   
9. interface Pet {
   
10.         public void Sanbu();
    
11. }
    
12. 
    
13. public class Demo2 {
    
14. 
    
15.         public static void main(String[] args) {
    
16.                 Dog dog = new Dog(2, "旺财", "黑色");//创建dog
    
17.                 Cat cat = new Cat(3, "小白", "白色");//创建cat
    
18.                 dog.Sanbu();
    
19.                 cat.Sanbu();
    
20.         }
    
21. }
    
22. 
    
23. // 定义动物类
    
24. class Animal {
    
25.         int age; // 年龄
    
26.         String name;// 名字
    
27.         String color;// 颜色
    
28.         // 构造函数
    
29. 
    
30.         public Animal(int age, String name, String color) {
    
31.                 this.age = age;
    
32.                 this.color = color;
    
33.                 this.name = name;
    
34.         }
    
35. 
    
36.         // set和get方法
    
37.         public int getAge() {
    
38.                 return age;
    
39.         }
    
40. 
    
41.         public void setAge(int age) {
    
42.                 this.age = age;
    
43.         }
    
44. 
    
45.         public String getName() {
    
46.                 return name;
    
47.         }
    
48. 
    
49.         public void setName(String name) {
    
50.                 this.name = name;
    
51.         }
    
52. 
    
53.         public String getColor() {
    
54.                 return color;
    
55.         }
    
56. 
    
57.         public void setColor(String color) {
    
58.                 this.color = color;
    
59.         }
    
60. 
    
61. }
    
62. 
    
63. // 定义狗类，继承Animal类和Pet接口
    
64. class Dog extends Animal implements Pet {
    
65. 
    
66.         public Dog(int age, String name, String color) {
    
67.                 super(age, name, color);
    
68. 
    
69.         }
    
70. 
    
71.         // 实现接口里面的Sanbu()方法
    
72.         public void Sanbu() {
    
73.                 System.out.println("名叫" + name + "狗狗在和主人散步！");
    
74. 
    
75.         }
    
76. 
    
77. }
    
78. 
    
79. // 定义猫类，继承Animal类和Pet接口
    
80. class Cat extends Animal implements Pet {
    
81. 
    
82.         public Cat(int age, String name, String color) {
    
83.                 super(age, name, color);
    
84. 
    
85.         }
    
86. 
    
87.         // 实现接口里面的Sanbu()方法
    
88.         public void Sanbu() {
    
89. 
    
90.                 System.out.println("名叫" + name + "猫猫在和主人散步！");
    
91.         }
    
92. 
    
93. }
    

复制代码

于陈 发表于 2012-5-11 20:52
java里面继承是单继承，也就是说一个父类可以有多个子类，但一个子类却不能有多个父类。
为什么java要单继 ...

补充一点，接口里面定义的方法不能在接口里面实现，就连｛｝都不能有，但是implement接口的类必须要重载这个方法，并且必须要实现它。还有接口里面定义的常量可以在任何非静态方法里里面直接使用，但不能更改它。我们一般把圆周率，或者比较长的字符串定义在接口里面作为一个常量。这样方便阅读程序，也保证常量不被随意更改。