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开头
public interface Running2.3接口的特点
1.接口成员变量
接口中没有成员变量，只有公有静态常量
在默认情况下，属性前都会有 public static final 修饰。
即 public static final 数据类型 常量名 = 值；
在定义时必须初始化，否则报错。对于公有静态常量，初始化的途径有两种：
1.在定义的时候初始化
2.在静态代码块中初速化，但是接口中不允许存在代码块，而且接口没有构造方法。
所以我们在只能在定义时就初始化。
1.2接口中成员方法的特点
接口中方法默认是公有抽象方法，在定义接口时，我们可以直接写返回类型 方法名（参数）
接口中可以有public static 方法（通过接口名引用）和 public default 方法（可重写或者不重写，由对象引用）
2.4多接口
在Java中，类和类之间是单继承的，一个类只能有一个父类，即Java中不支持多继承，但是一个类可以实现多个接口
注意：一个类实现多个接口时，每个接口中的抽象方法都要实现，否则类必须设置为抽象类。
我们动物为例
先创建个Animal类
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();
}有了动物，那么他们的行为有多种，如果我们用继承，只能继承一个，不能多继承。但是对于一种动物，它的行为不止一种，对于猫，它会跑，跳。用继承明显不行，所以我们可以用接口，一个类可以实现多个接口。
跑的接口，游泳接口 飞的接口，跳的接口
public interface IRunning {
void run();
}
public interface ISwumming {
void swim();
}
public interface IFly {
void fly();
}
public interface Ijump {
void jump();
}
我们创建具体的动物，如猫，狗。
猫是动物，所以我们需要继承Animal类，再实现跑和跳的接口
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+"跳");
}
}
狗
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呢，这里我们不需要关心对象是谁，只需要知道对象是否具有这个功能。
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关键字，实现复用
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这个接口有局限性
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一下它的对象，然后进行使用
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
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，按照图中步骤生成即可。
浅拷贝注意事项：
1. 需要接入Clonable接口
2.需要实现clone方法并抛出异常
3.main方法也需要抛出异常
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也发生改变。
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。
既然浅拷贝不行，那么我们就得用深拷贝
深拷贝
对对象的复制，创建一模一样的对象，新的对象不会对被拷贝的对象造成影响。
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.抽象类和接口的区别
抽象类中可以包含普通方法和普通字段, 这样的普通方法和字段可以被子类直接使用(不必重写)
而接口中 不能包含普通方法, 子类必须重写所有的抽象方法
注意：抽象类存在的意义是为了让编译器更好的校验
看图：
