AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

【JavaSE】抽象类和接口重点语法知识汇总（附有代码）

2023-08-14 61
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 【JavaSE】抽象类和接口重点语法知识汇总（附有代码）

思维导图：

 

抽象类：

  1. 一个类如果被abstract修饰称为抽象类，抽象类中被abstract修饰的方法称为抽象方法，抽象方法不能写出具体的实现，例如：

abstract class move{

    public abstract void run();//抽象方法

    public abstract void eat();//抽象方法

}

  1. 抽象类中不一定有抽象方法，但是有抽象方法的类一定是抽象类。抽象类也是类，内部也可以有构造方法、成员方法和成员变量。
  2. 包含抽象方法的类一定要设计为抽象类，用abstract来修饰这个类。
  3. 抽象类不能进行实例化，这也是和普通类的重要区别之一。既然抽象类不能实例化，那抽象类的存在就是为了被继承。
  4. 如果一个普通类继承了一个抽象类，那么一定要重写这个抽象类中的抽象方法，如果不重写那么子类也成了抽象类，就必须使用abstract修饰。
  5. 如果一个抽象类a继承了另外一个抽象类b，那么抽象类a可以不重写抽象类b中的抽象方法。但是若再有一个普通类继承了抽象类a，那么这个普通类不仅要重写抽象类a中的抽象方法还要重写抽象类b中的抽象方法。
  6. 抽象方法不能被private、final和static修饰，因为抽象方法要被重写！抽象方法没有加访问修饰限定符时默认为public。
  7. 抽象类的存在相当于多了一重编译器的检验，一般是实例化子类来完成实际工作，如果不小心实例化了父类则编译器就会报错提醒你。

接口：

  1. 接口就是多个类的公共规范，接口是一种引用类型。接口中的成员变量默认都是public static final修饰的；接口中的成员方法默认都是抽象方法，用public abstract修饰。
  2. 接口的定义使用关键字interface并且在创建接口时，接口的命名一般用大写字母I开头。
  3. 接口当中的成员方法是不能有具体实现的，只能由具体实现接口的类实现。如果要有具体实现需要加上访问修饰限定符default。
  4. 接口当中可以有静态的成员方法，不论是静态的方法还是default方法，默认都是由public修饰的。
  5. 接口是不可以实例化的，如果要使用接口就必须用一个类来实现，并且重写接口中所有的抽象方法。当子类重写接口中的方法时不能用default访问修饰限定符。
  6. 接口不能有静态代码块、实例代码块和构造方法。
  7. 一个类实现多个接口时一定要把每个接口的抽象方法都实现，否则这个类要加上abstract。
  8. 在java中虽然不支持多继承，但是支持一个类实现多个接口。接口和接口之间可以多继承，从而实现功能的扩展。
  9. 子类和父类之间是继承extends关系，类和接口之间是实现implements关系。
  10. 接口不是类，但是编译完成后字节码文件的格式是 .class 。

几种重要的接口：

  1. 如果需要比较自定义类型数据的大小需要用到Comparable接口，实现Comparable接口就要重写其中的compareTo方法。但是Comparable接口有个缺陷，compareTo方法是固定了的，如果不想比较age只能重写修改compareTo中的参数，局限性大！这时候就可以使用比较器。
class Student implements Comparable<Student>{
......
    @Override
    public int compareTo(Student o) {
        //this.age - o.age排的是升序
        //o.age - this.age排的是降序
        return o.age - this.age;
    }
}
  1. 除了Comparable接口可以实现自定义类型大小的比较之外，也可以使用比较器。根据需求调用不同的比较器就可以满足要求了，如果想按年龄比较就使用AgeComparator；比较分数就使用
ScoreComparato。//比较器
class AgeComparator implements Comparator<Student>{
    @Override
    public int compare(Student o1, Student o2) {
        //o1.age - o2.age是升序
        return o1.age - o2.age;
    }
}
//比较器
class ScoreComparator implements Comparator<Student>{
    @Override
    public int compare(Student o1, Student o2) {
        return (int)(o1.score - o2.score);
    }
}
  2. Clonable接口可以进行拷贝，需要具体的类实现Clonable接口，特别注意：Clonable接口中没有抽象方法，是一个空接口！不能直接重写clone方法而不去实现Clonable接口，Clonable接口的存在表示这个类能被clone。需要手动重写Object类中的clone方法，例如：
class Student implements Cloneable {
    ...
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();//调用父类Object中的clone方法
    }
}
public static void main(String[] args) throws CloneNotSupportedException {
    Student student = new Student();
    Student student2 = (Student) student.clone()
}//

