Java基础之面向对象详细讲解（6)——抽象、接口

1、抽象

1.1、抽象

抽象：现实中不存在的东西

只需要声明而不进行实现，因为对于一个抽象的东西，是找不到一组与之对应的属性。

抽象方法：使用abstract来修饰的方法，不需要进行实现，只进行声明。

抽象类：如果一个类中有抽象方法，那么这个类就是抽象类

特点：

1.抽象类不可以创建对象，没有与之对应的具体的东西

2.抽象类的子类，必须重写父类中的抽象方法，除非，子类也是抽象类（因此，通过该方法，可以强制要求子类中用有一些方法）

3.抽象类中可以有正常的方法

1.2、代码助理解

cat.java

package AbstractTest;

public class cat extends animal{
    //因为继承了animal这个抽象类，所以必须重写抽象类中的抽象方法
    @Override
    public void eat() {
        System.out.println("猫猫吃");
    }
}

animal.java

package AbstractTest;
//抽象类
public abstract class animal {
    //抽象方法
    public abstract void eat();
    //普通方法
    public void play(){

    };
}

插入——final

被final（最终的变量）饰的变量以及方法不能再次更改或者重写

2、接口

2.1、接口

2.1.1、是什么

接口实际上是一种特殊的抽象类

接口中所有方法自动默认为抽象方法（不需要再重复写abstracts，写了也不错）

接口不用class而使用interface

接口的继承不用extends而是使用implements

2.1.2、为什么要有接口

可以发现，继承和接口有着很大的相似性，那么为什么还要有接口呢？这是因为接口可以多实现（继承）但是类的继承只能继承一个！！

2.1.3、特点

接口中所有的方法都是抽象方法，都是公开的

接口中所有的变量都是全局静态（public static final）变量

2.2、代码助理解

main.java

package AbstractTest;

public class main {
    public static void main(String[] args) {
        animal animal_cat = new cat();//接口也具有多态性
        cat_class cat_class_cat = new cat();//接口也具有多态性
        cat cat = new cat();//接口也具有多态性
        Pets pets_cat = new cat();//接口也具有多态性

        animal_cat.play();
        animal_cat.eat();
        ((cat) animal_cat).climb_up();
        ((cat) animal_cat).cute();

        ((cat)cat_class_cat).play();
        ((cat)cat_class_cat).eat();
        cat_class_cat.climb_up();
        ((cat) animal_cat).cute();

        ((cat)pets_cat).play();
        ((cat)pets_cat).eat();
        ((cat)pets_cat).climb_up();
        pets_cat.cute();

        cat.eat();
        cat.play();
        cat.climb_up();
        cat.cute();

    }
}

animal.java

package AbstractTest;
//接口，一个特殊的类
public interface animal {
    //抽象方法
    void eat();
    void play();
}

cat_class.java

package AbstractTest;
//只有接口才能通过extends继承接口
public interface cat_class /*extends animal*/ {
    void climb_up();
}

cat.java

package AbstractTest;
//普通类继承接口使用implements，
// 这个过程不再叫做继承，而被称作实现
// 类可以继承一个类，实现多个接口
public class cat extends Pets implements animal,cat_class {
    //因为了实现了animal这个几口，所以必须实现抽象类中的抽象方法
    //重写接口中的抽象方法也叫做实现
    @Override
    public void eat() {
        System.out.println("猫猫吃");
    }

    @Override
    public void play() {
        System.out.println("猫猫玩");
    }

    @Override
    public void climb_up() {
        System.out.println("猫猫爬树");
    }

    public void cute() {
        System.out.println("猫猫很可爱");
    }
}

Pets.java

package AbstractTest;

public class Pets {
    public void cute(){
        System.out.println("宠物会撒娇");
    }
}