java---抽象类和接口详解

抽象类

抽象类的概念

在面向对象的概念中，所有的对象都是通过类来描述的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。

图22：55

没有实际工作的方法我们把它设计为抽象方法，使用关键字abstract进行修饰。
抽象类：不能完全代表一个对象，此时使用abstract来修饰这个类。

抽象类需要注意的地方
1.抽象类和抽象方法都是使用abstract进行修饰的
2.抽象类不能进行实例化的
3.抽象类当中不一定包含抽象方法，包含抽象方法的类，一定是抽象类
4.抽象类当中可以定义成员变量和成员方法
5.当普通类继承抽象类时，普通类当中要重写抽象类的抽象方法
6.抽象类存在的最大意义就是为了继承。

抽象类语法

//抽象类：被abstract修饰的类
public abstarct class Shape{
//抽象方法：被abstarct修饰的方法，没有方法体
abstract static void draw();
abstract void calcArea();
//抽象也是类，也可以增强普通方法和属性
public double getAera(){
 return area;
}
protected double arear;//面积
}

注意:抽象类也是类，内部可以包含普通方法和属性，甚至构造方法。

抽象类特性

1.抽象类不能直接实例化对象

Shape shape=new Shape();
//编译出错
Shape是抽象的：无实例化

2.抽象方法不能是private的

abstract class Shape{
 abstract private void draw();
 }
 //编译出错
 非法的修饰符组合：abstract和private

3.抽象方法不能被final和static修饰，因为抽象方法要被子类重写

public abstract class Shape{
 abstract final void methodA();
  abstract public static void methodB();
 }
 //非法的修饰符组合：abstract和final

4.抽象类必须被继承，并且继承后子类要重写父类中抽象方法，否则子类也是抽象类，必须使用abstract修饰

//矩形类
public class rect extends Shape{
 private double length;
 private double width;

rect(double length,double width){
 this.length=length;
 this.width=width;
 }
public void draw(){
System.out.println("矩形:length="+length+"width="+width);
}
public void calcArea(){
 area=length*width;
 }
}

5.抽象类中不一定包含抽象方法，但是有抽象方法的类一定是抽象类。
6.抽象类中可以有构造方法·，供子类创建对象时，初始化父类的成员变量。

抽象类的作用

抽象类本身不能被实例化，想要使用，只能创建抽象类的子类，然后让子类重写写抽象类中的抽象方法。
使用抽象类的场景就如上面的代码，实际工作不应该由父类完成，而应由子类完成，那么此时如果不小心误用成父类，使用普通编译器是不会报错，但是父类是抽象类就会在实例化的时候提示错误。

接口

接口的概念

接口就是公共的行为规范标准，大家在实现时，只要符合规范标准，就可以通用。在Java中，接口可以看成是：多个类的公共规范，是一种引用数据类型。

语法规则

接口的定义格式与定义类的格式基本相同，将class关键字换成interface关键字，就定义了一个接口。

public interface接口名称{
//抽象方法
 public abstract void main method1();
 //public abstract2(); 是固定搭配，可以不写
 abstract void method3();
 void method4();
 }

提示
1.创建接口时，接口的命名一般以大写字母i开头
2.接口的命名一般使用“形容词”词性的单词
3.阿里编码规范中约定，接口中的方法和属性不要加任何修饰符号，保持代码的简洁性。

接口使用

接口不能直接使用，必须要有一个“实现类”来“实现”该接口，实现接口中的所有抽象方法

public class 类名称 implements 接口名称{
//
}

注意：子类和父类之间是extends继承关系，类与接口之间是implements实现关系

请实现笔记本电脑使用usb鼠标，usb键盘的例子
1.usb接口：包括打开设备，关闭设备功能
2.笔记本类：包含开机功能，关机功能，使用usb设备功能
3.鼠标类：实现usb接口，并具备点击功能
4.键盘类：实现usb接口，并具备输入功能

