目录
前言
1.抽象类
1.2抽象类语法
1.3抽象类特性
1.4抽象类的作用
2.接口
2.1接口概念
2.2接口的定义
2.3接口的使用
接口使用栗子
2.4接口特性
2.5 实现多个接口
请看栗子
2.6接口间的继承
2.7接口使用实例
2.8Clonable 接口和深浅拷贝
2.9 抽象类和接口的区别
3.object类
2.1 equals和hashCode
前言
本文内容：抽象类的语法、特性、作用，以及接口的概念、定义、使用、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，所以输出一样 }
