JAVA中为什么会有extends和implements 两个关键字

解决方案 »

  1.   

    这就是人家的习惯形成了规定啊,进而就成了标准了啊,为了通用就要符合标准啊,如果是你创立的java语言,你完全可以别的
      

  2.   

    2个不同的Java封装数据传递方式
      

  3.   

    因为那个写jdk的人写了两个单词
      

  4.   

    java 不支持多继承 , 但可以通过 实现多个接口 来 变相达到多继承的 效果这个两个东西存在的意义也是不一样的继承 封装 和 多态 , 应该了解一下
      

  5.   

    extends是子类继承父类,implements是实现接口
      

  6.   

    jdk里面很多类有父类,同时有对应的接口,实现功能一样
      

  7.   

    extends和implements 两个关键字是为了更好表达类、接口与类、接口之间的父子关系。
    子--父      
    类--类          extends
    类-- 接口       implements 
    接口-类         N/A
    接口-接口       extends
      

  8.   

    extends表示继承,可以继承类也可以继承接口。implements表示实现接口。
    一个类只能继承一个,即单继承。但可以实现多个。
      

  9.   


    不错
    继承只能继承一种,实现能实现多个。两种互相补充才能更好的实现多重继承。
    extends 用来描述"is a"的关系
    implements 用来描述"like a"的关系
      

  10.   

    extends java中继承的意思,是为了让子类继承父类的一些属性和方法,便于程序的功能扩充和代码复用;
    implements java中是实现接口的意思,是为了弥补java类不能直接实现多继承的缺陷,实现程序运行时的多态(多态:一般是根据传入的参数的类型决定执行哪个类或子类的方法)
      

  11.   

    因为他们java设计者觉得extends太短,发帖不符合"贴名一定要长定律"所以设计出个implements
      

  12.   

    当你写很多类,并且都有公共部分时,你就发现extends 跟 implements 的 妙用了……
      

  13.   

    extends-继承 可以不用做什么,直接用父类方法等。就像富二代 直接拿父亲的东西用。
    implements-实现 需要自己去实现方法才能去用。 就像我这样的平头老百姓,自己的目标,需要自己努力去实现。
      

  14.   

    接口与抽象类
    区别与联系
    1、 组成:
    抽象类:抽象方法、普通方法、常量、变量、构造方法、全局常量,所以说抽
    象类只比普通类多了一个抽象方法;
    接口:抽象方法和全局常量;
    此处需要注意:抽象类的抽象方法必须加入abstract关键字进行修饰,而接口不需要,因为接口总默认的方法都是抽象的,默认的常量都是全局常量;
    2、 定义:
    抽象类:abstract;
    接口:interface;
    3、 子类:
    子类通过extends继承抽象类;
    子类通过implements实现接口;
    4、 限制:
    一个子类只能继承一个抽象类;
    但一个子类可以同时实现都个接口
    5、 关系:
    一个抽象类可以实现多个接口,但是一个接口不能继承一个抽象类只能实现多个接口;
    一个抽象类可以包含多个接口,一个接口中可以包含多个抽象类;
    6、 设计模式:
    抽象类;模版设计
    接口:工厂设计、代理设计
    两个在一起操作可以完成适配器设计
    7、 实例化:
    都是通过对象的多态性,通过子类进行对象的实例化操作;
    8、 实现限制:
    抽象类:存在单继承的局限性;
    接口:不存在此局限性;
    9、 特性:
    接口:表示一个标准、一种能力;
    接口(inteface):接口被用来建立类与类之间关联的标准;
    抽象类(abstract class):只要类中有抽象方法,此类就被称为抽象类,而我认为,抽象类除了被继承之外,没有任何意义;
    所以,综上所述:如果接口和抽象类可以同时使用的话,则优先选择接口,这样可以通过接口避免了单继承的局限性;
    适配器设计模式:
    将两个不兼容的类纠结在一起使用,属于结构型模式,需要有Adaptee(被适配者)和Adaptor(适配器)两个身份,例如如果我们将两个没有关系的类组合在一起使用, 此时我们可以修改各自类的接口,但是如果我们没有接口的源码,或者说,我们不愿意为了一个应用程序来修改各自的接口,这时我们就可以使用实现Adapter方式(使用Adapter,在这两个接口之间创建一个混合接口):
    范例:假设我们现在要打桩,有两种类:方形桩和圆形桩;
    方形桩:
    public class SquarePeg{
      public void insert(String str){
        System.out.println("SquarePeg insert():"+str);
      }
    }
    圆形桩:
    public class RoundPeg{
      public void insertIntohole(String msg){
        System.out.println("RoundPeg insertIntoHole():"+msg);
    }
    }
    Now,有一个应用,需要既要打印圆形桩又要打印方形桩,那么我们需要将这两个没有关系的类综合应用.假设RoundPeg我们没有源代码,或源代码我们不想修改,那么我们使用Adapter来实现这个应用:
    public class PegAdapter extends SquarePeg{
      private RoundPeg roundPeg;
      public PegAdapter(RoundPeg peg)(this.roundPeg=peg;)
      public void insert(String str){ roundPeg.insertIntoHole(str);
    }
    }
    在上面代码中,RoundPeg属于Adaptee,是被适配者.PegAdapter是Adapter,将Adaptee(被适配者RoundPeg)和Target(目标SquarePeg)进行适配.实际上这是将组合方法(composition)和继承(inheritance)方法综合运用.
    PegAdapter首先继承SquarePeg,然后使用new的组合生成对象方式,生成RoundPeg的对象roundPeg,再重载父类insert()方法。从这里,你也了解使用new生成对象和使用extends继承生成对象的不同(new生成的是一个新的一模一样的对象,extends继承了属性 生成的对象可以对属性进行修改),前者无需对原来的类修改,甚至无需要知道其内部结构和源代码.
    如果你有些Java使用的经验,已经发现,这种模式经常使用。进一步使用上面的PegAdapter是继承了SquarePeg,如果我们需要两边继承,即继承SquarePeg 又继承RoundPeg,因为Java中不允许多继承,但是我们可以实现(implements)两个接口(interface)
    public interface IRoundPeg{
      public void insertIntoHole(String msg);
    }
    public interface ISquarePeg{
      public void insert(String str);
    }
    下面是新的RoundPeg 和SquarePeg, 除了实现接口这一区别,和上面的没什么区别。
    public class SquarePeg implements ISquarePeg{
      public void insert(String str){
        System.out.println("SquarePeg insert():"+str);
      }
    }
    public class RoundPeg implements IRoundPeg{
      public void insertIntohole(String msg){
        System.out.println("RoundPeg insertIntoHole():"+msg);
      }
    }
    下面是新的PegAdapter,叫做two-way adapter:
    public class PegAdapter implements IRoundPeg,ISquarePeg{
      private RoundPeg roundPeg;
      private SquarePeg squarePeg;
      // 构造方法
      public PegAdapter(RoundPeg peg){this.roundPeg=peg;}
      // 构造方法
      public PegAdapter(SquarePeg peg)(this.squarePeg=peg;)
      public void insert(String str){ roundPeg.insertIntoHole(str);}
    }
    还有一种叫Pluggable Adapters,可以动态的获取几个adapters中一个。使用Reflection技术,可以动态的发现类中的Public方法。
    代理设计模式:
    接口:
    public interface IGive {
    public void giveMoney();
    }
    代理:
    package org.lxh.proxydesignmodedemo;
    public class ProxyGive implements IGive {
    private IGive give = null;
    public ProxyGive(IGive give) {// 讨债对象
    this.give = give;
    }
    public void before() {
    System.out.println("准备:刀、绳子、枪、斧子、、、、、");
    }
    public void giveMoney() {
    this.before();
    this.give.giveMoney();
    this.after();
    }
    public void after() {
    System.out.println("销毁所有证据!!!!!!!!");
    }
    }
    真正的实体:
    package org.lxh.proxydesignmodedemo;
    public class RealGive implements IGive {
    public void giveMoney() {
    System.out.println("把钱还给我!!!!");
    }
    }
    测试:
    package org.lxh.proxydesignmodedemo;
    public class ProxyDesignDemo {
    public static void main(String args[]) {
    IGive give = new ProxyGive(new RealGive());
    give.giveMoney();
    }
    }
    工厂设计模式:
    接口:
    package org.lxh.factorydesignmodedemo;
    public interface IFruit {
    public void eat();
    }
    实体1:
    package org.lxh.factorydesignmodedemo;
    public class Orange implements IFruit {
    public void eat() {
    System.out.println("吃橘子!!!!!");
    }
    }
    实体2:
    package org.lxh.factorydesignmodedemo;
    public class Apple implements IFruit {
    public void eat() {
    System.out.println("吃苹果!!!!!");
    }
    }
    工厂:
    package org.lxh.factorydesignmodedemo;
    public class Factory {
    public static IFruit getFruit(String className) {
    IFruit f = null;
    if ("Apple".equals(className)) {
    f = new Apple();
    }
    if ("Orange".equals(className)) {
    f = new Orange();
    }
    return f;
    }
    }
    测试:
    package org.lxh.factorydesignmodedemo;
    public class FactoryDesignDemo {
    public static void main(String args[]) {
    IFruit f = Factory.getFruit("Apple");
    if (f != null)
    f.eat();
    else {
    System.out.println("没有任何有效的东西可吃的!!!!!!!!");
    }
    }
    }
    接口是公开的(public)里面不能有私有的方法和变量,是让别人使用的,实现接口的类一定要实现接口里定义的所有方法,而对于抽象类,里面可以有私有方法或私有变量,实现抽象类的类可以有选择的重写需要用到的方法,但是必须实现里面所有的抽象方法;