思维导图：
抽象类：
- 一个类如果被abstract修饰称为抽象类，抽象类中被abstract修饰的方法称为抽象方法，抽象方法不能写出具体的实现，例如：
abstract class move{
public abstract void run();//抽象方法
public abstract void eat();//抽象方法
}
- 抽象类中不一定有抽象方法，但是有抽象方法的类一定是抽象类。抽象类也是类，内部也可以有构造方法、成员方法和成员变量。
- 包含抽象方法的类一定要设计为抽象类，用abstract来修饰这个类。
- 抽象类不能进行实例化，这也是和普通类的重要区别之一。既然抽象类不能实例化，那抽象类的存在就是为了被继承。
- 如果一个普通类继承了一个抽象类，那么一定要重写这个抽象类中的抽象方法，如果不重写那么子类也成了抽象类，就必须使用abstract修饰。
- 如果一个抽象类a继承了另外一个抽象类b，那么抽象类a可以不重写抽象类b中的抽象方法。但是若再有一个普通类继承了抽象类a，那么这个普通类不仅要重写抽象类a中的抽象方法还要重写抽象类b中的抽象方法。
- 抽象方法不能被private、final和static修饰，因为抽象方法要被重写！抽象方法没有加访问修饰限定符时默认为public。
- 抽象类的存在相当于多了一重编译器的检验，一般是实例化子类来完成实际工作，如果不小心实例化了父类则编译器就会报错提醒你。
接口：
- 接口就是多个类的公共规范，接口是一种引用类型。接口中的成员变量默认都是public static final修饰的；接口中的成员方法默认都是抽象方法，用public abstract修饰。
- 接口的定义使用关键字interface并且在创建接口时，接口的命名一般用大写字母I开头。
- 接口当中的成员方法是不能有具体实现的，只能由具体实现接口的类实现。如果要有具体实现需要加上访问修饰限定符default。
- 接口当中可以有静态的成员方法，不论是静态的方法还是default方法，默认都是由public修饰的。
- 接口是不可以实例化的，如果要使用接口就必须用一个类来实现，并且重写接口中所有的抽象方法。当子类重写接口中的方法时不能用default访问修饰限定符。
- 接口不能有静态代码块、实例代码块和构造方法。
- 一个类实现多个接口时一定要把每个接口的抽象方法都实现，否则这个类要加上abstract。
- 在java中虽然不支持多继承，但是支持一个类实现多个接口。接口和接口之间可以多继承，从而实现功能的扩展。
- 子类和父类之间是继承extends关系，类和接口之间是实现implements关系。
- 接口不是类，但是编译完成后字节码文件的格式是 .class 。
几种重要的接口：
- 如果需要比较自定义类型数据的大小需要用到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; } }
- 除了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); } }
- 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中的参数。浅拷贝！
- 浅拷贝和深拷贝。浅拷贝对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.抽象类可以包含普通方法和普通成员变量
而接口中不能包含普通方法；接口中的方法都是抽象方法子类必须重写若不重写需要加abstract
2.抽象类中抽象方法不能是private的，如果没写访问修饰限定符默认是public
而接口的访问修饰限定符都是public，但是如果要具体实现抽象方法需要使用default
3.一个抽象类可以实现多个接口
而接口不能继承抽象类，但是接口可以继承多个其他接口，实现功能的拓展
4.一个子类只能继承一个抽象类
而一个子类可以实现多个接口
5.抽象类中可以有普通方法、构造方法
而接口中不能有普通方法、静态代码块实例代码块和构造哦方法
6.子类是使用extends关键字继承抽象类
而子类使用implements来实现接口
Object类：
- Object类是所有类的父类，所有的类默认会继承Object类。
- Object类中有一些常用的方法：equals方法、toString方法、hashCode方法和clone方法。
- 在java中使用 == 号来比较时，如果左右俩侧是基本数据类型，则比较值是否相同；如果左右俩侧是引用类型，则比较引用变量的地址是否相同。
- 如果要比较对象的内容就必须使用equals方法，需要重写Object类中的equals方法，因为若不重写默认还是按照地址来进行比较。所以比较俩个自定义的对象中的内容是否相同时，一定要重写equals方法。
- hashCode方法用来确定俩个对象在内存中存储的位置是否相同，也可以通过重写hashCode方法将俩个对象存储在同一位置上。
- 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. }
如果对您有帮助的话，
不要忘记点赞+关注哦，蟹蟹
如果对您有帮助的话，
不要忘记点赞+关注哦，蟹蟹
如果对您有帮助的话，
不要忘记点赞+关注哦，蟹蟹
