1. abstract class Student
   
2. {
   
3.         abstract void study();
   
4.         void sleep()
   
5.         {
   
6.                 System.out.println("sleep");
   
7.         };
   
8. }
   
9. interface Smoking
   
10. {
    
11.         void smoke();
    
12. }
    
13. class ZhangSan extends Student implements Smoking
    
14. {
    
15.         void study(){};
    
16. public void smoke(){};//此处必须加public，否则报错为什么？
    
17. }
    
18. class Lisi extends Student
    
19. {
    
20.         void study(){};
    
21. }

复制代码

接口是特殊的抽象类，这个类中全部都是抽象方法。为什么会有以上不同？

01.abstract class Student

02.{

03.        abstract void study();

04.        void sleep()

05.        {

06.                System.out.println("sleep");

07.        };

08.}

09.interface Smoking

10.{

11.        void smoke();

12.}

13.class ZhangSan extends Student implements Smoking

14.{

15.        void study(){};

16.public void smoke(){};//接口中的方法只声明，不实现，字段都是final的static的（都是自动）。接口中的方法是abstract和public（这些都是自动）。当类来实现他的时候如果不添加public，那么它只有包访问权限，这样在方法被继承的过程中，他的访问权限就会被降低。java编译器中这样的情况是不允许的。所以必须写上public修饰符
17.}

18.class Lisi extends Student

19.{

20.        void study(){};

21.}

public void smoke(){};//此处必须加public，否则报错为什么？

因为接口里的方法都是public，而子类重写父类方法时访问权限只能大于或者等于，所以实现类实现接口里的方法只能使用public访问控制权限！！！

接口中的方法默认的访问权限是public，所以实现类中对应的实现方法的访问修饰也要使用public，
这样才能保持一致，因为在能够访问此接口中方法的地方，必须能够访问到此实现类的对应的方法。
而你的抽象类的访问权限是default的，所以子类不必加public.

接口也是一种抽象类。接口中的方法必须由它的子类类实现。
16.public void smoke(){};//此处必须加public，否则报错为什么？  因为接口中的方法默认是public的。
                                                                      子类重写父类方法时访问权限必须大于或等于父类的访问权限

17.}

用 abstract 修饰的类是抽象类，含有抽象方法，不能生成对象。
抽象类与接口其实是紧密相关的。
但是接口又比抽象类更加抽象
差别：
a.类可以实现无限个接口，但仅能从一个抽象类继承，从抽象类派生的类仍可实现接口，从而得出接口是用来解决多重继承问题的。
b.抽象类当中可以存在非抽象的方法，可接口不能且它里面的方法只是一个声明必须用public来修饰没有具体实现的方法。
c.抽象类中的成员变量可以被不同的修饰符来修饰，可接口中的成员变量默认的都是静态常量（static final）。
d.抽象类是对象的抽象，然而接口是一种行为规范

接口和抽象类的区别：

1，
类是用来继承的，只能单继承。
接口是用来实现的，可以多实现。

2，
类中可以定义非抽象内容，直接提供给子类使用。
接口中只能定义抽象方法，需要子类全部实现。

3，
类存在着继承关系，是is a关系。
接口的实现关系，是 like a 关系。

共同点：
        它们都是不断抽取而来的。

类/抽象类：对一类具有共同特征的事物的描述
接口：对一类具有共同行为的事物的描述

定义一个接口，Sport
public interface Soprt {
    //默认是public abstract
    void run();
}

打个比方，“人”，可以定义一个抽象类, 同时他又具备Sport的行为
public absract class Persion implements Sport {
      //抽象出一些共同的特征
      private int age;
      private String name;
      //getter,setter。。。。
      //抽象方法，子类实现
      public abstract void eat();
     //实现Sport的run方法，当然也可以让子类实现
     public void run() {System.out.println("runing.......");}
}
//Student可以继承人的特征，同时也具备了Sport的行为
public class Student extends {
      //自己特有的特征
      private class int;
      //getter,setter
      //实现父类抽象方法
      public void eat() {}
     //自己特有方法
     publci void study() {}
}

//Cat也具有Sport的行为，所以：
public class Cat implements Sport P
      public void run() { System.out.println("Cat is running......"); }
}

再interface中，默认权限为public，而在类中默认权限为缺省，即什么都不写。在子类中实现接口或复写父类中的方法时，子类方法的访问权限不能低于interface或父类中该方法的权限，即要么相同，要么大于。显然，类中的缺省权限要小于interface的public，故在子类实现interface接口中的方法时，子类中的方法必须为public。

1.接口中定义的是多个类共同的公共行为规范，因此接口里定义的内部类，接口，枚举类默认都采用public static修饰符。
接口中定义的方法都是抽象方法，系统自动使用abstract修饰符进行修饰。
实现接口方法时，子类重写父类方法时访问权限只能更大或相等，所以实现类实现接口中的方法时只能使用public访问权限。

2，抽象方法和抽象类必须使用abstract修饰符定义。
当使用abstract修饰类或方法时，表明其只能被继承或重写，final修饰的类或方法无法被继承或重写，因此abstract和final无法共同使用。
因为抽象方法无法通过类来调用，因此static和abstruct不能共同修饰方法。
抽象方法必须被其子类重写才有意义，因此抽象方法不能被private修饰。

• interface Smoking
• {
•         void smoke();//-->1
• }
• 接口中所有的方法默认都是public abstract修饰的，所以1处完整语句是public abstract void smoke();
• 如果要实现接口中的方法，则重写方法的访问权限必须大于等于接口中原本的方法的访问权限，而原本方法的访问权限是public，所以重写方法必须是public权限。