欢迎大家来这次博客-----抽象类和接口。 

1.抽象类

1.1 抽象类概念

在Java中我们都是通过类来描述对象，但反过来并不是所有的类都是用来描述对象的。当一个类中没有足够的信息来描述一个具体对象，我们就将该类称为抽象类。

如上图中的Shape类，我们想通过Shape类中的draw()方法来实现画各种图形，但由于Shape类不是具体的图形，所以Shape类中的draw()方法也无法实现画各种图形，所以我们将Shape类设置成抽象类。

代码演示

<code>abstract class Shape{

public abstract void draw();

}

class Triangle extends Shape{

@Override

public void draw() {

System.out.println("画一个三角形");

}

}

class Cycle extends Shape{

@Override

public void draw() {

System.out.println("画一个圆");

}

}

class Rect extends Shape{

@Override

public void draw() {

System.out.println("画一个矩形");

}

}

public class Test {

public static void main(String[] args) {

Shape[] shapes={new Triangle(), new Cycle(), new Rect()};

for(Shape shape:shapes){

shape.draw();

}

}

}

代码演示

<code>abstract class Animal{

public abstract void Bark();

}

class Dog extends Animal{

@Override

public void Bark() {

System.out.println("小狗在汪汪叫");

}

}

class Cat extends Animal{

@Override

public void Bark() {

System.out.println("小猫在喵喵叫");

}

}

public class Test {

public static void func(Animal animal){

animal.Bark();

}

public static void main(String[] args) {

Dog dog=new Dog();

func(dog);

Cat cat=new Cat();

func(cat);

}

}

注意，如以上代码有些地方看不懂，后面回一 一介绍。

1.2 抽象类语法

在Java中，当一个类被关键字abstract修饰，该类就被称为抽象类，抽象类中如果有方法被abstract修饰，则该方法就被称为抽象方法，抽象方法不需要具体实现。

//抽象类

abstract class Animal{

//抽象方法

public abstract void Bark();

}

注意事项：

抽象类中也可以包含普通的方法，甚至也可以包含构造方法。 

1.3 抽象类的特性

1. 抽象类不能实例化对象

2. 抽象方法不能被private修饰。

3. 抽象方法不能被final和static修饰，因为子类要重写抽象方法。

4. 抽象类必须被继承，继承抽象类的子类必须重写抽象类中的抽象方法。否则子类也是抽象类，必须用abstract修饰。

5. 抽象类中不一定有抽象方法，但有抽象方法的类一定是抽象类。

6. 抽象类中可以有构造方法，供子类创建对象时，初始化父类的成员变量。

1.4 抽象类的作用

抽象类本身是不能实例化的，要想使用抽象类，必须需要继承的子类重写抽象类中的抽象方法。

有人这时候就很疑惑，普通类不是也能被继承吗？

确实如此，但是使用抽象类多了一层编译器的校验。

如上面的代码，我们完成的操作都是由子类去完成的，但是如果交由父类去完成，普通编译器是不会报错的，但使用了抽象类，父类在实例化的时候就会报错，起到一个提醒的作用。

2. 接口

2.1 接口的概念

在生活中，接口比比皆是，如插座，USB插口。

接口通俗来说就是一种固定行为规范，只要你的操作符合规范，就能使用接口。

在Java中，接口可以看作为多个类的行为规范，是一种引用数据类型。 

2.2 接口的语法规则

关键字interface  接口名字

举例，如下图，

2.3 接口的特性

1.接口是一种引用数据类型，但是不能直接new关键字来创建对象。

2.接口中的每一个方法都是默认由public abstract 修饰的，也就是说接口中的方法不能被其他关键字修饰。（可以不写修饰接口中方法的关键字，编译器默认为public abstract）

3. 接口中的方法不能在接口中实现，只能在使用接口的类中实现。（有特殊情况）

 4. 如果接口中的方法被default或者static修饰，可以有具体实现。

5.  重写接口中的方法时，不能使用默认的访问权限。