//usb接口
public interface usb{
 void openDevice();
 void closeDevice();
 }
 //鼠标类，实现usb接口
 public class Mouse implements usb{
  public void openDevice(){
  System.out.println("打开鼠标"):
}

接口特性

1.接口类型是一种引用类型，但是不能直接new接口的对象

public class TestUSB{
 public static void main(String[] args){
   USB usb=new USB();
   }
}
无法实例化

2.接口中每一个方法都是public的抽象方法，即接口中的方法会被隐式的指定为public abstract（只能是public abstract，其他修饰符都会报错）

public interface USB{
//此处不允许使用修饰符
private void openDevice();
void closeDevice();
}

3.接口中的方法是不能在接口中实现的，只能由实现接口的类来实现

public interface USB{
  void openDevice();
  //因为接口中的方式默认认为抽象方法
  void closeDevice(){
   System.out.println("关闭USB设备");
   }
}

4.重写接口中方法时，不能使用默认的访问权限

public interface USB{
  void openDevice();//默认是public的
  void closeDevice();//默认是public的
}
public class Mouse implements USB{
   void openDevice(){
     System.out.println("打开鼠标");
     }
}
//正常尝试分配更低的访问权限；以前为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);//可以直接通过接口名访问，说明静态的
  //无法最终变量brand分配值
  USB.brand=2.0;
   }
}

6.接口中不能有静态代码块和构造方法

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)://可以直接通过接口名访问，说明是静态
     //无法为最终变量brand分配值
     USB.brand=2.0;//说明brand具有final
     }
  }

6.接口中不能有静态代码块和构造方法

public interface USB{
//编译失败
  public USB(){
  }
  {}//编译失败
  void openDevice();
  void clodeDevice();
  }

7.接口虽然不是类，但是接口编译完成后字节码文件的后缀格式也是.class
8.如果类没有实现接口中的所有的抽象方法，则类必须设置为抽象类
9.jdk8中：接口中还可以包含default方法

实现多个接口

在Java中，类和类之间是单继承，一个类只能有一个类，即java中不支持多继承，但是一个类可以实现多个接口。

clss Animal{
  protected String name;
  public Animal(String name){
   this.name=name;
   }
}  

另外我们再提供一组接口，分别表示”会飞的“，”会跑的“，”会游泳“

interface IFlying{
  void fly();
}
interface Irunning{
  void run();
}
interface ISwimming{
  void swim():
}   

接下来我们创建几个具体的动物
猫，是会跑的

class Cat extends Animal implements Irunning{
  public Cat(String name){
   super(name);
 }
 public void run(){
   System.out.println(this.name+"正在用四条腿跑");
   }
}

鱼，是会游的

class Fish extends Animal implements Irunning{
  public Fish(String name){
   super(name);
 }
 public void swim(){
   System.out.println(this.name+"正在用尾巴游泳");
   }
}

注意：一个类实现多个接口时，每个接口中抽象方法都要实现，否则类必须设置为抽象类
IDea中使用ctrl+i快速实现接口
水陆空

class Duck extends Animal inplents Irunning,ISwimming,IFlyig{
  public Duck(String name){
   super(name);
 }
  public void fly(){
    System.out.println(this.name+"正在用翅膀飞");
}
  public void run(){
    System.out.println(this.name+"正在用两条腿跑");
}
  public void swim(){
    System.out.println(this.name+"正在漂在水上");
}
}

上面的代码展示了java面向对象编程中最常见的用法：一个类继承一个父类，同时实现多中接口。
继承表达式的含义是is-a语义，而接口表达的含义是 具有—特性

猫是一种动物，具有会跑的特性
青蛙也是一种动物，既能跑，也能游泳
鸭子也是一种动物，既能跑，也能游，还能飞

这样设计有什么好处，时刻记牢多态的好处，让程序源忘记类型，有了接口后，类的使用者就不必关注具体类型，而只关注某个类是否具备某种能力

接口间的继承

在Java中，类和类之间是单继承的，一个类可以实现多个接口，接口与接口之间可以多继承。即：用接口可以达到多继承的目的。
接口可以继承一个接口，达到复用的效果，使用extends关键字。

