抽象类和接口（我学习做的笔记供大家参考）

抽象类，定义
接口 定义
两者的区别

-----------------------------
抽象类：
abstract关键字修饰

public abstract class Pet{//抽象类

    public abstract void toHospitol();//抽象方法

}
（1）抽象类不能不被实例
但是可以创建一个抽象类类型的引用变量
，这个引用变量指向非抽象的子类类型；

Pet dog=new Dog();
dog.toHospital();


（2）抽象方法没有方法体

抽象类中可以有非抽象的构造方法，创建子类的
实例时可以调用。
没有 抽象够着方法，没有抽象静态方法

怎么调用了？？？？？
（1）如果父类中有静态方法（用static 修饰），子类也 有同名的静态方法，在调用的（静态绑定）
时候还是调用父类的静态方法。
（2）如果父类和子类中都有成名的成员变量，在调用的饿时候调用的是父类的成员变量（静态绑定）
（3）父类有构造方法。子类也有构造方法，先调用父类，在调用子类（静态绑定）



（4）java虚拟机动态绑定机制，在子类中重写了父类的方法后，
在调用这个方法的时候是调用子类重写后的方法



eg：public abstract class Base{
    public String var="base1";
    
    public Base(){System.out.println("父类的构造方法");}

    public static void method4(){

    System.out.println("父类的静态方法method4");
          }




    }


public class Sub1 extends Base{

    public String var="base2";

    public Sub1(){System.out.println("子类的构造方法");}
    public static void method4(){
        
    System.out.println("子类的静态方法method4");
        }

    }


public class Test{

    Base base=new Sub1();//先调用父类的，在调用子类的
    base.method4();//调用的是父类的
    System.out.println(base.var);//也是调用父类的
    }


---------------------------------------
接口：
为什么使用接口？
在java中支持单根继承的。

问题：实现防盗门的功能

将门定义为抽象类，锁定义为接口，

防盗门继承们，实现 锁的 接口

接口：interface  叫做实现一个接口

is a 的关系  防盗门是一个门

has  a 的关系   防盗门有一个锁

上锁、开锁是一种能力，接口表示一种能力

定义Door抽象类：具有开、关门的功能
定义Lock接口：具有上锁、开锁
编写防盗门类，继承door 实现lock接口

/*
 * 门抽象类
 */
public abstract class Door {
    //开
    public abstract void open();
    //关
    public abstract void close();
}

public interface DoorBell {
//门铃，具有拍照的功能
    public abstract void takePhotos();
}

public interface Lock {
//锁
    public abstract void lockup();
    //开锁
    public abstract void lockopenI();
}


//防盗门
public class TheftproofDoor extends Door implements Lock, DoorBell {

    public void lockup() {
        System.out.println("插进钥匙，向左转三圈，锁上了");

    }

    public void lockopenI() {
        System.out.println("插进钥匙，向右转三圈，锁开了");

    }

    public void open() {
        System.out.println("用力推，门开了");

    }

    public void close() {
        System.out.println("亲亲拉门，门关上了");

    }

    public void takePhotos() {
        System.out.println("主人不在家，拍照可存档！");

    }

}

public class Test {

    /**
     * @param args
     */
    public static void main(String[] args) {
        TheftproofDoor myDoor=new TheftproofDoor();
        myDoor.close();
        myDoor.open();
        myDoor.lockopenI();
        myDoor.lockup();
        myDoor.takePhotos();
    }
}

一个人可以具有多项能力，
一个类可以实现多个接口

接口有比抽象类更好的特性：
可以被多个继承
设计和实现完全分离
更自然的使用多态
更容易搭建程序框架
更容易跟换实现
............

接口是一种约定：有些接口只有名称

面向接口编程：程序设计面向接口的约定而不考虑具体实现






public interface MyInterface{
    //变量： 默认：public static final
    public void foo();//默认：public abstrct
    //其他方法
    }

public class MyClass extends Base implements MyInterface,MyInterface2{


     }
继承了Base类，实现了接口MyInterface和MyInterface2


接口中的方法就是抽象方法，可以不写abstract
，模认的就是public abstract







特征：
接口不可以被实例化
实现类必须实现接口的所有方法
实现类可以实现多个接口，用implements/多接口使用逗号隔开变量都是静态常量：public static final


用程序来描述usb接口：
分析：

可以使用java接口来实现：
编写usb接口
实现usb接口
使用接口（父类的引用指向子类对象，多态）

接口表示一种能力，体系在接口的方法上

面向接口编程：
关心实现类有和能力，而不关心实现细节
面向接口的约定二不考虑接口的具体实现

//定义了usb接口规范
public interface UsbInterface {
//提供usb服务
    public void service();
}


/*
 * U盘
 */

public class UDisk implements UsbInterface{
    public void service(){
        System.out.println("U盘:连接usb接口传输数据");
        
    }
}

/*
 * 风扇
 */
public class UFan implements UsbInterface {

    
    public void service() {
        System.out.println("开始转动了");
        
    }

}


public class Test {
public static void main(String[] args) {
    UsbInterface udisk=new UDisk();
    udisk.service();
    
    System.out.println("******实现接口********");
    UsbInterface ufan=new UFan();
    ufan.service();    
       }
}