抽象类和抽象方法的使用，接口的详解

抽象类和和抽象方法的使用
什么是抽象方法：使用abstract修饰的方法，没有方法体，只有声明，它定义的是一种规范，通过子类去具体实现
什么是抽象类：包含抽象方法的类就是抽象类（普通类不能定义抽象方法）

package cn.com.qq;

public abstract class Animal {
    //第一 抽象方法没有实现 第二 子类必须实现
    abstract public void shot();
    public void run() {
        System.out.println("跑跑跑！");
    }

    public static void main(String[] args) {
        Animal a = new Dog();
        a.run();
        a.shot();
        //抽象类的意义就在于给子类提供一个统一的，规范的模板
    }
}

class Dog extends Animal {
    @Override
    public void shot() {
        System.out.println("汪汪汪！");
    }
}

抽象类需要注意的点：
1，有抽象方法的类只能定义成抽象类
2，抽象类不能实例化对象，也就是不能new
3，抽象类可以包含属性，方法，构造方法，但是构造方法不能new，只能被子类来调用
4，抽象类只能用来被继承
5，抽象方法必须被子类实现

接口的详解
1，访问修饰符：只能是public或者default
2，接口名：和类名采用相同机制
3，extends：接口可以多继承
4，常量：接口中的属性只能是常量，并且是public static final修饰，不写也是
5，方法：被public abstract修饰，不写也是
需要注意的有：
1，子类通过implements来实现接口
2，接口不能创建实例
3，一个子类实现了接口，必须实现接口中所有的方法，并且这些方法只能是public的
4，jdk1.7之前，接口中只能包含静态常量，抽象方法，不能有普通属性，构造方法，普通方法
5，jdk1.8后，接口中包含普通的静态方法

package cn.com.qq;

public interface MyInterfence {
    /*public static final*/ int MAX_AGE =100;
    /*public abstract*/     void test01();

    public static void main(String[] args) {
        MyInterfence a = new MyClass();
        a.test01();

    }
}
class MyClass implements MyInterfence {
    @Override
    public void test01() {
        System.out.println(MAX_AGE);
        System.out.println("MyClass.test01");
    }
    public void test02() {
        System.out.println("+++");
    }
}

package cn.com.qq;

public class TestInterfence {
    public static void main(String[] args) {
        volant v = new Angel();
        v.fly();
        Angel a = new Angel();

        a.fly();
        a.helpOther();
        Honest h = new GoodMan();
        h.helpOther();

    }
}
interface volant {
    int FLY_HEIGHT = 2000;
    void fly();
}
interface Honest {
    void helpOther();
}
//实现多接口
class Angel implements volant,Honest {
    @Override
    public void fly() {
        System.out.println("angle.fly()");
    }

    @Override
    public void helpOther() {
        System.out.println("angle.helpOther()");
    }
}
class GoodMan implements Honest {
    @Override
    public void helpOther() {
        System.out.println("GoodMan.helpOther()");
    }
    public void otherWay() {
        System.out.println("+++");
    }
}
class BirdMan implements volant {
    @Override
    public void fly() {
        System.out.println("BrdMan.fly()");
    }
}

package cn.com.qq;

public class TestInterfence02 {
    public static void main(String[] args) {
        A a = new Mysublass();
        //默认的a是A 的类型，而不是其它的类型
        a.testa();
    }
}
interface A {
    void testa();
}
interface B {
    void testb();
}
//接口可以多继承，类是单继承的，也就是 单继承，多接口
interface C extends A,B {
    void testc();
}
class Mysublass implements C {
    @Override
    public void testa() {
        System.out.println("Mysublass.testa()");
    }

    @Override
    public void testb() {
        System.out.println("Mysublass.testb()");

    }

    @Override
    public void testc() {
        System.out.println("Mysublass.testc()");
    }
}