抽象类A继承自抽象类B，A可以实现也可以不实现B中的抽象方法
问题：
抽象类实现了接口，是否必须要实现接口中的方法
知道的兄弟给说说啊

抽象类可以不用，但必须先明其抽象方法。。以便其子类实现

抽象类可以不实现接口中的方法，但若此抽象类实现了该接口，那么继承这个抽象类的具体类必须实现接口中的所有方法。

在java中可以创建一种类专门用来当做父类，这种类称为“抽象类”。
抽象类规则如下“
1.抽象类和抽象方法都必须用abstract关键字来修饰。
2.抽象类不能直接实例化，也就是说不能直接用new关键字去产生对象。
3.抽象方法只需声明，而不需实现。
4.含有抽象方法的类必须被声明为抽象类，抽象类的子类必须覆写所有的抽象方法后才能被实例化，否则这个子类还是个抽象类。
从规则4可得楼主的问题答案：抽象类A继承自抽象类B，抽象类可以不实现接口中的方法，但此抽象类的非抽象子类必须实现接口的所有方法。

interface DoStuff2 {

2. float getRange(int low, int high);

}

4. interface DoMore {

5. float getAvg(int a, int b, int c);

}

7. abstract class DoAbstract implements DoStuff2, DoMore { }//抽象类实现接口，却不实现DoStuff2, DoMore中的抽象方法，也不声明。

9. class DoStuff implements DoStuff2 {

10. public float getRange(int x, int y) { return 3.14f; }

}

12. interface DoAll extends DoMore {//接口实现接口，不实现DoMore抽象方法也不声明

float getAvg(int a, int b, int c, int d);

}

The file will compile without error.编译无错。

这个例子说明抽象类实现接口，接口实现接口都可以不实现抽象方法。

1. interface Myinterface{//接口Myinterface
   
2.         public void f1();//方法声明f1和f2，留给实现该接口的非抽象类实现
   
3.         public void f2();
   
4. }
   
5. abstract class MyAbstructClass implements Myinterface {//实现了Myinterface,但是未实现该接口中的方法，因为其是抽象类，允许存在未实现方法。
   
6.         public abstract void f3();//抽象方法，留给子类实现
   
7.         public void f4(){//抽象类中已实现的方法
   
8.                 this.f1();//虽然此时还未实现f1方法，但f4被调用时，一定是实现了此抽象类的普通类调用的，其也一定实现了f1()和f2().
   
9.                 this.f2();
   
10.         }
    
11. }
    
12. public class Main extends MyAbstructClass{//继承了抽象类，必须实现抽象中所有未实现的方法
    
13.         public static void main(String[] args) {
    
14.                 Main m = new Main();
    
15.                 m.f1();
    
16.                 m.f2();
    
17.                 m.f3();
    
18.                 m.f4();//这4个方法均能顺利调用。
    
19.         }
    
20.         @Override
    
21.         public void f1() {}//实现未实现类，此抽象方法来自接口
    
22.         @Override
    
23.         public void f2() {}
    
24.         @Override
    
25.         public void f3() {}//实现抽象方法，此方法来自父抽象类
    
26. }

复制代码

抽象类可以不实现接口的方法,但该类必须声明为抽象类,让他的子类来实现. 如果他的子类还是抽象类那就再由子类的子类去实现,直到继承该类的类不是抽象类为止.前提是所继承该类的派生类是不是抽象类来衡量是否需要实现接口的方法

接口是公开的，里面不能有私有的方法或变量，是用于让别人使用的，而抽象类是可以有私有方法或私有变量的，
其次实现接口的一定要实现接口里定义的所有方法，而实现抽象类可以有选择地重写需要用到的方法，一般的应用里，最顶级的是接口，然后是抽象类实现接口，最后才到具体类实现。
最后接口可以实现多重继承，而一个类只能继承一个超类，但可以通过继承多个接口实现多重继承。

1. abstract class Person
   
2. {
   
3.    abstract void study();
   
4.    abstract void sleep();
   
5. }
   
6. 
   
7. interface Function
   
8. {
   
9.   abstract void smoke();
   
10. }
    
11. 
    
12. abstract class Student extends Person implements Function
    
13. {
    
14.         void study()
    
15.                 {
    
16.                         System.out.println("good study");//抽象类(Student)继承了抽象类(Person)，但并没有完全实现Person中的抽象方法(sleep()).
    
17.                 }//抽象类(Student)实现（implements）接口（Function）时并没有实现接口中的方法（smoke())
    
18. }
    
19. 
    
20. class GoodStudent extends Student
    
21. {
    
22.         public void sleep()
    
23.         {
    
24.                 System.out.println("sleep");
    
25.         }
    
26.         public void smoke()
    
27.         {
    
28.                 System.out.println("no smoke");//抽象类Student继承了抽象类Person，但并没有完全实现Person中的抽象方法:sleep()
    
29.         }
    
30. }
    
31. class InterfaceDemo
    
32. {
    
33. public static void main(String[] args)
    
34.         {
    
35.                 GoodStudent s= new GoodStudent();
    
36.                 s.study();
    
37.                 s.sleep();
    
38.                 s.smoke();
    
39.         }
    
40. }
    
41. 
    
42. /*以上程序可以正常运行，所以抽象类继承抽象类可以不实现父类中的抽象方法，抽象类也可以不实现接口中的方法。
    

复制代码