Java之抽象类与接口

一、抽象类

(一)、抽象类的基本概念

在面对对象的概念中，所以的对象都是通过与之对应的类来描述的，但是不是所有的类都可以用于描述对象的，普通类是一个完善的功能类，可以直接产生实例化对象，并且在普通类中可以包含有构造方法、普通方法、static方法、常量和变量等内容去更加完整的描述一个对象，而没有包含足够的信息来描述一个对象的类，就是称为抽象类

(二)、抽象类的语法

博主直接给出范例：

abstract class A{//定义一个抽象类
    int a = 0;
	
	public void fun(){//普通方法
		System.out.println("存在方法体的方法");
	}
	
	public abstract void print();//抽象方法，没有方法体，有abstract关键字做修饰
	
}

注意： 抽象类中也可以包含普通方法和属性，甚至构造方法

(三)、抽象类的特性总结

1、抽象类是不能实例化对象

2、抽象方法不能被private修饰

原因:子类继承抽象类，要重写父类的抽象方法，另外在不写访问限定符时候，默认是public

3.抽象方法不能被final和static修饰

原因:子类继承抽象类，要重写父类的抽象方法

4、抽象类如果被继承，子类要重写父类所有的抽象方法，如果子类不重写，就必须要使用abstract修饰符修饰

5、抽象类不一定要有抽象方法，但是有抽象方法的类必须是抽象类

6、抽象类不能被final修饰，因为final定义的类必须要有子类

(四)、抽象类的使用案例

加油站支付卡案例

1、需求

（1）某加油站推出了两种支付卡，一种是预存10000的金卡,后续加油享受8折优惠;一种是预存5000的银卡,后续加油享受8.5折优惠

（2）请分别实现两种卡片进入收银系统后的逻辑,卡片需要包含主人的姓名、余额、支付功能

2、分析

（1）创建一张普通卡作为父类:定义属性包含卡主姓名,余额,支付功能（具体的现交给子类）

（2）创建一张金卡类:重写支付功能,按照原价的8折计算输出

（3）创建一张银卡类:重写支付功能,按照原价的8.5折计算输出

//父类
abstract class Card {
    private String userName;
    private double money;
    /*
        定义一个支付方法，具体的实现有子类去完成，因为不同的卡支付规则不一样
     */
    public abstract void pay(double money2);

    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
    public double getMoney() {
        return money;
    }
    public void setMoney(double money) {
        this.money = money;
    }
}

//金卡
class GoldCard extends Card{
    @Override
    public void pay(double money2) {
        System.out.println("您当前消费: " + money2);
        System.out.println("您的金卡当前余额是: " + getMoney());
        double rs1 = money2 * 0.8;
        System.out.println(getUserName() + "您实际支付:" + rs1);
        //更新账户余额
        setMoney(getMoney() - rs1);
    }
}

//银卡
class SilverCard extends Card{
    @Override
    public void pay(double money2) {
        System.out.println("您当前消费: " + money2);
        System.out.println("您的银卡当前余额是: " + getMoney());
        double rs2 = money2 * 0.85;
        System.out.println(getUserName() + "您实际支付:" + rs2);
        //更新账户余额
        setMoney(getMoney() - rs2);
    }
}

//测试类
class Test {
    public static void main(String[] args) {
        GoldCard gc = new GoldCard();
        gc.setMoney(10000);
        gc.setUserName("小周");
        gc.pay(300);
        System.out.println("剩余: " + gc.getMoney());
        System.out.println("--------------------------");
        SilverCard sc = new SilverCard();
        sc .setMoney(5000);
        sc .setUserName("小李");
        sc .pay(500);
        System.out.println("剩余: " + sc .getMoney());
    }
}

 

二、接口

 (一)、接口的概念

Java官方解释:接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）

博主的理解是:接口就是统一的一种标准，我们只要遵守这个标准去使用接口，根据不同的事物的使用，就可以体现出不同的功能，例如电脑的USB插口，只要是符合USB标准规范的设备都可以与之链接，并且体现出不同的功能或者作用

(二)、接口的特点

接口就像一个类一样，故而一个接口也能够拥有方法和属性，但是在接口中声明的方法默认是抽象的。（即只有方法标识符，而没有方法体）

● 接口就像一个蓝图一样的东西，有了蓝图，类就会被告知怎么做和不能做什么

● 一个接口就是一种能力的描述，就比如"跑"可以作为一个接口，并且任何实现“跑”接口的类都必须有能力实现奔跑这个动作（或者implement run()方法，所以接口的作用就是告诉类，你要实现我这种接口代表的功能，你就必须实现某些方法，我才能承认你确实拥有该接口代表的某种能力。

● 如果一个类实现了一个接口中要求的所有的抽象方法，然而没有提供方法体而仅仅只有方法标识，那么这个类一定是一个抽象类。（必须记住：抽象方法只能存在于抽象类或者接口中，但抽象类中却能存在非抽象方法，即有方法体的方法。接口是百分之百的抽象类）

● 举一个Java库中常见的接口的例子:Comparator 接口，这个接口代表了“进行比较”这种能力，任何类只要实现了这个Comparator接口的话，这个类也具备了“比较”这种能力，那么就可以用来进行排序操作了

(三)、接口存在的意义

1、最重要的一点：Java不能像C++那样实现多继承，而接口恰好可以来弥补这个局限性，并且接口也可以存在继承的关系，继承的方式参照Java的类的继承关系

2、接口可以用来降低耦合度(博主自己的看法)

(四)、接口的语法

1、接口的定义

通过interface关键字+接口名的方式定义

2、接口的实现

通过在一个类的创建后面加上implements关键字+接口名的形式

(五)、接口使用案例

interface Animal {
   public void eat();
   public void travel();
}

public class Mammal implements Animal{
 
   public void eat(){
      System.out.println("Mammal eats");
   }
 
   public void travel(){
      System.out.println("Mammal travels");
   } 
 
   public int noOfLegs(){
      return 0;
   }
 
   public static void main(String args[]){
      Mammal m = new Mammal();
      m.eat();
      m.travel();
   }
}

三、抽象类和接口的区别

1. 抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。

2. 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。

3. 接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。

4. 一个类只能继承一个抽象类，而一个类却可以实现多个接口。

注：JDK 1.8 以后，接口里可以有静态方法和方法体了。

注：JDK 1.8 以后，接口允许包含具体实现的方法，该方法称为"默认方法"，默认方法使用 default 关键字修饰。更多内容可参考 Java 8 默认方法。

注：JDK 1.9 以后，允许将方法定义为 private，使得某些复用的代码不会把方法暴露出去。更多内容可参考 Java 9 私有接口方法。