目录
[十、 Object类](#十、 Object类)
一、接口的概念
在现实生活中,接口的例子比比皆是,比如:笔记本上的USB口
电脑的USB口上,可以插:U盘、鼠标、键盘...所有符合USB协议的设备
通过上述例子可以看出:接口就是公共的行为规范标准,大家在实现时,只要符合规范标准,就可以通用。 在Java中,接口可以看成是:多个类的公共规范,是一种引用数据类型。
二、语法规则
接口的定义格式与定义类的格式基本相同,将class关键字换成 interface 关键字,就定义了一个接口。
java
public interface 接口名称{
// 抽象方法
public abstract void method1(); // public abstract 是固定搭配,可以不写
public void method2(); //自动加上abstract
abstract void method3(); //自动加上public
void method4(); //自动加上public abstract
// 注意:在接口中上述写法都是抽象方法,跟推荐方式4,代码更简洁
}
只能是public abstract类型
提示:
创建接口时, 接口的命名一般以大写字母 I 开头.
接口的命名一般使用 "形容词" 词性的单词.
阿里编码规范中约定, 接口中的方法和属性不要加任何修饰符号, 保持代码的简洁性
三、接口使用
接口不能直接使用,必须要有一个"实现类"来"实现"该接口,实现接口中的所有抽象方法。
注意:子类和父类之间是extends 继承关系,类与接口之间是 implements 实现关系。
实现接口用:implements,继承类用:extends
java
public class 类名称 implements 接口名称{
// ...
}
请实现笔记本电脑使用USB鼠标、USB键盘的例子
USB接口:包含打开设备、关闭设备功能
笔记本类:包含开机功能、关机功能、使用USB设备功能
鼠标类:实现USB接口,并具备点击功能
键盘类:实现USB接口,并具备输入功能
以下代码需要多态的知识可以看我这篇文章:JAVA-多态 和 重写 (彻底给你讲明白)_多态和重写的区别-CSDN博客
java
interface USB {
void openDevice();
void closeDevice();
}
//实现鼠标类
class Mouse implements USB {
@Override
public void openDevice() {
System.out.println("打开鼠标");
}
@Override
public void closeDevice() {
System.out.println("关闭鼠标");
}
public void click(){
System.out.println("鼠标点击");
}
}
//实现键盘类
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 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) usb).click();
// Mouse mouse = (Mouse)usb;
// mouse.click();
}else if(usb instanceof KeyBoard) {
//向下转型
((KeyBoard) usb).inPut();
// KeyBoard keyBoard = (KeyBoard)usb;
// keyBoard.inPut();
}
usb.closeDevice();
}
}
public class Test {
public static void main(String[] args) {
Computer computer = new Computer();
computer.powerOn();
//打开键盘
computer.useDevice(new KeyBoard());
System.out.println("====================");
//打开鼠标
computer.useDevice(new Mouse());
computer.powerOff();
}
}
结果:
四、接口特性
- 接口类型是一种引用类型,但是不能直接new接口的对象
java
public class TestUSB {
public static void main(String[] args) {
USB usb = new USB();
}
}
// Error:(10, 19) java: day20210915.USB是抽象的; 无法实例化
2.接口中每一个方法都是public的抽象方法, 即接口中的方法会被隐式的指定为 public abstract(只能是 public abstract,其他修饰符都会报错)
java
public interface USB {
// Error:(4, 18) java: 此处不允许使用修饰符private
private void openDevice();
void closeDevice();
}
3.接口中的方法是不能在接口中实现的,只能由实现接口的类来实现
java
interface USB {
void openDevice();
// 编译失败:因为接口中的方式默认为抽象方法
// Error:(5, 23) java: 接口抽象方法不能带有主体
void closeDevice(){
System.out.println("关闭USB设备");
}
default void test(){
//可以实现方法
}
}
- 重写接口中方法时,不能使用默认的访问权限
java
public interface USB {
void openDevice(); // 默认是public的
void closeDevice(); // 默认是public的
}
public class Mouse implements USB {
@Override
void openDevice() {
System.out.println("打开鼠标");
}
// ...
}
// 编译报错,重写USB中openDevice方法时,不能使用默认修饰符
// 正在尝试分配更低的访问权限; 以前为public
- 接口中可以含有变量,但是接口中的变量会被隐式的指定为 public static final 变量**(必须附初始值)**
java
public interface USB {
double brand = 3.0; // 默认被:public static final 修饰
void openDevice();
void closeDevice();
}
public class TestUSB {
public static void main(String[] args) {
System.out.println(USB.brand); // 可以直接通过接口名访问,说明是静态的
// 编译报错:Error:(12, 12) java: 无法为最终变量brand分配值
USB.brand = 2.0; // 说明brand具有final属性
}
}
- 接口中不能有静态代码块和构造方法
java
public interface USB {
// 编译失败
public USB(){
}
{} // 编译失败
void openDevice();
void closeDevice();
}
-
接口虽然不是类,但是接口编译完成后字节码文件的后缀格式也是.class
-
如果类没有实现接口中的所有的抽象方法,则类必须设置为抽象类.(抽象类再被继承,子类必须实现全部抽象方法)
-
jdk8中:接口中还可以包含default方法。
五、实现多个接口
在Java中,类和类之间是单继承的,一个类只能有一个父类 ,即Java中不支持多继承 ,但是一个类可以实现多个接口。下面通过类来表示一组动物
java
class Animal {
public String name;
public Animal(String name) {
this.name = name;
}
}
另外我们再提供一组接口, 分别表示 "会飞的", "会跑的", "会游泳的"
java
interface ISwimming {
void swim();
}
java
interface IFly {
void fly();
}
java
interface IRunning {
void run();
}
我们一般会单独建一个文件放接口
接下来我们创建几个具体的动物 :(我在打印时加上动物种类,方便观看)
猫, 是会跑的.
java
lass Cat extends Animal implements IRunning {
public Cat(String name) {
super(name);
}
@Override
public void run() {
System.out.println(super.name +"小猫正在跑");
}
}
青蛙, 既能跑, 又能游(两栖动物)
java
class Frog extends Animal implements IRunning, ISwimming {
public Frog(String name) {
super(name);
}
@Override
public void run() {
System.out.println(super.name +"青蛙正在跑");
}
@Override
public void swim() {
System.out.println(super.name +"正在游泳");
}
}
注意:一个类实现多个接口时,每个接口中的抽象方法都要实现,否则类必须设置为抽象类。
提示, IDEA 中使用 ctrl + i 快速实现接口
还有一种神奇的动物, 水陆空三栖, 叫做 "鸭子"
java
class Duck extends Animal implements IRunning, ISwimming, IFly {
public Duck(String name) {
super(name);
}
@Override
public void run() {
System.out.println(super.name +"鸭子正在跑");
}
@Override
public void fly() {
System.out.println(super.name +"鸭子正在飞");
}
@Override
public void swim() {
System.out.println(super.name + "鸭子正在游泳");
}
}
上面的代码展示了 Java 面向对象编程中最常见的用法: 一个类继承一个父类, 同时实现多种接口.
继承表达的含义是 is - a 语义, 而接口表达的含义是 具有 xxx 特性 .
这样设计有什么好处呢? 时刻牢记多态的好处, 让程序员忘记类型. 有了接口之后, 类的使用者就不必关注具体类型, 而只关注某个类是否具备某种能力.
例如, 现在实现一个方法, 叫 "散步"
java
public static void walk(IRunning running) {
System.out.println("我带着伙伴去散步");
running.run();
}
在这个 walk 方法内部, 我们并不关注到底是哪种动物, 只要参数是会跑的, 就行
java
Cat cat = new Cat("小猫");
walk(cat);
Frog frog = new Frog("小青蛙");
walk(frog);
// 执行结果
我带着伙伴去散步
小猫正在用四条腿跑
我带着伙伴去散步
小青蛙正在往前跳
六、接口间的继承
在Java中,类和类之间是单继承的,一个类可以实现多个接口,接口与接口之间可以多继承。即:用接口可以达到 多继承的目的。
接口可以继承一个接口, 达到复用的效果. 使用 extends 关键字.
java
interface IRunning {
void run();
}
interface ISwimming {
void swim();
}
// 两栖的动物, 既能跑, 也能游
interface IAmphibious extends IRunning, ISwimming {
}
class Frog implements IAmphibious {
...
}
通过接口继承创建一个新的接口 IAmphibious 表示 "两栖的". 此时实现接口创建的 Frog 类, 就继续要实现 run 方 法, 也需要实现 swim 方法。
接口间的继承相当于把多个接口合并在一起
七、接口使用实例
题目:给接口数组排序
对象数组排序是应该靠什么来排序?对象的地址?
实际是根据实际的开发场景对对象里面的成员变量来进行排序的。
列如学生类:
java
public class Student {
public String name;
public int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
那么这还不简单:
java
public static void main(String[] args) {
Student[] students = new Student[3];
students[0] = new Student("zhangsan",25);
students[1] = new Student("lisi",22);
students[2] = new Student("wangwu",21);
if(students[0].age > students[1].age) {
System.out.println(students[0].name + ">" + students[1].name);
}//......
}
虽然这样可以,但是会有一些问题:
- 在实际开发中,写main方法和类的可能不是一个程序员。这对写main方法的程序员工作加大
- java是一个开发效率高的语言,这样开发效率太低
1.Comparable
那么就给大家介绍一个接口
java
class Student implements Comparable<Student>{
public String name;
public int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public int compareTo(Student o) {
return this.age - o.age;
}
}
代码解释:
- 尖括号里面的是泛型知识,后面来写
- 实现此接口需要重写compareTo方法,里面用于你控制判断类大小的条件
java
public static void main(String[] args) {
Student[] students = new Student[3];
students[0] = new Student("zhangsan",25);
students[1] = new Student("lisi",22);
students[2] = new Student("wangwu",21);
// Arrays.sort会调用你Student里面的compareTo来判断大小
Arrays.sort(students);
System.out.println(Arrays.toString(students));
}
结果:
我们也可以用名字来排序:
java
class Student implements Comparable<Student>{
public String name;
public int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public int compareTo(Student o) {
// 谁调用,this.name就是谁
return this.name.compareTo(o.name);
// 提醒,name.出来的compareTo是Sting类里面重写了的方法
// 和这里的comparaTo不同,它底层是对每一个字符挨个比较,
// 直到不同
}
// @Override
// public int compareTo(Student o) {
// return this.age - o.age;
// }
}
结果:
2.写一个自己的sort
我们用冒泡排序来实现:
java
//用接口做为参数可以让,实现了这个接口的所有类,都可以使用此方法
public static void MySort(Comparable[] comparable) {
for (int i = 0; i < comparable.length; i++) {
for (int j = 0; j < comparable.length - 1 - i; j++) {
if(comparable[j].compareTo(comparable[j+1]) > 0) {
Comparable tmp = comparable[j];
comparable[j] = comparable[j+1];
comparable[j+1] = tmp;
}
}
}
}
这里的compareTo调用的是自己Student类里面的,以他的返回值来做判断。
我们就用名字来排序,看是否一样:
java
public static void main(String[] args) {
Student[] students = new Student[3];
students[0] = new Student("zhangsan",25);
students[1] = new Student("lisi",22);
students[2] = new Student("wangwu",21);
MySort(students);
System.out.println(Arrays.toString(students));
}
可以看到确实是可以排序。
但其实我们发现,一旦写好不易更改。如果对名字和年龄都会用到就不好办了。很不灵活
所以我再给大家介绍一个接口,可以很好的解决这个问题
3.Comparator
Student类不变:
java
class Student implements Comparable<Student>{
public String name;
public int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
@Override
public int compareTo(Student o) {
return this.age - o.age;
}
}
我们单独定义一个文件:
java
package demo3;
import java.util.Comparator;
public class AgeComparator implements Comparator<Student> {
@Override
public int compare(Student o1, Student o2) {
return o1.age - o2.age;
}
}
在这里实现Comparator方法,这个接口需要重写compare方法,一样是决定着判断类大小的方法。
我们再写一个关于年龄的比较方法,依然需要重新开一个文件:
java
package demo3;
import java.util.Comparator;
public class AgeComparator implements Comparator<Student> {
@Override
public int compare(Student o1, Student o2) {
return o1.age - o2.age;
}
}
写好了我们就可以在main方法中操作了
java
public static void main(String[] args) {
Student student1 = new Student("zhangsan",10);
Student student2 = new Student("lisi",15);
//年龄比较器
AgeComparator ageComparator = new AgeComparator();
int ret1 = ageComparator.compare(student1,student2);
System.out.println(ret1);
//名字比较强
NameComparator nameComparator = new NameComparator();
int ret2 = nameComparator.compare(student1,student2);
System.out.println(ret2);
}
结果:
八、类的克隆Clonable
1.Clonable接口
Java 中内置了一些很有用的接口, Clonable 就是其中之一.
Object是所有类的父类,Object 类中存在一个 clone 方法, 调用这个方法可以创建一个对象的 "拷贝". 但是要想合法调用 clone 方法, 必须要 先实现 Clonable 接口, 否则就会抛出 CloneNotSupportedException 异常.
java
class Student implements Cloneable{
public int age;
public Student(int age) {
this.age = age;
}
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
@Override
public String toString() {
return "Student{" +
"age=" + age +
'}';
}
}
public class Test {
public static void main(String[] args) throws CloneNotSupportedException{
Student student1 = new Student(12);
Student student2 = (Student) student1.clone();
System.out.println(student2.age);
}
}
那么实现克隆必须要有这几条件:
- 必须在类中实现Cloneable接口这个接口里并没有什么东西,只是做为标记接口或者称为空接口。只要实现了这个克隆接口证明当前类才能被克隆
- 必须重新clone方法
- 父类给到子类必须向下转型
- 异常
2.浅拷贝
将类改一下:
java
class Name {
public String name = "张三";
}
class Student implements Cloneable{
public int age;
public Name n = new Name();
public Student(int age) {
this.age = age;
}
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
java
public static void main(String[] args) throws CloneNotSupportedException{
Student student1 = new Student(20);
Student student2 = (Student) student1.clone();
System.out.println(student1.n.name);
System.out.println(student2.n.name);
System.out.println("========");
student1.n.name = "李四";
System.out.println(student1.n.name);
System.out.println(student2.n.name);
}
结果:
什么是浅拷贝,里面引用类型指向的地址不变。就是浅拷贝
深拷贝,就是引用类型指向的地址的空间也拷贝一份出来,重新划分空间并指向他
内存图解:
所以一定要注意这一点
3.深拷贝
java
class Name implements Cloneable{//写好拷贝条件
public String name = "张三";
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
class Student implements Cloneable{
public int age;
public Name n = new Name();
public Student(int age) {
this.age = age;
}
@Override
protected Object clone() throws CloneNotSupportedException {
Student tmp = (Student) super.clone();//放到临时变量中
tmp.n = (Name) this.n.clone();//将里面的对象也拷贝一份
return tmp;
}
}
java
public static void main(String[] args) throws CloneNotSupportedException{
Student student1 = new Student(20);
Student student2 = (Student) student1.clone();
System.out.println(student1.n.name);
System.out.println(student2.n.name);
System.out.println("========");
student1.n.name = "李四";
System.out.println(student1.n.name);
System.out.println(student2.n.name);
}
结果:
这样就是深拷贝了
内存图解:
九、抽象类和接口的区别
抽象类和接口都是 Java 中多态的常见使用方式. 都需要重点掌握. 同时又要认清两者的区别(重要!!! 常见面试题)
核心区别 : 抽象类中可以包含抽象方法、普通方法和普通字段, 这样的普通方法和字段可以被子类直接使用(不必重写), 而接口中 不能包含普通方法, 子类必须重写所有的抽象方法 。接口只能是抽象的方法,或者default、static修饰的方法。
再次提醒:抽象类存在的意义是为了让编译器更好的校验, 像 Animal 这样的类我们并不会直接使用, 而是使用它的子类. 万一不小心创建了 Animal 的实例, 编译器会及时提醒我们.
十、 Object类
Object是Java默认提供的一个类。Java里面除了Object类,所有的类都是存在继承关系的。默认会继承Object父 类。即所有类的对象都可以使用Object的引用进行接收。
范例:使用Object接收所有类的对象
java
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);
}
}
//执行结果:
Person@1b6d3586
Student@4554617c
所以在开发之中,Object类是参数的最高统一类型。但是Object类也存在有定义好的一些方法。如下:
对于整个Object类中的方法需要实现全部掌握。
本小节当中,我们主要来熟悉这几个方法:toString()方法,equals()方法,hashcode()方法
1.toString
这个比较简单这个就不多说了
2.对象比较equals方法
在Java中,==进行比较时:
a.如果==左右两侧是基本类型变量,比较的是变量中值是否相同
b.如果==左右两侧是引用类型变量,比较的是引用变量地址是否相同
c.如果要比较对象中内容,必须重写Object中的equals方法,因为equals方法默认也是按照地址比较的:
java
// Object类中的equals方法
public boolean equals(Object obj) {
return (this == obj); // 使用引用中的地址直接来进行比较
}
那么我们想要比较对象中的内容就要自己写:
java
class Student {
public String name;
public int age;
public Student(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public boolean equals(Object o) {
Student student = (Student) o;
if(this.name.equals(student.name)) {
return true;
}
return false;
}
}
java
public class Test {
public static void main(String[] args) {
Student student1 = new Student("zhangsan",10);
Student student2 = new Student("zhangsan",12);
System.out.println(student1.equals(student2));
}
}
结果:
java
public class Test {
public static void main(String[] args) {
Student student1 = new Student("zhangsan",10);
Student student2 = new Student("lisi",12);
System.out.println(student1.equals(student2));
}
}
结果:
写详细点的还有
java
class Student{
...
@Override
public boolean equals(Object obj) {
if (obj == null) {//地址为空肯定不相等
return false ;
}
if(this == obj) {//地址都一样一定相等
return true ;
}
// 不是Student类对象
if (!(obj instanceof Student)) {//是同一类型 = !true也就是false,不进入if
return false ;
}
Person person = (Person) obj ; // 向下转型,比较属性值
return this.name.equals(person.name) && this.age==person.age ;
}
}
结论:比较对象中内容是否相同的时候,一定要重写equals方法。
**3.**hashcode方法
回忆刚刚的toString方法的源码:
java
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
我们看到了hashCode()这个方法,他帮我算了一个具体的对象位置,这里面涉及数据结构,但是我们还没学数据结 构,没法讲述,所以我们只能说它是个内存地址。然后调Integer.toHexString()方法,将这个地址以16进制输出。
hashcode方法源码:
java
public native int hashCode();
该方法是一个native方法 ,底层是由C/C++代码写的。我们看不到。
java
public static void main(String[] args) {
Student student1 = new Student("zhangsan",10);
Student student2 = new Student("lisi",12);
System.out.println(student1.hashCode());
System.out.println(student2.hashCode());
}
结果:
注意事项:两个对象的hash值不一样。
从业户逻辑上来说,我们认为两个名字相同,年龄相同的对象 ,将存储在同一个位置,需要重写hashcode()方法,我们可以来看示例 代码:
java
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 TestDemo4 {
public static void main(String[] args) {
Person per1 = new Person("gaobo", 20) ;
Person per2 = new Person("gaobo", 20) ;
System.out.println(per1.hashCode());
System.out.println(per2.hashCode());
}
}
//执行结果
460141958
460141958
注意事项:哈希值一样。
结论:
1、hashcode方法用来确定对象在内存中存储的位置是否相同
2、事实上hashCode() 在散列表中才有用,在其它情况下没用。在散列表中hashCode() 的作用是获取对象的 散列码,进而确定该对象在散列表中的位置
我们一般可以通过idea自带的工具实现hashcode和equals步骤:
生成:
java
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Student student = (Student) o;
return age == student.age && Objects.equals(name, student.name);
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}