Java抽象类和接口使用梳理

目录
  • 抽象类
    • 抽象方法
    • 抽象类三大原则
  • 接口
    • 接口使用原则
    • JDK两大内置接口
      • java.lang.Comparable 比较接口
      • java.lang.Cloneable 克隆接口
    • 对象的深浅拷贝
  • 抽象类和接口的区别

抽象类

什么是抽象类呢?在现实生活中,我们说“人类”,我们无法对应到具体某个人,同样的,“动物类”、“图形类”这些无法映射到具体的对象的类就是抽象类。

抽象类是普通类的超集,意思就是普通类有的抽象类也有,只是它比普通类多了一些抽象方法而已。这些抽象方法可以有一个,也可以有多个。

它存在的意义就是让子类来覆写它的抽象方法,抽象类和抽象方法的实现使用 abstract 关键字实现:

此时Sharp类就是抽象类,可以看到它的图标和普通类都有所不同。

抽象方法

示例:

public abstract void print();

抽象方法所在的类一定是抽象类,抽象方法只有方法声明,没有方法体{}

注意区分没有方法体和方法体为空的情况

public abstract void print();//这是没有方法体

public abstract void print(){  } //这是方法体为空,它是普通方法

抽象类三大原则

1.抽象类无法直接实例化对象。例如上面的 Sharp 类,Sharp  sharp  = new Sharp();//这是错误的

2.子类继承抽象类,必须覆写抽象类中的所有抽象方法(前提是子类是普通类)

Triangle是一个普通类,此时没覆写方法就报错了,这时我们使用alt + enter 快捷键,点击第一行,再点击ok,就覆写了父类的抽象方法

但是当子类依然是抽象类时,可以选择不覆写抽象方法

3.final 和 abstract 不能同时使用、private 和 abstract 不能同时使用

抽象类存在的最大意义就是被继承,而且它仍然满足继承关系的 is a 原则

abstract class Person

class Chinese extends Person  √

class Dog extends Person × //因为Dog not is a Person

同时抽象类任然受到单继承的局限,此时我们就引出了接口来打破这两个局限

接口

Java使用 interface 关键字定义接口,接口中只有全局常量和抽象方法(JDK之前)JDK8扩展了default方法。子类使用 implements 实现接口

一般接口的命名使用大写 ' I ' 字母开头,子类命名以 Impl 结尾

全局常量:

public static final int NUM = 10;

抽象方法:

public abstract String msg( );

接口使用原则

1.接口中只有 public 权限,且只有全局常量和抽象方法,所以 abstract、static、final、public这些关键字在接口内部都可以省略

public interface IMassage {
    int NUM = 10;//全局常量
     String msg();//抽象方法
}

2.接口没有单继承限制,子类可以同时实现多个父接口,多个接口之间使用逗号分隔。此时子类必须实现父类接口中所有的抽象方法

public interface IMassage {
    int NUM = 10;//全局常量
    String msg();//抽象方法
}
 interface INews{
    void getNews();
}

//子类
public class MessageImpl implements IMassage,INews{

    public String msg() {
        return null;
    }
    public void getNews() {

    }
}

接口可以使用 extends 继承多个父接口,下面的示例若类要实现接口 C ,就必须覆写 A、B、C中所有的抽象方法

    interface A{
        void testA();
    }
    interface B{
        void testB();
    }
    interface C extends A,B{

    }

3.接口依然不能直接实例化对象,需要通过向上转型实现

public class MessageImpl implements IMassage,INews{

    public String msg() {
        return "hello JAVA";
    }

    public void getNews() {
      System.out.println("hello n~");

    }

    public static void main(String[] args) {
        IMassage m = new MessageImpl();
        System.out.println(m.msg());

    }
}

//输出:hello JAVA

m只能调用msg方法,不能调用INews接口类定义的方法,需要用父类间的相互转换实现调用

        INews n = (INews)m;
        n.getNews();

//输出:hello n~

4.子类若既要继承类又要实现接口,就先继承,后实现接口

public class D  extends A  implements X,Y{  }

JDK两大内置接口

java.lang.Comparable 比较接口

引入示例:使用排序方法比较Student类中的对象