对student2修改参数的值，不会影响student中的参数。浅拷贝！


  1. 浅拷贝和深拷贝。浅拷贝对teachernum的值修改后，children和children2的值都会改变； 深拷贝对teachernum的值修改后，children2的值会被修改，children则不会。深拷贝和浅拷贝不是那个方法决定的，具体是自己代码实现而来。

Comparable接口和Comparator接口的使用案例：

1. class Student implements Comparable<Student>{
2. public String name;
3. public int age;
4. public double score;
5. 
6. public Student(String name, int age, double score) {
7. this.name = name;
8. this.age = age;
9. this.score = score;
10.     }
11. 
12. @Override
13. public String toString() {
14. return "Student{" +
15. "name='" + name + '\'' +
16. ", age=" + age +
17. ", score=" + score +
18. '}';
19.     }
20. 
21. @Override
22. public int compareTo(Student o) {
23. //this.age - o.age排的是升序
24. //o.age - this.age排的是降序
25. return o.age - this.age;
26.     }
27. }
28. 
29. //比较器
30. class AgeComparator implements Comparator<Student>{
31. 
32. @Override
33. public int compare(Student o1, Student o2) {
34. //o1.age - o2.age是升序
35. return o1.age - o2.age;
36.     }
37. }
38. //比较器
39. class ScoreComparator implements Comparator<Student>{
40. 
41. @Override
42. public int compare(Student o1, Student o2) {
43. return (int)(o1.score - o2.score);
44.     }
45. }
46. //比较器
47. class nameComparator implements Comparator<Student>{
48. 
49. @Override
50. public int compare(Student o1, Student o2) {
51. return o1.name.compareTo(o2.name);
52.     }
53. }
54. 
55. public class Test {
56. //student类没有实现comparable接口时，使用sort调用比较器
57. public static void main3(String[] args) {
58.         Student[] student = new Student[3];
59.         student[0] = new Student("大哥",12,69.9);
60.         student[1] = new Student("二哥",15,60.8);
61.         student[2] = new Student("三哥",10,79.7);
62. //        AgeComparator ageComparator = new AgeComparator();
63. ScoreComparator scoreComparator = new ScoreComparator();
64. 
65.         System.out.println("排序前："+Arrays.toString(student));
66. 
67.         Arrays.sort(student,scoreComparator);
68. 
69.         System.out.println("排序后："+Arrays.toString(student));
70. 
71.     }
72. //student类没有实现comparable接口时，实例化AgeComparator等比较器，来调用compare方法
73. public static void main2(String[] args) {
74.         Student[] student = new Student[3];
75.         student[0] = new Student("大哥",12,69.9);
76.         student[1] = new Student("二哥",15,60.8);
77.         student[2] = new Student("三哥",10,79.7);
78. 
79. AgeComparator ageComparator = new AgeComparator();
80. int ret1 = ageComparator.compare(student[1],student[2]);
81.         System.out.println(ret1);
82. 
83. ScoreComparator scoreComparator = new ScoreComparator();
84. int ret2 = scoreComparator.compare(student[1],student[2]);
85.         System.out.println(ret2);
86.     }
87. //没有比较器，student类实现了comparable接口，使用sort方法
88. public static void main1(String[] args) {
89.         Student[] student = new Student[3];
90.         student[0] = new Student("大哥",12,69.9);
91.         student[1] = new Student("二哥",15,60.8);
92.         student[2] = new Student("三哥",10,79.7);
93. 
94.         System.out.println("排序前："+Arrays.toString(student));
95. 
96.         Arrays.sort(student);
97. 
98.         System.out.println("排序后："+Arrays.toString(student));
99. 
100.     }
101. }

浅拷贝和深拷贝的使用：

1. class Teacher implements Cloneable{
2. public int teachernum = 3;
3. @Override
4. protected Object clone() throws CloneNotSupportedException {
5. return super.clone();
6.     }
7. }
8. 
9. class Children implements Cloneable {
10. public int childtnum = 5;
11. Teacher teacher = new Teacher();
12. @Override
13. protected Object clone() throws CloneNotSupportedException {
14. //深拷贝，tmp是临时变量，会销毁的
15. Children tmp = (Children) super.clone();
16.         tmp.teacher = (Teacher) this.teacher.clone();
17. return tmp;
18. 
19. //        //浅拷贝
20. //        return super.clone();
21.     }
22. }
23. public class Main {
24. public static void main(String[] args) throws CloneNotSupportedException {
25. Children children = new Children();
26. Children children2 = (Children) children.clone();
27.         System.out.println(children.teacher.teachernum);//3
28.         System.out.println(children2.teacher.teachernum);//3
29.         System.out.println("======================");
30. 
31. //浅拷贝
32.         children2.teacher.teachernum = 10;
33.         System.out.println(children.teacher.teachernum);//10
34.         System.out.println(children2.teacher.teachernum);//10
35.         System.out.println("======================");
36. 
37. //深拷贝
38.         children2.teacher.teachernum = 10;
39.         System.out.println(children.teacher.teachernum);//3
40.         System.out.println(children2.teacher.teachernum);//10
41. 
42.     }
43. }

