Java面试题（面向对象）

1、下列说法错误的是？B
A:尽管现行的Java语言版本不允许类的多继承，但是我们仍然可以在extends关键字后面放置一个列表
B:在实现多态后，利用父类引用（声明时类型）调用父类子类均声明了的变量和方法，均调用在子类中声明的版本
C:Java中代码重用中的has a关系通过定义类属性方式实现，is a通过类继承来实现
D:this关键字代表当前对象，即this引用的是当前创建的类实例对象的句柄
解析：利用声明时类型调用父类和子类同时声明的属性时，调用方法是子类（运行时类型）声明的，而变量则是调用父类（声明时类型）声明的
PS：is-a，顾名思义，是一个，代表继承关系。

如果A is-a B，那么B就是A的父类。

一个类完全包含另一个类的所有属性及行为。

例如PC机是计算机，工作站也是计算机，PC机和工作站是两种不同类型的计算机，但都继承了计算机的共同特性。

因此在用Java语言实现时，应该将PC机和工作站定义成两种类，均继承计算机类。

has-a，顾名思义，有一个，代表从属关系。

如果A has a B，那么B就是A的组成部分。

同一种类的对象，通过它们的属性的不同值来区别。

例如一台PC机的操作系统是Windows，另一台PC机的操作系统是Linux。

操作系统是PC机的一个成员变量，根据这一成员变量的不同值，可以区分不同的PC机对象。

like-a，顾名思义，像一个，代表组合关系。

如果A like a B，那么B就是A的接口。

新类型有老类型的接口，但还包含其他函数，所以不能说它们完全相同。

例如一台手机可以说是一个微型计算机，但是手机的通讯功能显然不是计算机具备的行为，所以手机继承了计算机的特性，同时需要实现通讯功能，而通讯功能需要作为单独接口，而不是计算机的行为。

2、以下哪个是有关封装优点的正确描述？C
A、只需要一个public方法
B、从任何方法中没有异常抛出
C、可以不需要改变接口来改变实现，以达到外部使用代码无需变动
D、可以不需要改变实现来改变接口，以达到外部使用代码无需变动
解析：封装把实现细节隐藏起来了，因此封装可以实现对类内部的改变不会影响到其他代码
3、以下说法错误的是？D
A、Java中接口不能被private或Protected修饰符修饰
B、Java中一个类可以实现多个接口，但是只能继承一个父类
C、接口中定义的成员变量，即使不说明，默认均是public\static\final的
D、final\static\native关键字不能修饰接口，
解析：内部接口可以用static修饰
4、给出以下代码，请问以下哪个描述是正确的？C
Public XXXX extends something1,something2
A、如果XXXX是一个接口，something1和something2取消掉，则代码段合法
B、如果XXXX是一个类，something1和something2均是接口，则代码段合法
C、如果XXXX、something1和something2均是接口，则代码段合法
D、因为Java语言不支持多继承机制，所以代码段不合法
解析：java接口可以继承多个接口
5、请问以下哪个程序代码体现了对象之间的is a关系？B
A、 public interface Color {
}
public class Shape {
private Color color;
}
B、public interface Component {
}
public class Cpmtaomer implements Component {
private Component[] children;
}
C、public class Species{
}
public class Animal{
private Species species;
}
D、public class Animal{
public interface Species{
}
private Species species;
}
解析：isa关系为接口实现
6、给出以下代码，该程序的执行结果是？D
interface Base {
int k = 0;
}
public class Example implements Base {
public static void main(String[] args) {
inti;
Example exm = new Example();
i = exm.k;
i = Example.k;
i = Base.k;
System.out.println(i);
}
}
A、无内容输出
B、代码编译失败
C、代码运行出现异常信息
D、打印输出0
解析：接口中的默认为static常量
7、给出下面代码，请问该程序的运行结果是什么？C
interface A{
int x=0;
A(){
x=5;
}
A(int s){
x=s;1
}
}
A、编译不通过，因为接口中的构造器必须用public修饰
B、编译不通过，因为接口中不能超过一个以上的构造器
C、编译不通过，因为接口中不能存在构造器
D、编译不通过，因为接口名必须超过1个字符
解析：接口之中不可以存在构造器
8、以下代码的执行结果是：A
public class Example {
String s = "Outer";
public static void main(String[] args) {
S2 s2 = new S2();
s2.display();
}
}
class S1 {
String s = "S1";
void display() {
System.out.println(s);
}
}
class S2 extends S1 {
String s = "S2";
}
A、S1
B、S2
C、null
D、Outer
解析：本题中，由于子类S2中未定义display方法，因此在子类S2实例上调用的display 方法是继承自父类的S1中的，由于display方法只能对同类上的成员变量s进行访问，因此打印输出S1
9、关于构造器说法错误的是 B
A、构造器不属于类成员方法，因此构造器不能被继承
B、只有构造器才能拥有和类名相同的方法名
C、一个类可以拥有多个重载的构造器
D、在子类中调用父类的非默认构造器，必须使用super（...）语句，而且该语句必须位于子类构造器的第一行
解析：普通类成员方法也可以和类同名，但是会造成隐患，不建议这么命名
10、以下哪个针对默认无参构造器描述是正确的？C
A、均是public构造器
B、均无访问修饰符
C、均与所属类访问修饰符一致
D、由编译器决定
解析：和方法一样，构造器可以有任何访问的修饰： public, protected, private或者没有修饰（通常被package 和 friendly调用）. 不同于方法的是，构造器不能有以下非访问性质的修饰： abstract, final, native, static, 或者 synchronized。