public class Student {
    private String name;
    private int age;
    public Student(String name,int age){
        this.name = name;
        this.age = age;
    }
    public String toString(){
        return "Student{" +
    "name=" + name+'\''+ ",age="+ age + '}';
    }

    public static void main(String[] args) {
        Student s1 = new Student("张三",18);
        Student s2 = new Student("李四",20);
        Student s3 = new Student("王五",30);
        Student[] students = {s3,s1,s2};
        Arrays.sort(students);
        System.out.println(Arrays.toString(students));
    }
}

运行结果:

程序报错,因为Student类是自定义类型,当使用Arrays.sort方法对自定义类型进行排序时,自定义类型需要实现 Comparable 才具有可比较的能力

因此我们将上述示例做如下改动:

public class Student implements Comparable<Student>{
    private String name;
    private int age;
    public Student(String name,int age){
        this.name = name;
        this.age = age;
    }
    public String toString(){
        return "Student{" +
    "name=" + name+'\''+ ",age="+ age + '}';
    }
    @Override
    public int compareTo(Student o) {
        if (this.age == o.age){
            return 0;
        }else if (this.age < o.age){
            return -1;
        }
        return 1;
    }

    public static void main(String[] args) {
        Student s1 = new Student("张三",18);
        Student s2 = new Student("李四",20);
        Student s3 = new Student("王五",30);
        Student[] students = {s3,s1,s2};//乱序放入数组
        Arrays.sort(students);
        System.out.println(Arrays.toString(students));
    }

}

