abstract 抽象与interface 接口

abstract 抽象

当多个类中出现相同功能（方法），但是功能主体不同。
这时可以进行向上抽取（建立父类），这时，只抽取功能定义，而不抽取功能主体。
其实就是子类重写父类的方法，只不过此时父类的方法是没有方法体的，定义为抽象方法，此时父类为抽象类。要求子类必须重写父类的抽象方法。不同子类实现父类的抽象方法又体现了多态。

※ abstract修饰符
可以修饰类和成员方法
修饰的类叫抽象类，修饰的方法叫抽象方法

※抽象类

. 用abstract修饰的类表示抽象类，抽象类不能实例化，（因为具有不确定的抽象方法）即不允许创建抽象类本身的实例。没有用abstract修饰的类称为具体类，具体类可以被实例化。
· 抽象类和一般类没有什么太大的不同。该如何描述事物，就如何描述事物，只不过，该事物出现了一些看不懂的东西。这些不确定的部分，也是该事物的功能，需要明确出现，但是无法定义主体，通过抽象方法来表示。

※抽象类的特点：
1.抽象方法一定在抽象类中；
2.抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象；
3.抽象方法和抽象类都必须被abstract关键字修饰；
4.抽象类不可以被new创建对象，因为调用抽象方法没意义；
5.抽象类中的抽象方法要被使用时，必须由子类复写所有的抽象方法后，建立子类对象调用；
6.如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类，类名还要用用abstract修饰。

※抽象方法
. 用abstract修饰的方法表示抽象方法，抽象方法没有方法体。抽象方法用来描述系统具有什么功能，但不提供具体的实现。
注：没有abstract修饰的方法称为具体方法，具体方法具有方法体。

语法规则；
1) 抽象类中可以没有抽象方法，但包含了抽象方法的类必须被定义为抽象类；
2) 没有抽象构造方法，也没有抽象静态方法；
3) 抽象类中可以有非抽象的构造方法；
4) 抽象类及抽象方法不能被final修饰符修饰；
5）抽象类不能被实例化。

package angel;
        //定义抽象类
public abstract class Student
        {
        //定义抽象方法
         public abstract void study();
         public void sleep()
            {
            System.out.println("sleep");
          }
       }



class BaseStudent extends Student
       {
       public void study()
        {
       System.out.println("Study base");
              }
         }
//如果Student类中有另一抽象方法，而该类只重写了一条，则该类还是抽象类

interface 接口

一个抽象类中的所有方法都是抽象方法时，可以将该类定义成接口。（即抽象类的极致）
class用于定义类
interface 用于定义接口
implements 用于实现接口
接口与接口之间是extends继承关系

※接口使用的目的：
解决多重继承问题：例如Fish类继承Animal类，表明Fish是一种动物，但鱼同样也是一种食物，如何表示这种关系呢？ 由于Java语言不支持一个类有多个直接的父类，因此无法用继承关系来描述鱼既是一种食物，又是一种动物，为了解决这一问题，Java语言引入接口类型，简称接口。一个类只能有一个直接的父类，但是可以实现多个接口。 采用这种方式，Java语言对多继承提供了有力的支持。

1.接口是抽象类的另外一种形式
抽象类抽象到极致就是接口，抽象类可存在有方法体的方法，接口中的方法全部为抽象方法；
2.接口中的所有方法均是抽象方法， 默认都是public、abstract类型的；

 public interface A {
     //合法，默认为public、abstract类型
             void method1();                    
     //合法，显示声明为public、abstract类型
            public abstract void method2();
           }

3.接口中的成员变量默认都是public, static, final类型，必须被显式初始化；

public interface A {
  //合法，CONST默认为public, static, final类型
            int CONST = 1; 
  //合法，显示声明为public static final 类型                
      public static final int OPAQUE = 1;  
               }

4.接口中只能包含public, static, final类型成员变量和public、abstract类型的成员方法；
5.接口中没有构造方法，不能被实例化。需要被子类实现，子类对接口中的抽象方法全部覆盖后，子类才可以实例化。否则子类是一个抽象类。
6.一个类只能继承一个直接的父类，但能实现多个接口。

※ 接口的特点：
1.接口是对外暴露的规则
2.接口是程序的功能扩展
3.接口可以用来多实现
4.类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口
5.接口与接口之间可以有继承关系

抽象类和接口比较：
1.相同点：
a. 都不能被实例化；
b. 都能包含抽象方法；
2.不同点；
a. 抽象类中可以为部分方法提供默认的实现，从而避免子类中重复实现它们，提高代码的可重用性，而接口中只能包含抽象方法；
b. 一个类只能继承一个直接的父类，这个父类有可能是抽象类；但一个类可以实现多个接口，这是接口的优势所在。

1.
package angel;
//定义一个接口
interface Inter
{
public static final int X=3;
public abstract void show();
}



public class test implements Inter
     {
      public void show()
       {}
    }
public class InterfaceDemo {
    public static void main(String[] args) {
// TODO Auto-generated method stub
         test t=new test();
        //打印输出静态变量 类名.属性名
       System.out.println(Inter.X);
        //打印输出对象.属性名
       System.out.println(t.X);
        //继承接口静态属性
       System.out.println(test.X);
}
}


2.
package angel;
interface A 
      {
public abstract void show();
   }
interface B
      {
public abstract void show2();
   }
interface C extends A,B
      {
      //接口C继承A，B的抽象方法，仍写成抽象方法
       //public abstract void show();
       //public abstract void show2();
     }

class D implements A,B
    {
    //重写抽象方法
      public void show(){}
      public void show2(){}
     }

class E extends D implements A,B
{
   //E继承D 实现A，B接口
}
public class InterfaceDemo3 {
      public static void main(String[] args) {
// TODO Auto-generated method stub
      E e=new E();
    }
}