类和对象进阶 - 接口

最新推荐文章于 2024-07-14 14:59:27 发布
最新推荐文章于 2024-07-14 14:59:27 发布
阅读量19 收藏
点赞数
分类专栏： JavaSE 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xumu1_/article/details/134350258
版权

1. 接口

1.1 接口定义与重点

1. 使用 interface关键字定义接口

public interface 接口名称{
    
}

2. 接口中的方法不能有具体的实现

不能有具体的实现 是因为接口中的方法默认都是抽象方法

3. 如果要有具体实现 必须用default / static修饰 

4. 在接口中定义的成员变量 默认都是用public static final修饰的常量

5. 接口中的抽象方法 默认都是用public abstract修饰的

7. 接口不能用来实例化对象

8. 类和接口之间的关系 可以使用implements来关联

9. 一个类 继承一个普通类/抽象类 还可以同时关联接口

10. 一个类实现接口后 必须重写接口中的抽象方法

11.  如果类没有实现接口中的所有的抽象方法，则类必须设置为抽象类

12. 接口和接口之间可以使用关键字extends。表示某个接口拓展了某个接口的功能。
interface A extends B,C,D {}   

13. 子类继承抽象类或者关联接口后，可以用抽象类/接口引用 引用子类对象 发生向上转型 

1.2 理解接口

完整代码:

https://github.com/znxcmakhsd/JavaSE-code/tree/main/11-23/demo2

1.3 抽象类和接口的区别

1. 抽象类中可以有普通的成员变量和方法 但是接口中的成员变量只能是public static final 接口中的成员方法只能是public abstract抽象方法

2. 一个类只能继承一个抽象类 但是一个类可以实现多个接口 所以接口解决了java中不能多继承的问题

2. 几个重要的接口

2.1 comparable接口

如何比较两个对象的大小 ?

用 > 比较运算符 ? 


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

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

}

public class Main {
    public static void main(String[] args) {
        Student student1 = new Student("abc",18);
        Student student2 = new Student("abd",19);
        if (student1 > student2) {
            System.out.println("student1 > student2");
        }
    }
}

不能用>比较对象 因为比较运算符两边的操作数只能是 基本类型整数或浮点数 
比如: 1 > 2  1.1 > 1.2

那么 用什么办法比较对象 ？

这个问题稍后回答 先来看如何比较两个字符串大小

package demo2;

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

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

}

public class Main {
    public static void main(String[] args) {
        Student student1 = new Student("abc",18);
        Student student2 = new Student("abd",19);

        String str1 = "abc";
        String str2 = "abd";
        if (str1.compareTo(str2) >= 0) {
            System.out.println("str1 >= str2");
        }else {
            System.out.println("str1 < str2");
        }

    }
}

如图 str1 < str2 成功比较出了字符串的大小 但是 它是怎么比较的 原理是什么?

首先java中的字符串是对象 str1是"abc"这个字符串对象的引用 所以str1这个对象的引用可以访问String类中的方法 

String类实现了Compareable这个接口 然后重写了Compareable接口中的compareTo方法 如下图

所以 比较字符串大小 实际上调用的是String类自己的compareTo方法进行比较的

我们也可以模仿这种方法 对我们自己的对象进行比较

package demo2;

class Student implements Comparable<Student>{
    public String name;
    public int age;
    public Student(String name,int age) {
        this.name = name;
        this.age = age;
    }

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

    @Override
    public int compareTo(Student o) {
        // 用名字进行比较
        //return this.name.compareTo(o.name);
        // 用年龄进行比较
        return this.age - this.age;
    }
}

public class Main {
    public static void main(String[] args) {
        Student student1 = new Student("abc",20);
        Student student2 = new Student("abd",19);
        if (student1.compareTo(student2) >= 0) {
            System.out.println("student1 >= student2");
        }else {
            System.out.println("student1 < student2");
        }
    }
}

用名字比较:

用年龄进行比较:

接下来 有个重要的问题是 为什么一定要实现compareable这个接口 ?

