3.1、抽象类

       抽象类实际上也是一个类，只是与之前的普通类相比，在抽象类中多了抽象方法。
       抽象方法是只声明而未实现的方法，所有的抽象方法必须使用abstract关键字声明，包含抽象方法的类也必须使用abstract class声明。
一个抽象类的定义
abstract class A{<?xml:namespace prefix = o ns = "urn:schemas-microsoft-com:office:office" />

         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() ;

};