Java中的抽象类和接口怎么理解
这篇文章主要介绍"Java中的抽象类和接口怎么理解"，在日常操作中，相信很多人在Java中的抽象类和接口怎么理解问题上存在疑惑，小编查阅了各式资料，整理出简单好用的操作方法，希望对大家解答"Java中的抽象类和接口怎么理解"的疑惑有所帮助！接下来，请跟着小编一起来学习吧！
什么是抽象类
我们之前学过什么是类，那么抽象类是不是也是类的一种呢？
听名字就感觉好抽象呀！说对了，他就是抽象的，不是具体的。在类中没有包含足够的信息来描绘一个具体的对象，这样的类称为抽象类。
来看一个抽象类的例子
// 抽象类和抽象方法需要被 abstract 关键字修饰abstract class Shape { // 抽象类中的方法一般要求都是抽象方法，抽象方法没有方法体 abstract void draw();}大家觉得这个抽象类是不是什么也没干，他唯一的方法draw()还是空的。
像这样的类是不是就没有包含足够的信息来描绘一个具体的对象，自然也就不能实例化对象了。不信你看：
那既然一个类不能实例化，那这种抽象类存在的意义是什么呀别急，存在即合理，听我慢慢道来。
抽象类在实现多态中的意义
抽象类存在的一个最大意义就是被继承，当被继承后就可以利用抽象类实现多态。
来看一段代码
// 抽象类和抽象方法需要被 abstract 关键字修饰abstract class Shape { // 抽象类中的方法一般要求都是抽象方法，抽象方法没有方法体 abstract void draw();}// 当一个普通类继承一个抽象类后，这个普通类必须重写抽象类中的方法class Cycle extends Shape { @Override void draw() { // 重写抽象类中的draw方法 System.out.println("画一个圆圈"); }} public class Test4 { public static void main(String[] args) { //Shape shape = new Shape(); 抽象类虽然不能直接实例化 // 但可以把一个普通类对象传给一个抽象类的引用呀，即父类引用指向子类对象 Shape shape = new Cycle(); // 这称作：向上转型 /*Cycle cycle = new Cycle(); Shape shape = cycle // 这是向上转型的另一种写法 */ shape.draw(); // 通过父类引用调用被子类重写的方法 }}运行之后你就会发现神奇的一幕：
大家在看完了代码可能会有很多疑问，别急咱们一个一个的说，
什么是向上转型：一句话总结就是"父类引用指向子类对象"
向上转型后的变化
关于方法：父类引用可以调用子类和父类公用的方法（如果子类重写了父类的方法，则调用子类的方法），但子类特有的方法无法调用。
关于属性: 父类引用可以调用父类的属性，不可以调用子类的属性
向上转型的作用
减少一些重复性的代码
对象实例化的时候可以根据不同需求实例化不同的对象
这样的话就我们上面的代码就可以理解了
看来，我们可以通过子类对抽象类的继承和重写，抽象类还真有点用呀！
但这和多态有什么关系呢，抽象类用起来这么麻烦，我还不如直接用普通类，也能达到这样的效果，还不用再写一个子类呢
那行，你再看看下面的代码，你就知道抽象类在实现多态时的好处了。
abstract class Shape { public abstract void draw(); // 抽象方法不能里有具体的语句}// 当一个普通类继承一个抽象类的时候，再这个子类中必须重写抽象类中的抽象方法class Cycle extends Shape { @Override // 如果不重写会报错，但如果继承的是普通类则不会报错，用抽象类更安全 public void draw() { System.out.println("画一个圆圈"); }}class Flower extends Shape { // 不同的子类对父类的draw方法进行了不同的重写 @Override public void draw() { System.out.println("画一朵花"); }}class Square extends Shape { @Override public void draw() { System.out.println("画一个正方形"); }} public class Test4 { public static void main(String[] args) { Cycle cycle = new Cycle(); // 子类引用cycle Flower flower = new Flower(); // 子类引用flower Square square = new Square(); // 数组的类型是Shape,即数组中每一个元素都是一个父类引用 // 在这个过程其实也发生了向上转型，对抽象类中的方法进行了重写 Shape[] shapes = {cycle, flower, square}; // 父类引用引用不同的子类对象 for (int i = 0; i < shapes.length; i++) { Shape shape = shapes[i]; // 父类引用shape指向->当前所对应的子类对象 shape.draw(); // 通过父类引用调用子类重写的draw方法 } }}调用同一个方法竟然打印出了不同的结果，这难道就是所谓的多态
是不是有点懵，下面我们来解释一下
// 对上面的代码补充一下// 可能你对 Shape[] shapes = {cycle, flower, square};不太理解// 但上面的代码就相当于 Shape[] shapes1 = new Shape[3]; // 有三个不同的子类对象呀！数组大小为3 // (将指向->子类对象)的子类引用赋值给父类对象，不就相当于该夫类引用指向->所对应的子类对象吗//这是向上转型的另一种写法，应为前面已经实例化了子类对象 Cycle cycle = new Cycle(); shapes1[0] = cycle; // 如果前面没实例化子类对象，就要写成shape1[0] = new Cycle shapes1[1] = flower; shapes1[2] = square;对于多态来说，他有这三个要素
继承（我们刚才的Cycle类继承Shape抽象类）
重写（我们子类对draw方法的重写）
父类指向子类对象（就是shape1[0] = cycle -->也可以称作向上转型)
回头再看一下我们的代码，是不是就刚好符合了多态的三要素。
当我们的父类引用指向不同的子类对象时，当我们调用同一个draw方法时却输出了不同的结果。（其实就是该方法再子类中被重写成了不同形式）这就叫做多态 。
那为啥一定要用抽象类呢?我一个普通类继承普通类来实现多态不可以吗?
当然可以，但不太安全有风险；
但如果是抽象类的话，就不一样了
好了，相信到这里你对抽象类也有了一个大概的认识，下面我们来简单做一下总结
使用abstract修饰的类或方法，就抽象类或者抽象方法
抽象类是不能具体的描述一个对象，不能用抽象类直接实例化对象
抽象类里面的成员变量和成员方法，都是和普通类一样的，只不过就是不能进行实例化了
当一个普通类继承这个抽象类后，那么这个普通类必须重写抽象类当中的所有的抽象方法（我们之前说过抽象类是不具体的，没有包含足够的信息来描述一个对象，所以我们需要把他补充完整）
但当一个抽象类A继承了抽象类B，这是抽象类A就可以不重写抽象类B当中的抽象方法
final不能修饰抽象类和抽象方法（因为抽象类存在的最大意义就是被继承，而被final修饰的不能被继承，final和抽象，他们两个是天敌）
抽象方法不能被private修饰（抽象方法一般都是要被重写的，你被private修饰了，还怎么重写）
抽象类当中不一定有抽象方法，但如果一个类中有抽象方法，那么这个类一定是抽象类。
接口是什么
抽象类是从多个类中抽象出来的模板，如果将这种抽象进行的更彻底，则可以提炼出一种更加特殊的"抽象类"接口（Interface）。
接口是Java中最重要的概念之一，它可以被理解为一种特殊的类，不同的是接口的成员没有执行体，是由全局常量和公共的抽象方法所组成。
如何定义一个接口呢？下面我们来看一个栗子
//接口的定义格式与定义类的格式基本相同，将class关键字换成 interface 关键字，就定义了一个接口 public interface 接口名称{// 定义变量int a = 10; // 接口当中的成员变量默认都是public static final // 抽象方法public abstract void method1(); // public abstract 是固定搭配，可以不写void method2(); // 接口当中的成员方法默认都是public abstract, 更推荐用第二种来定义方法 }可以看到接口和类其实还是有很多相似点：
接口中也包含抽象方法，所以也不能直接实例化接口，那么我们怎么用接口呢？
很简单，我们再用一个普通类实现这个接口不就行了吗?，不同的是抽象类是被子类来继承而实现的，而接口与类之间则是用关键字implements来实现。
就像普通类实现实现抽象类一样，一个类实现某个接口则必须实现该接口中的抽象方法，否则该类必须被定义为抽象类。
通过接口实现多态
刚才我们是用抽象类来实现多态，那么现在我们可以尝试用接口来实现多态
接口可以看成是一种特殊的类，只能用 interface 关键字修饰interface IShape { int a = 10; 接口当中的成员变量默认都是public static final int b = 23; void draw(); 接口当中的成员方法一般只能是抽象方法，默认是public abstract（JDK1.8以前） default void show() { System.out.println("接口中的其他方法");//接口中的其他方法也可以实现，但要用default修饰 } public static void test() { System.out.println("这是接口当中的一个静态的方法"); }} // 一个普通的类要想实现接口，可以用implement, //因为接口也是抽象方法的，所以实现接口的这个类也要重写抽象方法class Cycle implements IShape { @Override public void draw() { System.out.println("画一个圆圈"); }}class Square implements IShape { @Override public void draw() { System.out.println("画一个正方形"); }}class Flower implements IShape { @Override public void draw() { System.out.println("画一朵花"); }}public class Test4 { public static void main(String[] args) { // IShape iShape = new IShape(); 接口也不能直接实例化 Cycle cycle = new Cycle(); Square square = new Square(); Flower flower = new Flower(); // 这里的IShape接口就相当与抽象类中父类，接口类型也是一种引用类型 IShape[] iShapes = {cycle, square, flower}; // 这个过程其实就发生了向上转型 for (IShape iShape : iShapes) { // 增强型的for-each循环，也可以写成普通的for循环形式 iShape.draw(); // 通过重写实现了多态 } }}引用变量cycle和square都赋值给了Shape类型的引用变量shape,但当执行shape.draw()时，java虚拟机到底要调用谁重写的的draw方法，就看此时接口引用的是那个对象的，是shape的、还是cycle的看一下运行结果
下面我们来总结一下Java中接口的几个主要特点
接口中可以包含变量和方法，变量被隐式指定为 public static final，方法被隐式指定为 public abstract（JDK 1.8 d一个类可以同时实现多个接口，一个类实现某个接口则必须实现该接口中的抽象方法，否则该类必须被定义为抽象类
接口支持多继承，即一个接口可以继承（extends）多个接口，间接解决了 Java 中类不能多继承的问题。
那么接口一般用在什么地方呢？
一般情况下，实现类和它的抽象类之前具有 "is-a" 的关系，但是如果我们想达到同样的目的，但是又不存在这种关系时，使用接口。
由于 Java 中单继承的特性，导致一个类只能继承一个类，但是可以实现一个或多个接口，此时可以使用接口。
下面就让我们来看看接口的正确用法：帮助java实现" 多继承 "????
由于 Java 中单继承的特性，导致一个类只能继承一个类，但是可以实现一个或多个接口，此时可以使用接口。class Animal { String name; // 不能使用private,后面的子类也要用 public Animal(String name) { // 父类的自定义的构造方法 this.name = name; }}interface IFlying { // 自定义多种接口 void fly();}interface IRunning { void run();}interface ISwimming { void swimming();}// 小鸭子，不仅会跑，还会游泳、飞行一个类继承父类，并实现多个接口，间接的解决java中不能多继承的问题class Duck extends Animal implements IRunning, ISwimming, IFlying { public Duck(String name) { // 子类构造方法 super(name); // 必须在子类构造方法的第一行 // 在给实现子类的构造方法前，先要用super()调用实现父类的构造方法，比较先有父后有子呀！ // 因为父类自己定义了构造方法，编译器不会自动给给子类构造方法中添加super();来实现父类的构造方法，需要我们自己实现 } // 对接口中的抽象方法进行重写 @Override public void fly() { System.out.println(this.name + "正在用翅膀飞"); } @Override public void run() { System.out.println(this.name + "正在用两条腿跑"); } @Override public void swimming() { System.out.println(this.name + "正在漂在水上"); } } public class 接口的使用 { // 不用学我用中文名作为类名，我只是为演示方便 public static void main(String[] args) { Duck duck = new Duck("第一个小鸭子"); // 实例化鸭子对象 duck.fly(); // 通过引用 变量名.方法名 输出重写后的方法 duck.run(); duck.swimming(); }}有人可能会说干嘛用接口，我直接在父类Animal中实现fly、run、swimming这些属性，然后不同的动物子类再继承父类这些方法不行吗？ 但问题是，鸭子会fly、swimming，那猫会飞和游泳吗？你再写个其他动物的子类是不是就不行了而用接口呢？我们只是把这种飞、游泳的行为给抽象出来了， 只要一个子类有这种行为，他就可以实现相对应的接口，接口是更加灵活的上面的代码展示了 Java 面向对象编程中最常见的用法: 一个类继承一个父类, 同时实现多个接口。
继承表达的含义是 is - a 语义, 而接口表达的含义是 具有 xxx 特性 ，能实现接口的类和该接口并不一定有is_a的关系，只要该类有这个接口的特性就行
猫是一种动物, 具有会跑的特性.
青蛙也是一种动物, 既能跑, 也能游泳
鸭子也是一种动物, 既能跑, 也能游, 还能飞
这样设计有什么好处呢? 时刻牢记多态的好处, 让程序猿忘记类型. 有了接口之后, 类的使用者就不必关注具体类型，只要这个类有有这个特性就好。
举个栗子
class Robot implements IRunning { private String name; public Robot(String name) { this.name = name; } // 对run方法进行重写 @Override public void run() { System.out.println("机器人" + this.name + "正在跑"); }}public class Test4 { public static void main(String[] args) { Robot robot1 = new Robot("图图"); robot1.run(); }}// 执行结果机器人图图正在跑到此，关于"Java中的抽象类和接口怎么理解"的学习就结束了，希望能够解决大家的疑惑。理论与实践的搭配能更好的帮助大家学习，快去试试吧！若想继续学习更多相关知识，请继续关注网站，小编会继续努力为大家带来更多实用的文章！
