java学习之路-抽象类和接口

前言

本文内容：抽象类的语法、特性、作用，以及接口的概念、定义、使用、clonable接口和深浅拷贝；抽象类和接口的区别，object类。

1.抽象类

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

比如

说明:

1.Animal是动物类，每个动物都有叫的方法，但由于Animal不是一个具体的动物，因此其内部bark()方法无法具体实现

2.Dog是狗类，首先狗是动物，因此与Animal是继承关系，其次狗是一种县体的动物，狗叫:汪汪汪，其bark0可以实现

3.Cat是猫类，首先猫是动物，因此与Animal是继承关系，其次猫是一种具体的动物，猫叫:喵喵喵，其bark()可以实现

4.因此:Animal可以设计为"抽象类”

1.2抽象类语法

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

// 抽象类：被abstract修饰的类
public abstract class Shape {
 // 抽象方法：被abstract修饰的方法，没有方法体
abstract public void draw();
 abstract void calcArea();
 // 抽象类也是类，也可以增加普通方法和属性
public double getArea(){
 return area;
 }
 
protected double area;    // 面积
}

抽象类也是类，内部可以包含普通方法和属性，甚至构造方法，但不可以实例化

1.3抽象类特性

//使用abstract的方法称为抽象方法
//使用abstract的类称为抽象类
//抽象类是不可以进行实例化的
//抽象类当中 可以和普通类一样定义成员变量 和成员方法
//当一个普通的类继承了这个抽象类，那么需要重写这个抽象类当中的所有抽象方法。
//抽象类就是为了继承
//abstract 和final是天敌 他们不能共存
//被private和 static修饰的也不可以

举例说明

//抽象类不能直接实例化对象
Shape shape = new Shape();
 
// 编译出错
Error:(30, 23) java: Shape是抽象的; 无法实例化

//抽象方法不能是 private 的
abstract class Shape {
    abstract private void draw();
 }
 
// 编译出错
Error:(4, 27) java: 非法的修饰符组合: abstract和private

//抽象方法不能被final和static修饰，因为抽象方法要被子类重写
 public abstract class Shape {
    abstract final void methodA();
    abstract public static void methodB();
 }
 
// 编译报错：
// Error:(20, 25) java: 非法的修饰符组合: abstract和final
 // Error:(21, 33) java: 非法的修饰符组合: abstract和static

1.4抽象类的作用

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

abstract class Shape{
    public abstract void draw();

}
class Bas extends Shape{
    public  void draw(){//需要重写不然报错
        System.out.println("韦坤k");
    }
}
class Ba extends Shape{
    public  void draw(){//需要重写不然报错
        System.out.println("韦k");
    }

}
public class Chouxiang {

    public static void raw(Shape shape){//这里要静态不道为啥
        shape.draw();

    }
    public static void main(String[] args) {
            //抽象不能实例化，但是可以用向上转型
        Shape ax = new Bas();
        Shape aa = new Ba();
        raw(ax);
        raw(aa);
    }
}

2.接口

2.1接口概念

电脑的USB口上，可以插：U盘、鼠标、键盘...所有符合USB协议的设备

接口就是公共的行为规范标准，大家在实现时，只要符合规范标准，就可以通用。

在Java中，接口可以看成是：多个类的公共规范，是一种引用数据类型。

2.2接口的定义

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

public interface 接口名称{
 // 抽象方法
public abstract void method1();   // public abstract 是固定搭配，可以不写
public void method2();
 abstract void method3();
 void method4();
 }
1. 创建接口时, 接口的命名一般以大写字母 I 开头.

2. 接口的命名一般使用 "形容词" 词性的单词.

3. 阿里编码规范中约定, 接口中的方法和属性不要加任何修饰符号, 保持代码的简洁性.

2.3接口的使用

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

public  class 类名称 implements 接口名称{
 // ...
 } 
子类和父类之间是extends 继承关系，类与接口之间是 implements 实现关系。

接口使用栗子

请实现笔记本电脑使用USB鼠标、USB键盘的例子
1. USB接口：包含打开设备、关闭设备功能
2. 笔记本类：包含开机功能、关机功能、使用USB设备功能
3. 鼠标类：实现USB接口，并具备点击功能
4. 键盘类：实现USB接口，并具备输入功能

接口端

//创建接口
public interface USB {
    void open();//打开功能
    void close();//关闭功能
}

鼠标端

public class Mouse implements USB {
    @Override
    public void open() {
        System.out.println("打开鼠标");
    }
    //鼠标点击实现
    public void click(){
        System.out.println("鼠标点击");
    }
    @Override
    public void close() {
        System.out.println("关闭鼠标");

    }
}