11、当一个类的所有构造器均为私有的，以下哪个描述是正确的？C
A、不能被其他类实例化
B、不能被其他类继承
C、既不能被其他类实例化，也不能被其他类继承
D、该类必须被final修饰
解析：使用private关键字声明的构造函数。

由于类的构造函数时私有的，所以此类不能被实例化，同时也不能被继承。

《Effective Java》第三条：用私有构造器或者枚举强化Singleton属性。

所谓Singleton属性是指仅仅被实例化一次的类。

第四条：通过私有构造器强化不可实例化的能力。

12、以下哪些修饰符可以用于构造器？D
A、final
B、static
C、synchronized
D、以上选项均不行
解析：同10题
13、下列给出的代码段运行结果是？ C
public class Example {
intmaxElements;
void Example() {
maxElements = 100;
System.out.println(maxElements);
}
public Example(inti) {
maxElements = i;
System.out.println(maxElements);
}
public static void main(String[] args) {
Example a=new Example();
Example b=new Example(999);
}
A、打印输出100 999
B、打印输出999 100
C、代码编译失败
D、代码编译成功但运行是输出异常信息
解析：普通方法也可以使用类名做方法名，而一旦提供了任意版本的构造器，编译器将不会再提供默认无参构造器，因此本题中不存在无参的构造器，构建实例失败
题目中的voidExample()就是将原本类中默认的无参构造方法覆盖，导致类中没有可用无参构造方法。

14、下列程序的运行结果是 B
class A{
class Dog{
private String name;
private int age;
public int step;
Dog(String s,int a)
{
name=s;
age=a;
step=0;
}
public void run(Dog fast)
{
fast.step++;
}
}
public static void main (String args[])
{
A a=new A();
Dog d=a.new Dog("Tom",3);
d.step=25;
d.run(d);
System.out.println(d.step);
}
}
A、25
B、26
C、编译不通过
D、输出异常信息
解析：不解释
15、已知如下代码： D
1: class Example{
2: String str;
3: public Example(){
4: str= "example";
5: }
6: public Example(String s){
7: str=s;
8: }
9:} }
10:class Demo extends Example{
11:}
12:public class Test{
13: public void f () {
14: Example ex = new Example("Good");
15: Demo d = new Demo("Good");
16:} }
哪句语句会导致错误？
A、line6
B、line10
C、line14
D、line15
解析：构造方法不能被继承，因此Demo类不存在带有一个字符串参数的构造方法
16、关于重载和覆盖，以下说法错误的是 C
A、重载方法的返回值、访问修饰符以及抛出的异常都不是重载方法判断的决定因素
B、一个静态方法既可以被重载为一个静态方法，也可以被重载为一个非静态方法
C、一个静态方法既可以被覆盖为一个静态方法，也可以被覆盖为一个非静态方法
D、覆盖的方法返回值必须和源方法返回值类型保持赋值兼容，访问权限不能小于源方法，只能抛出源方法异常或源方法异常的子类
解析：静态方法只能覆盖为静态方法
PS：重载与覆盖（重写）的区别：
重载一般在同一个类中发生，方法名字相同但参数类型与个数不同，返回类型与修饰符也可以不同。

