Java学习日记-7 抽象类和接口

一、抽象类

abstract修饰：类和类中的方法

抽象方法：abstract type name(parameter-list);
(abstract不能修饰static方法和构造函数)

引用：抽象类有其引用变量，可以引用任何继承了该抽象类的子类的对象，但抽象类不会有实例对象。

继承：子类继承抽象类时，必须实现超类中的所有抽象方法，否则子类仍为抽象类。

成员：抽象类可以有成员变量（接口只能有常量，抽象类可以有常量，也可以有变量），也可以有具体方法（甚至是静态方法）。

构造函数：抽象类也有构造函数，子类的构造函数必须调用。

注意：抽象类中可以有静态的方法和变量

 class A extends B
 {
     public static void main(String[] args)
     {
         B.show();
         System.out.println(B.x);
     }
 }

 abstract class B
 {
     static int x = 10;
     public static void show(){
         System.out.println("haha");
     }
 }

抽象类中的静态成员

抽象类和抽象方法的特点：

1.抽象方法一定在抽象类或者接口中

2.抽象方法和抽象类都必须被abstract关键字修饰（接口中的抽象方法可以省略abstract关键字）

3.因为调用抽象方法没有意义，故java规定抽象类不能new对象

4.抽象类中的方法想要被调用，就要由子类重写所有的抽象方法，然后建立子类对象进行调用，如果子类只覆盖了部分抽象方法，该子类肯定也必须还是一个抽象类

5.抽象类中可以全部为抽象方法也可以没有抽象方法(抽象类中可以没有抽象方法，在语法上是可行的)

抽象类的作用场景：

抽象类与一般类并无太大区别，该如何描述事物就如何描述。只不过有些功能，不同的子类有不用的实现内容，就可以把这些方法抽象化，不定义方法主体。

例如：

 class Employee extends Person {

     private double salary;
     private Date hireday;

     public Employee(String n, double salary, int year, int month, int day) {
         super(n);
         this.salary = salary;
         GregorianCalendar calendar = new GregorianCalendar(year, month, day);
         hireday = calendar.getTime();
     }

     public Employee(String n, double salary, int year, int month, int day, int hour,int minute, int second) {
         super(n);
         this.salary = salary;
         GregorianCalendar calendar = new GregorianCalendar(year, month, day, hour, minute, second);
         hireday = calendar.getTime();
     }

     public double getSalary() {
         return salary;
     }

     public Date getHireday() {
         return hireday;
     }

     @Override
     public String getDescription() {
         return "an employee with a salary of $" + salary + '\n' + hireday;
     }
 }

 public class Student extends Person {
     private String major;
     public Student(String n, String m) {
         super(n);
         major = m;
     }

     @Override
     public String getDescription() {
         return "a student majoring in " + major;
     }

 }

 public abstract class Person {
     private String name = "haha";
     public Person(String n){
         name = n;
     }

     public abstract String getDescription();

     public String getname(){
         return name;
     }
 }

 public class AbstractTest {

     public static void main(String[] args) {
         Person[] p = new Person[2];
         p[0] = new Employee("Tom", 9000.0, 1999, 1, 10, 19, 20, 21);
         p[1] = new Student("Jerry", "Math");

         for (Person person : p) {
             System.out.println(person.getDescription());
         }

     }

 }

抽象类举例

二、接口（比抽象类更抽象的存在）

接口关键字：interface和class同等级

接口的特点：

1.成员变量：全部默认public static final 即静态常量

2.方法：所有方法默认public abstract 即抽象的，声明时不必再写public，实现接口的方法必须声明为public（保持与接口一致）。
实现方法的返回类型和签名必须与接口中定义中定义的一致
（接口中的方法可常量都是可选项，什么都没有的空接口在语法上也是允许的）

3.继承/实现：一个接口可以继承多个接口（类只能单继承类），一个类可以实现多个接口

4.方法实现：接口的实现类必须实现接口中的全部抽象方法，否则其实现类必须是抽象类

5.访问修饰符：默认为包内可访问，public为包外也可（当一个接口被声明为public时，必须位于同名文件中）

（接口是比抽象类更加抽象的存在，不能有实例变量（可以有常量），不能有任何具体方法，是纯粹的抽象）

抽象类和接口的区别：

1.抽象类是类，接口是接口，不是类

2.抽象类中可以有：成员变量，静态常量，抽象方法，具体方法（四选0~4都OK）

接口中只能有：静态常量，抽象方法（至少二选一）

3.接口可以继承(extends)接口，但接口不能继承类/抽象类，而类/抽象类可以实现(implement)接口

4.抽象类和类之间只能单继承，接口之间、接口和类/抽象类可以多继承

5.一个类可以实现多个接口，但是只能继承一个抽象类

总结：抽象类、一般类和接口之间的关系

 class A extends B    //(1)
 {
     char name = 'A';
     public static void main(String[] args)
     {
         System.out.println("Hello World!");
     }
 }

 class B extends abstractA    //(2)
 {
     char name = 'B';
 }

 class C
 {
     char name = 'C';
 }

 abstract class abstractA extends C //(3)
 {
     String name = "abstractA";
 }

 abstract class abstractB extends abstractA    //(4)
 {
     String name = "abstractB";
 }

 interface inA
 {
     String name = "inA";
 }

 interface inB extends inA,inC    //(5)
 {
     String name = "inB";
 }

 interface inC
 {
 }

 class D implements inA //(6)
 {
     char name = 'D';
 }

 abstract class abstractD implements inB    //(7)
 {
     String name = "abstractD";
 }

抽象类、一般类和接口