java面向对象编程(八)--抽象类、接口

1、抽象类

1.1抽象类概念

当父类的一些方法不能确定时，可以用abstract关键字来修饰该方法[抽象方法]，用abstract来修饰该类[抽象类]。

//抽象类的必要性[Demo124.java]
public class Demo124 {
    public static void main(String[] args) {
        //Animal an=new Animal();抽象类不允许实例化
        Animal an=new Cat();
        an.cry();
        an=new Dog();
        an.cry();
    }
}
//抽象类abstract关键词
abstract class Animal{
    String name;
    int age;
    //动物会叫，使用了abstract抽象方法

    //抽象类中可以没有abstract抽象方法
    abstract public void cry();

    //抽象类内可以有实现方法
    public void sx(){
        System.out.println("实现方法");
    }
}
//当一个子类继承的父类是abstract抽象类的话，需要程序员把抽象类的抽象方法全部实现。
class Cat extends Animal{
    //实现父类的cry，其实类似上节学习中的子类覆盖父类
    public void cry(){
        System.out.println("猫猫叫");
    }
}
class Dog extends Animal{
    //实现父类的cry，其实类似上节学习中的子类覆盖父类
    public void cry(){
        System.out.println("汪汪叫");
    }
}

1.1、抽象类--深入讨论

抽象类是java中一个比较重要的类。

1、用abstract关键字来修饰一个类时，这个类就是抽象类。

2、用abstract关键字来修饰一个方法时，这个方法就是抽象方法。

3、abstract抽象类中的abstract抽象方法是不允许在抽象类中实现的，一旦实现就不是抽象方法和抽象类了。abstract抽象方法只能在子类中实现。

4、抽象类中可以拥有实现方法。

5、抽象方法在编程中用的不是很多，但是在公司笔试时，却是考官比较爱问的知识点。

1.2、抽象类--注意事项

1、抽象类不能被实例化

2、抽象类不一定要包含abstract方法。也就是说，抽象类可以没有abstract抽象方法。

3、一旦类包含了abstract抽象方法，则这个类必须声明为abstract抽象类。

4、抽象方法不能有主体。

正确的抽象方法例：abstract void abc();

错语的抽象方法例：abstract void abc(){}

2、接口

2.1、什么是接口？

接口就是给出一些没有内容的方法，封装到一起，到某个类要使用的时候，在根据具体情况把这些方法写出来。

接口的建立语法：

interface 接口名{
    方法;
}

实现接口语法：

class 类名 implements 接口{
      方法;
      变量;
}

接口是更加抽象的抽象的类，抽象类里的方法可以有方法体，接口里的所有方法都没有方法体。接口体现了程序设计的多态和高内聚低偶合的设计思想。

案例：

//接口的实现[Demo125.java]
//电脑，相机，u盘，手机

//usb接口
interface Usb{
    int a=1;//加不加static都是静态的，不能用private和protected修饰
    //声明了两个方法
    public void start();//接口开始工作
    public void stop();//接口停止工作
}
//编写了一个相机类，并实现了usb接口
//一个重要的原则：当一个类实现了一个接口，要求该类把这个接口的所有方法全部实现
class Camera implements Usb{
    public void start(){
        System.out.println("我是相机，开始工作了..");
    }
    public void stop(){
        System.out.println("我是相机，停止工作了..");
    }
}
//接口继承别的接口
class Base{
}
interface Tt{
}
interface Son extends Tt{
}
//编写了一个手机，并实现了usb接口
class Phone implements Usb{
    public void start(){
        System.out.println("我是手机，开始工作了..");
    }
    public void stop(){
        System.out.println("我是手机，停止工作了..");
    }
}
//计算机
class Computer{
    //开始使用usb接口
    public void useUsb(Usb usb){
        usb.start();
        usb.stop();
    }
}
public class Demo125 {
    public static void main(String[] args) {
        System.out.println(Usb.a);
        //创建 Computer
        Computer computer=new Computer();
        //创建Camera
        Camera camera=new Camera();
        //创建Phone
        Phone phone=new Phone();
        computer.useUsb(camera);
        computer.useUsb(phone);
    }
}

注意事项

(1)、接口不能被实例化

(2)、接口中所有的方法都不能有主体。错误语法例：void aaa(){}←(注意不能有花括号)

接口可以看作更加抽象的抽象类。

(3)、一个类可以实现多个接口

(4)、接口中可以有变量[但变量不能用private和protected修饰]

a、接口中的变量，本质上都是static的而且是final类型的，不管你加不加static修饰

b、在java开发中，我们经常把常用的变量，定义在接口中，作为全局变量使用

访问形式：接口名.变量名

(5)、一个接口不能继承其它的类，但是可以继承别的接口