方法重写发生在父类与子类之间，两个类存在继承关系，方法重写时方法的定义（修饰符，返回类型，参数列表）必须相同，只是方法体（方法实现）不同
17、现有基类中的一个方法：void method(){},请问以下哪些是子类中覆盖该方法的正确形式？ A
A、void method(){}
B、int method(){return 0;}
C、void method(inti)
D、private void method()
解析：解析同16题
18、现有如下代码：
class Super {
public float getNum() {
return 3.0f;
}
}
class Sub extends Super {
// 空白处
}
请问以下哪个语句放置在注释的空白处会引起编译错误？B
A、public float getNum(){return 4.0f;}
B、public void getNum(){}
C、public void getNum(double d){}
D、public double getNum(float d){return 4.0;}
解析：
19、以下代码的执行结果是什么？A
public class Example {
inti = 100;
public void print() {
System.out.println(50);
}
public static void main(String[] args) {
Example a = new A();
System.out.println(a.i);
a.print();
}
}
class A extends Example {
inti = 200;
public void print() {
System.out.println(300);
}
}
A、100300
B、200300
C、10050
D、20050
解析：多态环境下利用父类引用调用属性，调用变量使用的是父类声明的，调用方法则因为动态绑定使用的是子类声明的
20、在下面代码中，在插入代码处插入什么语句可以实现在A中的amethod()方法中直接调用类C的test()方法，而不需要创建一个类C的实例？D
class C{
public void test(){
System.out.println("C");
}
}
class B extends C{
public void test(){
System.out.println("B");
}
}
class A extends B{
public void test(){
System.out.println("A");
}
public void amethod(){
//插入代码处
}
}
A、test()
B、super.test()
C、super.super.test()
D、不能实现该要求
解析：super只能访问直接父类被覆盖的方法，不能跨级使用
21、现有以下代码：D
class Base {
}
class Sub extends Base {
public String getFields() {
String name = "Sub";
return name;
}
}
class DoSub {
public static void main(String[] args) {
Base b = new Sub();
// 插入语句处
}
}
在插入语句处插入那条代码能够输出Sub？
A、System.out.println(b.getFields());
B、System.out.println();
C、System.out.println((Base)b.getFields());
D、System.out.println(((Sub)b).getFields());
解析：父类对象，如果要调用子类方法需要做类型说明；即：a为A的对象，B继承 A 则 a调用B中的方法think()时需要 ((B)a).think();
22、预构造ArrayList类的一个实例.此类继承了List接口,下列哪个方法是正确的B
A、ArrayListmyList=new Object()
B、List myList=new ArrayList()
C、ArrayListmyList=new List()
D、List myList=new List()
解析：这个称之为面向接口编程，是java语言的一大优点。

ArrayList虽然是一个具体的类，按照ArrayListmyList=new ArrayList();的确可以生成一个myList对象，而且编译也不会报错。

但是在实际开发中时不采用这样的方式即实际开发时都是接口名xxx=new 接口某实现类
23、以下关于abstract的说法，正确的是 D
A、abstract只能修饰类
B、abstract只能修饰方法
C、abstract类中必须有abstract方法
D、abstarct方法所在的类必须用abstract修饰
解析：不解释
24、关于类继承的说法，正确的是 B
A、Java 类允许多继承
B、Java接口允许多继承
C、接口和类都允许多继承
D、接口和类都不允许多继承
解析：不解释
25、关于接口的说法，正确的是B
A、接口中的方法只能在接口的实现类中实现
B、接口中可定义变量成员
C、接口中不能定义常量
D、以上都不对
解析：接口（interface）是一些方法特征的集合，这些方法特征来自于具体方法，这些方法符合它们一般来自于一些在系统中不断出现的方法。

