JAVA中的抽象类与接口的使用

JAVA中的抽象类与接口

  • 一、抽象类
    • 1.抽象类的含义
    • 2.抽象类的使用原则
    • 3.抽象类使用限制
  • 二、接口
    • 1.接口的含义
    • 2.接口的实现
      • (1)定义接口
      • (2)实现接口
      • (3)利用接口实现计算机的四则运算
    • 3.接口与类的区别
    • 4.抽象类和接口的区别
    • 5.使用接口注意事项
    • 6.比较器接口
      • (1)内部比较器(Comparable接口)
      • (2)外部比较器(Comparator接口)
      • (3)Comparable与Comparator的区别
      • (4)Arrays.sort()用法理解
    • 7.Cloneable 标记接口

一、抽象类

1.抽象类的含义

在了解抽象类之前我们要先知道什么是普通类。普通类具有完整的类功能,不但可以直接产生实例化对象,而且在普通类中可以包含有构造方法、普通方法、static(静态)方法、常量和变量等内容。而抽象类是指在普通类的结构里面增加抽象方法的组成部分。
那么什么叫抽象方法呢?在所有的普通方法上面都会有一个“{}”,这个表示方法体,有方法体的方法一定可以被对象直接使用。而抽象方法,是指没有方法体的方法,同时抽象方法还必须使用关键字abstract做修饰。而拥有抽象方法的类就是抽象类,抽象类要使用abstract关键字声明。
**注意:abstract修饰符
1.abstract修饰的类为抽象类,此类不能有对象,(无法对此类进行实例化,说白了就是不能new);
2.abstract修饰的方法为抽象方法,此方法不能有方法体(就是什么内容不能有);
范例:定义一个抽象类

abstract class student{//定义一个抽象类	
	public void sleep(){//普通方法
		System.out.println("我喜欢学习");
	}	
	public abstract void play();//抽象方法,没有方法体,有abstract关键字做修饰	
}

2.抽象类的使用原则

在这里我们先看一个例子:

package Work;
abstract class Student{//定义一个抽象类
    public void sleep(){//普通方法
        System.out.println("学生喜欢学习");
    }
    public abstract void paly();//抽象方法,没有方法体,有abstract关键字做修饰
}
public class Work11_111 {
    public static void main(String[] args) {
        Student Me= new Student();
    }
}

运行结果:
JAVA中的抽象类与接口的使用_第1张图片
由此可知,Student是抽象的,无法直接进行实例化操作。什么是实例化?当一个类实例化之后,就意味着这个对象可以调用类中的属性或者方法,但在抽象类中存在抽象方法,而抽象方法没有方法体,没有方法体就无法进行调用。既然无法进行方法调用的话,自然无法产生实例化对象。
进而·可以得到抽象类的使用原则:
(1)抽象类不能直接使用,需要子类去实现抽象类,然后使用其子类的实例。(需要依靠子类采用向上转型的方式处理)
(2)抽象方法必须为public或者protected(因为如果为private,则不能被子类继承,子类便无法实现该方法),缺省情况下默认为public;
(3)抽象类必须有子类,使用extends继承,一个子类只能继承一个抽象类;
(4)子类(如果不是抽象类)则必须覆写抽象类之中的全部抽象方法(如果子类没有实现父类的抽象方法,则必须将子类也定义为为abstract类。);
*注:
JAVA中的抽象类与接口的使用_第2张图片
重写范例:

package Work;
abstract class Student{//定义一个抽象类
  public void sleep(){//普通方法
      System.out.println("学生喜欢学习");
  }
  public abstract void paly();//抽象方法,没有方法体,有abstract关键字做修饰
}
class People extends Student{
  @Override
  public void paly() {
      System.out.println("我喜欢学习");
  }
}
public class Work11_111 {
  public static void main(String[] args) {
      Student Me= new People();
      Me.paly();
      Me.sleep();
  }
}

运行结果如下:

我喜欢学习
学生喜欢学习

3.抽象类使用限制