3、实现接口VS继承类

java的继承是单继承，也就是一个类最多只能有一个父类，这种单继承的机制可保证类的纯洁性，比C++中的多继承机制简洁。但是不可否认，对子类功能的扩展有一定影响。所以：

1、实现接口可以看作是对继承的一种补充。(继承是层级式的，不太灵活。修改某个类就会打破继承的平衡，而接口就没有这样的麻烦，因为它只针对实现接口的类才起作用)

2、实现接口可在不打破继承关系的前提下，对某个类功能扩展，非常灵活。

//实例：建立子类并继承了父类且连接多个接口[Demo126.java]
public class Demo126 {
    public static void main(String[] args) {
        System.out.println("继承了Monkey父类");
        Monkey mo=new Monkey();
        mo.jump();
        LittleMonkey li=new LittleMonkey();
        li.swimming();
        li.fly();
    }
}
//接口Fish
interface Fish{
    public void swimming();
}
//接口Bird
interface Bird{
    public void fly();
}
//建立Monkey类
class Monkey{
    int name;
    //猴子可以跳
    public void jump(){
        System.out.println("猴子会跳!");
    }
}
//建立LittleMonkey子类并继承了Monkey父类并连接了Fish和Bird接口
class LittleMonkey extends Monkey implements Fish,Bird{
    public void swimming() {
        System.out.println("连接了Fish接口!");
    }
    public void fly() {
        System.out.println("连接了Bird接口!");
    }
}

4、用接口实现多态

java中多态是个难以理解的概念，但同时又是一个非常重要的概念。java三大特性之一(继承，封装，多态)，我们可以从字面上简单理解：就是一种类型的多种状态，以下通过卖小汽车的例子说明什么是多态。

案例：

//用接口实现多态
public class Demo127 {
    public static void main(String []args){
        CarShop aShop=new CarShop();
        //卖出一辆宝马
        aShop.sellCar(new BMW());
        //卖出一辆奇瑞QQ
        aShop.sellCar(new CheryQQ());
        //卖出一辆桑塔纳
        aShop.sellCar(new Santana());
        System.out.println("总收入："+aShop.getMoney());
    }
}
//汽车接口
interface Car{
    //汽车名称
    String getName();
    //获得汽车售价
    int getPrice();
}
//宝马
class BMW implements Car{
    public String getName(){
        return "BMW";
    }
    public int getPrice(){
        return 300000;
    }
}
//奇瑞QQ
class CheryQQ implements Car{
    public String getName(){
        return "CheryQQ";
    }
    public int getPrice(){
        return 20000;
    }
}
//桑塔纳汽车
class Santana implements Car{
    public String getName(){
        return "Santana";
    }
    public int getPrice(){
        return 80000;
    }
}
//汽车出售店
class CarShop{
    //售车收入
    private int money=0;
    //卖出一部车
    public void sellCar(Car car){
     System.out.println("车型："+car.getName()+"单价："+car.getPrice());
        //增加卖出车售价的收入
        money+=car.getPrice();
    }
    //售车总收入
    public int getMoney(){
        return money;
    }
}

运行结果：
车型：BMW 单价：300000
车型：CheryQQ 单价：20000
总收入：320000

继承是多态得以实现的基础。从字面上理解，多态就是一种类型(都是Car类型)表现出多种状态(宝马汽车的名称是BMW，售价是300000；奇瑞汽车的名称是CheryQQ，售价是2000)。将一个方法调用同这个方法所属的主体(也就是对象或类)关联起来叫做绑定，分前期绑和后期绑定两种。下面解释一下它们的定义：

1、前期绑定：在程序运行之前进行绑定，由编译器和连接程序实现，又叫做静态绑定。比如static方法和final方法，注意，这里也包括private方法，因为它是隐式final的。

2、后期绑定：在运行时根据对象的类型进行绑定，由方法调用机制实现，因此又叫做动态绑定，或者运行时绑定。除了前期绑定外的所有方法都属于后期绑定。

多态就是在后期绑定这种机制上实现的。多态给我们带来的好处是消除了类之间的偶合关系，使程序更容易扩展。比如在上例中，新增加一种类型汽车的销售。只需要让新定义的类实现Car类并实现它的所有方法，而无需对原有代码做任何修改，CarShop类的sellCar(Carcar)方法就可以处理新的车型了。新增代码如下：

//桑塔纳汽车
class Santana implements Car{
    public String getName(){
        return "Santana";
    }
    public int getPrice(){
        return 80000;
    }
}

至此，关于类的定义又可以更进一步得到完善：

package 包名;
class 类名 extends 父类 implements 接口名{
        成员变量;
        构造方法;
        成员方法;
}