java面向对象——抽象类、接口

抽象类

抽象类的概念有人会觉得有些抽象，下面我将彻头彻尾的介绍抽象类的概念及其应用
我们先来看下面这组代码

在刚才的例子中, 我们发现，父类 Shape 中的 draw 方法好像并没有什么实际工作，主要的输出都是由Shape 的各种子类的 draw 方法来完成的。像这种没有实际工作的方法，我们可以把它设计成一个抽象方法，包含抽象方法的类我们称之为抽象类。

abstract class Shapes{
    public abstract void draw();
}

1.在 draw 方法前加上 abstract 关键字, 表示这是一个抽象方法. 同时抽象方法没有方法体(没有 { }, 不能执行具体代码).
2.对于包含抽象方法的类, 必须加上 abstract 关键字表示这是一个抽象类。

注意事项：

• 1.用关键字abstract进行修饰
• 2.在抽象类中，可以有普通类的所有属性
• 3.和普通类不一样的地方是：包含了抽象方法
• 4.不能被实例化：不能new
• 5.主要作用就是被继承
• 6.不能用final修饰
• 7.不能是私有的，不能是static的
• 8.只要是有一个类，继承了这个抽象类，那么必须重写抽象类中的方法

下面来看一下代码的执行应用：

abstract class Shapes{
    public abstract void draw();
}

class Cycles extends Shapes{
    @Override
    public void draw(){
        System.out.println("这是一个圆");
    }
}
class Rects extends Shapes{
    @Override
    public void draw(){
        System.out.println("这是一个矩形");
    }
}

public class TextDemo3 {
    public static void main(String[] args) {
        Shapes[] shapes2 = {new Cycles(), new Rects()};
        for (Shapes shape : shapes2) {
            shape.draw();
        }
    }
}

输出结果：
这是一个圆
这是一个矩形

抽象类主要的作用是继承，需要注意的是，继承后必须在子类的里面进行重写！！

接口

接口是抽象类的更进一步. 抽象类中还可以包含非抽象方法, 和字段. 而接口中包含的方法都是抽象方法, 字段只能包含静态常量。

下面是接口的具体实现方法

interface Shape{
    void draw();//有几个这种方法，下面重写多少个
}
class Cycle implements Shape{
    @Override
    public void draw(){
        System.out.println("这是一个圆");
    }
}
class Rect implements Shape {
    @Override
    public void draw(){
        System.out.println("这是一个矩形");
    }
}
public class TestDemo1 {
    public static void main(String[] args) {
        Shape shape1 = new Cycle();
        shape1.draw();
    }
}

注意事项

1.使用 interface 定义一个接口
2.接口中的方法一定是抽象方法, 因此可以省略 abstract
3.接口中的方法一定是 public, 因此可以省略 public
4.Cycle 使用 implements 继承接口. 此时表达的含义不再是 “扩展”, 而是 “实现”
5.在调用的时候同样可以创建一个接口的引用, 对应到一个子类的实例.
6 接口不能被实例化
7 在接口中不能定义已经实现的方法
8 实现了该接口，一定重写该接口中的方法
9 接口和接口之间可以通过extends进行联系

补充：

1.接口中的方法都是抽象方法
2.其实可以有具体实现的方法（再jdk1，8加入的）,方法前面加上default：（一般情况不用）
default public void func(){}
3.接口中定义的成员变量默认为常量 ，需要初始化
4.接口中的成员变量，默认为public static final
接口中的成员方法默认为： public abstract
5.接口是不可以用来实例化
6.接口和类之间的关系为implements
7.解决java中的单继承问题，可以实现多个接口
8.只要这个类实现了该接口，那么你就可以进行向上转型

实现多个接口（可以实现多继承）

多个接口的实现可以配合继承来完成，该类连接了有几个接口，就要重写多少个方法

下面是完整代码

class Animal{
    public String name;
    public Animal(String name){
        this.name = name;
    }
}

interface Flying{
    void fiy();
}
interface Jumping{
    void jup();
}
interface Swimming{
    void swim();
}

class Dog extends Animal implements Swimming{
    public Dog(String name){
        super(name);
    }
    @Override
    public void swim() {
        System.out.println(this.name +"会游泳");
    }
}
class Bird extends Animal implements Jumping,Flying{
    public Bird(String name){
        super(name);
    }
    @Override
    public void fiy() {
        System.out.println(this.name +"会飞");
    }
    @Override
    public void jup() {
        System.out.println(this.name + "会跳");

    }
}

public class MoreImp {
    public static void jum(Jumping jumping){
        jumping.jup();
    }
    public static void swim(Swimming swimming){
        swimming.swim();
    }
    public static void fly(Flying flying){
        flying.fiy();
    }
    public static void main(String[] args) {
        Dog dog = new Dog("露露");
        swim(dog);
        Bird bird = new Bird("huahua");
        fly(bird);
        jum(bird);
    }
}

接口使用示例（综合）

如果想比较一串数字的大小，并且从小到大输出，我们自然想到了以下函数

Arrays.sort();

但是如果想比较一个学生的分数、姓名等属性，应该怎么去写呢，下面是完整代码

自定义比较用Comparable或者Comparator接口

import java.util.Arrays;
//**自定义比较用Comparable接口**
class Student implements Comparable<Student>{
    public String name;
    public int age;
    public int score;

    public Student(String name, int age, int score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                '}';
    }

    @Override
    public int compareTo(Student o) {
        if(this.age<o.age){
            return -1;
        }
        if (this.age==o.age){
            return 0;
        }
        return 1;
    }
    //或者是以下几种
    // return this.age - o.age;//根据年龄从小到大（前面跟后面比）
    //return this.score - o.score;//根据分数从小到大
    //return this.name.compareTo(o.name);//字符串的比较大小
    }
public class TestDemocracy {
    public static void main(String[] args) {
        Student[] student = new Student[3];
        student[0] = new Student("bit",10,32);
        student[1] = new Student("bi",13,38);
        student[2] = new Student("b",14,34);

        Arrays.sort(student);//比较
        System.out.println(Arrays.toString(student));
    }
}

其中：其中Student 类实现 Comparable 接口, 并实现其中的 compareTo 方法，这样就可以实现几个对象属性的比较大小