若一个接口中定义了常量，那么子类在实现该接口的时候，对于接口中的常量子类可以直接拿过来用吗？

可以。其实像这种问题，楼主完全可以自己写几行代码测试一下

嗯 对的 可以直接接口名.常量名(因为在接口中定义的变量都是用public static final修饰的 所以变量就成了常量)

接口中的常量必须得用这几个修饰符来修饰：public static final------------------------------------这就是说接口中的常量必须是对外暴露的，是共享的，只能一次定义！所以只要是引用了这个接口的类都可以用这个接口里面的常量，但是不能在类里面对接口里面的常量进行修改！否则报错！！还有一个值得注意的是，接口里面的常量命名一般都是全部大写！毕老师说的，大家都这样命名，你不这样命名就是个另类，不利于代码的阅读！！

可以，不多说，来个小代码：

1. interface InterA
   
2. {
   
3.         public static final int NUM = 3;
   
4.         public abstract void show();
   
5. }
   
6. class Test implements InterA
   
7. {
   
8.         public void show(){}//覆盖方法
   
9. }
   
10. 
    
11. 
    
12. class InterfaceDemo
    
13. {
    
14.         public static void main(String[] args)
    
15.         {
    
16.                 Test t = new Test();
    
17.                 System.out.println(t.NUM);//子类调用接口中的常量
    
18.         }
    
19. }
    

复制代码

当然可以,接口的目的就是为了让别的类去实现它,从提高代码的复用度,也是JAVA中多态的表现形式,
实现一个接口类也就相当于把那个接口类里的代码复制过来,然后在方法中写具体的实现

这个必须可以啊! 在接口中， 可以把接口看成是父类，那么，实现这个接口的类可以看成是它的子类。
所以，接口中的常量或者变量，子类都是可以拿来使用的。
在接口中，常量的定义一般都用public static final 来修饰常量，不写的话，是默认修饰的。包括方法也是这样修饰的。

可以  格式为：接口名.变量名.  
1、接口是一个纯粹的抽象类，不提供任何具体的实现，只是提供了一个协议，实现它的子类共同遵守这份协议。
2、接口A中的属性a如果可以定义为静态变量，那么就可以直接通过A.a=xxx；的方法直接修改该属性，而这样做是不安全的。
3、因为接口中的属性是所有实现它的子类共享的，是全局变量，每一个更改都会影响所有的子类。

实现接口就具备了接口的特征，所以当然可以；额

当然可以，
对于接口当中常见的成员：而且这些成员都是固定的修饰符
全局常量  public static final
抽象方法  public abstract
常量都是静态的，不需要创建对象的，在类加载的时候已经加载到了方法区，当你定义一个类去现实
接口时，你也可以通过这个类名.属性访问了.而且这个属性不能被修改。

赵玮_Tom 发表于 2012-5-9 10:57
可以。其实像这种问题，楼主完全可以自己写几行代码测试一下

嗯嗯。其实以前有用过接口的，但是一般都是用的定义抽象方法，没有尝试过在接口中定义常量，以后关于这种小问题我一定自己写代码测试一下。嘿嘿。

杨威 发表于 2012-5-9 11:08
可以，不多说，来个小代码：

谢谢哥们的详细解答，呵呵，学习了。

1. /**
   
2. * 作者：于陈
   
3. * 功能：接口演示
   
4. * 时间：2012年5月3日 20:57:40
   
5. */
   
6. package com.demo05;
   
7. 
   
8. interface Car {
   
9.         String getCarname();
   
10.     int time =2003;   //定义了time
    
11.         int getCarprince();
    
12. }
    
13. 
    
14. 
    
15. class BMW implements Car {
    
16. 
    
17.         public String getCarname() {
    
18.                 System.out.println(Car.time); //在BMW里面调用time
    
19.                 return "BMW";
    
20.         }
    
21. 
    
22.         public int getCarprince() {
    
23. 
    
24.                 return 99999;
    
25.         }
    
26. 
    
27. }
    
28. 
    
29. class CheryQQ implements Car {
    
30. 
    
31.         public String getCarname() {
    
32.         System.out.println(Car.time);//在CheryQQ里面调用time
    
33.                 return "CheryQQ";
    
34.         }
    
35. 
    
36.         public int getCarprince() {
    
37. 
    
38.                 return 88888;
    
39.         }
    
40. 
    
41. }
    
42. 
    
43. public class Carshop {
    
44.         private int money;
    
45.         private int n=1;
    
46. 
    
47.         public void sellCar(Car car) {
    
48.                 System.out.println(n+"  车型：" + car.getCarname() + "  单价："
    
49.                                 + car.getCarprince());
    
50.                 money = money + car.getCarprince();
    
51.                 n=n+1;
    
52.         }
    
53.     public int getN(){
    
54.             return n;
    
55.     }
    
56.         public int getMoney() {
    
57.                 return money;
    
58.         }
    
59. 
    
60.         public static void main(String[] args) {
    
61.                 Carshop carshop = new Carshop();
    
62.                 carshop.sellCar(new BMW());
    
63.                 carshop.sellCar(new CheryQQ());
    
64.                 System.out.println(Car.time);
    
65.                 System.out.println("总收入：" + carshop.getMoney());
    
66. 
    
67.         }
    
68. 
    
69. }
    

复制代码

答案是肯定可以的~接口是用public static final来修饰的，那么接口中定义的常量，那么在类里面就可以直接调用，但是在类里面是不可以修改的。并且，很重要的一点是一般在写程序的时候，我们都习惯把类似圆周率π，或者很长的一组变量，不希望轻易更改的，这一类变量定义在接口里面，不仅增加程序可读性，又能方便的直接用变量名来使用它，还可以很方便的调用它.

java中的定义的常量是用public static final修饰的，
当在接口中定义了常量时，当某个类实现该接口时就可以把接口中的变量当常量来用了