Java抽象類別和介面如何使用

什麼是抽象類別

什麼是抽象類別呢？抽象類別顧名思義就是很抽象，就是當我們沒有足夠的資訊去描述這個類別的時候我們就可以先不用描述，這樣的類別就是抽象類別。

用程式碼舉個例子：

class Shape {
    public void draw() {
        System.out.println("我要画图形！！");
    }
}
class circle extends Shape {
    @Override
    public void draw() {
        System.out.println("我要画圆形！！！");
    }
}
class rect extends Shape {
    @Override
    public void draw() {
        System.out.println("我要画矩形！！！");
    }
}
public class TestDemo3 {
    public static void drawShape(Shape shape) {
        shape.draw();
    }
    public static void main(String[] args) {
        drawShape(new circle());
        drawShape(new rect());
    }
}

剛好也透過這個小小的案例來複習一下多態，我們建立一個Shape父類，然後又建立兩個子類別分別為rect類和circle類別接著利用這兩個類別使用同一個方法，產生的形態是不一樣的這就是多態，但是

我們可以發現我只用了這兩個子類別來畫圖形分別是圓形和矩形，我並沒有呼叫父類別來實作這個方法，為啥呢？ ？ ？就是因為這個父類別並不能畫出圖形，那這個父類別的draw方法的實作豈不是沒有用，我只需要它父類別要有這方法，透過子類別重寫就可以了，不需要父類別的方法有具體的實作。

沒錯，這就引入到我們今天的主題抽象類別

上面父類別的draw方法由於它的具體實作根本沒有用處，所以我們就可以不寫，這也正符合抽象類別的定義，當不能有足夠的資訊去描述它，那我們就把它叫做抽象類別。

抽象類別語法

上面父類別的draw方法沒有具體的實作我們就可以把它叫做抽象方法。利用abstract來修飾

public abstract void draw();

但是這樣為啥會報錯呢？ ？

原因是被abstract修飾的方法叫做抽象方法，如果一個類別裡面有抽象方法，那這個類別一定是抽象類，所以類別也要被abstract來修飾。

但相反，抽象類別裡面一定有抽象方法麼？ ？ ？

編譯器不會報錯，所以答案是不一定，抽象類別裡面可以有抽象方法也可以沒有抽象方法。

抽象類別能否被實例化呢？ ？ ？

所以，抽象類別是不能實例化的。 

抽象類別能否像普通類別一樣定義成員變數和方法，建構方法呢？ ？ ？

抽象類別與普通類別的區別就是在與抽象類別不能實例化，其他定義成員變量，成員方法，建構方法等等都是一樣的。

 既然抽象類別不能實例化，那他存在的意義是什麼呢？ ？ ？

老鐵思考的有道理，其實抽象類別最大的意義就是被繼承，因為抽象類別不能實例化對象，只能依靠子類別來重寫父類別(就是抽象類別)的方法來完成業務需求。

怎麼繼承抽象類別呢？ ？ ？有哪些注意的重點呢？ ？ ？

 這樣繼承為啥會出錯呢？ ？原因是在子類別繼承抽象類別的時候，子類別需要重寫父類別的所有方法或子類別需要用abstract修飾(抽象類別被抽象類別繼承或子類別重寫抽象類別(父類別)的所有方法) 。

這樣就對了。

這裡還要注意當我們沒有重寫父類別的方法時而是用abstract來修飾，這時當你在次繼承這個子類別的時候也就是這個子類別變成了父類，下一個子類別還是要繼續重寫這個父類別的方法和這個父類別的父類別的方法。 

抽象方法能否別static和final修飾呢？ ？ ？

 抽象方法不能被static  和final 修飾，因為子類別要重寫父類別的方法，同時可以省略存取修飾限定符，預設為public。

總結抽象類別：

• 我們把不能足夠描述清楚一個物件的類別叫做抽象類別。

• 被abstract修飾的方法稱為抽象方法，被abstract修飾的類別稱為抽象類別

• 抽象方法必須在抽象類別裡面，也就是說，只要有抽象方法，類別名稱也必須利用abstract來修飾，相反，抽象類別裡面可以沒有抽象方法，也可以有抽象方法。

