• 【Java SE】抽象类和接口

    🐳什么是抽象类？ 

    在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，那么这样的类称为抽象类。

    🐳如何构造出一个抽象类？

    在Java中，一个类如果被 abstract 修饰称为抽象类，抽象类中被 abstract 修饰的方法称为抽象方法，抽象方法不用给出具体的实现体。

    1. //抽象类
    2. public abstract class Shape {
    3.  
    4.     protected double area;
    5.     abstract public void draw();//抽象方法
    6.     public double getarea(){//普通方法
    7.         return area;
    8.     }
    9.  
    10. }

    注：抽象类也是类，内部可以包含普通方法和属性，甚至构造方法。

    🐳抽象类有哪些特性？ 

    1. 抽象类不能直接实例化对象 

    2.抽象方法不能是 private 的

    注意：抽象方法没有加访问限定符时，默认是public.

    3. 抽象方法不能被final和static修饰，因为抽象方法要被子类重写

    4. 抽象类必须被继承，并且继承后子类要重写父类中的抽象方法，否则子类也是抽象类，必须要使用 abstract 修饰

    5. 抽象类中不一定包含抽象方法，但是有抽象方法的类一定是抽象类

    6. 抽象类中可以有构造方法，供子类创建对象时，初始化父类的成员变量

    7.抽象类本身不能被实例化, 要想使用, 只能创建该抽象类的子类.，然后让子类重写抽象类中的抽象方法。

    🐳问题：普通类也能被继承，普通方法也能被重写，为什么要用抽象类和抽象方法呢？

    通常在使用抽象类的场景中实际工作不应该由父类完成, 而应由子类完成. 那么此时如果不小心误用成父类了, 使用普通类编译器是不会报错的。但是父类是抽象类由于抽象类不能实例化就会报错, 让我们尽早发现问题。

    🐳什么是接口？ 

    Java接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。

    接口可以理解为一种特殊的类，里面全部是由全局常量和公共的抽象方法所组成。接口是解决Java无法使用多继承的一种手段，但是接口在实际中更多的作用是制定标准的。或者我们可以直接把接口理解为100%的抽象类，即接口中的方法必须全部是抽象方法。（jdk1.8前）

    🐳如何实现一个接口？

    接口的定义格式与定义类的格式基本相同，将class关键字换成 interface 关键字，就定义了一个接口。 

    1. //接口的定义格式与定义类的格式基本相同，将class关键字换成 interface 关键字，就定义了一个接口。
    2. public interface USB {
    3.  
    4.     public abstract void method1();// public abstract 是固定搭配，可以不写
    5.  
    6.     void method2();// public abstract 是固定搭配，可以不写
    7.  
    8. }

     注意：接口不能直接使用，必须要有一个"实现类"来"实现"该接口，实现接口中的所有抽象方法

    1. public class 类名称 implements 接口名称{
    2.  
    3. //.......
    4.  
    5. }

    注意：子类和父类之间是extends 继承关系，类与接口之间是 implements 实现关系。

     下面实现一个简单的USB接口：

    1. public interface USB {
    2.  
    3.  void OpenDevice();
    4.  
    5.  void CloseDevice();
    6.  
    7. }
    8.  
    9. public class Mouse implements USB{
    10.  
    11.     @Override
    12.     public void OpenDevice() {
    13.         System.out.println("打开鼠标");
    14.  
    15.     }
    16.  
    17.     @Override
    18.     public void CloseDevice() {
    19.         System.out.println("关闭鼠标");
    20.  
    21.     }
    22.  
    23.     public void Click(){
    24.         System.out.println("鼠标点击");
    25.     }
    26. }
    27.  
    28.  
    29. public class KeyBoard implements USB{
    30.     @Override
    31.     public void OpenDevice() {
    32.         System.out.println("打开键盘");
    33.  
    34.     }
    35.  
    36.     @Override
    37.     public void CloseDevice() {
    38.         System.out.println("关闭键盘");
    39.  
    40.     }
    41.  
    42.     public void Input(){
    43.         System.out.println("键盘输入");
    44.     }
    45. }
    46.  
    47. public class Computer implements USB{
    48.     @Override
    49.     public void OpenDevice() {
    50.         System.out.println("打开电脑");
    51.     }
    52.  
    53.     @Override
    54.     public void CloseDevice() {
    55.         System.out.println("关闭电脑");
    56.     }
    57.  
    58.     public void UseDevice(USB usb){
    59.  
    60.         usb.OpenDevice();
    61.         if(usb instanceof Mouse){
    62.             Mouse mouse=(Mouse) usb;
    63.             mouse.Click();
    64.         } else if (usb instanceof KeyBoard) {
    65.             KeyBoard keyBoard=(KeyBoard) usb;
    66.             keyBoard.Input();
    67.         }
    68.         usb.CloseDevice();
    69.  
    70.     }
    71. }
    72.

    🐳接口有哪些特性？

    1. 接口类型是一种引用类型，但是不能直接new接口的对象。

    2. 接口中每一个方法都是public的抽象方法, 即接口中的方法会被隐式的指定为 public abstract（只能是public abstract，其他修饰符都会报错。 

    3. 接口中的方法是不能在接口中实现的，只能由实现接口的类来实现。

    4. 重写接口中方法时，不能使用default访问权限修饰。

    5. 接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量。

    6. 接口中不能有静态代码块和实例代码块和构造方法。

    7. 接口虽然不是类，但是接口编译完成后字节码文件的后缀格式也是.class

    8. 如果类没有实现接口中的所有的抽象方法，则类必须设置为抽象类

    9. jdk8中：接口中还可以包含default方法


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

    🐳如何去实现多个接口？

    1. //定义一个动物类
    2.  
    3. class Animal{
    4.     protected String name;
    5.  
    6.     public Animal(String name){
    7.         this.name=name;
    8.     }
    9.  
    10. }
    11.  
    12. //下面提供一些有关动物的接口
    13.  
    14. interface IRunning{
    15.  
    16.     void run();
    17. }
    18.  
    19. interface ISwimming{
    20.     void swim();
    21.  
    22. }
    23.  
    24. interface Iflying{
    25.     void fly();
    26. }
    27.  
    28. //猫会跑
    29.  
    30. class Cat extends Animal implements IRunning{
    31.     public Cat(String name) {
    32.         super(name);
    33.     }
    34.  
    35.     @Override
    36.     public void run() {
    37.  
    38.         System.out.println(name+"正在跑");
    39.  
    40.     }
    41. }
    42. //鱼会游泳
    43.  
    44. class Fish extends Animal implements ISwimming{
    45.  
    46.     public Fish(String name) {
    47.         super(name);
    48.     }
    49.  
    50.     @Override
    51.     public void swim() {
    52.         System.out.println(name+"正在游泳");
    53.     }
    54. }
    55.  
    56. //天鹅会跑，会游泳，会飞
    57.  
    58. class Swan extends Animal implements IRunning,ISwimming,Iflying{
    59.  
    60.  
    61.     public Swan(String name) {
    62.         super(name);
    63.     }
    64.  
    65.     @Override
    66.     public void run() {
    67.         System.out.println(name+"正在跑");
    68.  
    69.     }
    70.  
    71.     @Override
    72.     public void swim() {
    73.         System.out.println(name+"正在游泳");
    74.  
    75.     }
    76.  
    77.     @Override
    78.     public void fly() {
    79.         System.out.println(name+"正在飞");
    80.  
    81.     }
    82. }

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

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

    时刻牢记多态的好处, 让程序猿忘记类型. 有了接口之后, 类的使用者就不必关注具体类型,
    而只关注某个类是否具备某种能力。

    1. public static void walk(IRunning running){
    2.         running.run();
    3.  
    4.     }

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

    1. public class Test {
    2.     public static void walk(IRunning running){
    3.         running.run();
    4.  
    5.     }
    6.     public static void main(String[] args) {
    7.         Cat cat=new Cat("咪咪");
    8.         walk(cat);
    9.  
    10.     }
    11.  
    12. }

    1. class Robot extends Animal implements IRunning{
    2.  
    3.     public Robot(String name){
    4.         super(name);
    5.     }
    6.  
    7.     @Override
    8.     public void run() {
    9.         System.out.println(name + "正在跑");
    10.  
    11.     }
    12. }
    13. public class Test {
    14.     public static void walk(IRunning running){
    15.         running.run();
    16.  
    17.     }
    18.     public static void main(String[] args) {
    19.         Cat cat=new Cat("咪咪");
    20.         walk(cat);
    21.         walk(new Robot("大白"));
    22.     }
    23.  
    24. }


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

    🐳如何实现接口间的继承

    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. }

     

     哈希值一样。

    所以必要情况下我们也要重写hashcode()方法。

  • 相关阅读:
    R语言使用plot函数可视化数据散点图，移除坐标轴、通过设置axes参数为FALSE
    腾讯云CVM标准型S4服务器性能测评_CPU_网络收发包PPS详解
    FPBJXDN224、FPBJXDV224插头式电比例节流阀放大器
    【微信h5】获取用户openid：基于vue3+springBoot
    Qt 创建包含多个项目的工程以及各项目之间的调用
    ant-design-vue 下拉框随页面滚动问题
    【C语言基础】rand()和srand()的使用
    Python：自动化处理PDF文档集合，提取文献标题、合并文献PDF并生成目录和页码
    Vue中如何进行拖拽与排序功能实现
    Mybatis-Plus分页查询，使用分页插件添加拦截器，看这一篇就够了
  • 原文地址：https://blog.csdn.net/m0_67995737/article/details/126247855