抽象类和接口的区别：

  1. 抽象类和接口都是多态的常见使用方式
  2. 二者的区别

不同点：

1.抽象类可以包含普通方法和普通成员变量

 而接口中不能包含普通方法；接口中的方法都是抽象方法子类必须重写若不重写需要加abstract

2.抽象类中抽象方法不能是private的，如果没写访问修饰限定符默认是public

 而接口的访问修饰限定符都是public，但是如果要具体实现抽象方法需要使用default

3.一个抽象类可以实现多个接口

 而接口不能继承抽象类，但是接口可以继承多个其他接口，实现功能的拓展

4.一个子类只能继承一个抽象类

 而一个子类可以实现多个接口

5.抽象类中可以有普通方法、构造方法

 而接口中不能有普通方法、静态代码块实例代码块和构造哦方法

6.子类是使用extends关键字继承抽象类

 而子类使用implements来实现接口

Object类：

  1. Object类是所有类的父类，所有的类默认会继承Object类。
  2. Object类中有一些常用的方法：equals方法、toString方法、hashCode方法和clone方法。
  3. 在java中使用 == 号来比较时，如果左右俩侧是基本数据类型，则比较值是否相同；如果左右俩侧是引用类型，则比较引用变量的地址是否相同。
  4. 如果要比较对象的内容就必须使用equals方法，需要重写Object类中的equals方法，因为若不重写默认还是按照地址来进行比较。所以比较俩个自定义的对象中的内容是否相同时，一定要重写equals方法。
  5. hashCode方法用来确定俩个对象在内存中存储的位置是否相同，也可以通过重写hashCode方法将俩个对象存储在同一位置上。
  6. equals方法和hashCode方法，具体使用代码：
1. class Student {
2. public String name;
3. 
4. public Student(String name) {
5. this.name = name;
6.     }
7. 
8. @Override
9. public String toString() {
10. return "Student{" +
11. "name=" + name +
12. '}';
13.     }
14. 
15. /**
16.      * 一般来说，引用类型都要重写equals
17.      * @param obj
18.      * @return
19.      */
20. @Override
21. public boolean equals(Object obj){
22. //判断当前的obj参数是否为空
23. if(obj == null){
24. return false;
25.         }
26. if(this == obj){
27. return true;
28.         }
29. //不是Student类对象
30. if(!(obj instanceof Student)){
31. return false;
32.         }
33. Student tmp = (Student)obj;
34. return this.name.equals(tmp.name);
35. 
36.     }
37. 
38. /**
39.      * 定位的作用
40.      * @return
41.      */
42. @Override
43. public int hashCode() {
44. return Objects.hash(name);
45.     }
46. 
47. 
48. //编译器自动添加的
49. //    @Override
50. //    public boolean equals(Object o) {
51. //        if (this == o) return true;
52. //        if (o == null || getClass() != o.getClass()) return false;
53. //        Student student = (Student) o;
54. //        return Objects.equals(name, student.name);
55. //    }
56. //
57. //    @Override
58. //    public int hashCode() {
59. //        return Objects.hash(name);
60. //    }
61. 
62. }
63. public class Test {
64. public static void main2(String[] args) {
65. Student student = new Student("大哥大");
66. Student student2 = new Student("张三");
67.         System.out.println(student.hashCode());//22629480
68.         System.out.println(student2.hashCode());//774920
69.         System.out.println("=================");
70. Student student3 = new Student("大哥大");
71. Student student4 = new Student("大哥大");
72.         System.out.println(student3.hashCode());//22629480
73.         System.out.println(student4.hashCode());//22629480
74.     }
75. public static void main(String[] args) {
76. Student student = new Student("大哥大");
77. Student student2 = new Student("张三");
78. Student student3 = new Student("大哥大");
79.         System.out.println(student.equals(student2));//false
80.         System.out.println(student.equals(student3));//true
81.     }
82. }

如果对您有帮助的话，

不要忘记点赞+关注哦，蟹蟹

如果对您有帮助的话，

不要忘记点赞+关注哦，蟹蟹

如果对您有帮助的话，

不要忘记点赞+关注哦，蟹蟹