• 抽象类不能实例化，除了不能实例化之外其他与普通类一样可以定义成员变量，成员方法，构造方法等。同时构造方法和类方法(被static修饰的方法)不能被abstract来修饰

• 抽象方法的访问修饰限定符不能是private，如果省略默认是public，同时抽象方法不能被final修饰。

• 子类继承抽象类的时候，子类必须重写抽象类的所有方法并且要有方法的具体实现，如果重写那子类还是抽象类，必须用abstract来修饰。

• 抽象类中的方法没有具体实现，要通过子类重写在子类中实现。

• 一个类只能继承一个抽象类

接口

说到接口我们会想到什么呢？？？我一开始想到的就是充电接口插排等等，比如充电接口，只要符合那个插口的标准，我们都可以使用那个接口来进行充电。这就是把标准进行统一起来，然后大家就可以根据不同的标准来使用不同的接口，比如苹果手机与安卓手机的手机接口就是不一样的，他们就是两种不同的标准，安卓手机用安卓的接口，苹果用苹果的接口这就将标准统一起来。

而在Java中也是一样的，我们把这个标准或者可以说是一种公共的规范叫做接口，只要符合这一接口的标准我们就可以使用它。

听着这抽象的概念你可能现在还是不太明白这到底是什么，我在来拿代码举个例子：

class Animal {
    public String name;
    public int age;
    public void eat() {
        System.out.println(this.name+"吃饭***！");
    }
}

这里我定义了一个动物类，这个动物有名字，年龄，还有吃饭的行为。

class Animal {
    public String name;
    public int age;
    public void eat() {
        System.out.println(this.name+"吃饭***！");
    }
    public void swim() {
        System.out.println("我要游泳~~~~");
    }
}
class Fish extends Animal {
}

接着我又定义了一个鱼类(子类)继承这个动物类(父类)，我想让这个鱼有这个游泳的行为，但是这就会有一个问题，在父类定义了一个swim方法，接着我还要定义很多类，难道所有的类都要有这个游泳的行为么？？？答案是不可以的。所以我们就不能把这个swim方法定义在父类里面，那我们就可以把这个方法定义在子类(鱼类)里面，这样就符合了，但是如果我还要定义1000个动物都会游泳难道都要在自己类中写这个游泳的方法么？？这样做显然是不可行的。那我们该怎么做呢？？

我们可以就提供一个公共的接口，这也是一种标准，只要符合这一标准都可以使用这个接口或者可以说可以实现这一功能。

看了上面的引例我们应该接口是干什么的了，接下来我们来学一下接口的语法。

怎么定义接口

定义接口要使用interface关键字：

//创建一个接口
//创建接口要是用interface关键字  接口的命名最好是形容词其他的也可以
interface IFlying{
    //这就是一个flying接口
}

接口中的成员变量：

这样会报错，接口中的成员变量都是常量，所以必须初始化，接口中的成员变量会被隐式指定为public static final 修饰的。

interface IFlying{
    //接口中的成员变量默认都是被public static final修饰的常量
    //这里的成员变量不可改变
   public static final int a =10;
}

接口中的成员方法：

interface IFlying{
    //接口中的成员方法都是抽象方法，默认是public abstract 
    //其中public abstract 可以被省略
    //接口中的成员方法不能有具体的实现
    public abstract void eat();
    //一般就写成：
    //void eat();
    default void sleep(){
        //接口中的方法想要具体实现，要加上default修饰
    }
    //接口中可以有静态方法的具体实现
    public static void method() {
        System.out.println("我是静态的方法!!");
    }
}

接口能否实例化？？？

接口是不能被实例化的。

怎么使用接口？？？

实现的接口如下：

interface IFlying{
    void eat();
}
interface IRunning{
    void run();
}
interface ISwimming{
    void swim();
}
interface IClimbing{
    void climb();
}

//创建一个Ant类 
//利用implements关键字来实现接口
//一个类可以实现多个接口，接口之间利用逗号连接
//实现了接口必须要在接口中重写接口中的方法
//重写方法快捷键：鼠标移动到implements关键字上然后 alt+enter
class Ant implements IClimbing,IRunning{
    public String name;
    @Override
    public void run() {
        System.out.println(this.name+"要跑步");
    }
    @Override
    public void climb() {
        System.out.println(this.name+"爬山");
    }
}

