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

抽象类，定义

接口 定义

两者的区别

—————————–

抽象类：

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();    

       }

}