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

红太狼 2024-04-23 20:28 5阅读 0赞

> ⭐ 作者：小胡\_不糊涂  
> 🌱 作者主页：[小胡\_不糊涂的个人主页][Link 1]  
> 📀 收录专栏：[浅谈Java][Java]  
> 💖 持续更文，关注博主少走弯路，谢谢大家支持 💖

#### 抽象类与接口 ####

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

![在这里插入图片描述][56355bddf6254618a45a2a8cec11434e.gif_pic_center]

## 1. 实现多个接口 ##

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

> 通过类来表示一组动物：

class Animal {
        
    	protected String name;
    	public Animal(String name) {
        
    	this.name = name;
    	}
    }

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

interface IFlying {
        
    	void fly();
    }
    interface IRunning {
        
    	void run();
    }
    interface ISwimming {
        
    	void swim();
    }

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

> 猫，是会跑的

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

> 鱼，是会游的

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

> 青蛙，既能跑，又能游

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 + "正在蹬腿游泳");
    	}
    }

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

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

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 + "正在漂在水上");
        }
    }

**对上述代码的实现：**

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();
    
        }
    }

🍤 *运行结果：*

![在这里插入图片描述][051ef9191072413a8e1052797d1ebfde.png]

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

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

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

**例如，现在实现一个方法，叫“散步”**

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

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

## 2. 接口间的继承 ##

在Java中，类和类之间是单继承的，一个类可以实现多个接口，接口与接口之间可以多继承。即：**用接口可以达到多继承的目的**。  
接口可以继承一个接口，达到复用的效果。使用 extends 关键字。

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 异常。

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);
        }
    }

🍤 *运行结果：*

![在这里插入图片描述][ffb19dad067248819b6dfabb45e4a90d.png]  
Cloneable 拷贝出的对象是一份“浅拷贝”

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);
        }
    }

🍤 *运行结果：*

![在这里插入图片描述][49fb33adc2d64b4b9ec5124330f80de3.png]  
如上代码，我们可以看到，通过clone，我们只是拷贝了Person对象。但是Person对象中的Money对象，并没有拷贝。通过person2这个引用修改了m的值后，person1这个引用访问m的时候，值也发生了改变。这里就是发生了浅拷贝。

## 4. 抽象类和接口的区别 ##

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

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

## 5. Object类 ##

Object 是 Java 默认提供的一个类。Java里面除了 Object类，所有的类都是存在继承关系的。默认会继承 Object父类。即所有类的对象都可以使用 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);
    	}
    }
    //执行结果：
    Person@1b6d3586
    Student@4554617c

在开发之中，Object类是参数的最高统一类型。  
但是Object类也存在有定义好的一些方法。如下：

![在这里插入图片描述][97414fcc7bd844ef98ce63a05993b8e4.png]

### 5.1 获取对象信息 ###

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

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

### 5.2 对象比较equals方法 ###

在Java中，进行比较时：

*  如果==左右两侧是基本类型变量，比较的是变量中值是否相同
 *  如果==左右两侧是引用类型变量，比较的是引用变量地址是否相同
 *  如果要比较对象中内容，必须重写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.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方法后，然后比较：

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方法源码：**

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

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

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());
        }
    }

🍤 *运行结果：*

![在这里插入图片描述][4bcf5b6dcc1441228480e2af69e7c80b.png]  
**从运行结果可以发现：两个对象的hash值是不一样的。**

重写hashcode()方法：

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());
        }
    }

🍤 *运行结果：*

![在这里插入图片描述][f89da8db854b4df28e52253c56c041dd.png]  
**此时，哈希值是一样。**

注：

*  hashcode方法用来确定对象在内存中存储的位置是否相同
 *  事实上hashCode() 在散列表中才有用，在其它情况下没用。在散列表中hashCode() 的作用是获取对象的散列码，进而确定该对象在散列表中的位置。

--------------------

![在这里插入图片描述][83a339574b8f4988878454ae3a1ad75b.png]

[Link 1]: https://blog.csdn.net/iLoyo_
[Java]: http://t.csdn.cn/P9HTz
[56355bddf6254618a45a2a8cec11434e.gif_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/a581b67d9fe04e0d9b86b0f5486388f0.gif
[051ef9191072413a8e1052797d1ebfde.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/f2ecba543c1a433e9be186d70ca91064.png
[ffb19dad067248819b6dfabb45e4a90d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/7391455cfff147fabb7f7f0f5999c214.png
[49fb33adc2d64b4b9ec5124330f80de3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/4d8be2ba019c4339910deed655624a68.png
[97414fcc7bd844ef98ce63a05993b8e4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/49b87de04bca4838b6f322e9632e2fcc.png
[4bcf5b6dcc1441228480e2af69e7c80b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/99eb0cd99cef4f12b7ad1718ef9cb326.png
[f89da8db854b4df28e52253c56c041dd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/eacd596e45b54fa1925be8a1ddd5e737.png
[83a339574b8f4988878454ae3a1ad75b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/7310bf38168c4b9d92b244558761247c.png