接口不能实例化，但可以声明引用类型的变量。如何理解此话，求大神解释，并代码证明

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

复制代码

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 10:59
这是我自己的理解不知道对不对，多谢指正！

不是吧  我写了那么多  ，怎么就只显示了几行:'(

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
}
//类与类之间是继承关系，类与接口直接是实现关系。  
/*
接口不可以实例化。

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

*/

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 Ｄemo 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(){}

复制代码

interface AbsDemo //接口可以认为是一种特殊的抽象类，从而弥补了java单继承的短板，用了多实现
{
　　abstract void show();
}
class Ｄemo 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来调用抓老鼠方法，就比如说小动物去抓老鼠，因为小动物类中没有这个方法，所以小动物，就不会去执行。
　　}
}

你好，朋友。
首先，接口不能实例化，这个好理解。
接口中是没有构造方法的。没有构造方法，也就注定了不能被实例化。当然，通过实现了接口的一个类并重写了接口中所有的抽象方法后，将该类实例化，也可以看做是将这个接口实例化了。如下代码：
        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();，其他地方不变，程序一样运行，代码之间的耦合度降低，实现了可插拔。
        以上是我的理解，不是很透彻，也不太全面，如你能帮我完善，我也会很感谢的。

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();
        }