java修行之路（五）

7.抽象类(abstract class)

概念：在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类
(1)abstract修饰类，抽象类
    a、不能被实例化（所以抽象类必须被继承，才能被使用）
    b、抽象类有构造器（凡是类都有构造器）
    c、抽象方法所在的类一定是抽象类。

(2)abstract修饰方法，抽象方法
    a、没有方法体，包括{}，如 public abstract void eat();
    b、抽象方法只保留方法的功能，具体的执行交给继承抽象类的子类，由子类重写此抽象方法。
    c、若子类继承抽象类，没有重写所有的抽象方法，则此类必需声明为抽象的。
(3)abstract 不能用来修饰属性、构造器、private、final、static

示例代码：

abstract class Person {
        private String name;

    //    public void eat(){
    //        System.out.println("吃饭");
    //    }
    //    public void walk(){
    //        System.out.println("走路");
    //    }
        public abstract void eat();

        public abstract void walk();

        public Person() {
        }
    }

    class Student extends Person {
        public void eat() {
            System.out.println("学生吃饭");
        }

        public void walk() {
            System.out.println("学生走路");
        }
    }

更多实例：http://www.runoob.com/java/java-abstraction.html

8.接口（interface）

(1)有时必须从几个类中派生出一个子类，继承它们所有的属性和方法。但是，Java不支持多重继承。有了接口，就可以得到多重继承的效果。
(2)接口(interface)是抽象方法和常量值的定义的集合,不能包含变量和一般的方法。
(3)从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现
(4)实现接口类：class SubClass implements InterfaceA{ }
(5)一个类可以实现多个接口，接口也可以继承其它接口。（java中的继承是单向的）
(6)接口的特点：
    a、用interface来定义（接口是与类并行的一个概念）
    b、接口中的所有成员变量都默认是由public static final修饰的
    c、接口中的所有方法都默认是由public abstract修饰的
    d、接口没有构造器。(没必要实例化)
    e、接口定义的就是一种功能，此功能可以被类所实现（implements）
    f、实现接口的类，必需要重写所有的抽象方法，方可实例化。

示例代码：

public class TestInterface {
        public static void main(String[] args) {
            System.out.println(AA.NUMBER); //100
           // AA.NUMBER = 200;  报错，说明是static final修饰的全局常量
        }

    }

    interface AA{
         //常量：所有的常量都默认用 public static final 修饰
    //    public static final int NUMBER = 100;
        int NUMBER = 100;
        boolean FLAG = true;
    //    String name ;//报错，接口不能包含变量
        //抽象方法：所有的抽象方法都默认用 public abstract 修饰
    //    public abstract void method1();
        void method1();
        void method2();
    }

    class BB implements AA{
        //要重写接口中所有的方法，或者把类设置为抽象类(用abstract修饰类)否则报错
        public void method1(){};
        public void method2(){};
    }

(7)类与接口之间的关系：实现，类与类之间的关系：继承

示例代码：

    interface C1{
        void method1();
        void method2();
    }
    class C2{
        public void method3(){

        }
    }

    class C3 extends C2 implements C1{
        //实现c1中method1，method2方法
        public void method1(){

        }
        public void method2(){

        }
        //重写C2中的方法
        public void method3(){

        }
    }

(8)接口与接口之间的关系：继承,可以实现多继承

示例代码：

interface D1{
        void method1();
    }

    interface D2 extends D1{
        void method2();
    }

    class D3 implements D1,D2{
        public void method1(){

        }
        public void method2(){

        }
    }

(9)接口与具体的类之间也存在多态性

示例代码：

public class Test3 {
        public static void main(String[] args) {
            Person1 p = new Person1();
            Test3.getRunner(p);
        }
        public static void getRunner(Runner r){ // 等同于Runner r = new Person1()
            r.run();
        }
        public static void getDancer(Dancer d){
            d.dance();
        }
    }

    interface Runner{
        void run(
    }

    interface Dancer{
        void dance();
    }

    class Person1 implements Runner,Dancer{
        @Override
        public void run() {
            System.out.println("跑步");
        }

        @Override
        public void dance() {
            System.out.println("跳舞");
        }
    }