下面是我看资料上的习题敲的一段小代码，麻烦大家帮我看下注解有没有问题。
其中有个小疑问：
class Computer//定义电脑{        //静态是为了能让主函数直接调用        public static void usb(Usb usb)//提供一个使用方法        {                usb.use();        }}这一步中的Usb usb，表示有点看不懂，希望知道的哥们详细解释下，谢啦！




需求：
通过一个接口，让电脑接上U盘和打印机。

interface Usb//定义一个USB接口{        public abstract void use();//使用}

class Computer//定义电脑
{
        //静态是为了能让主函数直接调用
        public static void usb(Usb usb)//提供一个使用方法
        {
                usb.use();
        }
}

class Udisk implements Usb//实现接口
{
        public void use()//覆盖接口中的方法，实列化
        {
                System.out.println("U盘接入");
        }
}

class Print implements Usb
{
        public void use()
        {
                System.out.println("打印机接入");
        }
}

class Interface01
{
        public static void main(String[] args)
        {
                Computer.usb(new Udisk());
                Computer.usb(new Print());
        }
}

首先，注解没有问题。

1. //静态是为了能让主函数直接调用
   
2.         public static void usb(Usb usb)//提供一个使用方法
   
3.         {
   
4.                 usb.use();
   
5.         }

复制代码

Usb是形参的类别，usb是形参的名称，通过传入一个实参（一个USB类型的对象，它的名称是usb）来确定是用哪一个确切的usb接口。
可以理解为在我们生活中，usb接口是一类东西，这时候我们给它取个类名叫Usb。Java标识符命名规范规定类名第一个字母大写。
而usb是一个具体的Usb对象。这个具体的对象才可以去调用Usb类的use()方法。
希望对你有帮助。

接口interface
        (1)当一个类中的方法都是抽象的时候，java提供了另一种表示方式，叫接口。
           用interface关键字表示。类与接口关系用implements表示。
        (2)接口的成员特点
                成员变量是常量，默认修饰 public static final       
                成员方法都是抽象的，默认修饰 public abstract       

你看一下这个，我修改了一下你的代码，里面有注释。

1. public class Test {
   
2. 
   
3.         /*
   
4.          * 需求： 通过一个接口，让电脑接上U盘和打印机。
   
5.          */
   
6. 
   
7.         public static void main(String[] args) {
   
8.                 // Computer.usb(new Udisk());
   
9.                 // Computer.usb(new Print());
   
10. 
    
11.                 // 这也是可以的，可以理解为新产生了一个电脑，而且给电脑装上了U盘和打印机，通过usb的方式
    
12.                 Computer c = new Computer();
    
13.                 c.usb(new Udisk());
    
14.                 c.usb(new Print());
    
15.         }
    
16. }
    
17. 
    
18. // 定义一个USB接口：相对于定义了一个规则
    
19. interface USB {
    
20.         // 相当于定义规则的细节
    
21.         public abstract void use();
    
22. }
    
23. 
    
24. // 定义电脑类
    
25. class Computer {
    
26.         // 静态是为了能让主函数直接调用（static修饰之后类名可以直接调用，你建立一个实例对象也可调用）
    
27.         public static void usb(USB usb)  // 这句代码在调用时相当于：USB usb=new Udisk();
    
28.                                                                         //                  或者USB usb=new Print();
    
29.         {                                                //  接口类型指向自己的子类对象,这是多态的知识
    
30.                 usb.use();
    
31.         }
    
32. }
    
33. 
    
34. // 定义一个U盘类并实现USB接口
    
35. class Udisk implements USB {
    
36.        
    
37.         // 覆盖接口中的方法，相当于U盘厂商按照USB的规则生产U盘
    
38.         public void use() {
    
39.                 System.out.println("U盘接入");
    
40.         }
    
41. }
    
42. 
    
43. // 定义一个打印机类并实现USB接口
    
44. class Print implements USB {
    
45.        
    
46.         public void use() {
    
47.                 System.out.println("打印机接入");
    
48.         }
    
49. }
    

复制代码

wenbaoxing 发表于 2013-10-24 18:15
你看一下这个，我修改了一下你的代码，里面有注释。

很详细，谢啦！

匡文 发表于 2013-10-24 17:48
首先，注解没有问题。Usb是形参的类别，usb是形参的名称，通过传入一个实参（一个USB类型的对象，它的名称 ...

这个USB usb属于自己构造的一个形参的类别是吧？

额。。 这是一个接口多继承的问题。
也就是说一个接口同时有多个类继承自它。这里定义了一个USB接口，还有个use()的抽象方法。
然后udisk和Print两个子类继承了USB接口，并实现了其中的抽象方法use(),最后用个电脑类computor来调用该USB接口的use()方法,这里的USB usb应该是对接口类的引用和声明，后面main()方法对该引用进行了实例化。