下载文档原格式
南航java面试题一、简介Java，一种面向对象的编程语言，在计算机科学领域得到广泛应用。
作为南航面试的一部分，以下是一些常见的Java面试题。
本文将逐一介绍这些问题，并提供详细的解答。
二、面试题目及解答1. 说说Java的特点以及与其他编程语言的区别。
Java的特点：- 简单性：Java语法相对简单易懂，容易上手。
- 面向对象：Java是一种纯粹的面向对象编程语言，支持封装、继承、多态等面向对象的特性。
- 跨平台性：Java程序可以在不同的操作系统上运行，这要归功于Java虚拟机（JVM）。
- 健壮性：Java通过垃圾回收机制、异常处理等机制保证程序的稳定性。
- 安全性：Java提供了丰富的安全措施，如访问控制、类型检查等。
- 高性能：Java通过JIT（即时编译器）和面向对象设计，提供了良好的性能。
与其他编程语言的区别：- C/C++：Java相对于C/C++更易学、更安全；Java具有跨平台性，而C/C++需要为不同平台编写不同的代码；Java具有自动垃圾回收机制，而C/C++需要手动管理内存。
- Python：Java比Python更适合大型项目，因为Java有更好的性能和多线程支持；Java需要提前编译，而Python是解释型语言。
- JavaScript：Java是一种后端语言，而JavaScript主要用于前端开发；Java是一种强类型语言，而JavaScript是一种动态类型语言。
2. 请解释Java中的异常处理机制。
Java的异常处理机制通过try-catch-finally语句块来实现。
当程序出现异常时，会抛出一个异常对象，如果这个异常对象没有被捕获，程序将终止执行。
try-catch语句块用于捕获并处理异常。
try块中包含可能会抛出异常的代码，当异常发生时，程序会跳转到与其匹配的catch块进行处理。
catch块中可以指定捕获特定类型的异常，也可以使用通用的Exception 类型来捕获所有异常。
C#中抽象类和接⼝的区别与应⽤场景⼀、1.抽象类：抽象类是特殊的类，只是不能被实例化；和普通类⼀样⾥⾯什么都有，⽐普通类多了⼀个抽象⽅法成员；抽象⽅法只能声明于抽象类中，且不包含任何实现，派⽣类必须覆盖它们。
另外，抽象类可以派⽣⾃⼀个抽象类，可以覆盖基类的抽象⽅法也可以不覆盖，如果不覆盖，则其派⽣类必须覆盖它们。
不能对字段抽象（因为字段只能⽤等号赋值，没其他代码（不同于属性），没啥抽象的意义）；不能对 private 抽象；可以含有⾮抽象的成员；不能实例化；只能从⼀个类继承；可以被抽象类继承，此时不必实现抽象成员；可以被普通类继承，此时必须实现抽象成员；实现抽象成员时要加overrride；可对类⽤ abstract，不对其⽅法⽤ abstract；但若对⽅法⽤ abstract，其类必须⽤ abstract；若类⽤了 abstract，⽅法没⽤ abstract，不表⽰⽅法也是 abstract；不能使⽤ new 来实例化抽象类；抽象⽅法不能有主体，只需要在参数写完后，直接收括号，引号结束；抽象的⽅法是隐式的 virtual ⽅法，所以它还有覆盖（改写、重写）的特点2.接⼝：可以包含属性、⽅法、索引指⽰器和事件，但不能包含常量、域、操作符、构造函数和析构函数，⽽且也不能包含任何静态成员不能对字段接⼝（因为字段只能⽤等号赋值，没其他代码（不同于属性），没啥接⼝的意义）；接⼝只能是 public 的，且不能使⽤ public 关键字；除了接⼝成员，不能有其他任何实现代码；不能实例化；可以从多个接⼝继承；可以被接⼝继承；此时不必也⽆法实现接⼝成员；可以被抽象类继承，此时必须实现接⼝成员；可以被普通类继承，此时必须实现接⼝成员；实现接⼝不能加 override，必须加 public。
⼆、接⼝是引⽤类型的，类似于类,和抽象类的相似之处有三点：1、不能实例化；2、包含未实现的⽅法声明；3、派⽣类必须实现未实现的⽅法，抽象类是抽象⽅法，接⼝则是所有成员（不仅是⽅法包括其他成员）；三、抽象类和接⼝的区别：1.类是对对象的抽象，可以把抽象类理解为把类当作对象，抽象成的类叫做抽象类.⽽接⼝只是⼀个⾏为的规范或规定，微软的⾃定义接⼝总是后带able字段，证明其是表述⼀类类“我能做。
接⼝和抽象类的区别和作⽤（功能、⽤途、好处）接⼝：抽象类和接⼝亲兄弟，但是有嫡出庶出的区别总结了4点接⼝存在的意义：1、重要性：在Java语⾔中， abstract class 和interface 是⽀持抽象类定义的两种机制。
正是由于这两种机制的存在，才赋予了Java强⼤的⾯向对象能⼒。
2、简单、规范性：如果⼀个项⽬⽐较庞⼤，那么就需要⼀个能理清所有业务的架构师来定义⼀些主要的接⼝，这些接⼝不仅告诉开发⼈员你需要实现那些业务，⽽且也将命名规范限制住了（防⽌⼀些开发⼈员随便命名导致别的程序员⽆法看明⽩ 3、维护、拓展性：⽐如你要做⼀个画板程序，其中⾥⾯有⼀个⾯板类，主要负责绘画功能，然后你就这样定义了这个类。
可是在不久将来，你突然发现这个类满⾜不了你了，然后你⼜要重新设计这个类，更糟糕是你可能要放弃这个类，那么其他地⽅可能有引⽤他，这样修改起来很⿇烦。
如果你⼀开始定义⼀个接⼝，把绘制功能放在接⼝⾥，然后定义类时实现这个接⼝，然后你只要⽤这个接⼝去引⽤实现它的类就⾏了，以后要换的话只不过是引⽤另⼀个类⽽已，这样就达到维护、拓展的⽅便性。
4、安全、严密性：接⼝是实现软件松耦合的重要⼿段，它描叙了系统对外的所有服务，⽽不涉及任何具体的实现细节。
这样就⽐较安全、严密⼀些（⼀般软件服务商考虑的⽐较多）。
那么什么是接⼝呢？接⼝是⼀种能⼒1：接⼝的命名规则与类型不同。
如果修饰符是public。
则该接⼝在整个项⽬中可见，如果省略修饰符则该接⼝只能在该包可见2：接⼝中可以定义常量，不能定义变量，接⼝中的属性都会⾃动⽤public static final修饰，即接⼝中的属性都是全局静态常量，接⼝中的常量必须在定义时指定初始值3：接⼝中所有的⽅法抽象⽅法。
接⼝中的⽅法都会⾃动⽤public abstract修饰。
即接⼝中只有全局抽象⽅法，4：和抽象类⼀样，接⼝不能被实例化，接⼝中不能有狗构造⽅法5：接⼝之间可以通过extends 实现继承关系，⼀个接⼝可以继承多个接⼝。
接⼝和抽象类的区别和联系1、抽象类抽象类不能创建实例，它只能作为⽗类被继承。
抽象类是从多个具体类中抽象出来的⽗类，它具有更⾼层次的抽象。
从多个具有相同特征的类中抽象出⼀个抽象类，以这个抽象类作为其⼦类的模板，从⽽避免了⼦类的随意性。
(1) 抽象⽅法只作声明，⽽不包含实现，可以看成是没有实现体的虚⽅法(2) 抽象类不能被实例化(3) 抽象类可以但不是必须有抽象属性和抽象⽅法，但是⼀旦有了抽象⽅法，就⼀定要把这个类声明为抽象类(4) 具体派⽣类必须覆盖基类的抽象⽅法(5) 抽象派⽣类可以覆盖基类的抽象⽅法，也可以不覆盖。
如果不覆盖，则其具体派⽣类必须覆盖它们2、接⼝(1) 接⼝不能被实例化(2) 接⼝只能包含⽅法声明(3) 接⼝的成员包括⽅法、属性、索引器、事件(4) 接⼝中不能包含常量、字段(域)、构造函数、析构函数、静态成员3、接⼝和抽象类的区别（1）抽象类可以有构造⽅法，接⼝中不能有构造⽅法。
（2）抽象类中可以有普通成员变量，接⼝中没有普通成员变量（3）抽象类中可以包含静态⽅法，接⼝中不能包含静态⽅法（4）⼀个类可以实现多个接⼝，但只能继承⼀个抽象类。
（5）接⼝可以被多重实现，抽象类只能被单⼀继承（6）如果抽象类实现接⼝，则可以把接⼝中⽅法映射到抽象类中作为抽象⽅法⽽不必实现，⽽在抽象类的⼦类中实现接⼝中⽅法4、接⼝和抽象类的共同点(1) 都可以被继承(2) 都不能被实例化(3) 都可以包含⽅法声明(4) 派⽣类必须实现未实现的⽅法5、为什么要写接⼝或抽象类1. 减少代码的书写（代码重载）2. 提⾼了代码的可维护性和扩展性。
3. 在团队合作中，代码的规范性6、抽象类和接⼝都差不多，什么时候选择使⽤接⼝1. 在当前类族中不是必须的（例如Tager需要⽽Rabbit不需要）的⽅法时2. 不同类族的多个类需要实现同样的⽅法时（接⼝）。
1、课程名称：接口的定义及使用2、知识点2.1、上次课程的主要知识点1、抽象类的设计是在普通类之上的抽象类；2、抽象类关键的问题就是约定了子类必须要覆写的抽象方法；3、抽象类的使用原则：·抽象类必须有子类，子类利用extends关键字来继承抽象类，一个子类只能够继承一个父类；·抽象类的子类（如果不是抽象类），那么必须要覆写抽象类中的全部抽象方法；·抽象类可以利用对象的向上转型机制，通过子类对象进行实例化操作。
2.2、本次预计讲解的知识点1、接口的基本定义以及使用形式；2、与接口有关的设计模式的初步认识；3、接口与抽象类的区别。
3、具体内容（★★★★★★★★★★★★★★）接口与抽象类相比，接口的使用几率是最高的，所有的设计几乎都是围绕着接口进行的，但是要想把接口彻底闹明白，需要很长一段时间。
3.1、接口的基本概念接口是一种特殊的类，但是在接口里面的组成与类不同，比类的组成部分简单，主要由抽象方法和全局常量所组成。
而接口使用interface关键字来定义。
范例：定义一个接口当一个接口定义完成之后，需要遵循如下的步骤进行接口的使用：·接口一定要定义子类，子类利用implements关键字来实现接口，一个子类可以同时实现多个接口；|- 秒杀抽象类的单继承局限，一个抽象类只能够被一个子类所继承；·接口的子类（如果不是抽象类）那么必须覆写接口中的全部抽象方法；·接口的对象利用子类对象的向上转型进行实例化操作。
范例：使用接口但是这个时候会有这样一种比较神奇的操作。
注意：关于接口的组成描述接口里面在定义的时候就已经明确的给出了开发要求：抽象方法和全局常量，所以以下两种接口的定义从本质上讲是完全一样的。
如果在定义接口方法的时候没有使用public ，那么本质上也不是default 权限，而默认就是public 。
很多时候为了防止一些开发者概念不清晰，所以以后建议大家在定义接口的时候永远都写上public ，但是一般都不会去写abstract 。
抽象类与接口-笔记关键字：接口抽象类，接口与类是一个层次的概念，是java中极其重要的概念抽象类是从多个类中抽象出来的公共模板，提供子类均具有的功能。
接口是从多个类中抽象出来的规范，体现的是规范和实现分离的原则，同时也有效的解决Java单重继承的缺陷。
*******普通方法与抽象方法的不同*******普通方法需要有访问修饰符，返回类型，方法名，还要有一个方法体，抽象方法也有访问修饰符，返回类型，方法名，但是它还多了一个修饰符——abstract，同时没有方法体，也就是说抽象方法没有实现。
普通方法与抽象方法的区别：1，普通方法必须要有实现体，抽象方法不能有实现体，抽象方法要用abstract修饰符来修饰。
********普通类与抽象类的区别*********普通类：要有访问修饰符，class关键字和类名。
抽象类：在普通类的基础之上，还多了一个abstract修饰符。
在使用的时候抽象类与普通类也不一样：普通类：可以通过new关键字实例化。
抽象类：不能使用new关键字来实例化。
**********抽象类********************抽象类：是一个不能实例化的类，它可以具有抽象方法或者普通方法。
定义抽象类的语法与定义普通类类似，只是多了一个关键字abstract。
注意：抽象类中可以定义抽象方法，也可以拥有普通方法，而普通类当中只能定义普通方法。
********对比抽象类与接口***************抽象类用abstract修饰符来定义，而且抽象类中可以有抽象方法，也可以有普通方法。
**接口是使用interface关键字来定义，关键字后面是接口名。
注意：：定义接口的时候不再使用class关键字。
同时，接口只能拥有抽象方法。
***从定义就可以看出抽象类与接口的区别：1，抽象类使用abstract声明，接口使用interface声明。
2，抽象类除了抽象方法，还可以有普通方法，而接口中只能有抽象方法。
JA V A继承、抽象类、接口编辑人：星辰·樱联系QQ：838826112一．类的继承通过继承可以实现代码的复用，被继承的类称为父类或超类（superclass），由继承而得到的类称为子类（subclass）。
一个父类可以拥有多个子类，但一个类只能有一个直接父类，这是因为JA V A语言中不支多重继承。
子类继承父类的成员变量和成员方法，同时可以修改父类的成员变量或重写父类的方法，还可以添加新的成员变量或成员方法。
JA V A语言中有一个名为ng.Object的特殊类，所有的类都是直接或间接地继承该类而得到的。
1.子类的创建类的继承是通过extends关键字来实现的，在定义类时若使用ectends关键字指出新定义类的父类，就是在两个类之间建立了继承关系。
新定义的类称为子类，它可以从父类那里继承所有非private的成员作为自己的成员。
子类的创建：* 格式：class SubClass extends SuperClass* {* .* .* .* }2.调用父类中特定的构造方法在没有明确地指定构造方法时，子类还是会先调用父类中没有参数的构造方法，以便进行初始化的操作。
在子类的构造方法中可以通过super()来调用父类特定的构造方法。
例：//以Person作为父类，创建学生子类Student，并在子类中调用父类里某指定的构造方法。
class Person2{private String name;private int age;public Person2()//定义Person2类的无参构造方法{System.out.println("调用了Person2类的无参构造方法");}public Person2(String name,int age)//定义Person2类的有参构造方法{System.out.println("调用了Person2类的有参构造方法");=name;this.age=age;}public void show(){System.out.println("姓名："+name+" 年龄："+age);}}class Student2extends Person2//定义继承自Person2类的子类Student2{private String department;public Student2()//定义Student2类的无参构造方法{System.out.println("调用了学生类的无参构造方法Student2()");}public Student2(String name,int age,String dep)//定义Student2类的有参构造方法{super(name,age);//调用父类的胡参构造方法department=dep;System.out.println("我是"+department+"学生");System.out.println("调用了学生类的有参构造方法Student2(String name,int age,String dep)");}}public class App8_2 {public static void main(String[] args){Student2 stu1=new Student2();//创建对象，并调用无参构造方法Student2 stu2=new Student2("李小四",23,"信息系");//创建对象并调用有参构造方法stu1.show();stu2.show();}}/*在子类中访问你类的构造方法，其格式为super(参数列表)。
先看各自的概念：虚函数是动态联编的基础，它是引入派生概念之后用来表现基类和派生类成员函数之间的一种关系的。
虚函数在基类中定义，它也是一种成员函数，而且是非静态成员函数。
引自msdn：若一个实例方法的声明中含有virtual 修饰符，则称该方法为虚拟方法；一个虚拟方法的实现可以由派生类取代。
取代所继承的虚拟方法的实现的过程称为重写该方法；在一个虚拟方法调用中，该调用所涉及的那个实例的运行时类型确定了要被调用的究竟是该方法的哪一个实现。
虚函数的限制：1.虚函数仅适用于有继承关系的类对象, 所以只有类的成员函数才能说明为虚函数.2.静态成员函数不能是虚函数.3.内联函数不能是虚函数.4构造函数不能是虚函数.5.析构函数可以是虚函数.接口可以有静态成员、嵌套类型、抽象、虚拟成员、属性和事件。
实现接口的任何类都必须提供接口中所声明的抽象成员的定义。
接口可以要求任何实现类必须实现一个或多个其他接口。
对接口有以下限制：接口可以用任何可访问性来声明，但接口成员必须全都具有公共可访问性。
不能向成员或接口自身附加安全性权限。
接口可以定义类构造函数，但不能定义实例构造函数。
每种语言都必须为需要成员的接口映射一个实现提供规则，因为不只一个接口可以用相同的签名声明成员，且这些成员可以有单独的实现。
接口可以由类和结构来实现。
为了指示类或结构实现了某接口，在该类或结构的基类列表中应该包含该接口的标识符。
如果一个类或结构实现某接口，则它还隐式实现该接口的所有基接口。
即使在类或结构的基类列表中没有显式列出所有基接口，也是这样。
虚函数为了重载和多态的需要，在基类中是由定义的，即便定义是空，所以子类中可以重写也可以不写基类中的函数！纯虚函数在基类中是没有定义的，必须在子类中加以实现，很像java中的接口函数！虚函数引入原因：为了方便使用多态特性，我们常常需要在基类中定义虚函数。
class Cman{public:virtual void Eat(){……};void Move();private:};class CChild : public CMan{public:virtual void Eat(){……};private:};CMan m_man;CChild m_child;//这才是使用的精髓，如果不定义基类的指针去使用，没有太大的意义CMan *p ;p = &m_man ;p->Eat(); //始终调用CMan的Eat成员函数，不会调用 CChild 的p = &m_child;p->Eat(); //如果子类实现(覆盖)了该方法，则始终调用CChild的Eat函数//不会调用CMan 的 Eat 方法；如果子类没有实现该函数，则调用CMan的Eat函数p->Move(); //子类中没有该成员函数，所以调用的是基类中的纯虚函数引入原因：1、同“虚函数”；2、在很多情况下，基类本身生成对象是不合情理的。
抽象类和接口的区别对于面向对象编程来说，抽象是它的一大特征之一。
在Java中，可以通过两种形式来体现OOP的抽象：接口和抽象类。
这两者有太多相似的地方，又有太多不同的地方。
下面是为大家准备的抽象类和接口的区别，希望大家喜欢!抽象类和接口的相关知识一.抽象类在了解抽象类之前，先来了解一下抽象方法。
抽象方法是一种特殊的方法：它只有声明，而没有具体的实现。
抽象方法的声明格式为：1abstract void fun();抽象方法必须用abstract关键字进行修饰。
如果一个类含有抽象方法，则称这个类为抽象类，抽象类必须在类前用abstract关键字修饰。
因为抽象类中含有无具体实现的方法，所以不能用抽象类创建对象。
下面要注意一个问题：在《JAVA编程思想》一书中，将抽象类定义为“包含抽象方法的类”，但是后面发现如果一个类不包含抽象方法，只是用abstract修饰的话也是抽象类。
也就是说抽象类不一定必须含有抽象方法。
个人觉得这个属于钻牛角尖的问题吧，因为如果一个抽象类不包含任何抽象方法，为何还要设计为抽象类?所以暂且记住这个概念吧，不必去深究为什么。
123[public] abstract class ClassName {abstract void fun();}从这里可以看出，抽象类就是为了继承而存在的，如果你定义了一个抽象类，却不去继承它，那么等于白白创建了这个抽象类，因为你不能用它来做任何事情。
对于一个父类，如果它的某个方法在父类中实现出来没有任何意义，必须根据子类的实际需求来进行不同的实现，那么就可以将这个方法声明为abstract方法，此时这个类也就成为abstract类了。
包含抽象方法的类称为抽象类，但并不意味着抽象类中只能有抽象方法，它和普通类一样，同样可以拥有成员变量和普通的成员方法。
注意，抽象类和普通类的主要有三点区别：1)抽象方法必须为public或者protected(因为如果为private，则不能被子类继承，子类便无法实现该方法)，缺省情况下默认为public。
Java中Interface的用法1. 什么是Interface在Java中，Interface（接口）是一种特殊的抽象类，它定义了一组方法签名（方法的名称、参数列表和返回类型），但没有方法的实现。
接口可以看作是一种合同，所有实现该接口的类必须按照接口定义的方式来实现其中的方法。
接口可以用来描述类应该具备的行为，通过使用接口，可以实现多态性、代码重用性和可扩展性。
2. 定义接口接口的定义使用interface关键字，定义的方法默认是抽象的，也可以包含常量和默认方法。
public interface MyInterface {// 常量public static final int MAX_COUNT = 100;// 抽象方法public void myMethod();// 默认方法public default void myDefaultMethod() {System.out.println("This is a default method in interface");}}接口方法的可见性修饰符默认是public，可以省略。
接口中的常量默认是public static final类型的，可以省略这些修饰符。
3. 实现接口要实现一个接口，使用implements关键字，类中必须实现接口中的所有方法。
一个类可以实现多个接口，以逗号分隔。
public class MyClass implements MyInterface {// 实现接口中的抽象方法public void myMethod() {System.out.println("This is my method implementation");}}4. 接口的继承接口可以继承其他接口，使用extends关键字。
一个接口可以继承多个接口，接口之间使用逗号分隔。
public interface MyExtendedInterface extends MyInterface {// 添加新的方法public void myExtendedMethod();}接口的继承可以形成接口的层次结构，子接口继承了父接口的所有方法和常量。
接⼝和抽象类有什么区别他们都不能实例化对象，都可以包含抽象⽅法，⽽且抽象⽅法必须被继承的类全部实现。
区别：1、抽象类和接⼝都不能直接实例化，如果要实例化，抽象类变量必须指向实现所有抽象⽅法的⼦类对象，接⼝变量必须指向实现所有接⼝⽅法的类对象。
2、抽象类要被⼦类继承，接⼝要被类实现。
3、接⼝只能做⽅法申明，抽象类中可以做⽅法申明，也可以做⽅法实现4、接⼝⾥定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量。
5、抽象类⾥的抽象⽅法必须全部被⼦类所实现，如果⼦类不能全部实现⽗类抽象⽅法，那么该⼦类只能是抽象类。
同样，⼀个实现接⼝的时候，如不能全部实现接⼝⽅法，那么该类也只能为抽象类。
6、抽象⽅法只能申明，不能实现，接⼝是设计的结果，抽象类是重构的结果7、抽象类⾥可以没有抽象⽅法8、如果⼀个类⾥有抽象⽅法，那么这个类只能是抽象类9、抽象⽅法要被实现，所以不能是静态的，也不能是私有的。
10、接⼝可继承接⼝，并可多继承接⼝，但类只能单根继承。
参数抽象类接⼝默认的⽅法实现它可以有默认的⽅法实现接⼝完全是抽象的。
它根本不存在⽅法的实现实现⼦类使⽤extends关键字来继承抽象类。
如果⼦类不是抽象类的话，它需要提供抽象类中所有声明的⽅法的实现。
⼦类使⽤关键字implements来实现接⼝。
它需要提供接⼝中所有声明的⽅法的实现构造器抽象类可以有构造器接⼝不能有构造器与正常Java类的区别除了你不能实例化抽象类之外，它和普通Java类没有任何区别接⼝是完全不同的类型访问修饰符抽象⽅法可以有public、protected和default这些修饰符接⼝⽅法默认修饰符是public。
你不可以使⽤其它修饰符。
main⽅法抽象⽅法可以有main⽅法并且我们可以运⾏它接⼝没有main⽅法，因此我们不能运⾏它。
（java8以后接⼝可以有default和static⽅法，所以可以运⾏main⽅法）多继承抽象⽅法可以继承⼀个类和实现多个接⼝接⼝只可以继承⼀个或多个其它接⼝速度它⽐接⼝速度要快接⼝是稍微有点慢的，因为它需要时间去寻找在类中实现的⽅法。
interface和abstract的区别抽象类(abstract)含有abstract修饰符的class即为抽象类，abstract 类不能创建的实例对象。
含有abstract⽅法的类必须定义为abstract class，abstract class类中的⽅法不必是抽象的。
abstract class类中定义抽象⽅法必须在具体(Concrete)⼦类中实现，所以，不能有抽象构造⽅法或抽象静态⽅法。
如果的⼦类没有实现抽象⽗类中的所有抽象⽅法，那么⼦类也必须定义为abstract类型。
接⼝（interface）interface 可以说成是抽象类的⼀种特例，接⼝中的所有⽅法都必须是抽象的。
接⼝中的⽅法定义默认为public abstract类型，接⼝中的成员变量类型默认为public static final。
下⾯⽐较⼀下两者的语法区别：1.抽象类可以有构造⽅法，接⼝中不能有构造⽅法。
2.抽象类中可以有普通成员变量，接⼝中没有普通成员变量3.抽象类中可以包含⾮抽象的普通⽅法，接⼝中的所有⽅法必须都是抽象的，不能有⾮抽象的普通⽅法。
4. 抽象类中的抽象⽅法的访问类型可以是public，protected和（默认类型,虽然eclipse下不报错，但应该也不⾏），但接⼝中的抽象⽅法只能是public类型的，并且默认即为public abstract类型。
5. 抽象类中可以包含静态⽅法，接⼝中不能包含静态⽅法6. 抽象类和接⼝中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接⼝中定义的变量只能是public static final 类型，并且默认即为public static final类型。
7. ⼀个类可以实现多个接⼝，但只能继承⼀个抽象类。
下⾯接着再说说两者在应⽤上的区别：接⼝更多的是在系统架构设计⽅法发挥作⽤，主要⽤于定义模块之间的通信契约。
⽽抽象类在代码实现⽅⾯发挥作⽤，可以实现代码的重⽤.例如，模板⽅法设计模式是抽象类的⼀个典型应⽤，假设某个项⽬的所有Servlet类都要⽤相同的⽅式进⾏权限判断、记录访问⽇志和处理异常，那么就可以定义⼀个抽象的基类，让所有的Servlet都继承这个抽象基类，在抽象基类的service⽅法中完成权限判断、记录访问⽇志和处理异常的代码，在各个⼦类中只是完成各⾃的业务逻辑代码，伪代码如下：import java.io.IOException;import javax.servlet.ServletException;import javax.servlet.http.HttpServlet;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;public abstract class BaseServlet extends HttpServlet {public final void service(HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException {//记录访问⽇志// 进⾏权限判断if (具有权限) {try {doService(request, response);} catch (Exception e) {记录异常信息}}}// 注意访问权限定义成protected，显得既专业，⼜严谨，因为它是专门给⼦类⽤的protected abstract void doService(HttpServletRequest request,HttpServletResponse response) throws IOException, ServletException;}⼦类:import javax.servlet.ServletException;import javax.servlet.http.HttpServletResponse;import java.io.IOException;public class MyServlet1 extends BaseServlet {protected void doService(HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException {本Servlet只处理的具体业务逻辑代码}}⽗类⽅法中间的某段代码不确定，留给⼦类⼲，就⽤模板⽅法设计模式。
抽象方法和接口的区别
抽象方法和接口是面向对象编程中的两个重要概念，它们之间存在以下区别：
1. 定义方式：抽象方法是在抽象类中定义的方法，使用关键字abstract修饰，没有方法体；接口是由方法签名组成的集合，使用关键字interface进行定义。
2. 继承关系：抽象方法通过继承的方式实现子类对该方法的重写，一个类只能继承一个抽象类；接口通过实现的方式实现对接口中方法的定义，一个类可以实现多个接口。
3. 状态：抽象方法可以有非抽象方法和属性，并可以包含构造函数，一个抽象类可以有自己的状态；接口只能包含抽象方法和常量，没有自己的状态。
4. 实例化：抽象方法不能直接被实例化，需要通过子类继承和重写来实现；接口不能被实例化，但可以通过实现类实例化，使用接口引用来调用实现类的方法。
5. 使用场景：抽象方法适用于需要有默认实现和状态的情况，可以用作基类从而提供一些共享的实现；接口适用于需要强制与不同类之间进行某种逻辑上的约束的情况。
总结来说，抽象方法提供了一种非强制性的基类实现，而接口则是一种强制性的实现规范。
抽象方法更强调类的继承和共享实现，接口更强调类的多态和实现规范。