文章标签：
Java
编译器
对象存储
存储
珠江上上上
目录
相关文章
Designer小郑
|
Java
【JavaSE专栏57】妙用this和super关键字，让父类和子类之间来回自如
【JavaSE专栏57】妙用this和super关键字，让父类和子类之间来回自如
Designer小郑
98 0
sky_qiyi
|
4月前
|
Java
JavaSE——面向对象高级一（3/4）-面向对象三大特征之二：继承（初步认识继承、了解继承的好处）
JavaSE——面向对象高级一（3/4）-面向对象三大特征之二：继承（初步认识继承、了解继承的好处）
sky_qiyi
24 0
盒马盒马
|
5月前
|
C++
C++：类的补充知识
C++：类的补充知识
盒马盒马
33 0
Aileen_0v0~
|
5月前
|
Java 编译器
【Java不看后悔系列】|面向对象编程|[继承、封装、多态全覆盖]
【Java不看后悔系列】|面向对象编程|[继承、封装、多态全覆盖]
Aileen_0v0~
37 0
珠江上上上
|
Java
【JavaSE】继承和多态重点语法知识汇总
【JavaSE】继承和多态重点语法知识汇总
珠江上上上
72 0
【JavaSE】继承和多态重点语法知识汇总
敖云岚
|
存储 Java 编译器
教你精通JavaSE语法之第九章、抽象类和接口
Object是Java默认提供的一个类。Java里面除了Object类，所有的类都是存在继承关系的。默认会继承Object父类。即所有类的对象都可以使用Object的引用进行接收。范例：使用Object接收所有类的对象。
敖云岚
131 0
潇潇雨声迟
|
存储 Java C++
《JavaSE-第十章》之抽象类与接口
《JavaSE-第十章》之抽象类与接口
潇潇雨声迟
135 0
潇潇雨声迟
|
存储 SQL Java
《JavaSE-第七章》之抽象的类-实例的对象-合理的封装
《JavaSE-第七章》之抽象的类-实例的对象-合理的封装
潇潇雨声迟
98 0
t75yjb52rsccc
2022年 一月19号复盘内容二。（继承 多态 接口 抽象）（一）
2022年 一月19号复盘内容二。（继承 多态 接口 抽象）（一）
t75yjb52rsccc
40 0
前端歌谣
|
Java
java学习第十三天笔记-面向对象244-子类能继承父类的那些内容4代码实现
java学习第十三天笔记-面向对象244-子类能继承父类的那些内容4代码实现
前端歌谣
75 0
java学习第十三天笔记-面向对象244-子类能继承父类的那些内容4代码实现

热门文章

最新文章

  • 1
    Spring Boot 中文乱码问题解决方案汇总
  • 2
    软考高级 系统架构师考试经验分享(一次性通过)
  • 3
    DataWorks百问百答69：有哪些数据集成报错（数据集成报错归类）？
  • 4
    用 Prettier 美化代码
  • 5
    ClusterShell之自动化运维工具
  • 6
    RHEL7系统破解密码
  • 7
    物联网将如何改善社会运行效率?
  • 8
    美国互联网公司欲修复与特朗普关系 呼吁支持加密
  • 9
    HTML超链接之伪类注意事项
  • 10
    listview优化（中）
  • 1
    基于BP译码的LDPC误码率matlab仿真,分析码长,码率,信道对译码性能的影响,对比卷积码,turbo码以及BCH码
    32
  • 2
    ROS 编程入门的介绍
    35
  • 3
    基于遗传算法的智能天线最佳阵列因子计算matlab仿真
    28
  • 4
    TypeScript无缝衔接ArkTS：快速入门鸿蒙ArkTS基本语法
    27
  • 5
    探索深度学习的奥秘
    24
  • 6
    技术之旅：从困惑到启迪的探索之路
    9
  • 7
    技术之旅：从迷茫到探索的蜕变
    9
  • 8
    基于贝叶斯优化卷积神经网络(Bayes-CNN)的多因子数据分类识别算法matlab仿真
    11
  • 9
    智能照明系统：技术、应用与未来趋势###
    14
  • 10
    云原生技术在现代企业中的应用与挑战####
    11

    • 相关课程

    更多
  • Java面向对象开发
  • 5天玩转Java面向对象编程
  • Java面向对象编程

    • 相关电子书

    更多
  • 继承与功能组合
  • JAVA反射原理以及一些常见的应用
  • 低代码开发师（初级）实战教程

    • 相关实验场景

    更多
  • 面向对象-1：类的定义
  • 对象和接口-2：常见用法
  • 使用Java面向对象编写网络通信程序应用
    • 下一篇
    AI助理直击要害，从繁复中提炼精华——使用CDN加速访问OSS存储的图片