抽象类和接口的总结

一、抽象类

1、什么是抽象类

包含抽象方法的类
基本语法：⬇

abstract class shape{
    abstract public void draw();
}

2、语法规则

1、抽象类不能有方法体，即{}，不能执行具体代码
2、抽象方法不能被实例化（不能new）
3、抽象方法不能是私有的(因为抽象类要被继承)
4、抽象类中可以包含其他的非抽象方法，也可以包含字段，这个非抽象方法和普通方法一样，可以被重写，也可以被其他子类直接调用
5、抽象类被继承了一定要重写抽象方法
6、如果抽象类B继承了抽象类A，那么B可以重写或者不重写抽象方法

abstract class Shape{
    abstract public void draw();
    public int a;//属性
    public void func() {//普通方法
        System.out.println("调用普方func()");
    }
}
class Circle extends Shape{

    public void draw() {//重写draw 方法，Circle继承了Shape,必须要重写抽象方法 
        System.out.println("画圆");
    }

}

=======================================================================
abstract class A {
    abstract public void dowhat();

}
abstract class B extends A {

}
abstract class C extends B {
    public void dowhat() {
        System.out.println("可重写，也可以不重写");
    }

}
=====================================================================
public class Nov16 {
    public static void main(String[] args) {
        Shape shape=new Circle();
        shape.draw();
        shape.func();
        
    }

}

3、抽象类的作用

抽象类的存在就是为了被继承的
抽象类本身不能被实例化, 要想使用, 只能创建该抽象类的子类. 然后让子类重写抽象类中的抽象方法.
使用抽象类相当于多了一层校验，比如某些工作该有子类完成的时候，却调用了父类，如果是普通类的话可能不会报错，但是父类为抽象类时实例化就会报错（还是因为抽象类不能被实例化)，所以可以预防出错。

二、接口

1、什么是接口

抽象方法的集合，也就是说接口当中的方法 全部不能有具体的实现
定义一个接口⬇
用interface定义一个接口

interface I {
    public abstract void func2();//抽象方法，默认为public abstract
    public static final int size=0;//接口只能包含静态常量
    
}
========================================================================
//简化版
interface I {     
	void draw();     
	public static final int num = 10; 
}

2、语法规则

1、接口中的方法默认是抽象的（public abstract），可以写public abstract，也可以省略
2、接口只能包含静态常量，并且静态常量在定义是必须初始化
3、类与接口之间的关系是implement，也就是实现。
4、接口不能被单独实例化，
5、在调用的时候同样可以创建一个接口的引用, 对应到一个子类的实例

interface IShape {
    public abstract void draw() ; // 即便不写public，也是public
 }

 class Rect implements IShape {//使用 implements 继承接口
     @Override
     public void draw() {
        System.out.println("□") ;

    }
}
interface T {
    void fun4();
}
interface F extends IShape,I,T {//接口可以实现多重继承，接口与接口之间是继承
    void funF();

}
public class Test1 {
    public static void main(String[] args) {
        IShape shape=new Rect();
        shape.draw();
        
    }

}

3、实现多个接口

Java里没有多重继承，通常使用接口来实现多重继承，一个类只能继承一个父类，但他可以实现多个接口。

class Animal2 {
    protected String name;

    public Animal2(String name) {
        this.name = name;
    }
}
//定义一组接口
    interface Irunning {
        void run();
}
interface Iswimming {
    void swim();
}
interface Ifiying {
    void fly();
}
class Bird1 extends Animal2 implements Ifiying,Irunning {
    public Bird1(String name) {
        super(name);
    }

    @Override
    public void run() {
        System.out.println(this.name+"在"+"run()");
    }

    @Override
    public void fly() {
        System.out.println("fly()");

    }
}
class Fish extends Animal2 implements Irunning,Iswimming {
    public Fish(String name) {
        super(name);
    }

    @Override
    public void run() {
        System.out.println(this.name+"在"+"run");
    }

    @Override
    public void swim() {
        System.out.println(this.name+"在"+"swim");

    }
}
public class Test3 {
    public static void main(String[] args) {
        Bird1 bird1=new Bird1("xiaoxiao");
        bird1.fly();
        bird1.run();

    }
}

上面的代码展示了一个类继承了一个类实现了多个接口，接口的出现也正体现了封装性，类的使用者就不必关注具体类型, 而只关注某个类是否具备某种能力.

4、接口的实际应用，给对象数组排序
在讨论这个问题时，我们要想现在是对对象数组排序，此时不能简单的调用Arrays.sort方法，对于数据类型的比较我们用的是CompareTo方法，而这个方法Java中所有的compareTo方法都源于一个共同的接口，那就是Comparable接口。

定义：

public interface Comparable<T>

class Student implements Comparable<Student>{
    private String name;
    private int grade;

    public Student(String name, int grade) {
        this.name = name;
        this.grade = grade;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", grade=" + grade +
                '}';
    }
//按分数排序，
    @Override
    public int compareTo(Student o) {
        return this.grade-o.grade;
    }
}

public class Test4 {
    public static void main(String[] args) {
        Student[] students = new Student[] {
                new Student("张三", 95),
                new Student("李四", 96),
                new Student("王五", 97),
                new Student("赵六", 92), };
        Arrays.sort(students);
        System.out.println(Arrays.toString(students));
    }

}

Cloneable接口
有时候我们需要拷贝一个对象，而Cloneable接口给出了一个可以克隆的对象

//这是Cloneable的源码
public interface Cloneable {
}

我们可以看到Cloneable接口是空的，其中没有抽象方法
空接口》》也叫标记接口，（）一个标记接口没有常量和方法，只是为了表示一个类拥有某些特定属性。实现Cloneable接口的类标记为可克隆的

三、抽象类和接口的区别

核心区别：: 抽象类中可以包含普通方法和普通字段, 这样的普通方法和字段可以被子类直接使用(不必重写), 而接口中不能包含普通方法, 子类必须重写所有的抽象方法

抽象类	接口
抽象方法+普通类（普通方法、属性）	抽象方法+全局常量
各种权限	public
一个子类只能继承一个抽象类	一个子类可以实现多个接口
一个抽象类可以实现若干接口	接口不能实现抽象类，但可以 继承多个父接口