文章目录
- 1. 接口
- 1.1 接口的概念
- 1.2 语法规则
- 1.3 接口的使用
- 1.4 接口的特性
- 1. 5 实现多个接口
- 1.6 接口间的继承
- 1.7 接口使用实例
- 1.8 Clonable 接口和深拷贝
- 1.9 抽象类和接口的区别
- 2. Object类
- 2.1 获取实例对象
- 2.2 对象比较equals方法
- 2.3 hashcode方法
1. 接口
1.1 接口的概念
在现实生活中，接口的例子比比皆是，比如：笔记本上的USB口，手机的Type—c接口等。
电脑的USB口上，可以插：U盘、鼠标、键盘…所有符合USB协议的设备。
手机Type—c接口上，可以插：耳机、充电线…所有符合规范的设备。
接口就是公共的行为规范标准，大家在实现时，只要符合规范标准，就可以通用。
在Java中，接口可以看成是：多个类的公共规范，是一种引用数据类型。
1.2 语法规则
接口的定义格式与定义类的格式基本相同，将class关键字换成 interface 关键字，就定义了一个接口。
interface IShape{
public abstract void draw();
}
public class Test {
}这里定义了一个draw方法（抽象方法），因为被abstract修饰所以不需要写出是怎样实现的。
- 创建接口时, 接口的命名一般以大写字母 I 开头。
- 接口的命名一般使用 “形容词” 词性的单词。
- 阿里编码规范中约定, 接口中的方法和属性不要加任何修饰符号, 保持代码的简洁性。
可以实现一个静态方法
interface IShape{
public abstract void draw();
default public void func() {
System.out.println("YYDS！");
}
public static void func1() {
System.out.println("java!");
}
}接口不能实例化，那该怎么使用？
类与接口之间使用implements来实现多个接口。
class A implements IShape {
@Override
public void draw() {
System.out.println("*******");
}
}1.3 接口的使用
接口不能直接使用，必须要有一个"实现类"来"实现"该接口，实现接口中的所有抽象方法。
public class 类名称 implements 接口名称{
// ...
}【注意】
子类和父类之间是extends 继承关系，类与接口之间是 implements 实现关系。
interface USB {
public void openDevice();//打开
public void closeDevice();//关闭
}
class KeyBoard implements USB{
@Override
public void openDevice() {
System.out.println("打开键盘~");
}
@Override
public void closeDevice() {
System.out.println("关闭键盘~");
}
public void inPut(){
System.out.println("键盘输入~");
}
}
class Mouse implements USB{
@Override
public void openDevice() {
System.out.println("打开鼠标~");
}
@Override
public void closeDevice() {
System.out.println("关闭鼠标~");
}
public void click() {
System.out.println("鼠标点击~");
}
}
public class Computer {
public void powerOn(){
System.out.println("打开笔记本电脑");
}
public void powerOff(){
System.out.println("关闭笔记本电脑");
}
public void useDevice(USB usb) {
usb.openDevice();
if (usb instanceof Mouse) {
Mouse mouse = (Mouse) usb;
mouse.click();
} else if (usb instanceof KeyBoard) {
KeyBoard keyBoard = (KeyBoard) usb;
keyBoard.inPut();
}
usb.closeDevice();
}
public static void main(String[] args) {
Computer computer = new Computer();
computer.powerOn();
//使用鼠标设备
computer.useDevice(new Mouse());
// 使用键盘设备
computer.useDevice(new KeyBoard());
computer.powerOff();
}
}
1.4 接口的特性
- 接口类型是一种引用类型，但是不能直接new接口的对象
编译器报错
- 接口中每一个方法都是public的抽象方法, 即接口中的方法会被隐式的指定为 public abstract（只能是public abstract，其他修饰符都会报错）。
可见编译器报错。
- 接口中不能有方法的具体实现。
可见编译器报错。
- 重写接口中方法时，不能使用默认的访问权限修饰
编译器报错。
- 接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量。
interface USB {
public void openDevice();//打开
public void closeDevice();//关闭
public static final int brand = 1;
}
- 接口中不能有静态代码块和构造方法
报错
- 接口虽然不是类，但是接口编译完成后字节码文件的后缀格式也是.class
- 如果类没有实现接口中的所有的抽象方法，则类必须设置为抽象类
- jdk8中：接口中还可以包含default方法
1. 5 实现多个接口
Java中不支持多继承，但是一个类可以实现多个接口。
用implements来实现，每个接口之间用逗号来连接。
interface A1 {
public void func1();
}
interface B1 {
public void func2();
}
class C1 implements A1,B1 {
@Override
public void func1() {
}
@Override
public void func2() {
}
}
public class Test {
}下面来看一个例子。
interface IFlying {
public void fly();
}
interface IRunning {
public void run();
}
interface ISwimming {
public void swim();
}
class Animals {
protected String name;
public void eat() {
System.out.println("吃食物~");
}
public Animals(String name) {
this.name = name;
}
}
class Dog extends Animals implements IRunning, ISwimming{
public Dog(String name) {
super(name);
}
@Override
public void run() {
System.out.println(this.name + "正在跑~");
}
@Override
public void swim() {
System.out.println(this.name + "正在游泳~");
}
}
class Bird extends Animals implements IFlying{
public Bird(String name) {
super(name);
}
@Override
public void fly() {
System.out.println(this.name + "正在飞~");
}
}
class Frog extends Animals implements IRunning, ISwimming{
public Frog(String name) {
super(name);
}
@Override
public void run() {
System.out.println(this.name + "正在跑~");
}
@Override
public void swim() {
System.out.println(this.name + "正在游泳~");
}
}
class Duck extends Animals implements IFlying, IRunning, ISwimming{
public Duck(String name) {
super(name);
}
@Override
public void fly() {
System.out.println(this.name + "正在飞~");
}
@Override
public void run() {
System.out.println(this.name + "正在跑~");
}
@Override
public void swim() {
System.out.println(this.name + "正在游泳~");
}
}
class Robot implements IRunning {
private String name;
public Robot(String name) {
this.name = name;
}
@Override
public void run() {
System.out.println(this.name + "正在用轮子跑");
}
}
public class Test1 {
public static void walk(IRunning iRunning) {
iRunning.run();
}
public static void main(String[] args) {
walk(new Dog("小狗"));
walk(new Duck("鸭子"));
walk(new Frog("青蛙"));
walk(new Robot("机器人"));
}
}
狗是一种动物, 具有会跑、游泳的特性。
鸟是一种动物，具有会飞的特性。
青蛙也是一种动物, 既能跑, 也能游泳。
鸭子也是一种动物, 既能跑, 也能游, 还能飞。
注意：一个类实现多个接口时，每个接口中的抽象方法都要实现，否则类必须设置为抽象类。
有了接口之后，类的使用者就不必关注具体类型，而只关注某个类是否具备某种能力。
1.6 接口间的继承
接口与接口之间可以多继承。即：用接口可以达到多继承的目的。
接口可以继承一个接口，达到复用的效果，使用 extends 关键字。
interface Iflying {
public void fly();
}
interface Iswimming {
public void swim();
}
interface Ifunc extends Iflying, ISwimming {
public void func();
}
interface Ifunc1 extends Ifunc {
public void func1();
}接口间的继承相当于把多个接口合并在一起
1.7 接口使用实例
class Student {
public String name;
public int age;
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
}
public class Test {
public static void main(String[] args) {
Student[] student = new Student[3];
student[0] = new Student("zhangsan", 19);
student[1] = new Student("lisi", 17);
student[2] = new Student("wangwu", 20);
Arrays.sort(student);
System.out.println(Arrays.toString(student));
}
}上面代码是按照学生的姓名比较的？还是按照学生的年龄比价的？
我们要让Student类可支持比较大小。
现在分别写出按照年龄和姓名排序的方法：
import java.util.Arrays;
import java.util.Comparator;
class StudentSort implements Comparable<StudentSort>{
public String name;
public int age;
public StudentSort(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public int compareTo(StudentSort o) {
if(this.age - o.age > 0) {
return 1;
}else if(this.age - o.age < 0) {
return -1;
}else {
return 0;
}
//return 0;
}
}
class AgeComparator implements Comparator<StudentSort> {
@Override
public int compare(StudentSort o1, StudentSort o2) {
return o1.age - o2.age;
}
}
class NameComparator implements Comparator<StudentSort> {
@Override
public int compare(StudentSort o1, StudentSort o2) {
return o1.name.compareTo(o2.name);
}
}
public class TestSort {
public static void main(String[] args) {
StudentSort[] students = new StudentSort[3];
students[0] = new StudentSort("zhangsan", 10);
students[1] = new StudentSort("lisi", 40);
students[2] = new StudentSort("wangwu", 5);
AgeComparator ageComparator = new AgeComparator();//按照年龄排序
Arrays.sort(students, ageComparator);
System.out.println(Arrays.toString(students));
NameComparator nameComparator = new NameComparator();//按照姓名排序
Arrays.sort(students, nameComparator);
System.out.println(Arrays.toString(students));
}
}
输出的第一行是年龄有小到排序的，第二行是姓名有小到大排序的。
1.8 Clonable 接口和深拷贝
Object 类中存在一个 clone 方法，调用这个方法可以创建一个对象的 “拷贝”。但是要想合法调用 clone 方法，必须要先实现 Clonable 接口，否则就会抛出 CloneNotSupportedException 异常。
class Person1 implements Cloneable{
public int id;
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
@Override
public String toString() {
return "Person{" +
"id=" + id +
'}';
}
}
public class Test {
public static void main(String[] args) throws CloneNotSupportedException {
Person1 person = new Person1();
person.id = 99;
Person1 person1 = (Person1)person.clone();
person1.id = 100;
System.out.println(person);
System.out.println(person1);
}
}
浅拷贝：
先来看一段代码
class Money {
public double money = 12.5;
}
class Person implements Cloneable{
public int id;
public Money money = new Money();
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
@Override
public String toString() {
return "Person{" +
"id=" + id +
'}';
}
}
public class Test {
public static void main(String[] args) throws CloneNotSupportedException {
Person person = new Person();
Person person1 = (Person)person.clone();
System.out.println("person:" + person.money.money);
System.out.println("person1:" + person.money.money);
}
}
如果将person1中的money的值改变会发生什么呢？
public class Test {
public static void main(String[] args) throws CloneNotSupportedException {
Person person = new Person();
Person person1 = (Person)person.clone();
person1.money.money = 199;
System.out.println("person:" + person.money.money);
System.out.println("person1:" + person.money.money);
}
}
根据运行结果会发现，person1的值修改后。person的值也跟着一起修改了。
这种情况就叫做浅拷贝。
很明显这并不是想要得到的结果，那该怎么做呢？
深拷贝：
class Money implements Cloneable{
public double m = 12.5;
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
class Person implements Cloneable{
public int id;
public Money money = new Money();
@Override
protected Object clone() throws CloneNotSupportedException {
Person tmp = (Person) super.clone();
tmp.money = (Money) this.money.clone();
return tmp;
}
@Override
public String toString() {
return "Person{" +
"id=" + id +
'}';
}
}
public class Test {
public static void main(String[] args) throws CloneNotSupportedException {
Person person = new Person();
Person person2 = (Person)person.clone();
person2.money.m = 1999;
System.out.println("person："+person.money.m);
System.out.println("person2："+person2.money.m);
}
}
1.9 抽象类和接口的区别
抽象类中可以包含普通方法和普通字段, 这样的普通方法和字段可以被子类直接使用(不必重写), 而接口中不能包含普通方法, 子类必须重写所有的抽象方法。
如之前写的 Animal 例子， 此处的 Animal 中包含一个 name 这样的属性， 这个属性在任何子类中都是存在的。因此此处的 Animal 只能作为一个抽象类，而不应该成为一个接口。
class Animal {
protected String name;
public Animal(String name) {
this.name = name;
}
}抽象类存在的意义是为了让编译器更好的校验，像 Animal 这样的类我们并不会直接使用，而是使用它的子类。万一不小心创建了 Animal 的实例，编译器会及时提醒我们。
2. Object类
Object是Java默认提供的一个类，所有类的对象都可以使用Object的引用进行接收。
class Person {
}
class Student {
}
public class Test {
public static void func(Object object) {
System.out.println(object);
}
public static void main(String[] args) {
func(new Person());
func(new Student());
}
}
对于整个Object类中的方法需要实现全部掌握。
本小节当中，我们主要来熟悉这几个方法：toString()方法，equals()方法，hashcode()方法。
2.1 获取实例对象
如果要打印对象中的内容，可以直接重写Object类中的toString()方法，之前已经讲过了，此处不再赘述。
// Object类中的toString()方法实现：
public String toString() {
return getClass().getName() + "@" Integer.toHexString(hashCode());
}2.2 对象比较equals方法
在Java中，== 进行比较时：
- a.如果 == 左右两侧是基本类型变量，比较的是变量中值是否相同
- b.如果==左右两侧是引用类型变量，比较的是引用变量地址是否相同
- c.如果要比较对象中内容，必须重写Object中的equals方法，因为equals方法默认也是按照地址比较的：
// Object类中的equals方法
public boolean equals(Object obj) {
return (this == obj); // 使用引用中的地址直接来进行比较
}因为是按照地址进行比较的，是两块不同的空间，所以比较出来的结果不相等。
class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
}
class Student {
}
public class Test {
public static void main(String[] args) {
Person person1 = new Person("张三", 19);
Person person2 = new Person("张三", 19);
System.out.println(person1.equals(person2));
}
}
调试后可见person1和person2所在的位置不一样。
要换一种比较的方法。
按照自己的逻辑重写一下。
class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public boolean equals(Object obj) {
Person person = (Person) obj;
if (this.name.equals(person.name) && this.age == person.age) {
return true;
}else {
return false;
}
}
}
class Student {
}
public class Test {
public static void main(String[] args) {
Person person1 = new Person("张三", 19);
Person person2 = new Person("张三", 19);
System.out.println(person1.equals(person2));
}
}
2.3 hashcode方法
hashCode()这个方法，他帮我算了一个具体的对象位置。由于这里面涉及数据结构，现在只是简单的认识一下。
两个名字相同，年龄相同的对象，将存储在同一个位置，如果不重写hashcode()方法。
我们可以来看示例代码：
class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
}
class Student {
}
public class Test {
public static void main(String[] args) {
Person per1 = new Person("zhangsan", 20) ;
Person per2 = new Person("zhangsan", 20) ;
System.out.println(per1.hashCode());
System.out.println(per2.hashCode());
}
}
可以看到两个值不一样大。
这里和equals一样需要重写一下。
import java.util.Objects;
class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
}
class Student {
}
public class Test {
public static void main(String[] args) {
Person per1 = new Person("zhangsan", 20) ;
Person per2 = new Person("zhangsan", 20) ;
System.out.println(per1.hashCode());
System.out.println(per2.hashCode());
}
}
可以发现两个值一样大了。
- hashcode方法用来确定对象在内存中存储的位置是否相同
- 事实上hashCode() 在散列表中才有用，在其它情况下没用。在散列表中hashCode() 的作用是获取对象的散列码，进而确定该对象在散列表中的位置
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