1)抽象类不可以用final声明:因为抽象类必须有子类,而final定义的类不能有
子类。
2)抽象类中存在有构造方法:抽象类里会存在一些属性,所以抽象类中一定存在构造方法,其存在目的是为了属性的初始化。并且子类对象实例化的时候,依然满足先执行父类构造,再执行子类构造的顺序。
3)抽象类能否使用static声明?
先看一个关于外部抽象类的范例:

package Work;
 static abstract class Student{//定义一个抽象类
    public void sleep(){//普通方法
        System.out.println("学生喜欢学习");
    }
    public abstract void paly();//抽象方法,没有方法体,有abstract关键字做修饰
}
class People extends Student{
    @Override
    public void paly() {
        System.out.println("我喜欢学习");
    }
}
public class Work11_111 {
    public static void main(String[] args) {
        Student Me= new People();
        Me.paly();
        Me.sleep();
    }
}

运行结果:
JAVA中的抽象类与接口的使用_第3张图片
再看一个关于内部抽象类:

package Work;
abstract class Student{//定义一个抽象类
     static abstract class B{//static定义的内部类属于外部类
         public abstract void play();
     }
     //抽象方法,没有方法体,有abstract关键字做修饰
}
class People extends Student.B{
    @Override
    public void play() {
        System.out.println("我喜欢学习");
    }
}
public class Work11_111 {
    public static void main(String[] args) {
        Student.B Me= new People();
        Me.play();
    }
}

运行结果:

我喜欢学习

由此可见,外部抽象类不允许使用static声明,而内部的抽象类运行使用static声明。使用static声明的内部抽象类相当于一个外部抽象类,继承的时候使用“外部类.内部类”的形式表示类名称。

二、接口

1.接口的含义

Java里面由于不允许多重继承,所以如果要实现多个类的功能,则可以通过实现多个接口来实现。接口可以看作是抽象类的变体,接口中所有的方法都是抽象的。接口通常以interface来声明。一个类通过继承接口的方式,从而来继承接口的抽象方法。
我们使用interface关键字定义接口,一般使用接口声明方法或常量,接口中的方法只能是声明,不能是具体的实现,这一点和抽象类是不一样的。接口是更高级别的抽象。接口的定义格式是:

public interface 接口名称{
    //可以定义常量
    //方法只有方法声明,而且是公共的。
    public void 方法名称();
    ...
}

类要实现接口,只需要使用implements关键字,实现类必须要实现接口中的所有的方法

public class 实现类名 implements 接口{
    //实现接口的方法
}

2.接口的实现

(1)定义接口

示例代码如下:

// 定义方法的接口
public interface People {
  // 定义程序使用的常量的接口,接口中只能有常量。
  public static final double count = 1314.00;
  public static final int age = 5;
  //接口中所有的方法都没有方法体。
  public void add(int x, int y);
  public void volume(int x,int y, int z);
}

(2)实现接口

代码如下:

//实现     接口
public class Student implements People {
    @Override
    public void add(int x, int y) {
    }
    @Override
    public void volume(int x, int y, int z) {
    }
}

一个类是可以实现多个接口,因为java是单继承的,这点接口可以弥补。我们可以再定义一个接口,如下:

public interface People2 {
    public void num();
}

修改上面的实现类,要实现多个接口,可以使用逗号隔开,当然所有的接口的方法都要实现。

//实现       接口1,接口2
public class Student implements People ,People2{
    @Override
    public void add(int x, int y) {
    }
    @Override
    public void volume(int x, int y, int z) {
    }
    @Override
    public void num() {
    }
}

(3)利用接口实现计算机的四则运算

代码如下:

