1. interface Playable {
   
2.     void play();
   
3. }
   
4. interface Bounceable {
   
5.     void play();
   
6. }
   
7. interface Rollable extends Playable, Bounceable {
   
8.   Ball ball = new Ball("PingPang");
   
9. }
   
10. class Ball implements Rollable {
    
11.     private String name;
    
12.     public String getName() {
    
13.         return name;
    
14.     }
    
15.     public Ball(String name) {
    
16.         this.name = name;        
    
17.     }
    
18.     public void play() {
    
19.         //x = 20;
    
20.         ball = new Ball("Football");
    
21.         System.out.println(ball.getName());
    
22.     }
    
23. }

复制代码

这个代码是有问题的，大家能帮我看一下为什么错，并且给我详细解释一下吧，谢谢

java是单继承……
interface Rollable extends Playable, Bounceable {
你这句话是不是想继承两个？

java中接口是可以多继承的，但是你继承的2个接口中的方法是同样功能，有这个必要？接口的主要用途是扩展功能，比如人具有吃饭睡觉的功能，可以将吃饭睡觉定义在人的类中，但是抽烟就不是每个人都需要的，所以可以将这个功能定义在一个接口中，由人的子类来实现，接口中不要创建对象，只定义需要呗实现的功能即可，。以上拙见。。

月光海 发表于 2014-4-14 20:58
java中接口是可以多继承的，但是你继承的2个接口中的方法是同样功能，有这个必要？接口的主要用途是扩展功 ...

这个是程序是有问题的，我知道，所以要找出问题在哪

首先。你继承那里错了。不能写多个继承，当方法调用的时候不知道调用哪个父类的方法；
然后，接口不能实例化对象，可以被类实现，实现接口的类主要是要使用接口的方法，
最后，类可以实现多个接口。

1. package object;
   
2. 
   
3. public class Test11 {
   
4. public static void main(String[] args) {
   
5.         Ball ball = new Ball("PingPang");
   
6.         ball.play();
   
7. }
   
8. }
   
9. interface Playable {
   
10.     void play();
    
11. }
    
12. interface Bounceable {
    
13.     void play();
    
14. }
    
15. interface Rollable extends Playable, Bounceable {
    
16. // Ball ball = new Ball("PingPang");//首先来说接口里面定义变量和方法，不能创建对象，即使是用的是Ball这个类创建也不可以
    
17. }
    
18. class Ball implements Rollable {
    
19.     private String name;
    
20.     public String getName() {
    
21.         return name;
    
22.     }
    
23.     public Ball(String name) {
    
24.         this.name = name;        
    
25.     }
    
26.     public void play() {
    
27.         //x = 20;
    
28.             //Ball ball = new Ball("PingPang");//这样才符合你的初衷，不报错，但是却不能达到你的要求，主要封装方法，不是用来创建对象的，定义在主函数比较合适
    
29. //        ball = new Ball("Football");//这个ball变量在play这个方法区根本没有定义，只是在Rollable定义了，但是和着没关系，因为作用域不同，同理定义在主函数
    
30.         //System.out.println(ball.getName());
    
31.     }
    
32. }
    
33. 
    
34. 
    
35. 
    
36. 
    
37. 我改了改，这样可以运行，没有问题,,在学基础的时候，是调用者和执行者不太分，但是两者有很明显的区别，在后面的时候会衍生出客户端，服务器端的，所以谁调用的一定要分清楚，主函数调用其实就是模拟了客户端，而本封装的方法体也就类似于将来的服务器端，像new对象，不是方法要做的事儿

复制代码

kuroro自走核炮 发表于 2014-4-14 20:51
java是单继承……
interface Rollable extends Playable, Bounceable {
你这句话是不是想继承两个？ ...

接口是可以多继承的

你回去看看毕老师视频接口的第一节，你就明白了，接口中的成员变量和成员函数有固定的修饰符的，即使你没那样写，系统也会自动帮你家上修饰符！成员变量：public static final;成员函数 public abstract；像你前面定义的两个接口void play(),虽然你没写标示符，但是系统还会自动帮你加上pubic abstract void play();所以你明白了吧，你在接口中定义的变量public static final Ball ball是final的，也就是只能赋值一次，你实现的类里面又赋值了一次，当然会报异常了

interface Playable {
    void play();
}
interface Bounceable {
    void play();
}
interface Rollable extends Playable, Bounceable {
  Ball ball = new Ball("PingPang");
}
class Ball implements Rollable {
    private String name;
    public String getName() {
        return name;
    }
    public Ball(String name) {
        this.name = name;        
    }
    public void play() {
        //x = 20;
        ball = new Ball("Football");
        System.out.println(ball.getName());
    }
}

// 这个程序关键在这 Playable, Bounceable 他们都是接口  而Rollable 也是接口
我们知道在接口当中定义的变量都是用
  public  static final 数据类型 变量名 = 值

形式 也就是说 变量是一不可以改变值的

Ball ball = new Ball("PingPang");
虽然 ball 是一个对象  但是他也是一个变量 （引用类型 的）
所以 ball的值不可以改变的

在main 方法中
ball = new Ball("Football");
给予了 ball新的值 这是不允许的
问题就出在这了

姜姗姗 发表于 2014-4-14 22:28

interface Playable {
    void play();
}
interface Bounceable {
    void play();
}
interface Rollable extends Playable, Bounceable {
        //这里是没有错的，引用ball前面的修饰符是public static final
        //也就是说引用ball所指向的对象是最终静态的，相当与一个Ball类型的常量
  Ball ball = new Ball("PingPang");
}
class Ball implements Rollable {
    private String name;
    public String getName() {
        return name;
    }
    public Ball(String name) {
        this.name = name;        
    }
    public void play() {
        //x = 20;
        //前面说了ball引用所指的对象不可变，而static所修饰的变量的作用域是
        //从它所声明的地方到源文件结束。所有下面的语句是错的。
        //我编译试了一下，报错：无法为最终变量 ball 指定值。
       //ball = new Ball("Football");

        //下面语句确实不会报错。相当于把外面的那个ball屏蔽了。
          // Ball ball = new Ball("Football");

          //同上，这里的ball所指的对象还是不可变的
        System.out.println(ball.getName());  //结果只会是PingPang
    }
}

public class MyBall
{
        public static void main(String[] args)
        {
                Ball ball = new Ball("Football");
                ball.play();   
        }
}

以上是我的理解。我猜想楼主的意思是希望将PingPang改成Football。以下是我改动后的代码，改动较大：
interface Playable {
    void play();
}
interface Bounceable {
    void play();
}
interface Rollable extends Playable, Bounceable {
}
class Ball implements Rollable {
    private String name;
    public String getName() {
        return name;
    }
        public void setName(String name) {
        this.name = name;
    }
    public Ball(String name) {
        this.name = name;        
    }
        //覆盖Playable, Bounceable中的方法
        public void play() {               
    }
        //成员方法
    public void play(Ball ball) {
                System.out.println(ball.getName());   //结果是Football
    }
}
public class MyBall
{
        public static void main(String[] args)
        {
                //创建对象
                Ball ball = new Ball("PingPang");
                //修改属性
                ball.setName("Football");
                //输出结果
                ball.play(ball);   
        }
}

月光海 发表于 2014-4-14 20:58
java中接口是可以多继承的，但是你继承的2个接口中的方法是同样功能，有这个必要？接口的主要用途是扩展功 ...

接口可以借助多态new对象是吧？

姜姗姗 发表于 2014-4-17 23:58
接口可以借助多态new对象是吧？

可以的，和抽象类一样的

ball = new Ball("Football");这里错了，接口中的变量是final的
还有你以后调用play()也会报错的，
因为你Playablet和 Bounceable都定义了play()方法，
虚拟机不知道调用 那个..

package com.itheima;

public interface inter_playble {
        abstract void play();

}
package com.itheima;

public interface Bounceable {
        abstract void play();
}
package com.itheima;

public interface inter_Rollable extends inter_playble,Bounceable{
        //
}

package com.itheima;

public class Ball implements inter_Rollable{
         private String name;
            public String getName() {
                return name;
            }
            public Ball (String name) {
                this.name = name;        
            }
            public void play(Ball a) {
               System.out.println(a.name);
                    }
            public void play(){  //必须覆盖 抽象接口的抽像 方法
                    System.out.println(" 用到了我 ");
            }
            public static void main(String []args)
            {
                    Ball a=new Ball("football");
                    a.play(a);
                   
            }
            

}