图灵日记之java奇妙历险记--抽象类和接口

抽象类

概念

在面向对象的概念中,所有对象都是通过类来描述的,但是反过来,并不是所有的类都是用来描绘对象的,如果一个类中没有包含足够的信息描绘一个具体的对象,这样的类就是抽象类

使用abstract修饰的方法称为抽象方法
使用abstract修饰的类称为抽象类
抽象类是不可以进行实例化的
抽象类当中可以和普通类一样定义成员变量和成员方法
当一个普通的类继承了这个抽象类,那么需要重写这个抽象类当中的所有抽象方法
抽象类的出现就是为了被继承
abstract和final不能共存
被private static修饰抽象方法也不可以

抽象类语法

在java中,一个类如果被abstract修饰称为抽象类,抽象类中被abstract修饰的方法称为抽象方法,抽象方法不用给出具体的实现体
注意:抽象类也是类,内部也可以包含普通方法和属性,甚至构造方法

接口

概念

接口是公共的行为规范标准,大家在实现时,只要符合规范标准
就可以调用
在java中,接口可以看成是:多个类的公共规范,是一种引用数据类型

规则

接口是使用interface方法修饰的
接口当中不能有被实现的方法,意味着只能有抽象方法.但是两个方法除外:一个是static修饰的方法一个是被default修饰的方法
接口当作的抽象方法默认都是public abstract修饰的
什么都不写的时候默认abstract修饰
接口当中的成员变量默认都是public static final 修饰的
接口不能进行实例化
类和接口之间的关系,可以使用implements来进行关联
接口也是有对应的字节码文件的

接口定义格式与定义类的格式基本相同,将class关键字换成interface关键字,就定义了一个接口

interface 接口名称 {}

使用

接口不能直接使用,必须要有一个"实现类"来实现该接口,实现接口中所有的抽象方法

class 类名称 implements 接口名称{// ...
}

注意:子类和父类之间是extends继承关系,类和接口之间是implements实现关系

特性

接口类型是一种引用类型,但是不能直接new接口的对象,无法实例化
接口的每个方法都是public修饰的抽象方法,即接口中的方法被隐式的指定为public abstract(只能是public abstract, 其他修饰符都会报错)
接口的方法是不能在接口实现的,只能由实现接口的类来实现
但在接口的方法里非要实现需要static或者default修饰
static修饰的方法不能重写
default修饰方法可重写可不重写
重写接口方法时,不能使用默认的访问权限
因为接口方法里默认就是public abstract,又因为子类的访问权限大于等于父类,子类只能被public修饰
接口中可以含有变量,但是接口中的变量会被隐式的指定为public static final 变量
接口不能有代码块(实例代码块和静态代码块)和构造方法
接口虽然不是类,但是接口编译完成后字节码文件的后缀格式也是class
如果类没有实现接口中的所有的抽象方法,则类必须被设置为抽象

实现多个接口

接口解决java多继承的问题

abstract class Animal{public String name;Animal(String name) {this.name = name;}abstract public void eat();abstract public void swim();
}

动物里并不是所有的动物都可以游泳,所以把swim写在Animal这个类里面不好,但是如果你把swim写到一个类就行了嘛?但是java不支持同时继承多个类,所以写进类里也不行,所以我们把他封装成了接口

注意:一个类实现多个接口时,每个接口中的抽象方法都要实现,否则类
必须设置为抽象类

接口的继承

在java中,类和类之间是单继承的,一个类可以实现多个接口,接口和接口之间可以多继承.即用接口可以达到多继承的目的

interface walk {public void walk();
}
interface run extends walk {public void run();
}

run接口有walk接口的特性,可以使用extends关键字来实现复用的效果,extends理解为拓展的意思,即run拓展了walk的功能
run接口不仅具备run接口本身的功能,而且具备walk这个接口的功能

interface A {public void a();
}
interface B extends A{public void a();
}
class test implements B{@Overridepublic void a() {}
}

接口B和接口A有一样的方法,当接口B拓展接口A时,类test获得B接口,要实现a这个方法
在这里插入图片描述
实现的是接口B的方法a

两个关系:

类和接口之间的关系–>>implements实现
接口和接口之间的关系–>>extends拓展

接口之间的继承相当于把多个接口并在一起

接口使用实例

    public static void main(String[] args) {int a = 10;int b = 20;System.out.println(a>b);}

在这里插入图片描述

public class Test {public static void main(String[] args) {Person person01 = new Person();Person person02 = new Person();System.out.println(person01>person02);}
}class Person {public String name;public int age;public int height;
}

引用类型比较就不可以了,因为比较两个引用类型没有意义,但是你想比较引用类型里的成员变量的话,他也不知道是哪一个

public class Test {public static void main(String[] args) {Person person01 = new Person();Person person02 = new Person();System.out.println(person01.compareTo(person02));}
}class Person implements Comparable<Person>{public String name;public int age;public int height;@Overridepublic int compareTo(Person o) {if(this.age>o.age) {return 1;} else if(this.age==o.age) {return 0;}else {return -1;}}
}