• 接口的使用时利用implements关键字与类连接，类与接口之间使用implements连接的。

• 一个类可以实现多个接口，多个接口之间利用逗号连接。

• class Ant implements IClimbing,IRunning.的意思是类Ant可以实现两个功能，既可以爬又可以跑。

• 类实现接口时，必须要重写接口中的方法。如果不重写该类还是抽象类，要用abstract来修饰。

接口能否有静态方法和代码块呢？？？

接口中是不能有静态代码块和构造方法的。 

接口间的继承

我们这里总结一下类与接口之间的联系

• 类与类之间是继承关系利用extends来连接   代表子类继承了父类

• 类与接口之间是利用implements来连接， 代表类能实现某个功能

• 接口与接口之间也可以进行联系，利用extends 接口A和接口B  interface A enxtends B 代表接口A拓展了接口B的功能。

这里来讲一下接口与接口之间的继承

我们利用extends关键字将两个接口连接起来，这样就实现了接口之间的继承。

例如：

interface IRunning extends IFlying{
    //类IRunning拓展了IFlying的功能
    void run();
    //接口与接口之间继承后IRunning拓展了IFlying功能
    //有了IRunning的功能的类也要重写IFlying这个方法
}

• 类IRunning拓展了IFlying的功能

• 接口与接口之间继承后IRunning拓展了IFlying功能

• 有了IRunning的功能的类也要重写IFlying这个方法

几个重要的接口

接口comparable

我们这里举一个例子：

比如我们要进行给一个学生进行排序，我们之前学过Arrays的sort方法，好我们来尝试一下这个方法对学生进排序。

class Student{
    public String name;
    public int age;
    public double score;
    public Student(String name, int age, double score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                '}';
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Student[] student = new Student[4];
        student[0] = new Student("张三",18,88);
        student[1] = new Student("李四",98,98);
        student[2] = new Student("王二麻子",8,18);
        student[3] = new Student("赵老八",58,38);
        System.out.println(Arrays.toString(student));
        Arrays.sort(student);
        System.out.println(Arrays.toString(student));
    }
}

从这里发现Arrays.sort方法是比较具体的数字大小的，而我们这里比较学生这个对象并没有指定,我们究竟依靠什么来比较这个学生对象，目前这个学生有名字，分数，年龄，我们到底依靠什么比较是根据我们的需求来定，那我们要具体的比较学生对象的某一个学生怎么比较呢·？？？看报错信息也就是这个异常，我们需要提供这个comparable这个接口然后重写这个comparable方法。

怎样提供接口？？？？

 我们根据类要实现一个接口是利用关键字implements来连接的。

 然后使用comparable这个接口,尖括号里面写上你要排序的类。

好这样我们就实现了这个接口，当然看前面那个红线就知道会有报错，这也就是当我们实现一个接口我们必须重写这个接口中的方法，然后Alt+enter重写这个接口中的方法。

好，我们就重写了这样的一个方法，比如我们要比较年龄按照升序排列：

 

然后调用Arrays.sort方法就可以进行排序了。

 同样我们还可以根据名字排序：

由于，名字是String类型也就是引用类型所以我们要调用compareTo方法来进行比较。

同样的我们还可以根据分数来排序这个学生对象。

 comparator接口-比较器

我们刚才使用comparable这个接口会有一个缺陷，就比如当我们已经实现按照年龄排序好了，但是有个人突然把他改成了名字比较，如果是未来做项目开发的时候，那就会给程序猿造成很大的困扰，就怕有一天别人修改了那段代码，所以我们就有了这个comparator这个比较器，我们还是把他封装起来，不用在去学生这个类中去修改。

对学生年龄排序：

class AgeComparator implements Comparator<Student>{
    @Override
    public int compare(Student o1, Student o2) {
        return o1.age - o2.age;
    }
}

对学生分数排序：

class ScoreComparator implements Comparator<Student>{
    @Override
    public int compare(Student o1, Student o2) {
        return (int)(o1.score - o2.score);
    }
}

对学生名字排序：

class NameComparator implements Comparator<Student>{
    @Override
    public int compare(Student o1, Student o2) {
        return o1.name.compareTo(o2.name);
    }
}