package Work;
interface Computer{
    int count(int n,int m);
}
//加法
class Add implements Computer {
    @Override
    public int count(int n, int m) {
        return n + m;
    }
}
//减法
class Sub implements Computer {
    @Override
    public int count(int n, int m) {
        return n - m;
    }
}
//除法
class Div implements Computer{
    @Override
    public int count(int n, int m) {
        if(m!=0){
            return n/m;
        }
        else {
            System.out.println("分母不能为0");
            return 0;
        }
    }
}
//乘法
class Mul implements Computer{
    @Override
    public int count(int n, int m) {
        return n*m;
    }
}
//接口是不能直接实例化的,需要定义一个实现类,将接口的引用作为example的参数,利用Realize类实现接口。
class Realize{
    public void example(Computer s,int n, int m){
        System.out.println(s.count(n,m));
    }
}
public  class TestDemo11_2 {
        public static void main (String[] args){
            Realize s=new Realize();
            s.example(new Add(),1,2);
            s.example(new Sub(),1,2);
            s.example(new Div(),4,2);
            s.example(new Mul(),1,2);
        }
}

3.接口与类的区别

  • 接口不能用于实例化对象。
  • 接口中所有的方法必须是抽象方法。
  • 接口不能包含成员变量,除了 static 和 final 变量。
  • 接口不是被类继承了,而是要被类实现。
  • 接口支持多继承。

4.抽象类和接口的区别

1)抽象类中的方法可以有方法体,就是能实现方法的具体功能,但是接口中的方法不行。
2)抽象类中的成员变量可以是各种类型的,而接口中的成员变量只能是 public static final 类型的。
3)接口中不能含有静态代码块以及静态方法(用 static 修饰的方法),而抽象类是可以有静态代码块和静态方法。
4)一个类只能继承一个抽象类,而一个类却可以实现多个接口。

5.使用接口注意事项

1)不能够new创建对象
2)如果要去创建一个接口对应的对象,则需要通过它的具体实现类, 使用implements关键字去实现接口 。
3) 接口被编译之后也会产生对应的字节码文件
4)接口之间也是可以相互继承 extends
5) 接口对应是多实现 eg.class C implements A,B
6) 抽象类中设置的都是通用的方法,功能与实体都是一种"是"的关系,接口中功能与实体都是一种"有"的关系
7)接口中定义的属性为什么是static final的?
static 原因主要是接口的实现是多实现,为了区分不同接口当中的相同变量
final 原因是因为如果是变量,接口的存在就失去其意义,同时接口来说指的 是统一的协议,Java设计者直接规定接口中的属性只能是public static final的。
8)接口是隐式抽象的,当声明一个接口的时候,不必使用abstract关键字。
接口中每一个方法也是隐式抽象的,声明时同样不需要abstract关键字。

6.比较器接口

(1)内部比较器(Comparable接口)

*注意:内部比较器位于 java.lang包下
下面看看Comparable接口的源码:

public interface Comparable<T>
{
    public int compareTo(T o); 
1)如果此对象(调用比较器方法的对象)大于指定对象(目标比较对象),返回正整数   
2)如果此对象小于指定对象,返回负整数   
3)如果此对象等于指定对象,返回零 
}

Comparable接口的使用:

