【JAVA】抽象类与接口--下

小胡_不糊涂2023-08-26 11:42

⭐ 作者：小胡_不糊涂

🌱 作者主页：小胡_不糊涂的个人主页

📀 收录专栏：浅谈Java

💖 持续更文，关注博主少走弯路，谢谢大家支持 💖

抽象类与接口

  • [1. 实现多个接口](#1. 实现多个接口)
  • [2. 接口间的继承](#2. 接口间的继承)
  • [3. Clonable接口和深拷贝](#3. Clonable接口和深拷贝)
  • [4. 抽象类和接口的区别](#4. 抽象类和接口的区别)
  • [5. Object类](#5. Object类)
    • [5.1 获取对象信息](#5.1 获取对象信息)
    • [5.2 对象比较equals方法](#5.2 对象比较equals方法)
    • [5.3 hashcode方法](#5.3 hashcode方法)

1. 实现多个接口

在Java中，类和类之间是单继承的，一个类只能有一个父类，即Java中不支持多继承，但是一个类可以实现多个接口。

通过类来表示一组动物：

java 复制代码 
class Animal {
	protected String name;
	public Animal(String name) {
	this.name = name;
	}
}

另外我们再提供一组接口，分别表示"会飞的"，"会跑的"，"会游泳的"：

java 复制代码 
interface IFlying {
	void fly();
}
interface IRunning {
	void run();
}
interface ISwimming {
	void swim();
}

接下来我们创建几个具体的动物：

猫，是会跑的

java 复制代码 
class Cat extends Animal implements IRunning {
	public Cat(String name) {
	super(name);
	}
	@Override
	public void run() {
	System.out.println(this.name + "正在用四条腿跑");
	}
}

鱼，是会游的

java 复制代码 
class Fish extends Animal implements ISwimming {
	public Fish(String name) {
		super(name);
	}
	@Override
	public void swim() {
		System.out.println(this.name + "正在用尾巴游泳");
	}
}

青蛙，既能跑，又能游

java 复制代码 
class Frog extends Animal 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 + "正在蹬腿游泳");
	}
}

当一个类实现多个接口时，每个接口中的抽象方法都要实现，否则类必须设置为抽象类。

例如：鸭子，会游、会飞、会跑

java 复制代码 
class Duck extends Animal implements IRunning, ISwimming, IFlying {
    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 + "正在漂在水上");
    }
}

对上述代码的实现：

java 复制代码 
public class test {
    public static void main(String[] args) {
        Cat cat=new Cat("小花");
        cat.run();

        Fish fish=new Fish("jiujiu");
        fish.swim();

        Frog frog=new Frog("青蛙王子");
        frog.run();
        frog.swim();

        Duck duck=new Duck("可达鸭");
        duck.run();
        duck.fly();
        duck.swim();

    }
}

🍤 运行结果：

上面的代码展示了 Java 面向对象编程中最常见的用法：一个类继承一个父类，同时实现多种接口。

🍩继承表达的含义是 is - a 语义，而接口表达的含义是具有 xxx 特性

🍩有了接口之后，类的使用者就不必关注具体类型，而只关注某个类是否具备某种能力

例如，现在实现一个方法，叫"散步"

java 复制代码 
public static void walk(IRunning running) {
	System.out.println("我带着伙伴去散步");
	running.run();
}

在这个 walk 方法内部，我们并不关注到底是哪种动物，只要参数是会跑的就行。

2. 接口间的继承

在Java中，类和类之间是单继承的，一个类可以实现多个接口，接口与接口之间可以多继承。即：用接口可以达到多继承的目的 。

接口可以继承一个接口，达到复用的效果。使用 extends 关键字。

java 复制代码 
interface IRunning {
	void run();
}
interface ISwimming {
	void swim();
}
// 两栖的动物, 既能跑, 也能游
interface IAmphibious extends IRunning, ISwimming {
}
class Frog implements IAmphibious {
	...
}

通过接口继承创建一个新的接口 IAmphibious 表示"两栖的"，此时实现接口创建的 Frog 类，就继续要实现 run 方法，也需要实现 swim 方法。

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

3. Clonable接口和深拷贝

Java 中内置了一些很有用的接口，Clonable 就是其中之一。

Object 类中存在一个 clone 方法，调用这个方法可以创建一个对象的"拷贝"。但是要想合法调用 clone 方法，必须要先实现 Clonable 接口，否则就会抛出CloneNotSupportedException 异常。

java 复制代码 
class Animals implements Cloneable {
    private String name;
    @Override
    public Animals clone() {
        Animals o = null;
        try {
            o = (Animals)super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return o;
    }
}
public class Test1 {
    public static void main(String[] args) {
        Animals animal = new Animals();
        Animals animal2 = animal.clone();
        System.out.println(animal == animal2);
    }
}

🍤 运行结果：


Cloneable 拷贝出的对象是一份"浅拷贝"

java 复制代码 
class Money {
    public double m = 99.99;
}
class Person implements Cloneable{
    public Money money = new Money();
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
public class Test1 {
    public static void main(String[] args) throws CloneNotSupportedException {
        Person person1 = new Person();
        Person person2 = (Person) person1.clone();
        System.out.println("通过person2修改前的结果");
        System.out.println(person1.money.m);
        System.out.println(person2.money.m);
        person2.money.m = 13.6;
        System.out.println("通过person2修改后的结果");
        System.out.println(person1.money.m);
        System.out.println(person2.money.m);
    }
}

🍤 运行结果：

如上代码，我们可以看到，通过clone，我们只是拷贝了Person对象。但是Person对象中的Money对象，并没有拷贝。通过person2这个引用修改了m的值后，person1这个引用访问m的时候，值也发生了改变。这里就是发生了浅拷贝。

4. 抽象类和接口的区别

核心区别： 抽象类中可以包含普通方法和普通字段，这样的普通方法和字段可以被子类直接使用（不必重写），而接口中不能包含普通方法，子类必须重写所有的抽象方法。

区别 抽象类(abstract) 接口(interface)
1 结构组成 普通类+抽象方法 抽象方法+全局变量
2 权限 各种权限 public
3 子类使用 使用extends关键字继承抽象类 使用implements关键字实现接口
4 关系 一个抽象类可以实现若干接口 接口不能继承抽象类，但是接口可以使用extends关键字继承多个父接口
5 子类限制 一个子类只能继承一个抽象类 一个子类可以实现多个接口

5. 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类也存在有定义好的一些方法。如下：

5.1 获取对象信息

如果要打印对象中的内容，可以直接重写Object类中的toString()方法

java 复制代码 
// Object类中的toString()方法实现：
public String toString() {
	return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

5.2 对象比较equals方法

在Java中，进行比较时：

  • 如果==左右两侧是基本类型变量，比较的是变量中值是否相同
  • 如果==左右两侧是引用类型变量，比较的是引用变量地址是否相同
  • 如果要比较对象中内容，必须重写Object中的equals方法，因为equals方法默认也是按照地址比较的：
java 复制代码 
// Object类中的equals方法
public boolean equals(Object obj) {
	return (this == obj); // 使用引用中的地址直接来进行比较
}

实例：判断相等

java 复制代码 
class Person{
    private String name ;
    private int age ;
    public Person(String name, int age) {
        this.age = age ;
        this.name = name ;
    }
}
public class Test1 {
    public static void main(String[] args) {
        Person p1 = new Person("gaobo", 20) ;
        Person p2 = new Person("gaobo", 20) ;
        int a = 10;
        int b = 10;
        System.out.println(a == b); // 输出true
        System.out.println(p1 == p2); // 输出false
        System.out.println(p1.equals(p2)); // 输出false
    }
}

Person类重写equals方法后，然后比较：

java 复制代码 
class Person{
    private String name ;
    private int age ;
    public Person(String name, int age) {
        this.age = age ;
        this.name = name ;
    }
    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 ;
    }
}
public class Test1 {
    public static void main(String[] args) {
        Person p1 = new Person("gaobo", 20) ;
        Person p2 = new Person("gaobo", 20) ;
        int a = 10;
        int b = 10;
        System.out.println(a == b); // 输出true
        System.out.println(p1 == p2); // 输出false
        System.out.println(p1.equals(p2)); // 输出true
    }
}

所以比较对象中内容是否相同的时候，一定要重写equals方法。

5.3 hashcode方法

hashcode方法源码：

java 复制代码 
public native int hashCode();
//该方法是一个native方法，底层是由C/C++代码写的。

我们认为两个名字相同，年龄相同的对象，将存储在同一个位置，如果不重写hashcode()方法，我们可以来看示例代码：

java 复制代码 
class Person {
    public String name;
    public int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
public class Test1 {
    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());
    }
}

🍤 运行结果：


从运行结果可以发现：两个对象的hash值是不一样的。

重写hashcode()方法：

java 复制代码 
import java.util.Objects;
//重写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 Test1 {
    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());
    }
}

🍤 运行结果：


此时，哈希值是一样。

注：

  • hashcode方法用来确定对象在内存中存储的位置是否相同
  • 事实上hashCode() 在散列表中才有用，在其它情况下没用。在散列表中hashCode() 的作用是获取对象的散列码，进而确定该对象在散列表中的位置。
相关推荐
吾日三省吾码22 分钟前
JVM 性能调优
java
stm 学习ing27 分钟前
FPGA 第十讲 避免latch的产生
c语言·开发语言·单片机·嵌入式硬件·fpga开发·fpga
湫ccc1 小时前
《Python基础》之字符串格式化输出
开发语言·python
弗拉唐1 小时前
springBoot，mp，ssm整合案例
java·spring boot·mybatis
oi772 小时前
使用itextpdf进行pdf模版填充中文文本时部分字不显示问题
java·服务器
mqiqe2 小时前
Python MySQL通过Binlog 获取变更记录 恢复数据
开发语言·python·mysql
AttackingLin2 小时前
2024强网杯--babyheap house of apple2解法
linux·开发语言·python
少说多做3432 小时前
Android 不同情况下使用 runOnUiThread
android·java
热门推荐
01ICLR24大模型提示(1/11) | BadChain：大型语言模型的后门思维链提示02PyTorch机器学习实现液态神经网络03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04【音视频 | opus】opus编解码库(opus-1.4)详细介绍以及使用——附带解码示例代码05Coze扣子平台完整体验和实践（附国内和国际版对比）06(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明07IT专业入门，高考假期预习指南08玄机平台应急响应—webshell查杀09RAG 实践- Ollama+RagFlow 部署本地知识库10〔AI 绘画〕Stable Diffusion 之 解决绘制多人或面部很小的人物时面部崩坏问题 篇