黑马程序员技术交流社区

标题: interface 问题 [打印本页]

作者: muma    时间: 2014-4-12 09:39
标题: interface 问题
接口不能实例化,但可以声明引用类型的变量。如何理解此话,求大神解释,并代码证明
作者: 朱晓盼    时间: 2014-4-12 10:21
本帖最后由 朱晓盼 于 2014-4-12 11:59 编辑
  1. interface AbsDemo
  2. {
  3.         abstract void show();
  4. }
  5. class Outer
  6. {
  7.         int x = 3;
  8.         public void function()
  9.         {
  10.                 /*
  11.                 毕老师的例子,我稍微修改了下
  12.                 这段代码是用来表现匿名内部类的,
  13.                 AbsDemo接口不能创建实例,下面定义的d就是AbsDemo声明的引用类型变量,
  14.                 “=”后面的new到“}”后的分号结束,这段代码是子类对象,父类引用指向子类对象,这是多态的表现
  15.                 相当于 Animal a = new Cat();如果你看到了匿名内部类这部分视频的话,是能够看懂的
  16.                 */
  17.                 AbsDemo d = new AbsDemo()
  18.                 {
  19.                         int num = 9;
  20.                         public void show()
  21.                         {
  22.                                 System.out.println("num==="+num);
  23.                         }
  24.                 };
  25.                 d.show();
  26.         }
  27. }
  28. class InnerClassDemo4
  29. {
  30.         public static void main(String[] args)
  31.         {
  32.                 new Outer().function();
  33.         }
  34. }
复制代码