一个接口只有方法的特征，而没有方法的实现，因此这些方法在不同的地方被实现时，可以具有完全不同的行为
26、如果类中的成员变量只可以被同一包访问，则使用如下哪个约束符? D
A、private
B、public
C、protected
D、no modifier
解析：private：表示私有，私有的意思就是除了class自己之外，任何人都不可以直接使用，私有财产神圣不可侵犯嘛，即便是子女，朋友，都不可以使用。

public：表明该数据成员、成员函数是对所有用户开放的，所有用户都可以直接进行调用
protected：protected对于子女、朋友来说，就是public的，可以自由使用，没有任何限制，而对于其他的外部class，protected就变成private。

nomodifier（friendly）同样，没有明确指明access modifier的成员就是friendly的，相同包（package）内的所有类都能访问，不同包之间不能访问friendly 成员
27、以下哪个约束符可用于定义成员常量B
A、static
B、final
C、abstract
D、const
解析：不解释
28、给出如下代码: C
class Test{
private int m;
public static void fun() {
// some code...
}
}
如何使成员变量m 被函数fun()直接访问?
A、将private int m 改为protected int m
B、将private int m 改为 public int m
C、将private int m 改为 static int m
D、将private int m 改为 int m
解析：静态方法调用成员变量需要将成员变量定义为静态
29、下列代码能否正常运行，如果能够正常运行，输出结果是什么 A
public class TestClass {
public static void main(String[] args) {
int num1=5;
int num2=5;
class InnerClass{
public intadd(){
return num1+num2;
}
};
InnerClass in=new InnerClass();
System.out.println(in.add());
}
}
A、输出10
B、输出0
C、运行时输出异常信息
D、编译不能通过
解析：不解释
30、以下代码的执行结果是什么？B
public class Example {
public static void main(String[] args) {
Base b = new Base();
Subclass1 S1 = new Subclass1();
Subclass2 s2 = new Subclass2();
s1 = (Subclass1) s2;
}
}
class Base {
}
class Subclass1 extends Base {
}
class Subclass2 extends Base {
}
A、代码编译成功，运行期间没有异常抛出
B、代码编译失败，赋值语句s1 = （Subclass1）s2非法
C、代码编译成功，但运行时ClassCastException对象造型异常被抛出
D、代码编译失败，因为一个基类不能被多个子类继承
解析：Subclass2 s2 = new Subclass2()中新建的是Subclass2的对象；所以不可以进行对象说明；
但是,当Sbuclass1 s1 =newSbuclass2（）；时可以进行对象说明；
31、以下代码的执行结果是： C
public class Example {
static inti = 1, j = 2;
static {
display(i);
i = i + j;
}
static void display(int n) {
System.out.println(n);
}
public static void main(String[] args) {
display(i);
}
}
A、1 2
B、0 1
C、1 3
D、1 1
解析：首先执行静态代码块，接着执行构造代码块，最后指向构造方法
32、对于内部类，以下说法错误的是C
A、匿名内部类可以实现接口或继承其他类，但不能同时即实现接口又继承类
B、匿名内部类不能有任何明确的构造器
C、内部类可以定义在外部类类体中，也可以定义在外部类的方法体中，和外部类不
同，内部类均能使用访问修饰符，并能使用static修饰
D、在Java中，对内部类的嵌套层次没有限制
解析：定义在外部类方法中的内部类不可以使用static修饰。

成员位置:在成员位置定义的类，被称为成员内部类。

局部位置:在局部位置定义的类，被称为局部内部类。

内部类：
⒈内部类对象可以访问创建它的对象的实现，包括私有数据；
⒉内部类不为同一包的其他类所见，具有很好的封装性；
⒊使用内部类可以很方便的编写事件驱动程序；
⒋匿名内部类可以方便的定义运行时回调；
5.内部类可以方便的定义
1、成员内部类
成员内部类，就是作为外部类的成员，可以直接使用外部类的所有成员和方法，即使是private的。

同时外部类要访问内部类的所有成员变量/方法，则需要通过内部类的对象来获取。

要注意的是，成员内部类不能含有static的变量和方法。