我们还是利用Arrays.sort方法里面再加一个比较器的这个参数就可以比较了。

 public static void main(String[] args) {
        Student[] student = new Student[4];
        student[0] = new Student("张三",18,88);
        student[1] = new Student("李四",98,98);
        student[2] = new Student("王二麻子",8,18);
        student[3] = new Student("赵老八",58,38);
        System.out.println(Arrays.toString(student));
        AgeComparator ageComparator = new AgeComparator();
        Arrays.sort(student,ageComparator);
        System.out.println(Arrays.toString(student));
    }

这样我们将根据什么排序，实例化对应的对象，通过对象调用重写comparator的方法就可以进行比较，不需要担心类中被修改。

cloneable接口深入理解深拷贝与浅拷贝

我们之前学过数组中的克隆方法，就是把一个数组中的内容全部拷贝到另外一个数组中去。

今天我们学的cloneable接口可以将一个对象的属性拷贝到另外一个对象里面去。

怎么使用cloneable接口

我们创建一个人这个类，人这个类中有两个属性，一个是分数，一个是smartphone这个对象(引用类型)。

class SmartPhone{
    public int money = 9999;
}
class Person{
    public int score = 96;
    SmartPhone smartPhone = new SmartPhone();
}
public class TestDemo {
    public static void main(String[] args){
        Person person1 = new Person();
    }
}

我们现在要将这个person这个类实现cloneable接口，利用implements连接，同样的我们要重写这个cloneable这个接口中的方法。

这里我们要注意·重写cloneable这个方法，它的返回类型是object，object是Java中所有类的父类。

好，完成了接口的操作，我们接下来完成克隆的工作，我们怎么使用clone这个方法来进行克隆呢？？？

浅拷贝：

//浅拷贝
class SmartPhone{
    public int money = 9999;
}
class Person implements  Cloneable{
    public int score = 96;
    SmartPhone smartPhone = new SmartPhone();
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
    @Override
    public String toString() {
        return "Person{" +
                "score=" + score +
                ", smartPhone=" + smartPhone +
                '}';
    }
}
public class TestDemo {
    public static void main(String[] args) throws CloneNotSupportedException {
        Person person1 = new Person();
        Person person2 = (Person)person1.clone();
        System.out.println(person1.smartPhone.money);
        System.out.println(person2.smartPhone.money);
        person1.smartPhone.money=9;
        System.out.println("===============拷贝之后=================");
        System.out.println(person1.smartPhone.money);
        System.out.println(person2.smartPhone.money);
    }
}

 原因是什么呢？？画一下图理解一下

 这就是浅拷贝，对基本数据类型进行值传递，对引用数据类型进行引用传递般的拷贝，此

为浅拷贝。只要将money值进行修改两个对象的money的值都改变，没有彻底的拷贝。

深拷贝

//深拷贝
class SmartPhone implements  Cloneable{
    public int money = 9999;
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
    @Override
    public String toString() {
        return "SmartPhone{" +
                "money=" + money +
                '}';
    }
}
class Person implements  Cloneable{
    public int score = 96;
    SmartPhone smartPhone = new SmartPhone();
    @Override
    protected Object clone() throws CloneNotSupportedException {
        Person tmp = (Person)super.clone();
        tmp.smartPhone= (SmartPhone) this.smartPhone.clone();
        return tmp;
    }
    @Override
    public String toString() {
        return "Person{" +
                "score=" + score +
                ", smartPhone=" + smartPhone +
                '}';
    }
}
public class TestDemo {
    public static void main(String[] args) throws CloneNotSupportedException {
        Person person1 = new Person();
        Person person2 = (Person)person1.clone();
        System.out.println(person1.smartPhone.money);
        System.out.println(person2.smartPhone.money);
        person1.smartPhone.money=9;
        System.out.println("===============拷贝之后=================");
        System.out.println(person1.smartPhone.money);
        System.out.println(person2.smartPhone.money);
    }
}

 此时为深拷贝，进行了彻底的拷贝。对基本数据类型进行值传递，对引用数据类型，创建一个新的对象，并复制其内容，此为深拷贝。

以上是Java抽象類別和介面如何使用的詳細內容。更多資訊請關注PHP中文網其他相關文章！