//输出结果:
[Student{name=张三',age=18}, Student{name=李四',age=20}, Student{name=王五',age=30}]

可以看到数组按照年龄的升序排序,达到了预期效果。如果想要按照年龄降序排列,只需要修改 compareTo 方法中的一和负一

实现Comparable接口,必须覆写它的compareTo方法,该方法返回的数字:

  • =0 表示当前对象等于目标对象 o
  • >0 表示当前对象等于目标对象 o
  • <0 表示当前对象等于目标对象 o

java.lang.Cloneable 克隆接口

在程序中,克隆是指复制一个新的对象,而这个新对象的属性值是从旧对象中拷贝过来的

Cloneable 接口是一个标记接口,本身没有任何抽象方法,当一个类实现了 Cloneable 接口,就表示该类具备了克隆的能力,这个能力是JVM赋予的,要知道在堆上开辟空间和对象创建都由JVM实现。

我们需要覆写 Object 类的 clone 方法,点击向上转型的图标我们就能看到 Object 提供的该方法

可以看到,clone 方法没有方法体,用 native 关键字修饰,叫做本地方法,clone方法不是Java语言实现的,而是C++实现的,要知道JVM就是由C++实现的。所以本地方法就表示Java调用了C++的同名方法,此处只是方法声明,具体的方法实现是在C++中。所以虽然它没有方法体,但它并不是抽象方法。

这里我们就能知道一个小知识点:没有方法体的方法不一定就是抽象方法

代码示例:

public class Cat implements Cloneable{
    private String name;

    @Override
    protected Cat clone() throws CloneNotSupportedException {
        return (Cat) super.clone();
    }

    public static void main(String[] args) throws CloneNotSupportedException {
        Cat c1 = new Cat();
        c1.name = "喵喵";
        Cat c2 = c1.clone();
        System.out.println(c1 == c2);
        System.out.println(c2.name);
    }
}

输出结果:

可以看到,输出 false表示c1和c2不是同一个地址,也就是说在堆上为c2开辟了一个新空间,将c1的值拷贝给了c2

对象的深浅拷贝

我们先看一个示例:

class A{
    int num;
}
public class B implements Cloneable{
    A a = new A();

    @Override
    protected B clone() throws CloneNotSupportedException {
        return (B)super.clone();
    }

    public static void main(String[] args) throws CloneNotSupportedException {
        B b1 = new B();
        B b2 = b1.clone();
        System.out.println(b1 == b2);
        System.out.println(b2.a.num);
        b1.a.num = 100;
        System.out.println(b2.a.num);
    }
}

输出:false
0
100

根据结果我们看到,将b1.a的值改为100后,b2.a也随之变化,就是说b1.a 和 b2.a 指向了相同的对象

这就是浅拷贝,拷贝出的 b1 对象只是拷贝了 b1 自身, 而没有拷贝内部包含的 a 对象. 此时 b1 和 b2 中包含的 a 引用仍然是指向同一个对象. 此时修改一边, 另一边也会发生改变.

我们将代码做如下修改:

class A implements Cloneable{
    int num;

    @Override
    protected A clone() throws CloneNotSupportedException {
        return (A)super.clone();
    }
}
public class B implements Cloneable{
    A a = new A();

    @Override
    protected B clone() throws CloneNotSupportedException {
        B b = new B();
        b.a = a.clone();
        return b;
    }

    public static void main(String[] args) throws CloneNotSupportedException {
        B b1 = new B();
        B b2 = b1.clone();
        System.out.println(b1 == b2);
        System.out.println(b2.a.num);
        b1.a.num = 100;
        System.out.println(b2.a.num);
    }
}

结果:false
0
0

我们让A类也实现克隆接口,可以看到b1.a的修改没有影响b2.a,说明此时b1和b2内部包含的a对象也是不同的,这种拷贝就叫做深拷贝

在Java中,实现深拷贝的方式有两种:一种是递归实现Cloneable,上述的例子就是递归实现的;另外一种就是通过序列化(Serializable 接口)来进行拷贝。这两种方法现在已经不常用了,现在实现深拷贝是将对象转为json字符串

抽象类和接口的区别

到此这篇关于Java抽象类和接口使用梳理的文章就介绍到这了,更多相关Java 抽象类内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • Java入门基础之抽象类与接口

    目录 一.抽象类 1.什么是抽象类 2.语法规则 3.抽象类的作用 二.接口 1.什么是接口 2.语法规则 3.实现多个接口 4.接口之间的继承 三.接口的使用实例 1. Comparable 接口 2.Comparator接口 3.Clonable接口 四.总结 一.抽象类 1.什么是抽象类 首先我们来回顾一下上一篇文章提到的一个例子:打印图形 class Shape { public void draw() { // 啥都不用干 } } class Cycle extends Shape {

  • Java中比较抽象类与接口的异同

    目录 一.抽象类 (一)概念 (二)抽象类和抽象方法 (三)使用抽象类的意义 二.接口 (一)概念 (二)语法 三.比较抽象类与接口 Q: 为什么有了抽象类还要接口?  Q: 如何确定在什么情况下应该使用接口,什么情况下应该使用类呢? 一.抽象类 (一)概念       在继承的层次结构中,每个新的子类都使类变得更加明确和具体.如果从一个子类向父类追溯,类就会变得更通用.更加不明确.类的设计应该确保父类包含它的子类的共同特征.有时候,一个父类设计得非常抽象,以至于它都没有任何具体的实例.这样的类

  • Java语法之 Java 的多态、抽象类和接口

    目录 一.多态 1. 向上转型 2. 动态绑定 3. 方法重写 4. 向下转型 5. 关键字 super 6. 在构造方法中调用重写方法(坑) 7. 理解多态 8. 小结 二.抽象类 1. 概念 2. 注意事项 3. 抽象类的意义 3. 抽象类的作用 三.接口 1. 语法规则 2. 实现多个接口 3. 接口的继承 4. Comparable 接口 4. Comparator 接口 5. Cloneable 接口和深拷贝 上一篇文章:Java 基础语法之解析 Java 的包和继承 今天这章主要介绍

  • Java抽象类和接口的区别详情

    1.抽象类 vs 接口  方法类型: 接口只能有抽象方法.抽象类可以有抽象和非抽象方法.从 Java 8 开始,它也可以有默认和静态方法. 最终变量: 在 Java 接口中声明的变量默认是最终的.抽象类可能包含非最终变量. 变量类型: 抽象类可以有final.non-final.静态和非静态变量.接口只有静态和最终变量. 实现: 抽象类可以提供接口的实现.接口不能提供抽象类的实现. 继承 vs 抽象:  Java 接口可以使用关键字"implements"来实现,抽象类可以使用关键字&

  • 深入浅析Java 抽象类和接口

    目录 一.抽象类 1.抽象类 1.1抽象类的定义 1.2抽象方法的定义方式 1.3抽象类的定义方式 2.抽象类和实例类的区别 3.抽象类示例 4.抽象类的特征 二.接口 1.接口 1.1接口的定义 1.1定义一个接口 1.2 接口的使用 1.3接口的注意事项 2.接口示例 3.接口的特征 三.抽象类和接口的区别 一.抽象类 1.抽象类 1.1抽象类的定义 在Java面向对象当中,所有的对象都是用过类进行描绘的,但是并不是所有的类都是用来描绘对象的,如果一个类没有包含足够多的信息来描述一个具体的对

  • java中的抽象类和接口定义与用法详解

    目录 一.抽象类 1.什么叫抽象类? 2.抽象类的特点: 3.成员特点: 二.接口 1.接口是什么? 2.接口的特点 3.接口的组成成员 4.类与抽象的关系: 5.抽象类与接口的区别: 一.抽象类 1.什么叫抽象类? 例如在生活中我们都把狗和猫归为动物着一类中,但当只说动物时,我们是不知道是猫还是狗还是其他的.所以动物就是所谓的抽象类,猫和狗则是具体的类了.因此在Java中,一个没有方法体的方法应该定义为抽象类,而类中有抽象方法,则必须为抽象类. 2.抽象类的特点: 抽象类与抽象方法必须用abs

  • Java中抽象类和接口介绍

    目录 1.抽象类 1.1 什么是抽象类? 1.2 抽象类属于什么类型? 1.3 抽象类怎么定义? 1.4 抽象方法 2.接口 2.1 关于接口 2.2 接口怎么定义? 2.3 接口基础语法 总结 1.抽象类 1.1 什么是抽象类? 1.1.1 对抽象类的理解 1.1.2 关于抽象类 类与类之间具有共同特征,将这些共同特征提取出来,形成的就是抽象类: 类本身是不存在的,属于抽象类无法创建对象[无法实例化]: 抽象类是用来被子类继承的: finial关键字和abstract关键字不能同时出现: 抽象

  • 浅析Java中接口和抽象类的七大区别

    目录 接口 抽象类 区别1:定义关键字不同 区别2:继承或实现的关键字不同 区别3:子类扩展的数量不同 区别4:属性访问控制符不同 区别5:方法控制符不同 区别6:方法实现不同 区别7:静态代码块使用不同 总结 Java 是一门面向对象的编程语言,面向对象的编程语言有四大特征:抽象.封装.继承和多态. 而本文介绍的接口和抽象类就是面向对象编程中"抽象"的具体实现,也就是说接口和抽象类都是用来定义实体类的公共行为的,它们是对实体类(对象)更高层次的抽象. ​说明:本文以下内容基于 JDK

  • Java面向对象基础知识之抽象类和接口

    抽象类(abstract): 抽象类不能创建实例,它只能作为父类被继承.抽象类是从多个具体类中抽象出来的父类,它具有更高层次的抽象.从多个具有相同特征的类中抽象出一个抽象类,以这个抽象类作为其子类的模板,从而避免了子类的随意性. (1) 抽象方法只作声明,而不包含实现,可以看成是没有实现体的虚方法 (2) 抽象类不能被实例化 (3) 抽象类可以但不是必须有抽象属性和抽象方法,但是一旦有了抽象方法,就一定要把这个类声明为抽象类 (4) 具体派生类必须覆盖基类的抽象方法 (5) 抽象派生类可以覆盖基

  • Java抽象类和接口使用梳理

    目录 抽象类 抽象方法 抽象类三大原则 接口 接口使用原则 JDK两大内置接口 java.lang.Comparable 比较接口 java.lang.Cloneable 克隆接口 对象的深浅拷贝 抽象类和接口的区别 抽象类 什么是抽象类呢?在现实生活中,我们说“人类”,我们无法对应到具体某个人,同样的,“动物类”.“图形类”这些无法映射到具体的对象的类就是抽象类. 抽象类是普通类的超集,意思就是普通类有的抽象类也有,只是它比普通类多了一些抽象方法而已.这些抽象方法可以有一个,也可以有多个. 它

  • java 抽象类与接口的区别总结

    java 抽象类与接口的区别总结 abstract class和interface是Java语言中对于抽象类定义进行支持的两种机制,正是由于这两种机制的存在,才赋予了Java强大的面向对象能力. abstract class和interface之间在对于抽象类定义的支持方面具有很大的相似性,甚至可以相互替换,因此很多开发者在进行抽象类定义时对于 abstract class和interface 选择显得比较随意. 其实,两者之间还是有很大的区别的,对于它们的选择甚至反映出对于问题领域本质的 理解

  • 深入浅出分析Java抽象类和接口【功能,定义,用法,区别】

    本文实例讲述了Java抽象类和接口.分享给大家供大家参考,具体如下: 对于OOP编程来说,抽象是它一大特征之一.在Java中,可以通过两种形式来体现OOP的抽象:抽象类和接口. 这两者有相似之处也有很大的不同之处. 一.抽象类 在了解抽象类之前,先了解下抽象方法.抽象方法是一种特殊的方法:只有声明,而没有具体的实现.抽象方法的声明格式为: abstract void fun(); 抽象方法必须用abstract关键字进行修饰.如果一个类含有抽象方法,则称这个类为抽象类,这个类就必须在类前用abs

  • 浅谈Java抽象类和接口的个人理解

    今天来说一波自己对Java中抽象类和接口的理解,含参考内容: 一.抽象类 1.定义: public abstract class 类名{} Java语言中所有的对象都是用类来进行描述,但是并不是所有的类都是用来描述对象的.我所理解的抽象类其实就是对同一类事物公共部分的高度提取,这个公共部分包括属性和行为.比如牛.羊.猪它们的公共属性是都有毛,公共行为是都哺乳,所以我们可以把公共部分抽象成一个哺乳类,含有属性毛和行为哺乳,当牛.羊.猪继承了哺乳类后也就有了哺乳的功能,至于怎么完成这个功能就需要自己

  • java抽象类和接口定义与用法详解

    本文实例讲述了java抽象类和接口定义与用法.分享给大家供大家参考,具体如下: 抽象类 抽象类定义 只约定类所具有的抽象行为,没有具体实现相应行为. 语法格式 abstract class 类名{ 常量; 变量; 构造(); 访问修饰符abstract 返回类型 方法名;//抽象方法 普通方法; 静态方法(); } 应用场景 1.不适合创建对象. 2.有些功能没有必要实现,有不同的子类实现. 3.每次使用的都是子类的对象. 4.为所有的子类提供了一个模板,所有的子类都是在此模板的基础之上添加和修

  • Java 抽象类与接口的对比

    其实说实话,没有多大的可比较性,它们是完全不同的两个东西,它们的抽象不在同一个层级上.但是为了让大家更好的理解,还是做一个比较吧,毕竟它们都很抽象(233). 首先是语法层面上的对比 1)抽象类跟接口都不能被实例化,因为它们都很虚嘛.但是在访问权限上,两者有一定的区别. a.抽象类中的抽象方法(其前有abstract修饰)不能用private.static.synchronized.native访问修饰符修饰.理由很简单,容我慢慢道来. 抽象方法是没有方法体的,它的目的就是用来继承的,所以如果使

  • 深入理解JAVA抽象类和接口的比较与异同

    目录 一.理解抽象类 二.从语法定义层面看抽象类和接口 三.从编程的角度看抽象类和接口 四.从设计理念层面看抽象类和接口 五.总结 抽象类(abstract class)和接口(interface)是Java语言中对于抽象类定义进行支持的两种机制,正是由于这两种机制的存在,才赋予了Java强大的面向对象能力.抽象类和接口之间在对于抽象类定义的支持方面具有很大的相似性,甚至可以相互替换,因此很多开发者在进行抽象类定义时对于抽象类和接口的选择显得比较随意.其实,两者之间还是有很大的区别的,对于它们的

  • Java抽象类与接口区别详解

    很多常见的面试题都会出诸如抽象类和接口有什么区别,什么情况下会使用抽象类和什么情况你会使用接口这样的问题.本文我们将仔细讨论这些话题. 在讨论它们之间的不同点之前,我们先看看抽象类.接口各自的特性. 抽象类 抽象类是用来捕捉子类的通用特性的 .它不能被实例化,只能被用作子类的超类.抽象类是被用来创建继承层级里子类的模板.以JDK中的GenericServlet为例: public abstract class GenericServlet implements Servlet, ServletC

随机推荐