因为成员内部类需要先创建了外部类，才能创建它自己的，
2、局部内部类
局部内部类，是指内部类定义在方法和作用域内。

3、嵌套内部类
嵌套内部类，就是修饰为static的内部类。

声明为static的内部类，不需要内部类对象和外部类对象之间的联系，就是说我们可以直接引用outer.inner，即不需要创建外部类，也不需要创建内部类。

嵌套类和普通的内部类还有一个区别：普通内部类不能有static数据和static 属性，也不能包含嵌套类，但嵌套类可以。

而嵌套类不能声明为private，一般声明为public，方便调用。

4、匿名内部类
有时候我为了免去给内部类命名，便倾向于使用匿名内部类，因为它没有名字。

匿名内部类是不能加访问修饰符的。

要注意的是，new 匿名类，这个类是要先定义的，
5、内部类的继承
内部类的继承，是指内部类被继承，普通类 extents 内部类。

33、对于以下代码，请问插入哪个语句可以访问到内部类InsideOne? D
public class Example {
public static void main(String[] args) {
EnclosingOneeo=new EnclosingOne();
//插入语句处
}
}
class EnclosingOne{
public class InsideOne{
}
}
A、InsideOneei=new eo.InsideOne();
B、InsideOneei=EnclosingOne.newInsideOne();
C、InsideOneei=new EnclosingOne.InsideOne();
D、EnclosingOne.InsideOneei=eo.newInsideOne();
解析：不解释(InsideOne ins = eo.newInsideOne()也可以)
34、以下哪些是关于完全封装的正确描述？AC
A、所有的变量都是私有的
B、所有的方法都是私有的
C、只有通过提供的方法才能访问类属性
D、通过方法和变量名均可访问属性
解释：变量都是私有的，封装是把过程和数据包围起来，对数据的访问只能通过已定义的接口。

面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。

封装是一种信息隐藏技术，在java中通过关键字private，protected和public实现封装。

什么是封装？封装把对象的所有组成部分组合在一起，封装定义程序如何引用对象的数据，封装实际上使用方法将类的数据隐藏起来，控制用户对类的修改和访问数据的程度。

适当的封装可以让程式码更容易理解和维护，也加强了程式码的安全性。

优点：1. 良好的封装能够减少耦合。

2. 类内部的结构可以自由修改。

3. 可以对成员变量进行更精确的控制。

4. 隐藏信息，实现细节。

35、请选择所有的正确答案BC
A、在接口中定义的方法默认为private方法
B、在接口中定义的变量默认为public、static、final的
C、一个接口可以继承多个接口
D、关键字implements代表接口的继承关系
解析：接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 publicabstract（只能是 public abstract，其他修饰符都会报错）。

接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public，用 private 修饰会报编译错误。

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

36、以下哪些描述是正确的？AC
A、native关键字表明修饰的方法是由其他非Java语言编写的
B、能够出现在Java源文件中import语句前的只有注释语句
C、接口中定义的方法默认是public和abstract的，不能被private或protected 修饰
D、构造器只能被public或protected修饰
解析：一个Native Method就是一个java调用非java代码的接口。

一个Native Method 是这样一个java的方法：该方法的实现由非java语言实现，比如C。

构造方法有4种修饰，public、protected、默认、private。

public的构造方法你可以用 A a =new A(); 这样来创建对象而protected、默认修饰的构造方法你只能在这个类里进行创建该对象。

private的就不能new来创建对象了。

构造方法本来就是为了方便在其他类创建不同的对象，所以构造方法一般用public修饰，protected、默认修饰符很少见。

而private基本不用来修饰构造方法。

37、以下哪些关于构造器的描述是正确的？B CD
A、子类可以继承父类的构造器
B、如果没有编写构造器，编译器会自动为类提供一个无参的默认构造器
C、构造器都没有返回值
D、构造器可以抛出异常
解析：子类不能继承父类的构造方法，更不能覆盖父类的构造方法。

因此，子类如果想使用父类的构造方法，必须在子类的构造方法中使用，而且必须使用关键字super来表示，而且super必须是子类构造方法中的头一条语句。