键盘端

public class KeyBoard implements USB{
    @Override
    public void open() {
        System.out.println("打开键盘");
    }
    public void inPut(){
        System.out.println("键盘输入");
    }
    @Override
    public void close() {
        System.out.println("关闭键盘");

    }
}

笔记本端

public class Computer {
    public void powerOn(){
        System.out.println("打开笔记本电脑");
    }
    public void powerOff(){
        System.out.println("关闭笔记本电脑");
    }
    //笔记本跑起来
    public void useDevice(USB usb){
        usb.open();//打开usb接口

        //看传进来的参数是鼠标还是键盘，对应的进行操作实现
        if (usb instanceof Mouse)//进行向下转型，去调用鼠标
        {
            Mouse mouse = (Mouse) usb; //强制转换类型
            mouse.click();//点鼠标
        }
        else if (usb instanceof KeyBoard)//进行向下转型，去调用键盘
        {
            KeyBoard keyboard = (KeyBoard) usb;
            keyboard.inPut();
        }
        usb.close();//关闭usb
    }
}

测试端

public class Test {
    public static void main(String[] args) {
        Computer computer = new Computer();
        //打开电脑
        computer.powerOn();
        Mouse mouse = new Mouse(); //实例化鼠标对象
        KeyBoard keyboard = new KeyBoard(); //实例化键盘对象
        //电脑开始运行
        computer.useDevice(mouse);//鼠标点
        System.out.println("----------------");
        computer.useDevice(keyboard);//键盘敲

        //关闭电脑
        computer.powerOff();

    }
}

执行结果

2.4接口特性

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

2. 接口中每一个方法都是public的抽象方法, 即接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错)
public interface USB {
    // Error:(4, 18) java: 此处不允许使用修饰符private
    private void openDevice();
    void closeDevice();
 }
3. 接口中的方法是不能在接口中实现的，只能由实现接口的类来实现

4. 重写接口中方法时，不能使用默认的访问权限
public interface USB {

 void openDevice();    // 默认是public的
    void closeDevice();   // 默认是public的
}
 
public class Mouse implements USB {
    @Override
    void openDevice() {
        System.out.println("打开鼠标");
    }
    
    // ...
 }
 
// 编译报错，重写USB中openDevice方法时，不能使用默认修饰符
// 正在尝试分配更低的访问权限; 以前为public
原因是重写的权限要大于原方法的权限，如果接口这里给了最大的权限public，那么找不到更高的权限来重写，会导致类对接接口时候无法进行重写。

5. 接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量
 public interface USB {
    double brand = 3.0;  // 默认被：final public static修饰
    void openDevice();
    void closeDevice();
 }
 
public class TestUSB {
    public static void main(String[] args) {
        System.out.println(USB.brand);   // 可以直接通过接口名访问，说明是静态的
        
        // 编译报错：Error:(12, 12) java: 无法为最终变量brand分配值
        USB.brand = 2.0;       // 说明brand具有final属性
    }
 }
6. 接口中不能有静态代码块和构造方法
 public interface USB {
    // 编译失败
    public USB(){
 
    }
 
    {}    // 编译失败
    
    void openDevice();
    void closeDevice();
 }
7. 接口虽然不是类，但是接口编译完成后字节码文件的后缀格式也是.class

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

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

2.5 实现多个接口

类中存在一个问题：类和类之间是单继承的，一个类只能有一个父类，即Java中不支持多继承，但是一个类可以实现多个接口。那么就可以用接口解决这个问题

请看栗子

通过类来表示一组动物

public class Animal {
    public String name;
    public int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

再提供接口，分别表示会飞、会跑、会游

public interface Run {
    void run();
}
interface Swim{
    void swim();
}
interface Fly{
    void fly();
}

再创建几组动物来对接接口关系

//鸭子会游会跑会飞 ，所以要实现三个接口
class Duck extends Animal implements Run,Swim,Fly{//alt+回车，即可得到重写接口方法

       
    public Duck(String name,int age) {
        super(name,age);
    }

    @Override
    public void fly() {
        System.out.println(this.name+"鸭子飞飞");
    }

    @Override
    public void swim() {
        System.out.println(this.name+"鸭子游泳");
    }

    @Override
    public void run() {
        System.out.println(this.name+"鸭子跑路");
    }
}

//狗会跑
class Dog extends Animal implements Run{

    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void run() {
        System.out.println(this.name+"狗跑路");
    }
}
//青蛙游
class Fish extends Animal implements Swim{

    public Fish(String name, int age) {
        super(name, age);
    }