我们自己是可以写一个函数进行比较的 如下例

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

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

    /*@Override
    public int compareTo(Student o) {
        // 用名字进行比较
        //return this.name.compareTo(o.name);
        // 用年龄进行比较
        return this.age - this.age;
    }*/
    public int my_compareTo(Student o){
        // 用名字进行比较
        //return this.name.compareTo(o.name);
        // 用年龄进行比较
        return this.age - this.age;
    }
}

public class Main {
    public static void main(String[] args) {
        Student student1 = new Student("abc",20);
        Student student2 = new Student("abd",19);

        if (student1.my_compareTo(student2) >= 0) {
            System.out.println("student1 >= student2");
        }else {
            System.out.println("student1 < student2");
        }
    }
}

这个问题的回答通过下例说明

package demo2;

import java.util.Arrays;

class Student /*implements Comparable<Student>*/{
    public String name;
    public int age;
    public Student(String name,int age) {
        this.name = name;
        this.age = age;
    }

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

    /*@Override
    public int compareTo(Student o) {
        // 用名字进行比较
        //return this.name.compareTo(o.name);
        // 用年龄进行比较
        return this.age - o.age;
    }*/

    public int my_compareTo(Student o){
        // 用名字进行比较
        //return this.name.compareTo(o.name);
        // 用年龄进行比较
        return this.age - o.age;
    }

}

public class Main {
    public static void main(String[] args) {
        Student student1 = new Student("a",20);
        Student student2 = new Student("c",19);
        Student student3 = new Student("b",21);
        Student[] arr = {student1,student2,student3};
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
    }

    /*public static void main1(String[] args) {
        Student student1 = new Student("abc",20);
        Student student2 = new Student("abd",19);

        if (student1.my_compareTo(student2) >= 0) {
            System.out.println("student1 >= student2");
        }else {
            System.out.println("student1 < student2");
        }
    }*/
}

如图报错 报错的原因是什么？

package demo2;

import java.util.Arrays;

class Student implements Comparable<Student>{
    public String name;
    public int age;
    public Student(String name,int age) {
        this.name = name;
        this.age = age;
    }

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

    @Override
    public int compareTo(Student o) {
        // 用名字进行比较
        //return this.name.compareTo(o.name);
        // 用年龄进行比较
        return this.age - o.age;
    }

    public int my_compareTo(Student o){
        // 用名字进行比较
        //return this.name.compareTo(o.name);
        // 用年龄进行比较
        return this.age - o.age;
    }

}

public class Main {
    public static void main(String[] args) {
        Student student1 = new Student("a",20);
        Student student2 = new Student("c",19);
        Student student3 = new Student("b",21);
        Student[] arr = {student1,student2,student3};
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
    }

    /*public static void main1(String[] args) {
        Student student1 = new Student("abc",20);
        Student student2 = new Student("abd",19);

        if (student1.my_compareTo(student2) >= 0) {
            System.out.println("student1 >= student2");
        }else {
            System.out.println("student1 < student2");
        }
    }*/
}

也可以自己实现排序

package demo2;

import java.util.Arrays;

class Student implements Comparable<Student>{
    public String name;
    public int age;
    public Student(String name,int age) {
        this.name = name;
        this.age = age;
    }

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

    @Override
    public int compareTo(Student o) {
        // 用名字进行比较
        //return this.name.compareTo(o.name);
        // 用年龄进行比较
        return this.age - o.age;
    }

    public int my_compareTo(Student o){
        // 用名字进行比较
        //return this.name.compareTo(o.name);
        // 用年龄进行比较
        return this.age - o.age;
    }

}

public class Main {
    public static void my_sort(Comparable[] comparables) {
        for (int i = 0;i < comparables.length;i++) {
            for (int j = 0;j < comparables.length-i-1;j++) {
                if (comparables[j].compareTo(comparables[j+1]) > 0) {
                    Comparable tmp = comparables[j];
                    comparables[j] = comparables[j+1];
                    comparables[j+1] = tmp;
                }
            }
        }
    }
    public static void main(String[] args) {
        Student student1 = new Student("a",20);
        Student student2 = new Student("c",19);
        Student student3 = new Student("b",21);
        Comparable[] arr = {student1,student2,student3};
        /*Arrays.sort(arr);*/
        my_sort(arr);
        System.out.println(Arrays.toString(arr));
    }