6. 接口中可以含有变量，但会默认为被 public static final 修饰。  

7. 接口中不能含有静态代码块和构造方法

8.如果类中没有重写接口中所有的抽象方法，则该类要用abstract修饰。

9.接口虽然不是类，但接口编译完成后的字节码文件的后缀也是 .java 。

2.4 接口的使用

接口不能直接使用，必须要有一个 “实现类” 来重写接口中的抽象方法，通过这个实现类来使用接口。

如果一个类想使用一个接口，要用到implements关键字。

语法格式

<code>public class 类名称 implements 接口名称{

// ...

}

注意：父类与子类之间的关系为extends，类与接口之间的关系为implements。

实现一个USB接口

<code>interface USB{

void close();

void open();

}

class Mouse implements USB{

@Override

public void close() {

System.out.println("关闭鼠标");

}

public void open(){

System.out.println("打开鼠标");

}

public void click(){

System.out.println("点击鼠标");

}

}

class KeyBoard implements USB{

public void close(){

System.out.println("关闭键盘");

}

@Override

public void open() {

System.out.println("开启键盘");

}

public void input(){

System.out.println("输入功能");

}

}

class Computer implements USB{

@Override

public void close() {

System.out.println("关闭电脑");

}

public void open(){

System.out.println("打开电脑");

}

public void use(USB usb){

usb.open();

if(usb instanceof Mouse){

((Mouse) usb).click();

}else{

((KeyBoard)usb).input();

}

usb.close();

}

}

public class Test {

public static void main(String[] args) {

Computer computer=new Computer();

computer.open();

USB usb1=new Mouse();

computer.use(usb1);

System.out.println("=======");

USB usb2=new KeyBoard();

computer.use(usb2);

computer.close();

}

}

2.5  实现多个接口

一个类不能同时继承多个类，但是一个类可以同时使用多个接口。

举个例子：用Java来描述鸭子会飞，会游泳和会跑。

我们可以将会飞，会游泳，会跑设置为三个接口。

ISwimming接口

<code>public interface ISwimming {

void swim();

}

IRunning接口

public interface IRunning {

void run();

}

IFly接口

public interface IFly {

void fly();

}

Duck类

public class Duck extends Animal implements IFly,IRunning,ISwimming{

public Duck(String name){

super(name);

}

@Override

public void fly() {

System.out.println(this.name+"会飞");

}

@Override

public void run() {

System.out.println(this.name+"会跑");

}

@Override

public void swim() {

System.out.println(this.name+"会游泳");

}

}

测试类

public class Test {

public static void main(String[] args) {

Duck duck=new Duck("小鸭");

duck.fly();

duck.run();

duck.swim();

}

}

 快捷操作：CTRL+I键 快速实现接口

 使用接口的好处就是可以让程序员忘记类的限制，只需要关注该类有没有此接口对应的功能。

<code>class Robot implements IRunning{

@Override

public void run() {

System.out.println("机器人再跑1");

}

}

public class Test {

public static void func(IRunning running){

running.run();

}

public static void main(String[] args) {

Duck duck=new Duck("小鸭");

func(duck);

Robot robot=new Robot();

func(robot);

}

}

如以上代码，我们给func函数穿的参数可以是Duck类，也可以是Robot类，只要这两个类具备跑的能力就行了。

2.6 接口之间的继承

在Java中，类与类之间只允许单继承，不允许多继承。但是对于接口来说，接口之间既可以单继承，也可以多继承。

接口之间的继承也是用到extends关键字。

 代码演示

<code>interface Double extends IRunning,ISwimming{

}

class Dog implements Double{

@Override

public void run() {

System.out.println("狗会跑");

}

@Override

public void swim() {

System.out.println("狗会游泳");

}

}

public class Test {

public static void main(String[] args) {

Dog dog=new Dog();

dog.run();

dog.swim();

}

}

到此，抽象类和接口的基础内容就介绍完了，感谢观看。