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 {@Overridepublic void open() {System.out.println("打开鼠标");}//鼠标点击实现public void click(){System.out.println("鼠标点击");}@Overridepublic void close() {System.out.println("关闭鼠标");}
}

键盘端

public class KeyBoard implements USB{@Overridepublic void open() {System.out.println("打开键盘");}public void inPut(){System.out.println("键盘输入");}@Overridepublic 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: 此处不允许使用修饰符privateprivate void openDevice();void closeDevice();}
3. 接口中的方法是不能在接口中实现的，只能由实现接口的类来实现

4. 重写接口中方法时，不能使用默认的访问权限
public interface USB {void openDevice();    // 默认是public的void closeDevice();   // 默认是public的
}public class Mouse implements USB {@Overridevoid 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);}@Overridepublic void fly() {System.out.println(this.name+"鸭子飞飞");}@Overridepublic void swim() {System.out.println(this.name+"鸭子游泳");}@Overridepublic void run() {System.out.println(this.name+"鸭子跑路");}
}//狗会跑
class Dog extends Animal implements Run{public Dog(String name, int age) {super(name, age);}@Overridepublic void run() {System.out.println(this.name+"狗跑路");}
}
//青蛙游
class Fish extends Animal implements Swim{public Fish(String name, int age) {super(name, age);}@Overridepublic 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 {//接口能继承多个接口。@Overridevoid run();@Overridevoid 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这些成员转换为字符串@Overridepublic 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;}@Overridepublic 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> {@Overridepublic int compare(B o1, B o2) {return o1.age -o2.age;}
}//按姓名来排序class NameCompartor2 implements Comparator<B>{@Overridepublic 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;@Overrideprotected Object clone() throws CloneNotSupportedException {//这里也要重新克隆方法，不然无法使用return super.clone();}
}@Override//浅拷贝protected Object clone() throws CloneNotSupportedException {//throws CloneNotSupportedException 可能会异常 ，要解决异常，直接加throws //CloneNotSupportedExceptionreturn super.clone();}
public class AxJava {public static void main(String[] args) throws CloneNotSupportedException {  //这里要加上throws CloneNotSupportedExceptionAnimal 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;@Overrideprotected Object clone() throws CloneNotSupportedException {//这里也要重新克隆方法，不然无法使用return super.clone();}
}//深拷贝
protected Object clone() throws CloneNotSupportedException {//throws CloneNotSupportedException 可能会异常 ，要解决异常，直接加throws CloneNotSupportedExceptionAnimal tmp = (Animal) super.clone();//用临时创建的对象来接收tmp.ba = (BA) this.ba.clone();return tmp;}public class AxJava {public static void main(String[] args) throws CloneNotSupportedException {  //这里要加上throws CloneNotSupportedExceptionAnimal 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;}@Overridepublic String toString() {return "Animal{" +"name='" + name + '\'' +", age=" + age +'}';}//重写equals@Overridepublic 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参数是an3Animal tmp = (Animal) o;return this.name.equals(tmp.name) && this.age == tmp.age;}@Overridepublic 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，所以输出一样
}