抽象类

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

在刚才的例子中, 我们发现，父类 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 方法，这样就可以实现几个对象属性的比较大小