38、给出下面的代码段:
public class Base{
int w, x, y ,z;
public Base(inta,int b){
x=a; y=b;
}
public Base(int a, int b, int c, int d){
// assignment x=a, y=b
w=d;
z=c;
}
}
在代码说明// assignment x=a, y=b处写入如下哪几个代码是正确的？（CD）
A、Base(a,b);
B、x=a, y=b;
C、x=a; y=b;
D、this(a,b);
解析：构造函数之间的调用不可以直接调用，需要用this来代替；例如：this(a,b);
39、以下关于方法覆盖描述正确的有ABC
A、覆盖的方法和被覆盖的方法必须具有相同的方法名、参数列表和返回类型
B、覆盖的方法的访问范围不能比被覆盖的方法访问范围小
C、覆盖的方法不能抛出被覆盖方法不能抛出的异常
D、被覆盖的方法不能被private修饰符修饰
解析：重写和重载的区别：
1.重写必须继承，重载不用。

2.重写的方法名，参数数目相同，参数类型兼容，重载的方法名相同，参数列表不
同。

3.重写的方法修饰符大于等于父类的方法，重载和修饰符无关。

4.重写不可以抛出父类没有抛出的一般异常，可以抛出运行时异常
40、现有一下代码：protected void method(int x){...}，以下哪些有关覆盖该方法的描述是正确的？AB
A、覆盖的方法必须采用int型作为唯一个一个参数
B、覆盖的方法必须返回类型为void
C、覆盖的方法可以被private修饰符修饰
D、覆盖的方法可以返回任何类型的值
解析：同上题
41、现有以下代码：
public class MethodOver{
public void setVar(inta,intb,float c){
}
}
以下哪些是满足setVar方法的正确重载形式？ACD
A、private void setVar(inta,floatc,int b){}
B、protected void setVar(inta,intb,float d){}
C、public intsetVar(inta,floatc,int b){return a;}
D、public intsetVar(inta,float c){return a;}
解析：方法名相同，参数不同
42、现有以下代码，请问该程序的运行结果是什么？AC
class A {
protected intmethod(){
return 0;
}
}
class B extends A{
intmethod(){
return 0;
}
}
A、编译失败，因为覆盖方法的访问范围不能比被覆盖的方法更窄
B、编译失败，因为类A中的method()方法声明为protected,因此对其子类都是不可见的
C、编译失败，如果将第7行加上public修饰符，可编译通过
D、编译失败，如果将第7行加上pritected修饰符，可编译通过
解析：同39题
43、现有以下代码：
interface W {
}
class Z implements W {
}
class X extends Z {
}
class Y extends Z {
}
下列哪些代码段是正确的？CD
A、 X x=new X();
Y y=new Y();
Z z=new Z();
y=(Y)x;
B、X x=new X();
Y y=new Y();
Z z=new Z();
x=(X)y;
C、X x=new X();
Y y=new Y();
Z z=new Z();
z=(Z)x;
D、X x=new X();
Y y=new Y();
Z z=new Z();
W w=(W)x;
解析：父类对象可以引用子类对象接口可以引用实现类的对象（包括子类）
44、有关匿名内部类描述正确的有ABC
A、匿名内部类没有显式构造器
B、匿名内部类可以实现接口
C、匿名内部类可以继承非final类
D、匿名内部类可以同时实现接口和继承非final类
解析：匿名内部类没有显示构造器。

内部类可以同时继承和实现接口，而匿名内部类只可以继承或者实现接口
45、以下哪些类型的变量可以被一个内部类访问？AC
A、所有static变量
B、所有final变量
C、所有的实例成员变量（成员变量）
D、只有final静态变量
解析：成员内部类不可以访问其他类中方法的final常量
46、以下关于内部类的描述哪些是正确的？A BD
A、定义在内部类中的变量不能被static修饰符修饰，除非内部类本身是静态的
B、定义在类中非方法中的内部类，可以访问外部类的所有变量，而不管变量的访问控制声明
C、一个内部类实际上是外部类的子类
D、内部类可以被private修饰符修饰
解析：内部类和外部类联系：内部类可以访问外部类所有的方法和属性，如果内部类和外部类有相同的成员方法和成员属性，内部类的成员方法调用要优先于外部类即内部类的优先级比较高（只限于类内部，在主方法内，内部类对象不能访问外部类的成员方法和成员属性），外部类只能访问内部类的静态常量或者通过创建内部类来访问内部类的成员属性和方法，内部类定义的静态常量可以全局访问
47、abstract class和interface有什么区别
声明方法的存在而不去实现它的类被叫做抽象类（abstract class），它用于要创建一个体现某些基本行为的类，并为该类声明方法，但不能在该类中实现该类的情况。