interface Iunning{
 void run();
 }
 interface ISwiming{
  void swim();
  }
  //两栖动物，既能跑，也能游
 interface IAmphibious extends Irunnng,ISwimming{
   
 }
 class Frog implements IAmphibious{
 }

通过接口继承创建一个新的接口IAmphibious表示“两栖的”，此时实现创建的Frog类，就继续要实现run方法，也需要实现swim方法

目前存在的关系：
1.类和类之间：【通过extends类进行继承】
2.类和接口之间的关系：implements实现接口
3.接口和接口之间也是存在关系的 extends来进行

接口使用实例

给对象数组排序

class Student[
 private String name;
 private int score;
 
 public Student(String name,int score){
  this.name=name;
  this.score=score;
}
  public String toString(){
  return"["+this.name+":"+this.score+"]";
  }
}

在给定一个学生对象数组，对这个对象数组中的元素进行排序（按分数降序）

Student[] students =new Student[]{
   new Student("张三",95),
   new Student("李四",96),
   new Student("王五",97),
   new Student("赵六",92),
   };

按照我们之前的理解，数组我们有一个现成的sort方法，能否直接使用这个方法？

Arrays.sort(students);
System.out.println(Arrays.toString(students));

//运行出错，抛出异常

class Student
{
  private String name;
  private int socre;

  public Student(Strung name,int score){
   this.name=name;
   this.score=score;
}
  public Student toString(){
   return "["+this.name+":"+this.score+"]";
   }
} 

再给定一个学生对象数组，对这个对象数组中的元素进行排序（按分数排序）

Studebt[] students =new Student[]{
  new Student("张三",95);
  new Student("李四",96);
  new Student("王武",98);
};

数组有一个现成的sort方法，能否直接使用？

//运行错误，抛出异常

仔细思考，和普通整数不一样的是，两个整数是可以被直接比较的，大小关系明确。
Student的类实现Comparable接口，并实现其中的comparaTo方法