    @Override
    public void swim() {
        System.out.println(this.name+"鱼游泳");
    }
}

测试

public class AxTest {
    /*public static void fun(Animal animal){
        System.out.println(animal.name);

    }*/
    public static void running(Run run){
        run.run();

    }
    public static void swimming(Swim swim){
        swim.swim();
    }
    public static void flying(Fly fly){
        fly.fly();
    }
    public static void main(String[] args) {
        //接口解决多继承问题
        //有接口就你使用了
        running(new Dog("二哈",1));
        running(new Duck("二丫",1));
        swimming(new Fish("小红",2));
        swimming(new Duck("三丫",2));
        flying(new Duck("四丫",3));
        //running(new Fish("二哈",1));//这个就会报错，因为没有跑的接口

    }
}

测试结果

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

2.6接口间的继承

类与类可以继承，接口与接口也可以，接口可以继承一个接口, 同时接口也可以继承多个接口，达到复用的效果. 使用 extends 关键字，不过继承的接口，最后也要全部重写接口的方法。

interface IRunning {
    void run();
 }
 
interface ISwimming {
    void swim();
 }
 
// 两栖的动物, 既能跑, 也能游
interface IAmphibious extends IRunning, ISwimming {//接口能继承多个接口。
     @Override
    void run();

    @Override
    void swim();
 
}

2.7接口使用实例（Comparable 接口与Comparator接口）

给对象数组排序

我们知道，一个数组可以这么排序

        int[] a = new int[]{1,2,3};
        Arrays.sort(a);
        System.out.println(Arrays.toString(a));

如果给对象数组排序，就可以这样排

        //对对象类进行排序
        B[] b = new B[3];
        b[0] = new B("aiaowang",15);
        b[1] = new B("ciaowang",16);
        b[2] = new B("biaowang",11);
        System.out.println("排序前" + Arrays.toString(b));
        Arrays.sort(b);
        System.out.println("排序后" + Arrays.toString(b));

但是这样是不够的，会报错，因为对象数组里面有字符串和整数，sort无法确定从哪个来进行排序，所以在这里要用到Comparable 接口, 并实现其中的 compareTo 方法

//实现一个类的两个数据进行排序
//要想实现，那么就要对接一个能比较类的接口
class  B implements Comparable<B>{
    public String name;
    public int age;

