抽象类实际上也是一个类，只是与之前的普通类相比，在抽象类中多了抽象方法。
       抽象方法是只声明而未实现的方法，所有的抽象方法必须使用abstract关键字声明，包含抽象方法的类也必须使用abstract class声明。
一个抽象类的定义
abstract class A{
         private String name = "WWW" ;
         public void fun(){
                   // 此处定义了一个普通方法
                   System.out.println("Hello World!!!") ;
         }
         public abstract void print() ;
};
       可以发现抽象方法后面没有“{}”，则表示方法没有实现。
       如果对抽象方法直接实例化，则会出现无法实例化的错误。
abstract class A{
         private String name = "WWW" ;
         public void fun(){
                   // 此处定义了一个普通方法
                   System.out.println("Hello World!!!") ;
         }
         public abstract void print() ;
};
public class Demo01{
         public static void main(String args[]){
                   A a = new A() ;
         }
};
抽象类的使用原则：
       1、  抽象类必须有子类，抽象类必须被继承
       2、  抽象类的子类如果不是抽象类的话，则必须覆写里面的全部抽象方法。
       3、  抽象类不能直接实例化，必须依靠子类完成。
进一步完善之前的程序：
abstract class A{
         private String name = "WWW" ;
         public void fun(){
                   // 此处定义了一个普通方法
                   System.out.println("Hello World!!!") ;
         }
         public abstract void print() ;
};
class B extends A{
         // 覆写抽象方法
         public void print(){
                   System.out.println("**********************") ;
         }
};
public class Demo02{
         public static void main(String args[]){
                   B b = new B() ;
                   b.print() ;
                   b.fun() ;
         }
};
讨论问题：
       1、  能否用final修饰一个抽象类呢？
              · 因为抽象类必须被子类继承，而被final修饰的类不能有子类。所以不能
       2、  抽象类中能否有构造方法呢？可以有
abstract class Person{
         private String name ;
         private int age ;
         // 单独按一个类来说，应该可以直接在构造方法中初始化
         public Person(String name,int age){
                   this.name = name ;
                   this.age = age ;
         }
         public abstract String getInfo() ;
         public String getName(){
                   return this.name ;
         }
         public int getAge(){
                   return this.age ;
         }
};
class Student extends Person{
         private String school ;
         public Student(String name,int age,String school){
                   super(name,age) ;
                   this.school = school ;
         }
         public String getInfo(){
                   return "姓名："+super.getName()+"，年龄："+super.getAge()+"，学校："+this.school ;
         }
};
public class Demo03{
         public static void main(String args[]){
                   Student stu = new Student("张三",30,"北京大学") ;
                   System.out.println(stu.getInfo()) ;
         }
};
抽象类中可以有构造方法，但是要求在没有无参构造方法的时候，子类必须明确的调用父类中的构造方法。
回顾：子类对象的实例化过程
· 子类对象实例化的时候默认会先去调用父类中的无参构造方法，如果父类中没有无参构造，则可以通过super指定调用父类中的其他构造方法。
注意：
       一个类只可以继承一个抽象类，属于单继承。

3.2、接口

       接口定义：
              · 只包含抽象方法和全局常量的类称为接口。
              · 接口使用interface进行定义。
interface A{
         public static final String INFO = "HELLO" ;
         public abstract void print() ;
}
       接口定义完之后，一个接口也必须依靠其子类使用，子类继承接口的概念称为实现。格式如下：
              class 子类 implements 接口名称{}
       接口的子类如果不是抽象类的话，则也必须覆写里面的全部抽象方法。
interface A{
         public static final String INFO = "HELLO" ;
         public abstract void print() ;
}
class B implements A{
         public void print(){
                   System.out.println(INFO) ;
         }
};
public class Demo04{
         public static void main(String args[]){
                   B b = new B() ;
                   b.print() ;
         }
};
       接口与抽象类相比，有一个优点：说一个子类只能继承一个父类，但是可以同时实现多个接口，也就说是通过接口完成多继承。
       class 子类 implements 接口A,接口B
interface A{
         public static final String INFO = "HELLO" ;
         public abstract void print() ;
}
interface C{
         public static final String PARAM = "WWW" ;
         public abstract void fun() ;
}
class B implements A,C{
         public void print(){
                   System.out.println(INFO) ;
         }
         public void fun(){
                   System.out.println(PARAM) ;
         }
};
public class Demo05{
         public static void main(String args[]){
                   B b = new B() ;
                   b.print() ;
                   b.fun() ;
         }
};
 
       问题：
既然，接口中的一切方法都是抽象方法，接口中的一切变量都是全局常量，那么实际上接口就可以简化成如下的形式定义。
interface A{
         // public static final String INFO = "HELLO" ;
         String INFO = "HELLO" ;
         // public abstract void print() ;
         void print() ;     //à 此处虽然没有明确的写出权限，但实际上权限是public
}
       一定要明确：接口中的一切方法都是public访问权限，所以在子类实现方法的时候访问权限必须是public。写与不写是一样的。所以有时候为了避免此种情况，还是建议写上：public
         public void print() ;
 
       那么如果一个类继承继承一个抽象类又要实现一个接口，则必须按照以下格式完成：
       class 子类 extends 父类（一般都是抽象类） implements 接口A,接口B
 
interface A{
         // public static final String INFO = "HELLO" ;
         String INFO = "HELLO" ;
         // public abstract void print() ;
         void print() ;
}
abstract class X{
         public String param = "hello" ;
         abstract void fun() ;
};
class B extends X implements A{
         public void print(){
                   System.out.println(INFO) ;
         }
         void fun(){
                   System.out.println(INFO) ;
                   System.out.println(param) ;
         }
};
public class Demo07{
         public static void main(String args[]){
                   B b = new B() ;
                   b.print() ;
         }
};
 
开发原则：
       在开发中一定要记住，一个类往往很少去继承一个已经实现好的类，即：普通类之间不能互相继承。
 
注意点：
       1、  一个抽象类可以实现多个接口，但是一个接口不能继承一个抽象类。
interface A{
         // public static final String INFO = "HELLO" ;
         String INFO = "HELLO" ;
         // public abstract void print() ;
         void print() ;
}
abstract class X implements A{
         public String param = "hello" ;
         abstract void fun() ;
};
       2、  一个接口可以同时继承多个接口，即：实现多继承关系
              interface 子接口 extends 父接口A,父接口B,父接口C
interface A{
         public void printA() ;
}
interface B{
         public void printB() ;
}
interface C{
         public void printC() ;
}
interface X extends A,B,C{
         public void printX() ;
};
class Y implements X{
         public void printA(){}
         public void printB(){}
         public void printC(){}
         public void printX() ;
};