    /*public static void main1(String[] args) {
        Student student1 = new Student("abc",20);
        Student student2 = new Student("abd",19);

        if (student1.my_compareTo(student2) >= 0) {
            System.out.println("student1 >= student2");
        }else {
            System.out.println("student1 < student2");
        }
    }*/
}

2.2 comparator 接口

comparable接口 有个不好的地方 如下图

comparator 接口可以很好解决这个问题 如下例

import java.util.Arrays;
import java.util.Comparator;

class Student implements Comparable<Student>{
    public String name;
    public int age;
    public Student(String name,int age) {
        this.name = name;
        this.age = age;
    }

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

    @Override
    public int compareTo(Student o) {
        // 用名字进行比较
        //return this.name.compareTo(o.name);
        // 用年龄进行比较
        return this.age - o.age;
    }
}

// 以年龄排序
class AgeComparator implements Comparator<Student> {
    @Override
    public int compare(Student o1, Student o2) {
        return o1.age - o2.age;
    }
}

// 以名字排序
class NameComparator implements Comparator<Student> {
    @Override
    public int compare(Student o1, Student o2) {
        return o1.name.compareTo(o2.name);
    }
}

public class Main {
    public static void main(String[] args) {
        Student student1 = new Student("a", 20);
        Student student2 = new Student("c", 19);
        Student student3 = new Student("b", 21);

        Student[] students = {student1, student2, student3};

        // 比较器的使用
        AgeComparator ageComparator = new AgeComparator();
        NameComparator nameComparator = new NameComparator();

        System.out.println(ageComparator.compare(student1, student2));
        System.out.println(nameComparator.compare(student1, student2));
        System.out.println("================================");

        // 传入比较器排序
        Arrays.sort(students,ageComparator);
        System.out.println(Arrays.toString(students));
        System.out.println("================================");
        Arrays.sort(students,nameComparator);
        System.out.println(Arrays.toString(students));
    }

}

2.3 Clonable接口和深浅拷贝

浅拷贝

问题引入:

报错的原因是什么 ? 如何实现拷贝 ?

报错原因有4个

class Person implements Cloneable {
    public String name;