class Studednt implments Compararble{
  private String name;
  private int score;

public Student(String name,int score){
  this.name=name;
  this.score=score;
}
public Student toString(){
   return "["+this.name+":"+this.score+"]";
   }
   public int compara To(Object o){
   Student s=(Student)o;
   if(this.score>s.score){
   return -1;
   }
   else if(this.score<s.score){
   return1;
   }
   else{
   return 0;
   }

在sort方法中会自动调用compareTo方法，compareTo的参数是Object，其实就是传入Student类型的对象。

如果当前对象应排在参数对象之前，返回值小于0的数字。
如果当前对象应排在参数对象之后，返回值大于0的数字。
如果当前对象与参数对象不分先后，返回值0。

//执行结果
[[王武：98],[李四：96],[张三：95]]

注意事项：对于sort来说，需要传入的数组的每个对象都是“可比较”的，需要具备compareTo的能力。

抽象类和接口的区别

抽象类和接口都是Java中多态的常见使用方式。
核心区别：抽象类中可以包含普通方法和普通字段，这样的普通方法和字段可以被子类直接使用（不必重写），而接口中不能包含普通写法，子类必须重写所有的抽象方法。

class Animal{
    protected String name;
public Animal(String name){
  this.name=name;
  }
}

此处的Aniaml中包含一个name这样的属性，这个属性在任何子类中都是存在的，因此此处的Animal只能作为一个抽象类，而不应该成为一个接口。

抽象类存在的意义为了让编译器更好的校验，像Animal这样的我们并不会直接使用，而是使用它的子类，万一不小心创建了Animal的实例，编译器会及时提醒。

Clonable接口和深拷贝

object类中存在一个clone方法，调用这个方法可以创建一个对象的“拷贝”，但是要想合法的调用，必须实现Clonable接口

class Student implements Cloneable{
  private String name;
  private int age;

  public Student(int age){
    this.age=age;
    }
  public Student toString(){
   return "["+this.name+":"+this.score+"]";
   }
  public interface Cloneable {
  ｝
  //这个接口什么东西都没有，叫做标记接口，实现该接口，证明当前的类是可以被克隆的

  protected Odject clone() throws CloneNotSupportedException{
   return super.clone();
   
  public class Test{
     public static void main(String[] args){
     Student student1=new Student(age:10);
     Student student2=(String)
student1.clone();
System.out.println(student1);
System.out.println(student2);
     //student    Object  向下转型

Obiect类

Object是java默认提供的一个类。Java里面除了Object类，所有的类都是存在继承关系的。默认关系会继承Object父类。
可以认为Object是所有类的父类，哪怕没有显示继承这个类。

class Person{}
class Student{}
 public class Test{
 public static void main(String[] args){
   function(new Person());
   function(new Student());
}
public static void function(Object obj){
  System.out.println(obj);
  }
}

获取对象信息

如果要打印对象中的内容，可以直接重写Object类中的toString（）方法。

//Object类中的String()方法实现：
public String toString(){
  return getClass().getName()+"@"+Interger.toHexString(hashCode());
}

对象比较equals方法

在Java中，= =进行比较：
a.如果= =左右两侧是基本类型变量，比较的是变量中值是否相同
b.如果= =左右两侧是引用变量，比较的是引用变量地址是否相同
c.如果比较对象内容，必须重写Object中的equals的方法，因为equals方法默认也是按照地址比较的：、

public boolean equals(Object obj){
   return (this==obj);//使用引用地址直接来进行比较
   }

class Person{
  private String name;
  private int age;
  public Person(String name,int age){
   this.age=age;
   this.name;
 }
}
public class Test{
 ppublic static void main(String[] args){
  Person p1=new Person("gaobo",20);
  Person p2=new Person("gaobo",20);
  int a=10;
  int b=10; 
  System.out.println(a==b);//true
  System.out.println(p1==p2);//flase
  System.out.println(p1.equals(p2));//flase 
  }
} 

Person类重写equals方法后，然后比较：
class Peson
 public boolean equals(Object obj){
   if(obj ==null){
     return flase
     }
     //不是Person对象
     if (!(obj instanceof Person)){
      return flase;
      }
      Person person=(Person) obj;//向下转型，比较属性值
      return this.name.equals(person.name)&&this.age==person.age;
      }
 }

结论：比较对象中内容是否相同的时候，一定要重写equals方法。

hashcode方法

回忆刚刚的toString方法源码

public String toString(){
  return getClass().getName()+"@"+Interger.toHexString(hashCode());
  }

我们看到hashCode()这个方法，算了一个具体的对象位置，这里面涉及数据结构，没法简述，所以说我们只能说他是个内存地址。然后调用Integer.toHexString()方法，将这个地址以16进制输出
hashcode方法源码：

public native int hashCode();

我们认为两个名字相同，年龄相同的对象，将存储在同一个位置，如果不重要hashcode()方法，我们可以来看实例

class Person{
  public String name;
  public int age;
  public Person(String name,int age){
   this.name=name;
   this.age=age;
 }
}
 public classTEstD{
  public static void main(String[] args){
   Person per1=new Person("gaobo",20);
   Person per2=new Person("gaobo",20);
   System.out.println(per1.hashCode());
   System.out.println(per2.hashCode());
   }
   }

注意事项：两个对象的hash值不一样
像重写equals方法一样，我们也可以重写hashCode（）方法，此时我们再来看看。

class Person{
  public String name;
  public int age;
  public Person(String name,int age){
   this.name=name;
   this.age=age;
}
  public int hashCode(){
   return Object.hash(name,age);
   }
   }
    public classTEstD{
  public static void main(String[] args){
   Person per1=new Person("gaobo",20);
   Person per2=new Person("gaobo",20);
   System.out.println(per1.hashCode());
   System.out.println(per2.hashCode());
   }
   }

结论：
1.hashcode方法用来确定对象在内存中存储的位置是否相同。
2.事实上hashCode()在散列表中才有用，在其他情况下没用。在散列表中hashCode()的作用是获取对象的三列码，进而确定对象在散列表中的位置。