    public B(String name, int age) {
        this.name = name;
        this.age = age;
    }

//这是干嘛的，就是把name和age这些成员转换为字符串
    @Override
    public String toString() {
        return "B{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    //要重写接口Comparable的方法才可以使用
    public int compareTo(B b5){
        return b5.age-this.age;
}

public class Test2 {
    public static void main(String[] args) {
           //对对象类进行排序
        B[] b = new B[3];
        b[0] = new B("aiaowang",15);
        b[1] = new B("ciaowang",16);
        b[2] = new B("biaowang",11);
        System.out.println("排序前" + Arrays.toString(b));
        Arrays.sort(b);//排序，这里需要借助compareTo接口才能实现

        System.out.println("排序后" + Arrays.toString(b));

这样虽然能排序成功，不过有局限性，就是只能按默认的排序来排，如果想自己定义要用姓名来排序，那该如何？

要实现这个就要用到另一个接口 Comparator。

//实现一个类的两个数据进行排序
//要想实现，那么就要对接一个能比较类的接口
class  B implements Comparable<B>{
    public String name;
    public int age;

    public B(String name, int age) {
        this.name = name;
        this.age = age;
    }


    @Override
    public String toString() {
        return "B{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    //要重写接口Comparable的方法才可以使用
    public int compareTo(B b5){
        return b5.age-this.age;//返回值大于0说明 前者比后者大
}



//按年龄排序
class AgeComparator2 implements Comparator<B> {


    @Override
    public int compare(B o1, B o2) {
        return o1.age -o2.age;
    }
}

//按姓名来排序

class NameCompartor2 implements Comparator<B>{


    @Override
    public int compare(B o1, B o2) {
        return o1.name.compareTo(o2.name);//比较姓名的话 要用.来写，再利用compareTo方法来实现
        //总的来说，还是要两个类进行互相使用。
    }
}

public class Test2 {
    public static void main(String[] args) {
           //对对象类进行排序
        B[] b = new B[3];
        b[0] = new B("aiaowang",15);
        b[1] = new B("ciaowang",16);
        b[2] = new B("biaowang",11);
        System.out.println("排序前" + Arrays.toString(b));
            //按年龄排序
        //AgeComparator2 a2 = new AgeComparator2();
        //可以设置按年龄或者名字排序
       //Arrays.sort(b,a2);//指定按年龄排序

        //按名字比较
        /*NameCompartor2 n2 = new NameCompartor2();
        Arrays.sort(b,n2);*/
        System.out.println("排序后" + Arrays.toString(b));

2.8Clonable 接口和深浅拷贝

Java 中内置了一些很有用的接口, Clonable 就是其中之一.

Object 类中存在一个 clone 方法, 调用这个方法可以创建一个对象的 "拷贝". 但是要想合法调用 clone 方法, 必须要先实现 Clonable 接口, 否则就会抛出 CloneNotSupportedException 异常

class BA implements Cloneable{//设置支持拷贝
    public int a = 10;

    @Override
    protected Object clone() throws CloneNotSupportedException {//这里也要重新克隆方法，不然无法使用
        return super.clone();
    }
}

@Override//浅拷贝
    protected Object clone() throws CloneNotSupportedException {
       //throws CloneNotSupportedException 可能会异常 ，要解决异常，直接加throws //CloneNotSupportedException
       return super.clone();
  }
public class AxJava {
        public static void main(String[] args) throws CloneNotSupportedException {  //这里要加上throws CloneNotSupportedException
            Animal animal = new Animal("舍长", 21);
            //克隆上面这个对象,要强制转换类型
            Animal animal2 = (Animal) animal.clone();//但是找不到这方法，要类对接克隆接口关系
            System.out.println(animal);
            System.out.println(animal2);
}

Cloneable 拷贝出的对象是一份 "浅拷贝"

深拷贝

class BA implements Cloneable{//设置支持拷贝
    public int a = 10;

    @Override
    protected Object clone() throws CloneNotSupportedException {//这里也要重新克隆方法，不然无法使用
        return super.clone();
    }
}

//深拷贝
protected Object clone() throws CloneNotSupportedException {
        //throws CloneNotSupportedException 可能会异常 ，要解决异常，直接加throws CloneNotSupportedException
        Animal tmp = (Animal) super.clone();//用临时创建的对象来接收
        tmp.ba = (BA) this.ba.clone();
        return tmp;

    }


public class AxJava {
        public static void main(String[] args) throws CloneNotSupportedException {  //这里要加上throws CloneNotSupportedException
            Animal animal = new Animal("舍长", 21);
            //克隆上面这个对象,要强制转换类型
            Animal animal2 = (Animal) animal.clone();//但是找不到这方法，要类对接克隆接口关系
             //测一下深拷贝
            System.out.println("-----------------------");
            animal.ba.a = 30;
            System.out.println(animal.ba.a);
            System.out.println(animal2.ba.a);
}

2.9 抽象类和接口的区别

核心区别: 抽象类中可以包含普通方法和普通字段, 这样的普通方法和字段可以被子类直接使用(不必重写), 而接口中不能包含普通方法, 子类必须重写所有的抽象方法

3.object类

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

使用Object接收所有类的对象

class Person{

}
class Student{
    public Student() {
        System.out.println("韦坤");
    }

}
public class Objec {

    /*public static void fun(Object obj){//使用object来接收所有类
        System.out.println(obj);

    }*/

    public static void main(String[] args) {
        //System.out.println("阿祥");
        //object是所有没有继承类的父类
        //可以使用object来接收所有类
        /*fun(new Person());
        fun(new Student());*/

    }


}

2.1 equals和hashCode

两个都是object类中的方法，可以直接调用，作用分别是equals用于比较两个对象是否相等，相等返回true否则flase；而hashCode作用是可以定位该

   class Animal implements Cloneable {
    public String name;
    public int age;  
  public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Animal{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
    //重写equals
    @Override
    public boolean equals(Object o) {
//        if (this == o) return true;
//        if (!(o instanceof Animal)) return false;
//        Animal animal = (Animal) o;
//        return age == animal.age && Objects.equals(name, animal.name) && Objects.equals(ba, animal.ba);
        //上面这个写法也是一样好像
        //this指的是an2，传过来的o参数是an3
        Animal tmp = (Animal) o;
        return this.name.equals(tmp.name) && this.age == tmp.age;

    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}


public class AxJava {
        public static void main(String[] args) {
            Animal an2 = new Animal("张三",15);
            Animal an3 = new Animal("张三",15);
            System.out.println(an2.equals(an3));//进行比较是否一样，一样返回true
            //这时即使一样都返回flase ，说明equals方法已经不适用，要我们自己重写他的功能

            //hashCode定位在哪位置
            System.out.println(an2.hashCode());
            System.out.println(an3.hashCode());//因为重写了hashcode，所以输出一样
}