    public Person(String name) {
        this.name = name;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

public class Main {
    public static void main(String[] args) throws CloneNotSupportedException{
        Person person1 = new Person("a");
        Person person2 = (Person) person1.clone();
        System.out.println(person2.name);
    }
}

深拷贝

什么是深拷贝 ? 如何实现一个深拷贝 ?

package test;

class Identity implements Cloneable {
    public int id = 1;

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

class Person implements Cloneable {
    public String name;
    public Identity identity;

    public Person(String name) {
        this.name = name;
        this.identity = new Identity();
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Person tmp = (Person) super.clone();
        tmp.identity = (Identity) this.identity.clone();
        return (Object) tmp;
    }
}

public class Main {
    public static void main(String[] args) throws CloneNotSupportedException{
        Person person1 = new Person("a");
        Person person2 = (Person) person1.clone();
        System.out.println("修改之前:  " + person1.identity.id);
        System.out.println("修改之前: " + person2.identity.id);
        System.out.println("=============================");
        person2.identity.id = 2;
        System.out.println("修改之后:  " + person1.identity.id);
        System.out.println("修改之后: " + person2.identity.id);
    }
    public static void main1(String[] args) throws CloneNotSupportedException{
        Person person1 = new Person("a");
        Person person2 = (Person) person1.clone();
        System.out.println(person2.name);
    }
}

 

许木1
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
5.2 jmu-Java-04面向对象进阶--02-接口-Comparator (5 分)
wzy992981933的博客
04-22 918
Arrays.sort可以对所有实现Comparable的对象进行排序。但如果有多种排序需求，如有时候需对name进行降序排序，有时候只需要对年龄进行排序。使用Comparable无法满足这样的需求。可以编写不同的Comparator来满足多样的排序需求。 1.编写PersonSortable2类 属性：private name(String)、private age(int) 有参构造函数：参数为name,age toString方法：返回格式name-age 2 编写Comparator类 编写
7-2 jmu-Java-04面向对象进阶-01-接口-Comparable
一个恶意卖萌的博客
05-09 3247
7-2 jmu-Java-04面向对象进阶-01-接口-Comparable 问题描述： Arrays.sort不能对自定义对象进行排序。现希望对自定义的PersonSortable类的对象，使用Arrays.sort进行排序。 1.编写PersonSortable类 属性：private name(String)、private age(int) 有参构造函数：参数为name,age toStr...
【2023.6.2练习】面向对象进阶-接口-匿名内部类ActionListener
FeAtherHZM的博客
06-02 544
这道题出的不太好，因为对于题目给出的陌生接口ActionListener，并没有说明清楚必须要用ActionPerformed重写方法，导致解题出现未知阻碍。
7-1 jmu-Java-04面向对象进阶-01-接口-Comparable (5分)
Jay_fearless的博客
06-28 3699
编写实现Comparable接口的PersonSortable类，使其按name以及age排序 1.编写PersonSortable类 属性：private name(String)、private age(int) 有参构造函数：参数为name,age toString函数：返回格式为：name-age 实现Comparable接口：实现先对name升序排序，如果name相同则对age进行升序排序 2.main方法中 首先输入n 输入n行name age，并创建n个对象放入数组 对数组进行排序后输出。 最
Java PTA练习:jmu-Java-04面向对象进阶-03-接口-自定义接口ArrayIntegerStack
黄佳俊的博客
10-27 1094
定义IntegerStack接口，用于声明一个存放Integer元素的栈的常见方法: public Integer push(Integer item); //如果item为null，则不入栈直接返回null。如果栈满，也返回null。如果插入成功，返回item。 public Integer pop(); //出栈，如果为空，则返回null。出栈时只移动栈顶指针，相应位置不置为null public Integer peek(); //获得栈顶元素，如果为空，则返回null. public b
jmu-Java-04面向对象进阶-03-接口-自定义接口ArrayIntegerStack
黑白的黒's Blog
10-05 3264
定义IntegerStack接口，用于描述一个存放Integer元素的栈的常见方法: public Integer push(Integer item); //如果item为null，则不入栈直接返回null。如果栈满，也返回null。如果插入成功，返回item。 public Integer pop(); //出栈，如果为空，则返回null。出栈时只移动栈顶指针，相应位置不置为null public Integer peek(); //获得栈顶元素，如果为空，则返回null. public boo
7-2 jmu-Java-04面向对象进阶-03-接口-自定义接口ArrayIntegerStack (10 分)
m0_68363675的博客
04-20 373
定义IntegerStack接口，用于声明一个存放Integer元素的栈的常见方法: public Integer push(Integer item); //如果item为null，则不入栈直接返回null。如果栈满，也返回null。如果插入成功，返回item。 public Integer pop(); //出栈，如果为空，则返回null。出栈时只移动栈顶指针，相应位置不置为null public Integer peek(); //获得栈顶元素，如果为空，则
PTA: jmu-Java-04面向对象进阶--02-接口-Comparator (15 分)
qq_51167577的博客
05-29 358
jmu-Java-04面向对象进阶–02-接口-Comparator (15 分) Arrays.sort可以对所有实现Comparable的对象进行排序。但如果有多种排序需求，如有时候需对name进行降序排序，有时候只需要对年龄进行排序。使用Comparable无法满足这样的需求。可以编写不同的Comparator来满足多样的排序需求。 #1.编写PersonSortable2类 属性：private name(String)、private age(int) 有参构造函数：参数为name,age toS
7-4 jmu-Java-04面向对象进阶-03-接口-自定义接口ArrayIntegerStack
Mrrr_Li的博客
11-25 453
// package test;// 4 import java.util.*; interface IntegerStack{ public Integer push(Integer item); //如果item为null，则不入栈直接返回null。如果栈满，也返回null。如果插入成功，返回item。 public Integer pop(); //出栈，如果为空，则返回null。出栈时只移动栈顶指针，相应位置不置为null public Integer pe.
PTA7-2 jmu-Java-04面向对象进阶--02-接口-Comparator (5 分)
weixin_53361781的博客
05-08 901
PTA7-2 jmu-Java-04面向对象进阶–02-接口-Comparator (5 分) Arrays.sort可以对所有实现Comparable的对象进行排序。但如果有多种排序需求，如有时候需对name进行降序排序，有时候只需要对年龄进行排序。使用Comparable无法满足这样的需求。可以编写不同的Comparator来满足多样的排序需求。 #1.编写PersonSortable2类 属性：private name(String)、private age(int) 有参构造函数：参数为name,a
JavaSE进阶-01-面向对象.pdf
09-10
在Java编程语言中，面向对象特性是其核心概念之一，本资料主要讲解了JavaSE进阶中的面向对象相关知识，包括final关键字、抽象类、接口、抽象类与接口的区别、Object类、package和import以及访问权限控制。...
9-java进阶-反射1
08-03
- 静态代理：代理类和被代理类都实现相同的接口，代理类在方法中调用被代理类的同名方法。这种方式需要为每个被代理类创建一个代理类。 - 动态代理：通过`Proxy.newProxyInstance()`创建代理对象，它依赖于`...
Java进阶-JDBC（八）.zip
06-13
Java JDBC（Java Database Connectivity）是Java编程语言中用于与数据库交互的一组接口和类，它作为Java标准版的一部分，提供了一种标准化的方式来访问各种类型的数据库系统。本资料包"Java进阶-JDBC（八）"可能包含...
day06-10（FRAMEWORK进阶-V1.01）1
08-08
- **业务分析及实现**：定义业务接口和实现类。 - **创建并配置项目**：配置 Spring 容器，加载 Bean 配置。 - **业务实践与增强分析**：使用 Spring 容器管理 Bean，进行依赖注入和事务管理。 2.4. **SPRING IOC ...
面向对象进阶，面向对象进阶
09-10
本节我们将深入探讨面向对象的进阶概念，包括封装、继承、多态以及接口等核心原则，帮助开发者更好地理解和运用这一强大的编程范式。 1. 封装：封装是面向对象的基础，它将数据和操作数据的方法绑定在一起，形成一...
配置Java开发环境
Broken_x的博客
07-10 1518
Java开发环境配置
java版的上门家政系统和PHP版的上门家政有什么区别？
baina666的博客
07-12 492
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
Spring Security 授权
最新发布
persistence_PSH的博客
07-14 674
在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。在 loadUserByUsername 方法，在查询数据库用户信息的时候，同时查询出用户的权限，这里以角色名代指权限。通过 RBAC 获取到用户的具体权限后，再通过 Security 的 用户-权限-资源 来进行权限控制。HttpSecurity 权限配置。
【Go系列】 Sync并发控制
u013379032的博客
07-14 605
在上一篇文章中，我们介绍了goroutine和channel，理论上，通过channel可以实现并发控制，但是其他语言的开发者可能更习惯一些原子操作的库。当然Go语言也会提供这样的库，所以我们今天了解一下sync库。
jmu-java-04面向对象进阶-03-接口-自定义接口arrayintegerstack
06-06
好的，下面是回复： jmu-java-04面向对象进阶-03-接口-自定义接口arrayintegerstack 这个课程主要讲解了接口的概念和使用方法，以及如何自定义一个接口。其中，自定义接口arrayintegerstack是一个用于实现整数栈的接口，可以通过该接口来定义一个整数栈的数据结构，并实现相关的操作方法。通过学习这个课程，可以更好地理解接口的作用和使用方法，以及如何在实际开发中应用接口来提高代码的可维护性和可扩展性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值