作者: fufeng    时间: 2014-4-12 10:59
  1. interface AbsDemo//接口可以认为是一种特殊的抽象类,从而弥补了java单继承的短板,用了多实现
  2. {
  3.        abstract void show();
  4. }
  5. class
  6. Demo implements AbsDemo//Demo实现了接口,要对里面的抽象方法进行覆写;
  7. {
  8.   int x = 3;
复制代码
这是我自己的理解不知道对不对,多谢指正!

作者: fufeng    时间: 2014-4-12 11:01
fufeng 发表于 2014-4-12 10:59
这是我自己的理解不知道对不对,多谢指正!

不是吧  我写了那么多  ,怎么就只显示了几行:'(
作者: Sniper_qiu    时间: 2014-4-12 11:53
abstract class AbsDemo
{
  abstract void show1();
  abstract void show2();
}

当一个抽象类中的方法都是抽象的时候,这时可以将该抽象类用
另一种形式定义和表示,就是接口 interface。
*/

//定义接口使用的关键字不是class,是interface.

/*
对于接口当中常见的成员:而且这些成员都有固定的修饰符。
1,全局常量: public  static final  

2,抽象方法。public abstract  

由此得出结论,接口中的成员都是公共的权限.
*/
interface Demo
{
  public static final int NUM = 4;

  public abstract void show1();
  public abstract void show2();
  60
}
//类与类之间是继承关系,类与接口直接是实现关系。  
/*
接口不可以实例化。

只能由实现了接口的子类并覆盖了接口中所有的抽象方法后,该子类才可以实例化。
否则,这个子类就是一个抽象类。

*/
作者: fufeng    时间: 2014-4-12 12:14
  1. interface AbsDemo
  2. <span style="color: rgb(177, 8, 0); font-family: Monaco, Consolas, 'Lucida Console', 'Courier New', serif; font-size: 12px; line-height: 21.600000381469727px; background-color: rgb(255, 255, 255); ">//接口可以认为是一种特殊的抽象类,从而弥补了java单继承的短板,用了多实现</span>
  3. {
  4.   abstract void show();
  5. }
  6. class Demo implements
  7. AbsDemo
  8. <span style="color: rgb(177, 8, 0); font-family: Monaco, Consolas, 'Lucida Console', 'Courier New', serif; font-size: 12px; line-height: 21.600000381469727px; background-color: rgb(255, 255, 255); ">//Demo实现了接口,要对里面的抽象方法进行覆写;</span>
  9. {
  10.    public void show(){}
复制代码



作者: fufeng    时间: 2014-4-12 12:25
interface AbsDemo //接口可以认为是一种特殊的抽象类,从而弥补了java单继承的短板,用了多实现
{
  abstract void show();
}
class Demo implements  AbsDemo  //Demo实现了接口,要对里面的抽象方法进行覆写;
{
   public void show(){}
        public void function(){}
{
class ClassDem
{
  public static void main(String[] args)
  {
               AbsDemo ad = new  Demo();//Demo创建对象,用接口AbsDemo型引用ad来指向Demo的对象;AbsDemo是接口是不能创建对象,同时我们知道接口其实是一种特殊的抽象类,所以我们认为是AbsDemo是Demo的父类,父类引用指向子类对象,就比如: AbsDemo 类认为是动物类,Demo类认为是猫类,猫类创建的对象就是猫,我们说猫是小动物,是没有问题的,小动物是泛指,就如同是父类的引用,但是,如果你说用父类来创建一个小动物对象,那就不行,动物是个模糊的。同时用父类引用ad调用子类方法,只能调用子类复写父类的方法,比如说,猫抓老鼠,是猫类特有的,动物类没有的,用ad来调用抓老鼠方法,就比如说小动物去抓老鼠,因为小动物类中没有这个方法,所以小动物,就不会去执行。
  }
}
作者: 创造命运    时间: 2014-4-14 21:10
本帖最后由 创造命运 于 2014-4-14 22:48 编辑

你好,朋友。
首先,接口不能实例化,这个好理解。
接口中是没有构造方法的。没有构造方法,也就注定了不能被实例化。当然,通过实现了接口的一个类并重写了接口中所有的抽象方法后,将该类实例化,也可以看做是将这个接口实例化了。如下代码:
        public interface CustomerService
        {
                //定义一个退出系统的方法
                void logout();   //public abstract省略了
        }
        //编写接口的实现类
        //该类的编写是完全面向接口去实现的
        public class CustomerServiceImpl implements CustomerService
        {
                System.out.println("成功退出系统!");
        }
        //测试程序
        public class Test
        {
                public static void main(String[] args)
                {
                        //要执行CustomerServiceImpl中的logout方法
                        //以下程序面向接口去调用
                        CustomerService cs = new CustomerServiceImpl();   //多态
                        //调用
                        cs.logout();
                }
        }
        以上代码中CustomerService是一个接口,CustomerServiceImpl是一个类,它实现了CustomerServic接口。new CustomerServiceImpl()就是将CustomerServiceImpl这个类实例化了。
        对于“接口可以声明引用类型的变量”的理解。我在想,这句话是不是可以理解为:面向接口编程。再看上面代码,CustomerService cs = new CustomerServiceImpl(); 。将引用类型CustomerServiceImpl类实例化出来的对象声明为接口CustomerService类型。这样也体现了java的多态特性。
       面向接口编程的好处:
             1、可以使项目分层,所有层都面向接口开发,开发效率提高了。
             2、接口使代码之间的耦合度降低(就像灯头与灯泡,内存条与主板的关系),变得“可插拔”,可以随意切换
        代码如下:
import java.util.*;
public class ListTest01{        
        public static void main(String[] args){        
                //创建一个List集合.
                List  l  =  new ArrayList();        
                //添加
                l.add(100);
                l.add(99);
                l.add(23);
                //遍历
                Iterator it = l.iterator();
                while(it.hasNext()){
                        System.out.println(it.next());
                }        
        }
}
        上面的代码中List是一个接口, ArrayList是一个实现了List接口的类。List  l  =  new ArrayList();改为List  l  =  new LinkedList();或者List  l  =  new Vector();,其他地方不变,程序一样运行,代码之间的耦合度降低,实现了可插拔。
        以上是我的理解,不是很透彻,也不太全面,如你能帮我完善,我也会很感谢的。





作者: 四川男人    时间: 2014-4-14 21:52
interface InterFaceDemo
{
        void show();
}
class Demo implements InterFaceDemo
{
        void show(){
                System.out.println("show is running");
        }
}
class Test
{
        public static void main(String[] args)
        {
                InterFaceDemo inter = new Demo();
                inter.show();
        }
       




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