【Java SE】抽象类和接口（二）

2023-02-17 78

版权

本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。

简介： 【Java SE】抽象类和接口

🐳如何实现接口间的继承

1. //把IRunning,ISwimming,Iflying全部继承到IAction上
2. 
3. interface IAction extends IRunning,ISwimming,Iflying{
4. 
5. }
6. 
7. class Swan extends Animal implements IAction {
8. 
9. 
10. public Swan(String name) {
11. super(name);
12.     }
13. 
14. @Override
15. public void run() {
16.         System.out.println(name + "正在跑");
17. 
18.     }
19. 
20. @Override
21. public void swim() {
22.         System.out.println(name + "正在游泳");
23. 
24.     }
25. 
26. @Override
27. public void fly() {
28.         System.out.println(name + "正在飞");
29. 
30.     }
31. }
32. 
33. public class Test {
34. 
35. public static void main(String[] args) {
36.        Swan swan=new Swan("白白");
37.        swan.run();
38.        swan.swim();
39.        swan.fly();
40. 
41.     }
42. 
43. }

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

🐳抽象类和接口的区别：

（1）抽象类可以有构造方法，接口中不能有构造方法。

（2）抽象类中可以有普通成员变量，接口中没有普通成员变量。

（3）抽象类中可以包含静态方法，接口中不能包含静态方法。

（4）一个类可以实现多个接口，但只能继承一个抽象类。

（5）接口可以被多重实现，抽象类只能被单一继承。

（6）如果抽象类实现接口，则可以把接口中方法映射到抽象类中作为抽象方法而不必实现，而在抽象类的子类中实现接口中方法。

接口和抽象类的相同点：

(1) 都可以被继承。

(2) 都不能被实例化。

(3) 都可以包含方法声明。

(4) 派生类必须实现未实现的方法。

🐳何为Object类？

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

1. public class Test2 {
2. public static void main(String[] args) {
3. 
4.         fun1(new A());
5.         fun1(new B());
6.     }
7. public static void fun1(Object object){
8.         System.out.println(object);
9.     }
10. }
11. 
12. 
13. class A{
14. 
15. }
16. class B{
17. 
18. }

🐳利用Object类获取对象信息

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

1. class Animal{
2. protected String name;
3. 
4. public Animal(String name){
5. this.name=name;
6.     }
7. 
8. @Override
9. public String toString() {
10. return "Animal{" +
11. "name='" + name + '\'' +//可以修改
12. '}';
13.     }
14. }

🐳 利用Object类进行对象比较

在Java中，==进行比较时：
a.如果==左右两侧是基本类型变量，比较的是变量中值是否相同
b.如果==左右两侧是引用类型变量，比较的是引用变量地址是否相同
c.如果要比较对象中内容，必须重写Object中的equals方法，因为equals方法默认也是按照地址比较的

1. //Object类中的equals方法
2. public boolean equals(Object obj) {
3. return (this == obj); // 使用引用中的地址直接来进行比较
4. }
5. 
6. public class Test {
7. public static void main(String[] args) {
8.         Cat cat1=new Cat("小白",5);
9.         Cat cat2=new Cat("小白",5);
10. int a=10;
11. int b=10;
12.         System.out.println(a==b);
13.         System.out.println(cat1==cat2);
14.         System.out.println(cat1.equals(cat2));
15. 
16.     }
17. }
18. 
19. class Cat{
20. private String name;
21. private int age;
22. public Cat(String name,int age){
23. this.name=name;
24. this.age=age;
25.     }
26. }

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

1. @Override
2. public boolean equals(Object o) {
3. if (this == o) return true;
4. if (o == null || getClass() != o.getClass()) return false;
5. Cat cat = (Cat) o;
6. return age == cat.age && name.equals(cat.name);
7.     }

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

🐳hashcode方法

hashcode方法用来确定对象在内存中存储的位置是否相同

事实上hashCode() 在散列表中才有用，在其它情况下没用。在散列表中hashCode() 的作用是获取对象的散列码，进而确定该对象在散列表中的位置。

我们认为两个名字相同，年龄相同的对象，将存储在同一个位置，如果不重写hashcode()方法

1. public class Test {
2. public static void main(String[] args) {
3.         Cat cat1=new Cat("小白",5);
4.         Cat cat2=new Cat("小白",5);
5.         System.out.println(cat1.hashCode());
6.         System.out.println(cat2.hashCode());
7. 
8.     }
9. }
10. 
11. class Cat{
12. private String name;
13. private int age;
14. public Cat(String name,int age){
15. this.name=name;
16. this.age=age;
17.     }
18. 
19. 
20. }

注意事项：两个对象的hash值不一样

像重写equals方法一样，我们也可以重写hashcode()方法。此时我们再来看看。

1. import java.util.Objects;
2. 
3. public class Test {
4. public static void main(String[] args) {
5.         Cat cat1=new Cat("小白",5);
6.         Cat cat2=new Cat("小白",5);
7.         System.out.println(cat1.hashCode());
8.         System.out.println(cat2.hashCode());
9. 
10.     }
11. }
12. 
13. class Cat{
14. private String name;
15. private int age;
16. public Cat(String name,int age){
17. this.name=name;
18. this.age=age;
19.     }
20. @Override
21. public int hashCode() {
22. return Objects.hash(name, age);
23.     }
24. 
25. }