后续文章会讲,此处仅供参考

但是如果用如上代码,在比较身高等其他值的时候就不方便

public class Test {public static void main(String[] args) {Person person01 = new Person("张三",1,1);Person person02 = new Person("李四",2,2);System.out.println(new AgeCompare().compare(person01, person02));}
}class AgeCompare implements Comparator<Person> {@Overridepublic int compare(Person o1, Person o2) {return o1.age-o2.age;}
}class Person{public String name;public int age;public int height;public Person(String name, int age, int height) {this.name = name;this.age = age;this.height = height;}
}

比较器来进行年龄比较,之后同样的方法比较身高等

第一种方式比较对类的侵入性比较强,一旦写好了规定的比较方式,之后只能使用这种方式来进行比较
第二种方式就会比较灵活,单独创建一个类实现比较方法,调用方法时,传入要比较的两个对象即可


public class Test {public static void main(String[] args) {Person[] people = new Person[3];people[0] = new Person(111,"a");people[1] = new Person(101,"b");people[2] = new Person(121,"c");System.out.println(Arrays.toString(people));System.out.println("===========================");Arrays.sort(people);System.out.println("===========================");System.out.println(Arrays.toString(people));}
}class Person {@Overridepublic String toString() {return "Person{" +"age=" + age +", name='" + name + '\'' +'}';}int age;String name;Person(int age, String name) {this.age = age;this.name = name;}
}

同理,对自定义类型的数组排序此处也会报错
在这里插入图片描述
Array.sort的源代码追根溯源发现比较是依托compareTo来实现比较的,所以我们可以在类里自己实现compareTo方法


public class Test {public static void main(String[] args) {Person[] people = new Person[3];people[0] = new Person(111,"a");people[1] = new Person(101,"b");people[2] = new Person(121,"c");System.out.println(Arrays.toString(people));System.out.println("===========================");Arrays.sort(people);System.out.println("===========================");System.out.println(Arrays.toString(people));}
}class Person implements Comparable<Person>{@Overridepublic String toString() {return "Person{" +"age=" + age +", name='" + name + '\'' +'}';}int age;String name;Person(int age, String name) {this.age = age;this.name = name;}@Overridepublic int compareTo(Person o) {return this.age-o.age;}
}

在这里插入图片描述
sort方法的重载中还可以传入比较器


