目录
前言
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和static1.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，所以输出一样}