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

拼搏现实的明天。 2023-07-21 06:20 24阅读 0赞

## 抽象类 ##

抽象类的概念有人会觉得有些抽象，下面我将彻头彻尾的介绍抽象类的概念及其应用  
我们先来看下面这组代码  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MTM2MTg5_size_16_color_FFFFFF_t_70]  
在刚才的例子中, 我们发现，父类 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.只要这个类实现了该接口，那么你就可以进行向上转型

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

多个接口的实现可以配合继承来完成，该类连接了有几个接口，就要重写多少个方法  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MTM2MTg5_size_16_color_FFFFFF_t_70 1]  
下面是完整代码

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 方法，这样就可以实现几个对象属性的比较大小

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MTM2MTg5_size_16_color_FFFFFF_t_70]: /images/20230528/1c9e429a308e4f7d8e6cb8b0c304a4d1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MTM2MTg5_size_16_color_FFFFFF_t_70 1]: /images/20230528/089bd29630b9411e9165bff8faa87511.png