public class Test {public static void main(String[] args) {Person[] people = new Person[3];people[0] = new Person(111,"a");people[1] = new Person(101,"b");people[2] = new Person(121,"c");System.out.println(Arrays.toString(people));
//        Arrays.sort(people);AgeCompare ageCompare = new AgeCompare();Arrays.sort(people,ageCompare);System.out.println("===========================");System.out.println(Arrays.toString(people));}
}
//名字比较器
class NameCompare implements Comparator<Person> {@Overridepublic int compare(Person o1, Person o2) {return o2.name.compareTo(o1.name);}
}
//年龄比较器
class AgeCompare implements Comparator<Person> {@Overridepublic int compare(Person o1, Person o2) {return o2.age-o1.age;}
}class Person implements Comparable<Person>{@Overridepublic String toString() {return "Person{" +"age=" + age +", name='" + name + '\'' +'}';}int age;String name;Person(int age, String name) {this.age = age;this.name = name;}@Overridepublic int compareTo(Person o) {return this.name.compareTo(o.name);}
}

也可以自己实现排序方法来进行比较,如下

public class Test {public static void bubbleSort(Comparable[] comparables) {for (int i = 0; i < comparables.length-1; i++) {for (int j = 0; j < comparables.length-i-1; j++) {if(comparables[j].compareTo(comparables[j+1])>0) {Comparable tem = comparables[j];comparables[j] = comparables[j+1];comparables[j+1] = tem;}}}}public static void main(String[] args) {Person[] people = new Person[3];people[0] = new Person(111,"a");people[1] = new Person(101,"b");people[2] = new Person(121,"c");System.out.println(Arrays.toString(people));bubbleSort(people);System.out.println(Arrays.toString(people));}
}class Person implements Comparable<Person>{@Overridepublic String toString() {return "Person{" +"age=" + age +", name='" + name + '\'' +'}';}int age;String name;Person(int age, String name) {this.age = age;this.name = name;}@Overridepublic int compareTo(Person o) {return this.age-o.age;}
}

Clonable接口和深拷贝


public class Test {public static void main(String[] args) {Animal animal = new Animal("张三",10);Animal animal1 = animal.clone();}
}class Animal {String name;int height;@Overridepublic String toString() {return "Animal{" +"name='" + name + '\'' +", height=" + height +'}';}public Animal(String name, int height) {this.name = name;this.height = height;}@Overrideprotected Object clone() throws CloneNotSupportedException {return super.clone();}
}

在这里插入图片描述
创建了一个Animal类,实例化对象animal,想利用clone克隆animal到animal1,但是发生报错

可能会抛出异常,这个异常叫作不支持克隆异常
编译时期的异常

处理这种异常,对main函数也申请如上操作
在这里插入图片描述
发现依旧报错

在这里插入图片描述
观察clone方法里返回值是Object,但是main方法里animal1是Animal类,类型不匹配,需要强转一下
对main方法如下处理解决刚才的异常问题


public class Test {public static void main(String[] args) throws CloneNotSupportedException{Animal animal = new Animal("张三",10);Animal animal1 = (Animal)animal.clone();}
}

按照剧本来走的话
在这里插入图片描述
animal1克隆animal,一切祥和

public class Test {public static void main(String[] args) throws CloneNotSupportedException{Animal animal = new Animal("张三",10);Animal animal1 = (Animal)animal.clone();System.out.println(animal);System.out.println(animal1);}
}

运行起来却又报错
在这里插入图片描述
我们要想对自己写的类型进行克隆的时候,要实现Clonable 接口

运行成功,但是当我们点进Clonable 接口去看源代码的时候

就会发现这个接口是空的,所以我们实现这个接口的意义在哪里
刚才这种接口我们叫作空接口或者标记接口
他的作用在于类实现了Clonable 接口这种空接口,代表这个类是可以被克隆的


public class Test {public static void main(String[] args) throws CloneNotSupportedException{Stu stu = new Stu("张三",1);Stu stu1 = (Stu)stu.clone();System.out.println(stu.index.i);System.out.println(stu1.index.i);stu1.index.i = 0;System.out.println(stu.index.i);System.out.println(stu1.index.i);}
}class Index {public int i = 1;
}class Stu implements Cloneable{public String name;public int weight;Index index = new Index();public Stu(String name, int weight) {this.name = name;this.weight = weight;}@Overridepublic String toString() {return "Stu{" +"name='" + name + '\'' +", weight=" + weight +'}';}@Overrideprotected Object clone() throws CloneNotSupportedException {return super.clone();}
}

在这里插入图片描述
修改stu1里通过引用修改对象index里的成员变量i,但是stu里index的i值也改变

stu1克隆stu,stu和stu1两者共用同一个引用,而非另外开辟空间,所以当你通过引用改变stu1里index的i值时,也时改变stu里面index的i值,这种是浅拷贝,要实现stu里index和stu1里的index的引用不同,要进行深拷贝,Index也要支持克隆

在这里插入图片描述

如上,让Index也支持克隆,但这样仅仅是支持克隆,但是并未让Stu类里的克隆方法里进行实现对index的克隆,如下
在这里插入图片描述
这样就之后,改变stu1里index的i值就不会影响stu的了


public class Test {public static void main(String[] args) throws CloneNotSupportedException{Stu stu = new Stu("张三",1);Stu stu1 = (Stu)stu.clone();System.out.println(stu.index.i);System.out.println(stu1.index.i);stu1.index.i = 0;System.out.println(stu.index.i);System.out.println(stu1.index.i);}
}class Index implements Cloneable{public int i = 1;@Overrideprotected Object clone() throws CloneNotSupportedException {return super.clone();}
}class Stu implements Cloneable{public String name;public int weight;Index index = new Index();public Stu(String name, int weight) {this.name = name;this.weight = weight;}@Overridepublic String toString() {return "Stu{" +"name='" + name + '\'' +", weight=" + weight +'}';}@Overrideprotected Object clone() throws CloneNotSupportedException {Stu tmp = (Stu) super.clone();tmp.index = (Index) this.index.clone();return tmp;}
}

抽象类和接口的区别

**核心区别:**抽象类中可以包含普通方法和普通字段,这样的普通方法和字段可以被子类直接使用(不需要重写),而接口中不能包含普通方法,子类必须重写所有的抽象方法

在这里插入图片描述

Object类

Object是Java默认提过的一个类.Java里面除了Object类,所有的类都是存在继承关系的.默认会继承Object父类,即所有类的对象都可以使用Object的引用进行接收.

public class Test {public static void main(String[] args){Animal animal = new Animal("张三");Animal animal1 = new Animal("张三");System.out.println(animal1 == animal);}
}class Animal {String name;public Animal(String name) {this.name = name;}
}

如上比较两个对象是否相等,这种比较是比较引用,所以会打印false
Object里equals方法用来比较对象是否相等
在这里插入图片描述

public class Test {public static void main(String[] args){Animal animal = new Animal("张三");Animal animal1 = new Animal("张三");System.out.println(animal.equals(animal1));}}

在这里插入图片描述
结果仍是false

在这里插入图片描述
源码和第一次比较方式是一样的,在对引用进行比较相等,所以我们在Animal类里重写这个方法,自己来设计比较方法

class Animal {String name;public Animal(String name) {this.name = name;}@Overridepublic boolean equals(Object obj) {Animal animal = (Animal) obj;return animal.name.equals(this.name);}
}

public class Test {public static void main(String[] args){Animal animal = new Animal("张三");Animal animal1 = new Animal("张三");System.out.println(animal.equals(animal1));}}