java基础之抽象类和接口-蒲公英云

java基础之抽象类和接口

1、抽象类

* 1、abstract 修饰类：抽象类
 * 1) 不可被实例化
 * 2）抽象类有构造器
 * 3）抽象方法所在的类一定是抽象类，但是抽象类可以没有抽象方法
 * 
 * 2、abstract 修饰方法：抽象方法
 * 1）格式：没有方法体，包括{}
 * 2）抽象方法只保留方法的功能，而具体的执行交给继承抽象类的子类，由子类重写此抽象方法。
 * 3）若子类继承抽象类，并重写了所有的方法，则此类是一个可以实例化的类；若子类继承抽象类，没有重写所有的抽象方法，则此类必须声明为抽象的。
/**
 * abstract 不能用来修饰属性、构造器、private、final、static
 * //因为构造器不能被重写，所以构造器不能重写
 * //因为方法被声明成abstract，此方法必须要被子类重写，而private 修饰的方法，子类无法重写。
 * //当方法被static和abstract共用时，当类在调用这个方法时，方法没有body内容，无法执行。
 */

2、接口

/**
 * 接口（interface） :是与类并行的一个概念
 * 1、接口可以看成一个特殊的抽象类。是常量与抽象方法的集合。不能包含变量以及一般的方法.
 * 常量:默认都是public static final来修饰的，抽象方法:默认都是public abstract来修饰。
 * 2、接口是没有构造器的。
 * 3、接口定义的就是一种功能，这个功能可以被类所实现。
 * 4、实现接口类，必须要重写其中所有的抽象方法，方可实例化。若没有重写所有的抽象方法，则此类仍为一个抽象类。
 * 5、类可以实现多个接口，-----java中继承是单继承的。
 * 6、接口与接口之间也是继承关系，类与接口之间关系是实现，类跟类之间是继承。
 * 7、接口之间的继承可以使多重继承。（这点与类不同）
 */

（1）接口多态性

public class TestInterface {
        //接口多态性
    public static void main(String[] args) {
        Duck duck = new Duck();
        test1(duck);
        test2(duck);
        test3(duck);
    }
    public static void test1(Runner r){//Runner r = new Duck();
        r.run();
    }    
    public static void test2(Swimmer s){//Swimmer s= new Duck();
        s.swim();
    }    
    public static void test3(Flier f){//Flier f= new Duck();
            f.fly();
        }
    }
    interface Runner{
        public abstract void run();    
    }
    interface Swimmer{
        void swim();
    }
    interface Flier{
        void fly();
    }
    class Duck implements Runner,Swimmer,Flier{
        @Override
        public void fly() {
            System.out.println("起飞");
    }
    @Override
    public void swim() {
        System.out.println("游泳");
    }
    @Override
    public void run() {
        System.out.println("跑步");
        }    
    }

（2）接口代理：（静态代理）

public class TestProxy {
    public static void main(String[] args) {
        Object object = new ProxyObject();
        object.action();
    }
}
interface Object{
    void action();
}
class ProxyObject implements Object{
    Object obj;
    public ProxyObject(){
        System.out.println("代理类创建成功");
        obj = new ObjectImpl();
    }
    @Override
    public void action() {
        System.out.println("代理类开始执行");
        obj.action();
        System.out.println("代理类结束执行");
    }
}
class ObjectImpl implements Object{
    @Override
    public void action() {
        System.out.println("被代理类开始执行");
        System.out.println("具体操作");
        System.out.println("被代理类结束执行");
    }
}