1.抽象类

1.1.抽象类概念

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

例如

虽然动物类有eat方法，但是没有具体的说明，其类是无法实现的，所以我们就称其为抽象类。

虽然动物有吃的方法，但是动物是一个总体，各个动物都有自己的吃的方式，所以动物描述是不具体的，然而猫和狗都是一个具体的动物，所以他们的吃的方式是确定的，所以按这种理解animal也是一个抽象类。

1.2.抽象类语法

一个类如果被 abstract 修饰称为抽象类，抽象类中被 abstract 修饰的方法称为抽象方法，抽象方法不用给出具体的实现体。

代码如下：

abstract class Animal{
    public int age;
    public void play(){
    }
    abstract public void eat();
    
}

注意：抽象类也是一个类，可以有普通方法，构造方法，变量，以及抽象方法，抽象方法不能给出具体的实现体

1.3.抽象类的特点

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

即上述代码中不能够实例化：Animal animal=new Animal();

2.抽象方法不能是 private 的

即上述代码中不能有abstract private void eat();

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

 即上述代码中不能有abstract final void eat();
                                 abstract public static void eat();

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

abstract class Animal{
    public int age;
    public void play(){
    }
    abstract public void eat();
}
class Dog extends Animal{
    public void eat(){
        System.out.println("在吃狗粮");
    }
}

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

代码如下：

abstract class Animal{

    public int age;
    public String name; 
    public Animal(String name,int age){
        =name;
        this.age=age;
    }
    abstract public void eat();
}
class Dog extends Animal{
    public Dog(String name,int age){
        super(name,age);
    }
    public void eat(){
        System.out.println("在吃狗粮");
    }
}

1.4.抽象类的作用

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

2.接口

2.1.接口的概念

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

2.2.接口的语法

将class关键字换成 interface 关键字，就定义了一个接口

public interface 接口名称{
// 抽象方法
public abstract void method1(); // public abstract 是固定搭配，可以不写
public void method2();
abstract void method3();
void method4();
// 注意：在接口中上述写法都是抽象方法，跟推荐方式4，代码更简洁
}

2.3接口的实现

有一个实现类来实现这个接口，且要用关键字interface

代码实例：

interface Irunning{
     void run();
}
class Cat implements Irunning{
    public void run(){
        System.out.println("在奔跑");
    }
}

2.4接口的特性

1. 接口类型是一种引用类型，但是不能直接new接口的对象，因为接口中的方法是抽象的

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

private  abstract void function（）；//报错 

3. 接口中的方法是不能在接口中实现的，只能由实现接口的类来实现（因为接口中的方法是抽象方法，抽象方法不能带有主体）

4.重写接口中方法时，不能使用默认的访问权限（在重写中默认修饰符权限不能低于public）

5.接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量

例如

默认的public static final为灰色

6. 如果类没有实现接口中的所有的抽象方法，则类必须设置为抽象类

interface computer{
    void func();
}
abstract  class Mouse implements computer{
    
} 

如代码所示，Mouse类没有重写方法func但是仍没有报错

2.5实现多个接口

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

例如：

public class test2 {
    public static void main(String[] args) {
        Person person=new Person();
        person.read();
        person.write();
    }
}
interface Ireading{
    void read();
}
interface Iwriting{
    void write();
}
class Person implements Ireading,Iwriting{
    public void read(){
        System.out.println("正在读书");
    }
    public void write(){
        System.out.println("正在写字");
    }
}

注意：一个类实现多个接口时，每个接口中的抽象方法都要实现，否则类必须设置为抽象类。

2.有了接口之后, 类的使用者就不必关注具体类型,而只关注某个类是否具备某种能力.例如跑步，只用关心实现接口的物体是否具有跑的能力。

public class test2 {
    public static void walk(Running running) {

        running.run();
    }
    public static void main(String[] args) {
        System.out.println("我带着伙伴去散步");
        Rabbit rabbit=new Rabbit("小白兔");
        Bear bear=new Bear("小熊");
        walk(bear);
        walk(rabbit);

    }
}
interface Running{
    void run();
}
class Rabbit implements Running{
    public String name;
    public Rabbit(String name){
        =name;
    }
    public void run(){
        System.out.println(name+"正在跳着跑");
    }
}
class Bear implements Running{
    public String name;
    public Bear(String name){
        =name;
    }
    public void run(){
        System.out.println(name+"正在用四只腿跑");
    }
}

2.6接口间的继承

interface IRunning {
void run();
}
interface ISwimming {
void swim();
}
// 两栖的动物, 既能跑, 也能游
interface IAmphibious extends IRunning, ISwimming {
}
class Frog implements IAmphibious {
...
}

并且都要将接口的方法进行重写

2.7 接口使用实例

例如

public class test3 {
    public static void main(String[] args) {
        Student[] student=new Student[]{
                new Student("zhangsan",12),
                new Student("lisi",11),
                new Student("wangwu",13),
        };
        Arrays.sort(students);
        System.out.println(Arrays.toString(student));


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

此时我们不能进行排序，因为学生对象的比较大小是不明确的。

此时让我们的 Student 类实现 Comparable 接口, 并实现其中的 compareTo 方法，

public class test3 {
    public static void main(String[] args) {
        Student[] student=new Student[]{
                new Student("zhangsan",12),
                new Student("lisi",11),
                new Student("wangwu",13),
        };
        Arrays.sort(student);
        System.out.println(Arrays.toString(student));
    }
}
class Student implements Comparable{
    public String name;
    public int age;
    public Student(String name,int age){
        =name;
        this.age=age;
    }
    public String toString(){
        return "["++":"+this.age+"]";
    }
    @Override
    public int compareTo(Object o) {
        Student student=(Student) o;
        return this.age-student.age;
    }
}

在 sort 方法中会自动调用 compareTo 方法. compareTo 的参数是 Object , 其实传入的就是 Student 类型的对象.然后比较当前对象和参数对象的大小关系(按分数来算).

2.8抽象类和接口的区别

抽象类：可以包含普通方法和普通字段, 这样的普通方法和字段可以被子类直接使用(不必重写)

接口中：不能包含普通方法, 子类必须重写所有的抽象方法.

总结：