package Work;
class Student implements Comparable<Student>{
    private String name;
    private int age;
    private float score;//得分
    public Student(String name, int age, float score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }
    public String toString()
    {
        return name+"\t\t"+age+"\t\t"+score;
    }
    @Override
    public int compareTo(Student o) {
        if(this.score>o.score)//score是private的,为什么能够直接调用,这是因为在Student类内部
            return -1;//由高到底排序
        else if(this.score<o.score)
            return 1;//当后一个对象比当前对象大,返回结果值为1时,前后交换,说明是倒序排列。(从高到低)
        else{
            if(this.age>o.age)
                return 1;//当后一个对象比当前对象小,返回结果值为1时,前后交换,说明是升序排列。(从低到高)
            else if(this.age<o.age)
                return -1;
            else
                return 0;
        }
    }
}
public class Blog {
    /**
     * @name 博客
     *  先比较score在比较age
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Student stu[]={new Student("zhangsan",20,90.0f),
                new Student("lisi",22,90.0f),
                new Student("wangwu",20,99.0f),
                new Student("sunliu",22,100.0f)};
        java.util.Arrays.sort(stu);//Java的Arrays类中有一个sort()方法,该方法是Arrays类的静态方法,在需要对数组进行排序时,可以直接调用。
        for(Student s:stu)
        {
            System.out.println(s);
        }
    }
}

运行结果为:

sunliu		22		100.0
wangwu		20		99.0
zhangsan		20		90.0
lisi		22		90.0

(2)外部比较器(Comparator接口)

注意:Comparator位于包java.util下。
下面看看Comparator接口的源码:

package java.util;
public interface Comparator<T> {  

int compare(T o1, T o2);  

  1)如果o1大于o2,则返回正整数; 
  2)如果o1小于o2,则返回负整数 
  3)如果o1等于o2,则返回零   
  }

Comparator的使用:

package Work;
import java.util.*;
class Student {
    private String name;
    private int age;
    private float score;

    public Student(String name, int age, float score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public float getScore() {
        return score;
    }
    public void setScore(float score) {
        this.score = score;
    }
    public String toString()
    {
        return name+"\t\t"+age+"\t\t"+score;
    }
}
class StudentComparator implements Comparator<Student>{
    @Override
    public int compare(Student o1, Student o2) {
        // TODO Auto-generated method stub
        if(o1.getScore()>o2.getScore())
            return -1;
        else if(o1.getScore()<o2.getScore())
            return 1;//当后一个对象比当前对象大,返回结果值为1时,前后交换,说明是倒序排列。(从高到低)
        else{
            if(o1.getAge()>o2.getAge())
                return 1;//当后一个对象比当前对象小,返回结果值为1时,前后交换,说明是升序排列。(从低到高)
            else if(o1.getAge()<o2.getAge())
                return -1;
            else
                return 0;
        }
    }

}
public class Blog {
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Student stu[]={new Student("zhangsan",20,90.0f),
                new Student("lisi",22,90.0f),
                new Student("wangwu",20,99.0f),
                new Student("sunliu",22,100.0f)};
        java.util.Arrays.sort(stu,new StudentComparator());
        for(Student s:stu)
        {
            System.out.println(s);
        }
    }
}

运行结果如下:

sunliu		22		100.0
wangwu		20		99.0
zhangsan		20		90.0
lisi		22		90.0

(3)Comparable与Comparator的区别

1)Comparator位于包java.util下,而Comparable位于包 java.lang下
2)Comparable 是一个对象本身就已经支持自比较所需要实现的接口(如 String、Integer 自己就可以完成比较大小操作,已经实现了Comparable接口)而 Comparator 是一个专用的比较器,当这个对象不支持自比较或者自比较函数不能满足你的要求时,你可以写一个比较器来完成两个对象之间大小的比较。
可以说一个是自已完成比较,一个是外部程序实现比较的差别而已。

(4)Arrays.sort()用法理解

Java的Arrays类中有一个sort()方法,该方法是Arrays类的静态方法,在需要对数组进行排序时,可以直接调用。具体使用方法可以参照下面这篇文章。

https://blog.csdn.net/weixin_43761659/article/details/97442067Arrays.sort()用法理解

7.Cloneable 标记接口

如果一个类实现了Cloneable接口,就表示该类中的对象是可以被clone的,同时实现Cloneable则需要重写Object.clone方法。
具体实现可以参考如下文章:

https://blog.csdn.net/qq_37113604/article/details/81168224?Cloneable接口的作用与深入理解深度克隆与浅度克隆

面试题:为什么clone方法在Object类中定义为protected,而不是public?

  • protected受保护成员,分为与父类在同一包内和不在同一包内的子类,不在同一个包中 的子类,只能访问从父类继承而来的受保护成员,而不能访问父类实例本身的受保护成员, 在相同包内则没有以上的限制。并不是所有的对象都可以被克隆,如果子类对象可被克隆,则必须实现Cloneable接口并且重写clone方法。

你可能感兴趣的:(Java专栏,抽象类,接口)