黑马程序员技术交流社区

标题: Java为什么没有多继承，还多了一接口概念？ [打印本页]
作者: 黄坚声    时间: 2012-5-11 19:40
标题: Java为什么没有多继承，还多了一接口概念？
Java为什么没有多继承，还多了一接口概念？
作者: 陈波    时间: 2012-5-11 19:46
本帖最后由 陈波 于 2012-5-11 19:48 编辑

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

接口：是不可以创建对象的，因为有抽象方法。
需要被子类实现，子类对接口中的抽象方法全都覆盖后，子类才可以实例化。
否则子类是一个抽象类。
接口可以被类多实现，也是对多继承不支持的转换形式。java支持多实现。
作者: 王勃    时间: 2012-5-11 19:46
多继承之所以没提出，是因为，如果子类的父类们中的方法一样，子类怎么继承，该用谁的？你考虑过吗。用接口就不同了，可以变向的做到C++多继承的特性，当然，各个接口的方法也不同。
作者: 王怡然    时间: 2012-5-11 19:58
本帖最后由 王怡然 于 2012-5-11 20:00 编辑

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

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

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

使用接口就不同了,接口不能被实例化,接口中定义的方法都必须是抽象的,必须得实现接口,并且覆盖了接口中的方法了才能使用;
哥们,估计你没好好看视频...
作者: 王勃    时间: 2012-5-11 20:02
当然多个接口如果其中的抽象方法，有相同的，子类实现时，也只会实现一份。我做了个例子。
  1. package test;

  3. import java.lang.reflect.Method;

  5. public class A implements C,D{

  7. public static void main(String[] args) {
  8. A a = new A();
  9. a.method1();
  10. a.method2();
  11. a.method3();
  12. }

  14. @Override
  15. public void method1() {
  16. System.out.println("method1");

  18. }

  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. }

  33. @Override
  34. public void method3() {
  35. System.out.println("method3");

  37. }

  39. }

  41. interface C {
  42. public abstract void method1();
  43. public abstract void method2();
  44. public abstract void method3();

  46. }

  48. interface D {
  49. public abstract void method1();
  50. public abstract void method2();

  52. }
复制代码
结果：
method1
public void test.A.method2()
method3

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

多个接口具有相同的方法，调用的是任意一个接口的方法，因为他们本来就一样，不管多少个接口，方法都必须实现，既然方法一样，实现时代码会是同一段
作者: 于陈    时间: 2012-5-11 20:52
java里面继承是单继承，也就是说一个父类可以有多个子类，但一个子类却不能有多个父类。
为什么java要单继承呢？那是因为如果多继承会导致类的各种继承关系混乱，不利于程序阅读和维护。
但是这样在编写程序的时候就会有点问题。
比如说现在有猫类，狗类，他们都继承动物类，具有年龄，名字，毛发颜色的属性，我现在又想让他们继承一个宠物类，能实现和主人散步的方法，但很明显这在java里面是不允许的。这个就出现一个很神奇的东西叫做接口！~！，interfere的出现犹如平地一声雷，所有烦恼统统消失掉，我们可以接口来解决上面的问题了。把宠物定义为一个接口，就可以搞定了。
这个下面写了一段演示的代码，没什么实际意义，只是演示接口继承，希望能有用。
  1. /**
  2. * 作者：于陈
  3. * 功能：演示接口和继承
  4. * 时间：二〇一二年五月十一日 20:42:42
  5. */
  6. package com.paixu;

  8. //定义Pet接口
  9. interface Pet {
  10.         public void Sanbu();
  11. }

  13. public class Demo2 {

  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. }

  23. // 定义动物类
  24. class Animal {
  25.         int age; // 年龄
  26.         String name;// 名字
  27.         String color;// 颜色
  28.         // 构造函数

  30.         public Animal(int age, String name, String color) {
  31.                 this.age = age;
  32.                 this.color = color;
  33.                 this.name = name;
  34.         }

  36.         // set和get方法
  37.         public int getAge() {
  38.                 return age;
  39.         }

  41.         public void setAge(int age) {
  42.                 this.age = age;
  43.         }

  45.         public String getName() {
  46.                 return name;
  47.         }

  49.         public void setName(String name) {
  50.                 this.name = name;
  51.         }

  53.         public String getColor() {
  54.                 return color;
  55.         }

  57.         public void setColor(String color) {
  58.                 this.color = color;
  59.         }

  61. }

  63. // 定义狗类，继承Animal类和Pet接口
  64. class Dog extends Animal implements Pet {

  66.         public Dog(int age, String name, String color) {
  67.                 super(age, name, color);

  69.         }

  71.         // 实现接口里面的Sanbu()方法
  72.         public void Sanbu() {
  73.                 System.out.println("名叫" + name + "狗狗在和主人散步！");

  75.         }

  77. }

  79. // 定义猫类，继承Animal类和Pet接口
  80. class Cat extends Animal implements Pet {

  82.         public Cat(int age, String name, String color) {
  83.                 super(age, name, color);

  85.         }

  87.         // 实现接口里面的Sanbu()方法
  88.         public void Sanbu() {

  90.                 System.out.println("名叫" + name + "猫猫在和主人散步！");
  91.         }

  93. }
复制代码
作者: 于陈    时间: 2012-5-11 20:57
于陈 发表于 2012-5-11 20:52
java里面继承是单继承，也就是说一个父类可以有多个子类，但一个子类却不能有多个父类。
为什么java要单继 ...

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



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2