目录
思维导图：
抽象类：
- 一个类如果被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接口的使用案例：
class Student implements Comparable<Student>{
public String name;
public int age;
public double score;
public Student(String name, int age, double 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) {
//this.age - o.age排的是升序
//o.age - this.age排的是降序
return o.age - this.age;
}
}
//比较器
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);
}
}
//比较器
class nameComparator implements Comparator<Student>{
@Override
public int compare(Student o1, Student o2) {
return o1.name.compareTo(o2.name);
}
}
public class Test {
//student类没有实现comparable接口时，使用sort调用比较器
public static void main3(String[] args) {
Student[] student = new Student[3];
student[0] = new Student("大哥",12,69.9);
student[1] = new Student("二哥",15,60.8);
student[2] = new Student("三哥",10,79.7);
// AgeComparator ageComparator = new AgeComparator();
ScoreComparator scoreComparator = new ScoreComparator();
System.out.println("排序前："+Arrays.toString(student));
Arrays.sort(student,scoreComparator);
System.out.println("排序后："+Arrays.toString(student));
}
//student类没有实现comparable接口时，实例化AgeComparator等比较器，来调用compare方法
public static void main2(String[] args) {
Student[] student = new Student[3];
student[0] = new Student("大哥",12,69.9);
student[1] = new Student("二哥",15,60.8);
student[2] = new Student("三哥",10,79.7);
AgeComparator ageComparator = new AgeComparator();
int ret1 = ageComparator.compare(student[1],student[2]);
System.out.println(ret1);
ScoreComparator scoreComparator = new ScoreComparator();
int ret2 = scoreComparator.compare(student[1],student[2]);
System.out.println(ret2);
}
//没有比较器，student类实现了comparable接口，使用sort方法
public static void main1(String[] args) {
Student[] student = new Student[3];
student[0] = new Student("大哥",12,69.9);
student[1] = new Student("二哥",15,60.8);
student[2] = new Student("三哥",10,79.7);
System.out.println("排序前："+Arrays.toString(student));
Arrays.sort(student);
System.out.println("排序后："+Arrays.toString(student));
}
}浅拷贝和深拷贝的使用：
class Teacher implements Cloneable{
public int teachernum = 3;
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
class Children implements Cloneable {
public int childtnum = 5;
Teacher teacher = new Teacher();
@Override
protected Object clone() throws CloneNotSupportedException {
//深拷贝，tmp是临时变量，会销毁的
Children tmp = (Children) super.clone();
tmp.teacher = (Teacher) this.teacher.clone();
return tmp;
// //浅拷贝
// return super.clone();
}
}
public class Main {
public static void main(String[] args) throws CloneNotSupportedException {
Children children = new Children();
Children children2 = (Children) children.clone();
System.out.println(children.teacher.teachernum);//3
System.out.println(children2.teacher.teachernum);//3
System.out.println("======================");
//浅拷贝
children2.teacher.teachernum = 10;
System.out.println(children.teacher.teachernum);//10
System.out.println(children2.teacher.teachernum);//10
System.out.println("======================");
//深拷贝
children2.teacher.teachernum = 10;
System.out.println(children.teacher.teachernum);//3
System.out.println(children2.teacher.teachernum);//10
}
}抽象类和接口的区别：
- 抽象类和接口都是多态的常见使用方式
- 二者的区别
不同点： 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方法，具体使用代码：
class Student {
public String name;
public Student(String name) {
this.name = name;
}
@Override
public String toString() {
return "Student{" +
"name=" + name +
'}';
}
/**
* 一般来说，引用类型都要重写equals
* @param obj
* @return
*/
@Override
public boolean equals(Object obj){
//判断当前的obj参数是否为空
if(obj == null){
return false;
}
if(this == obj){
return true;
}
//不是Student类对象
if(!(obj instanceof Student)){
return false;
}
Student tmp = (Student)obj;
return this.name.equals(tmp.name);
}
/**
* 定位的作用
* @return
*/
@Override
public int hashCode() {
return Objects.hash(name);
}
//编译器自动添加的
// @Override
// public boolean equals(Object o) {
// if (this == o) return true;
// if (o == null || getClass() != o.getClass()) return false;
// Student student = (Student) o;
// return Objects.equals(name, student.name);
// }
//
// @Override
// public int hashCode() {
// return Objects.hash(name);
// }
}
public class Test {
public static void main2(String[] args) {
Student student = new Student("大哥大");
Student student2 = new Student("张三");
System.out.println(student.hashCode());//22629480
System.out.println(student2.hashCode());//774920
System.out.println("=================");
Student student3 = new Student("大哥大");
Student student4 = new Student("大哥大");
System.out.println(student3.hashCode());//22629480
System.out.println(student4.hashCode());//22629480
}
public static void main(String[] args) {
Student student = new Student("大哥大");
Student student2 = new Student("张三");
Student student3 = new Student("大哥大");
System.out.println(student.equals(student2));//false
System.out.println(student.equals(student3));//true
}
}如果对您有帮助的话，
不要忘记点赞+关注哦，蟹蟹
如果对您有帮助的话，
不要忘记点赞+关注哦，蟹蟹
如果对您有帮助的话，
不要忘记点赞+关注哦，蟹蟹
5281
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
