1.抽象类
1.1抽象类的概念
在面向对象中，所有对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息描绘一个具体的对象，这样的类就是抽象类。
例子：
说明：Animal类没有办法描述一个具体动物的行为，所以Animal无法具体实现，可以将Animal设置一个抽象类。
我们可以发现，父类Animal中的draw方法并没有什么实际工作，主要工作的是Animal中各种子类的方法来实现。
对于这种没有实际工作的方法，我们可以将其设计为一个抽象方法，包含抽象方法的类我们叫做抽象类。
1.2抽象类语法
在java中，一个类如果被 abstract修饰，抽象类中被abstract修饰的方法叫抽象方法，抽象方法不用给出具体的实现体。
注意：抽象类也是类，内部可以包含普通方法和属性，甚至构造方法
1.3特性
1.抽象类不能直接实例化
2.抽象类也可以发生向上转型，动态绑定，多态。
3.抽象方法不能被final和stati修饰，因为抽象方法要被子类重写
4.抽象类必须被继承，并且继承后子类要重写父类中的抽象方法，否则子类也是抽象类，必须要使用abstract修饰
5.抽象类不一定要包含抽象方法，但是有抽象方法的类一定是抽象类
6.抽象类中也可以有构造方法，供子类创建对象时，初始化父类的成员变量
抽象类的作用：
****使用抽象类相当于多了一重编译器的校验. 使用抽象类的场景就如上面的代码, 实际工作不应该由父类完成, 而应由子类完成. 那么此时如果不小心误用成父类 了, 使用普通类编译器是不会报错的. 但是父类是抽象类就会在实例化的时候提示错误, 让我们尽早发现问题.
2.接口
2.1接口的概念
接口就是公共的行为规范标准，在实现时，只要符合规范标准，就可以通用。
在java中，接口可以看成：多个类的公共规范，是一种引用数据类型。
用于描述类具有什么功能，但不给予实现，当某个类要使用接口时，需要重写接口中的方法。
例如：电脑上的USB口上，可以插：U盘、鼠标、键盘...所有符合USB协议的设备
2.2接口的语法规则
1.接口的定义格式与类的定义基本相同，只是将class换成interface关键字
2.格式：interface 接口名｛｝ （注意的是，接口的访问权限修饰符只能是public或者默认）
3.类和接口之间是实现关系，不再是继承，所以要用implements关键字
4.接口的命名一般以大写字母I开头
java
public interface Running2.3接口的特点
1.接口成员变量
接口中没有成员变量，只有公有静态常量
在默认情况下，属性前都会有public static final 修饰。
即 public static final 数据类型 常量名 = 值；
在定义时必须初始化，否则报错。对于公有静态常量，初始化的途径有两种：
1.在定义的时候初始化
2.在静态代码块中初速化，但是接口中不允许存在代码块，而且接口没有构造方法。
所以我们在只能在定义时就初始化。
1.2接口中成员方法的特点
接口中方法默认是公有抽象方法，在定义接口时，我们可以直接写返回类型 方法名（参数）
接口中可以有public static 方法（通过接口名引用）和 public default 方法（可重写或者不重写，由对象引用）
2.4多接口
在Java中，类和类之间是单继承的，一个类只能有一个父类，即Java中不支持多继承，但是一个类可以实现多个接口
注意：一个类实现多个接口时，每个接口中的抽象方法都要实现，否则类必须设置为抽象类。
我们动物为例
先创建个Animal类
java
public abstract class Animal {
protected String name;
protected int age;
public Animal(String name,int age){
this.name=name;
this.age=age;
}
public abstract void eat();
}有了动物，那么他们的行为有多种，如果我们用继承，只能继承一个，不能多继承。但是对于一种动物，它的行为不止一种，对于猫，它会跑，跳。用继承明显不行，所以我们可以用接口，一个类可以实现多个接口。
跑的接口，游泳接口 飞的接口，跳的接口
java
public interface IRunning {
void run();
}
public interface ISwumming {
void swim();
}
public interface IFly {
void fly();
}
public interface Ijump {
void jump();
}我们创建具体的动物，如猫，狗。
猫是动物，所以我们需要继承Animal类，再实现跑和跳的接口
java
public class Cat extends Animal implements IRunning,Ijump{
public Cat(String name, int age) {
super(name, age);
}
public void eat() {
System.out.println(this.name+"吃鱼");
}
public void run() {
System.out.println(this.name+"跑");
}
public void jump() {
System.out.println(this.name+"跳");
}
}狗
java
public class Dog extends Animal implements IRunning,ISwumming{
public Dog(String name, int age) {
super(name, age);
}
public void eat() {
System.out.println(this.name + "吃骨头");
}
public void swim() {
System.out.println(this.name + "在游泳");
}
public void run() {
System.out.println(this.name + "在跑");
}
}我们既然已经创建好猫和狗
那么我们就可以进行创建对象，这里我们创建了两个方法，runc和swim，但是为什么参数不是Dog和Cat呢，这里我们不需要关心对象是谁，只需要知道对象是否具有这个功能。
java
public class test {
public static void runc(IRunning irunning){
irunning.run();
}
public static void swim(ISwumming iswumming){
iswumming.swim();
}
public static void main(String[] args) {
runc(new Dog("旺财",3));
runc(new Cat("小花",2));
swim(new Dog("旺财",3));;
}
}
上面展示了一个类继承一个父类, 同时实现多种接口.
2.5接口继承
类与类之间是单继承的，一个类可以实现多个接口，接口与接口之间也可以多继承。
用接口可以达到多继承的目的。
接口与接口之间用extends关键字，实现复用
java
interface IA{
void testa();
}
interface IB{
void testb();
}
interface IC extends IA,IB{
void testc();
}
class TC implements IC{
public void testa()
{
System.out.println("testa");
}
public void testb()
{
System.out.println("testb");
}
public void testc()
{
System.out.println("testc");
}
}
public class test{
public static void main(String[] args) {
TC tc=new TC();
tc.testa();
tc.testb();
tc.testc();
}
}我们可以看到，虽然只implements IC，但是IA,IB的方法我们也要实现。
3.接口的实际使用
3.1给对象数组排序
引用类型不可以用>、=、<比较
对于引用类型，我们可以implements comparable
但是comparable这个接口有局限性
java
import java.util.Arrays;
class Student implements Comparable<Student>{
public int age;
public String name;
public Student(int age){
this.age=age;
}
@Override
public String toString() {
return "Student{" +
"age=" + age +
'}';
}
// @Override
// public int compareTo(Student o) {//通过名字排序
// if(this.name.compareTo(o.name)>0) {
// return 1;
// }else if(this.name.compareTo(o.name)<0) {
// return -1;
// }else {
// return 0;
// }
// }
public int compareTo(Student o) {//通过年龄
return this.age-o.age;
}
}
public class tesst {
public static void bubble_Sort(Student[] arr){
for (int i=0;i<arr.length-1;i++)
for (int j=0;j<arr.length-1-i;j++)
if (arr[j].compareTo(arr[j+1])>0){
Student temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
public static void main(String[] args) {
Student[] student=new Student[3];
student[0]=new Student(8);
student[1]=new Student(15);
student[2]=new Student(10);
Arrays.sort(student);
// bubble_Sort(student);
for (int i=0;i<student.length;i++)
System.out.println(student[i]);
}
}在对对象数组排序的时候，我们需要借助comparable接口，并重写compareTo方法
当然，我们也可以调用sort方法，但是sort方法判断是否排序，也是需要借助compareTo方法
优化：既然comparable有局限性，那么我们可以用Comparator接口，并重写里面的compare方法
只不过我们在使用这个AgeCompare时，需要先new一下它的对象，然后进行使用
java
import java.util.Comparator;
class AgeCompare implements Comparator<Student> {
@Override
public int compare(Student o1, Student o2) {
return o1.age-o2.age;
}
}
class Student {
public int age;
public String name;
public Student(int age){
this.age=age;
}
@Override
public String toString() {
return "Student{" +
"age=" + age +
'}';
}
}
public class tesst {
public static void bubble_Sort(Student[] arr) {
AgeCompare ageCompare = new AgeCompare();
for (int i = 0; i < arr.length - 1; i++)
for (int j = 0; j < arr.length - 1 - i; j++) {
if (ageCompare.compare(arr[j], arr[j + 1]) > 0) {
Student temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
public static void main(String[] args) {
Student[] student=new Student[3];
student[0]=new Student(8);
student[1]=new Student(15);
student[2]=new Student(10);
// Arrays.sort(student);
bubble_Sort(student);
for (int i=0;i<student.length;i++)
System.out.println(student[i]);
}
}3.2Clonable接口和浅，深拷贝
java中内置一些很有用的接口，Clonable就是其中一个。
Objet类中存在一个clone方法，调用这个方法可以创建一个对象的"拷贝"。但是要想合法调用clone方法，我们需要先实现Clonable接口，否则就会抛出CloneNotSupportedException异常。
我们先创建一个学生类并且接入Clonable
java
lass Student implements Cloneable {
public int age;
public String name;
public Student(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"age=" + age +
'}';
}
}我们需要对Clonable里的方法进行重写，这里我们可以点击鼠标右键，找到Generate，按照图中步骤生成即可。
浅拷贝注意事项：
- 需要接入Clonable接口
2.需要实现clone方法并抛出异常
3.main方法也需要抛出异常
javascript
class Student implements Cloneable {
public int age;
public String name;
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
public Student(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"age=" + age +
'}';
}
}
public class ttest {
public static void main(String[] args) throws CloneNotSupportedException {
Student s1=new Student(10);
Student s2=(Student)s1.clone();
System.out.println(s1);
System.out.println(s2);
}
}
浅拷贝缺点：
浅拷贝也有她的不足之处，在上面的例子中，我们新增个Money类并且也接入Clonable，如果我们只想修改student1的money，就会发现student2的money也发生改变。
java
class Money implements Cloneable {
int money=10;
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
class Student implements Cloneable {
public int age;
public String name;
public Money m=new Money();
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
public Student(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"age=" + age +
'}';
}
}
public class ttest {
public static void main(String[] args) throws CloneNotSupportedException {
Student s1=new Student(10);
Student s2=(Student)s1.clone();
System.out.println(s1.m.money);
System.out.println(s2.m.money);
System.out.println("==========");
s1.m.money=20;
System.out.println(s1.m.money);
System.out.println(s2.m.money);
}
}
为什么会这样，这是因为只拷贝了student1，但是内部的Money类并没有拷贝，student2的m还是指向的student1的m。
既然浅拷贝不行，那么我们就得用深拷贝
深拷贝
对对象的复制，创建一模一样的对象，新的对象不会对被拷贝的对象造成影响。
java
class Money implements Cloneable {
int money=10;
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
class Student implements Cloneable {
public int age;
public String name;
public Money m=new Money();
@Override
protected Object clone() throws CloneNotSupportedException {
Student tmp=(Student) super.clone();
tmp.m=(Money)this.m.clone();
return tmp;
}
public Student(int age) {
this.age = age;
}
@Override
public String toString() {
return "Student{" +
"age=" + age +
'}';
}
}
public class ttest {
public static void main(String[] args) throws CloneNotSupportedException {
Student s1=new Student(10);
Student s2=(Student)s1.clone();
System.out.println(s1.m.money);
System.out.println(s2.m.money);
System.out.println("==========");
s1.m.money=20;
System.out.println(s1.m.money);
System.out.println(s2.m.money);
}
}
我们可以看到，改student1的m的值，不会影响到student2的m的值，这就是深拷贝。下面是student的内存分配示意图。
4.抽象类和接口的区别
抽象类中可以包含普通方法和普通字段, 这样的普通方法和字段可以被子类直接使用(不必重写)
而接口中 不能包含普通方法, 子类必须重写所有的抽象方法
**注意：**抽象类存在的意义是为了让编译器更好的校验
看图：