不能创建abstract 类的实例。

然而可以创建一个变量，其类型是一个抽象类，并让它指向具体子类的一个实例。

不能有抽象构造函数或抽象静态方法。

Abstract 类的子类为它们父类中的所有抽象方法提供实现，否则它们也是抽象类为。

取而代之，在子类中实现该方法。

知道其行为的其它类可以在类中实现这些方法
接口（interface）是抽象类的变体。

在接口中，所有方法都是抽象的。

多继承性可通过实现这样的接口而获得。

接口中的所有方法都是抽象的，没有一个有程序体。

接口只可以定义static final成员变量。

接口的实现与子类相似，除了该实现类不能从接口定义中继承行为。

当类实现特殊接口时，它定义（即将程序体给予）所有这种接口的方法。

然后，它可以在实现了该接口的类的任何对象上调用接口的方法。

由于有抽象类，它允许使用接口名作为引用变量的类型。

通常的动态联编将生效。

引用可以转换到接口类型或从接口类型转换，instanceof 运算符可以用来决定某对象的类是否实现了接口。

抽象类与接口都用于抽象，但是抽象类(JAVA中)可以有自己的部分实现，而接口则完全是一个标识(同时有多重继承的功能)。

{
1、抽象类和接口都不能直接实例化，如果要实例化，抽象类变量必须指向实现所有抽象方法的子类对象，接口变量必须指向实现所有接口方法的类对象。

2、抽象类要被子类继承，接口要被类实现。

3、接口只能做方法声明，抽象类中可以做方法声明，也可以做方法实现
4、接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量。

5、抽象类里的抽象方法必须全部被子类所实现，如果子类不能全部实现父类抽象方法，那么该子类只能是抽象类。

同样，一个实现接口的时候，如不能全部实现接口方法，那么该类也只能为抽象类。

6、抽象方法只能申明，不能实现，接口是设计的结果，抽象类是重构的结果
7、抽象类里可以没有抽象方法
8、如果一个类里有抽象方法，那么这个类只能是抽象类
9、抽象方法要被实现，所以不能是静态的，也不能是私有的。

10、接口可继承接口，并可多继承接口，但类只能单根继承。

1.抽象类和接口都是用来抽象具体对象的. 但是接口的抽象级别最高
2.抽象类可以有具体的方法和属性, 接口只能有抽象方法和不可变常量
3.抽象类主要用来抽象类别,接口主要用来抽象功能.
4、抽象类中，且不包含任何实现，派生类必须覆盖它们。

接口中所有方法都必须是未实现的。

当你关注一个事物的本质的时候，用抽象类；当你关注一个操作的时候，用接口。

抽象类的功能要远超过接口，但是，定义抽象类的代价高。

因为高级语言来说（从实际设计上来说也是）每个类只能继承一个类。

在这个类中，你必须继承或编写出其所有子类的
所有共性。

虽然接口在功能上会弱化许多，但是它只是针对一个动作的描述。

而且你可以在一个类中同时实现多个接口。

在设计阶段会降低难度的。

}
48、abstract的method是否可同时是static,是否可同时是native，是否可同时是synchronized
都不可以，因为abstract申明的方法是要求子类去实现的，abstract只是告诉你有这样一个接口，你要去实现，至于你的具体实现可以是native和synchronized，也可以不是，抽象方法是不关心这些事的，所以写这两个是没有意义的。

然后，static 方法是不会被覆盖的，而abstract方法正是要子类去覆盖它，所以也是没有意义的。

所以，总的来说，就是java语法不允许你这样做，事实上，也没有意义这样做。

49、面向对象的特征有哪些方面
1.抽象：
抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。

抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分细节。

抽象包括两个方面，一是过程抽象，二是数据抽象。