抽象类
类中没有足够的信息来描绘具体的对象
包含抽象方法的类
语法
类被abstract修饰便是抽象类
方法被abstract修饰便是抽象方法
注意：
抽象类中也可以有成员变量，方法，构造方法
特点
1.抽象类不能被实例化
2.抽象方法不能是private的
3.抽象方法不能被static，final修饰，因为要被重写
4.抽象类必须被继承，如果是普通类继承那么必须重写抽象类中所有抽象方法，如果是另一个抽象类继承那么不用重写，但普通类继承这个类后需要重写两个抽象类中的抽象方法
public abstract class Shape {
protected double area;
abstract public void draw();
abstract void calcArea();
public double getArea(){
return area;
}
}
接口
类的公共规范，引用数据类型
语法
将class变为interface
public interface 接口名称{
void method4();
}
注意事项：
1.接口名称以大写字母I开头
2.抽象方法默认public abstract
当类需要实现接口时，使用以下语法
public class 类名称 implements 接口名称{
}
特点
1.接口不能new对象
2.接口的方法只能在实现接口的类中实现
3.重写接口时，不能用default修饰，在接口中方法默认是public的
4.接口中的变量默认是public static final修饰
5.接口中不能有静态代码块和构造方法
6.接口间也可以继承
接口使用实例
比较接口
import java.util.Comparator;
class Student implements Comparable<Student>{
public int age;
private int score;
private String name;
public Student(int age, int score, String name) {
this.age = age;
this.score = score;
this.name = name;
}
@Override
public String toString() {
return "Student{" +
"age=" + age +
", score=" + score +
", name='" + name + '\'' +
'}';
}
public static void mySort(Comparable[] array){
for (int bound = 0; bound < array.length; bound++) {
for (int cur = array.length - 1 ;cur > bound; cur--) {
if(array[cur - 1].compareTo(array[cur]) > 0){
Comparable tmp = array[cur - 1];
array[cur - 1] = array[cur];
array[cur] = tmp;
}
}
}
}
@Override
public int compareTo(Student o) {
return o.age - this.age;
}
}
通过让自己写的类继承jdk自带的Comparable接口，并且重写compareTo方法，可以实现自己定义对象之间的大小关系。
import java.util.Arrays;
public class test {
public static void main(String[] args) {
Student s1 = new Student(1,1,"z");
Student s2 = new Student(2,2,"a");
Student[] arr = {s1,s2};
System.out.println(Arrays.toString(arr));
Student.mySort(arr);
System.out.println(Arrays.toString(arr));
}
}
在main函数中创建一个数组，调用mySort方法，实现调用自己的比较大小方法，使数组排序
还有另一种比较方法
class AgeComparator implements Comparator<Student> {
@Override
public int compare(Student o1, Student o2) {
return o1.age - o2.age;
}
}
直接写一个类继承Comparator接口，重写其中的compare方法，可以在主函数中直接创建对象，传入两个Student对象接收返回值进行大小的比较
import java.util.Arrays;
public class test {
public static void main(String[] args) {
Student s1 = new Student(1,1,"z");
Student s2 = new Student(2,2,"a");
Student[] arr = {s1,s2};
AgeComparator ageComparator = new AgeComparator();
int ret = ageComparator.compare(s1,s2);
System.out.println(ret);
System.out.println(Arrays.toString(arr));
Arrays.sort(arr,ageComparator);
System.out.println(Arrays.toString(arr));
}
}
同时，自带的Arrays下的sort方法也可以传入我们的Comparator方法，使其知道我们想如何排列
克隆接口
public class Person implements Cloneable{
public int age = 10;
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
@Override
public String toString() {
return "Person{" +
"age=" + age +
'}';
}
}
通过继承自带的Cloneable接口，重写其中的clone方法，并抛出异常后，可以实现对象的克隆
import java.util.Arrays;
public class test {
public static void main(String[] args) throws CloneNotSupportedException {
Person person = new Person();
Person person2 = (Person) person.clone();
}
}
但是，需要注意的是，这里实现的是浅拷贝，即只是克隆了对象的引用，没有克隆引用的对象。例如我们的Person类中还有一个Money的类，其有一个成员变量money，其值为9.5，我们创建p1，用p2接收p1的拷贝，当我们改变p2中的Money的money值，可以发现p1的Money中的money值也变了。因为二者引用的同一个Money对象
因此，要改变这种情况，就需要我们实现深拷贝
public class Person implements Cloneable{
public int age = 10;
public Money money = new Money();
@Override
protected Object clone() throws CloneNotSupportedException {
// return super.clone();
Person tmp = (Person) super.clone();
tmp.money = (Money) this.money.clone();
return tmp;
}
@Override
public String toString() {
return "Person{" +
"age=" + age +
'}';
}
}
class Money implements Cloneable{
public double money = 9.5;
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
通过把Money类也实现Cloneable接口，重写clone方法，Person类的clone方法中不仅克隆Person，并且为克隆的对象中的Money也clone一份，便可实现深拷贝
抽象类和接口的区别
抽象类可以有普通方法，接口必须都是抽象方法
一个类只能继承一个抽象类，但是可以实现多个接口
object类
是一种用来接收所有类的对象
object类是所有类的父类
class Person{}
class Student{}
public class Test {
public static void main(String[] args) {
function(new Person());
function(new Student());
}
public static void function(Object obj) {
System.out.println(obj);
}
}
下面讲解几个Object类中的常用方法
toString
和之前讲的一样，可以通过重写toString方法来实现对象信息的打印。
equals
想要比较两个对象的相关信息是否相同时，如果使用==比较，那么比较的是引用对象的地址是否相同。我们应该重写Object类的equals方法
// Object类中的equals方法
public boolean equals(Object obj) {
return (this == obj); // 使用引用中的地址直接来进行比较
}
可以看到，Object类下的equals方法是比较地址
class Person{
...
@Override
public boolean equals(Object obj) {
if (obj == null) {
return false ;
}
if(this == obj) {
return true ;
}
// 不是Person类对象
if (!(obj instanceof Person)) {
return false ;
}
Person person = (Person) obj ; // 向下转型，比较属性值
return this.name.equals(person.name) && this.age==person.age ;
}
}
hashcode方法
在toString方法中，通过hashcode调用了对象的位置
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
我们在这里把hashcode简单的理解为内存地址，在后续的数据结构blog中再详细讲解
public native int hashCode();
可以看到，hashcode由native修饰，这代表着他是由c/c++实现的
class Person {
public String name;
public int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
}
public class TestDemo {
public static void main(String[] args) {
Person per1 = new Person("123", 23) ;
Person per2 = new Person("123", 23) ;
System.out.println(per1.hashCode());
System.out.println(per2.hashCode());
}
}
可以看到，这两个对象的hashcode是不一样的。但是如果我们想要姓名一样年龄一样的人是同一个人的话，我们要让这两个对象的hashcode相同，那么就用到了重写hashcode
class Person {
public String name;
public int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
}
public class TestDemo {
public static void main(String[] args) {
Person per1 = new Person("123", 23) ;
Person per2 = new Person("123", 23) ;
System.out.println(per1.hashCode());
System.out.println(per2.hashCode());
}
}
这样的话，两者的hashcode就相同了。
事实上，hashcode是用来确定对象的存储位置的。
在散列表中才有用，hashcode用来确定对象在散列表的位置
647
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
