抽象类与接口

1 抽象类(abstract)

  当父类的一些方法不能确定时，可以用 abstract 关键字来修饰该方法，这个方法就是抽象方法，用 abstract 来修饰类，就是抽象类。

abstract class Animal {
    String name;
    int age;
    abstract public void cry();
}

1.1 基本介绍

1. 用 abstract 关键字来修饰一个类时，这个类就叫抽象类

   /*
   访问修饰符 abstract 类名 {
   }
   */
   

2. 用 abstract 关键字来修饰一个方法时，这个方法就是抽象方法

   /*
   访问修饰符 abstract 返回类型 方法名(参数列表)；
   //注意抽象方法没有方法体
   */
   

3. 抽象类的价值更多作用是在于设计，是设计好之后，让子类继承并实现。简单来说，就是起一个占位作用。

---

1.2 抽象类使用注意事项及细节

1. 抽象类不能被实例化。

2. 抽象类不一定要包含 abstract 方法，也就是说，抽象类可以没有 abstract 方法

3. 一旦包含了 abstract 方法，则这个方法必须声明为 abstract

4. abstract 只能修饰类和方法，不能修饰属性和其它的。

5. 抽象类可以有任意成员[抽象类的本质还是类，具有类的属性]，比如：非抽象方法、构造器、静态属性等

6. 抽象方法不能有主体，即不能实现。

   abstract void aa();//即不能有大括号
   

7. 如果一个类继承了抽象类，则它必须要实现抽象类的所有抽象方法，除非它自己也声明为 abstract 类。

8. 抽象方法不能使用 private、final 和 static 来修饰，因为这些关键字都是和重写相违背的。即，如果使用了，private、final 和 static 进行修饰，则子类无法进行重写该方法，而子类又必须要实现父类抽象方法。

---

2 接口(interface)

2.1 基本介绍

  接口就是给出一些没有实现的方法，封装到一起，到某个类要使用的时候，再根据具体情况把这些方法写出来。

语法：

/*
interface 接口名 {
	//属性
	//抽象方法
}

class 类名 implements 接口名 {
	自己属性；
	自己方法；
	必须实现的接口的抽象方法
}

总结： 接口是更加抽象的抽象的类，抽象类里的方法可以有方法体，接口里的所有方法都没有方体[jdk 7.0]。接口体现了程序设计的多态和高内聚低耦合的设计思想。

特别说明：jdk 8.0 后接口类可以有静态方法，默认方法，也就是说接口中可以有方法的具体实现。

interface A {
    default void cry(){
    //必须使用 default 才可以实现，jdk 要为 8.0 之后的版本
        System.out.println("hhh");
    }
    
    static void say(){
        System.out.println("say()"); //同上，使用 static
    }
}

---

2.2 注意事项

1. 接口不能被实例化
2. 接口中所有的方法是 public 方法，接口中抽象方法，可以不用 abstract 修饰：

interface A {
    void a();
    //实际上是
    // public abstract void a();
}

3. 一个普通类实现接口，就必须将该接口的所有方法都实现
4. 抽象类实现接口，可以不用实现接口的方法。
5. 一个类可以同时实现多个接口

interface A {}
interface B {}
class C implements A,B {}

3. 接口中的属性，只能是 final ，而且是 public static final 修饰符。比如：int a = 1; 实际上是： public static final int a = 1; (必须初始化)

4. 接口中属性的访问形式：接口名.属性名

5. 接口不能继承其他的类，但是可以继承多个别的接口：

   interface B{}
   interface C{}
   interface A extends B,C{
   }
   

6. 接口的修饰符只能是 public 和默认，这点和类的修饰符是一样的。

---

3 接口的多态性

1. 看一个例子：

interface A {//接口
   	void say();
}
class B implements A {//B类实现接口A
    public void say() {
        System.out.println("我是B");
    }
}
class C implements A {//C类实现接口A
	public void say() {
        System.out.println("我是A");
    }
}
class D {
    public void work(A a) {
        a.say();
    }
}

class Test {
    public static void main(String[] args) {
        B b = new B();
        C c = new C();
        D d = new D();
        d.work(b);//动态绑定机制
        d.work(c);
    }
}

  在上面的例子中，A a 既可以接收 B 类对象，又可以接收 C 类对象。

2. 多态数组：

A a[] = new A[2];
a[0] = new B();
a[1] = new C();

3. 接口存在 多态传递 现象

interface A {
}
class B implements A {
}
class C extends B {
}

class Test {
    public static void mian(String[] args) {
        C c = new C();
        A a = c;
    }
}