java面试题目.docx
《java面试题目.docx》由会员分享，可在线阅读，更多相关《java面试题目.docx（15页珍藏版）》请在冰豆网上搜索。
java面试题目
1．面向对象的软件开发有哪些优点？
面向对象设计是一种把面向对象的思想应用于软件开发过程中，指导开发活动的系统方法，是建立在“对象”概念基础上的方法学。
所谓面向对象就是基于对象概念，以对象为中心，以类和继承为构造机制，来认识、理解、刻画客观世界和设计、构建相应的软件系统。
从面向过程到面向对象是程序设计技术的一个飞跃。
人们之所以要采用面向对象的程序设计技术，其目的在于：
按照与人类习惯思维方法一致的原则开发系统；提高代码的可重用性（或者称为复用性）；提升程序的开发与运行效率；提高程序的可靠性与可维护性；提高程序的可扩展性；增强程序的可控制性。
总之，面向对象的程序设计，能够有效分解、降低问题的难度与复杂性，提高整个求解过程的可控制性、可监视性和可维护性，从而获得较高的开发效率与可靠效果。
2．什么叫对象？
什么叫类？
类和对象有什么关系。
对象（Object）是一个应用系统中用来描述客观事物的实体，是具有特定属性（数据）和行为（方法）的基本运行单位，是类的一个特定状态下的实例。
对象是一件事、一个实体、一个名词、一个可以想象为有自己的标识的任何东西。
对象是类的实例化。
概括来说：
万物皆对象。
对象具有状态，一个对象用数据值来描述它的状态。
类（Class）是Java代码的基本组织模块，是用以描述一组具有共同属性和行为的对象的基本原型，是对这组对象的概括、归纳与抽象表达。
类是对象的模板，它定义了本类对象所应拥有的状态属性集及操作这组属性的行为方法集。
是对一组有相同数据和相同操作的对象的定义，一个类所包含的方法和数据描述一组对象的共同属性和行为。
类和对象之间的关系是抽象和具体的关系：
类就是一种模板，表达的是一种抽象的概念，它描述了该类对象的共同特征，类是在对象之上的抽象，对象则是类的具体化，是类的实例。
对象是模板的实例化，是个性的产物，是一个具体的个体；类必须通过对象才能使用，而对象中的属性和行为都必须在类中定义；类由属性和行为（方法）组成。
3．什么是包？
把一个类放在包里有什么作用？
Java中的包（Package） 是一种松散的类的集合，是用来组织与管理类与接口的容器。
包的作用主要是把需要协同工作的不同的类组织在一起，使得程序功能清楚、结构分明。
4．作用域public、private、protected以及不写时（default）有什么区别？
当用一个类创建了一个对象之后，该对象可以通过“.”运算符访问自己的变量，并使用类中的方法。
但访问自己的变量和使用类中的方法是有一定限制的。
通过修饰符private、default、protected和public来说明类成员的使用权限。
private（私有的）：
类中限定为private的成员只能在这个类中被访问，在类外不可见。
default（无修饰符，缺省的）：
如果没有访问控制符，则该类成员可以被该类所在包中的所有其它类访问。
protected（受保护的）：
用该关键字修饰的类成员可以被同一类、被该类所在包中的所有其它类或其子类（可以不在同一包中）的实例对象访问。
public：
用public修饰的类成员可以被其他任何类访问，前提是对类成员所在的类有访问权限。
类成员访问控制符与访问能力之间的关系
同一个类同一个包不同包的子类不同包非子类
private*
default**
protected***
public****
5．什么是方法？
方法的结构是怎样的？
设计方法应考虑哪些因素？
方法是Java类的一个组成部分，通过类的方法改变对象的状态。
方法的结构：
[方法修饰符] 返回值类型 方法名（[形参列表]）[throws异常列表]
{
方法体；
}
设计方法应考虑因素有：
（1） 方法名是Java中任意的标识符，按照命名的约定，方法名应该是有意义的动词或动词短语，它的第一个字母一般要小写，其他有意义的单词的首字母要大写，其余字母小写。
（2） 返回值类型可以是任意的Java类型，甚至可以是定义此方法的类。
如果方法没有返回值，则用void表示。
（3） 形式参数列表是可选的。
如果方法没有形式参数，就用一对小括号“（）”表示。
形式参数列表的形式如下：
（类型 形参名，类型 形参名，……）
（4） throws异常列表规定了在方法执行中可能导致的异常。
6．什么是方法的覆盖？
与方法的重载有何不同？
方法的覆盖与属性的隐藏有何不同？
子类重新定义父类中已经存在的方法，称为方法的覆盖。
方法重载指一个类中有多个方法享有相同的名字，但是这些方法的参数必须不同，或者是参数的个数不同，或者是参数类型不同。
返回类型不能用来区分重载的方法。
其实方法重载的最主要的作用就是实现同名的构造方法可以接受不同的参数。
参数类型的区分度一定要足够，例如不能是同一简单类型的参数，如int与long。
方法的重载不是子类对父类同名方法的重新定义，而是在一个类中定义了同名的不同方法。
方法覆盖与属性的隐藏不同：
子类重新定义父类已有的域，并不能完全取代它从父类那里继承的同名的域，这个域仍然占用子类的内存空间，在某些情况下会被使用；而当子类重新定义父类的方法时，从父类那里继承来的方法将被新方法完全取代，不再在子类的内存空间中占一席之地。
7．什么是成员变量、局部变量、类变量和实例变量？
在方法外但在类声明内定义的变量叫成员变量，作用域是整个类。
在方法体中定义的变量和方法的参数被称为局部变量。
类的成员变量分为类变量和实例变量，类变量是用关键字static声明的变量。
成员变量在整个类内都有效，局部变量只在定义它的方法内有效。
他们的生存期分别是：
局部变量在定义该变量的方法被调用时被创建，而在该方法退出后被撤销；实例变量在创建该类的实例时被创建，而其生存期和该类的实例对象的生存期相同；类变量在该类被加载时被创建，所有该类的实例对象共享该类变量，其生存期是类的生存期。
任何变量在使用前都必须初始化,但是需要指出的是局部变量必须显式初始化，而实例变量不必，原始类型的实例变量在该类的构造方法被调用时为它分配的缺省的值，整型是0，布尔型是false，而浮点型是0.0f，引用类型（类类型）的实例变量的缺省值是null，类变量的规则和实例变量一样，不同的是类变量的初始化是在类被加载时。
8．什么是继承？
什么是父类？
什么是子类？
继承的特性可给面向对象编程带来什么好处？
继承（Inheritance）：
继承是指从已有的类中派生出若干个新类，是子类自动共享父类之间数据和方法的机制。
已有类称为基类或父类，新类称为派生类或子类；子类将自动地获得基类的属性与方法，从而不需再重复定义这些属性与方法；当然子类还可以修改父类的方法或增加新的方法，从而使自己更适合特殊的需要。
类之间的继承关系是现实世界中遗传关系的直接模拟。
如果没继承性机制，则类对象中数据、方法就会出现大量重复。
继承不仅支持系统的可重用性，而且还促进系统的可扩充性。
继承是子对象可以继承父对象的属性和行为，亦即父对象拥有的属性和行为，其子对象也就拥有了这些属性和行为。
这非常类似大自然中的物种遗传。
9．什么是多态？
面向对象程序设计为什么要引入多态的特性？
多态性：
是指不同类的对象收到相同的消息时，得到不同的结果。
即允许不同类的对象对同一消息作出各自的响应，以统一的风格处理已存在的数据及相关的操作。
即
多态性语言具有灵活、抽象、行为共享、代码共享的优势，较好地解决了应用程序中方法同名的问题。
多态的特点大大提高了程序的抽象程度和简洁性，更重要的是它最大限度地降低了类和程序模块之间的耦合性，提高了类模块的封闭性，使得它们不需了解对方的具体细节，就可以很好地共同工作。
这对程序的设计、开发和维护都有很大的好处。
10．“子类的域和方法的数目一定大于等于父类的域和方法的数目”，这种说法是否正确？
为什么？
这样说是不对的，因为父类的私有方法不能被继承。
如果父类有N个私有域和方法而只有一个非私有的域或方法时，跟据继承的原则子类只能拥有父类的非私有域和方法。
这时子类的域和方法就要小于父类了。
11．父类对象与子类对象相互转化的条件是什么？
如何实现它们的相互转化？
一个子类对象也可以被合法地视为一个父类的对象，即一个父类对象的引用，其指向的内存单元可能实际上是一个子类的对象。
在这种情况下，可以使用强制类型转换，将父类对象的引用转换成实际的子类对象的引用。
12．以下代码共创建了几个对象:
2
String s1=new String（“hello”）;
String s2=new String（“hello”）;
String s3=s1;
String s4=s2;
13．分析以下代码，编译时出现什么现象:
The local variable myArg may not have been initialized
public class Test {
static int myArg = 1;
public static void main（String[] args） {
int myArg;
System.out.println（myArg）;
}
}
14．对于以下程序，运行“java Mystery Mighty Mouse”，得到的结果:
Mouse Mighty
public class Mystery {
public static void main（String[] args） {
Changer c = new Changer（）;
c.method（args）;
System.out.println（args[0] + ” ” + args[1]）;
}
static class Changer {
void method（String[] s） {
String temp = s[0];
s[0] = s[1];
s[1] = temp;
}
}
}
15．阅读下列程序，写出输出的结果:
i = 100 i = 10 i = 10
class Xxx {
private int i;
Xxx x;
public Xxx（） {
i = 10;
x = null;
}
public Xxx（int i） {
this.i = i;
x = new Xxx（）;
}
public void print（） {
System.out.println（“i = ” + i）;
System.out.println（x）;
}
public String toString（） {
return ”i = ” + i;
}
}
public class Test{
public static void main（String[] args） {
Xxx x = new Xxx（100）;
x.print（）;
System.out.println（x.x）;
}
}
16．为了使以下Java应用程序输出11、10、9，应在（**）处插入的语句是:
i[a]=（int）x[a]+1;
如果要求输出10、9、8，则在（**）处插入的语句应是:
i[a]=（int）x[a];
public class GetIt {
public static void main（String args[]） {
double x[] = {10.2, 9.1, 8.7};
int i[] = new int[3];
for（int a = 0;a < （x.length）;a++） {
（**）
System.out.println（i[a]）;
}
}
}
17．阅读下列程序，分析程序的输出结果:
My func
abstract class Base{
abstract public void myfunc（）;
public void another（）{
System.out.println（“Another method”）;
}
}
public class Abs extends Base{
public static void main（String argv[]）{
Abs a = new Abs（）;
a.amethod（）;
}
public void myfunc（）{
System.out.println（“My func”）;
}
public void amethod（）{
myfunc（）;
}
}
18．分析以下代码，编译时会出现的错误信息是:
Test.java:
6:
secret 可以在A中访问private
（return a.secret++; 出错）
class A{
private int secret;
}
public class Test{
public int method（A a）{
return a.secret++;
}
public static void main（String args[]）{
Test test=new Test（）;
A a=new A（）;
System.out.println（test.method（a））;
}
}
19、分析以下程序，写出运行结果:
1234
public class Test19 {
public static void changeStr（String str）{
str=”welcome”;
}
public static void main（String[] args） {
String str=”1234″;
changeStr（str）;
System.out.println（str）;
}
}
20、分析以下程序，写出运行结果:
ABDCBDCB
public class Test20 {
static boolean foo（char c） {
System.out.print（c）;
return true;
}
public static void main（String[] args） {
int i = 2;
for （foo（‘A’）; foo（‘B’） && （i < 4）; foo（‘C’）） {
i++;
foo（‘D’）;
}
}
}
21．编写程序，要求创建一个Dog类，添加name,eyeColor属性，为该属性自动添加相应的set和get方法，并给出至少两个构造方法。
public class Dog {
private String name, eyeColor;
// 无形参的构造方法
public Dog （）{
this. name =”逗逗“;
this. eyeColor = ”黑“;
}
// 有形参的构造方法
public Dog（String name, String eyeColor ）{
this. name = name;
this. eyeColor = eyeColor;
}
public String getEyeColor（） {
return eyeColor;
}
public void setEyeColor（String eyeColor） {
this.eyeColor = eyeColor;
}
public String getName（） {
return name;
}
public void setName（String name） {
this.name = name;
}
}
22．统计一个字符串中出现某个字母的次数（注意区分大小写）。
String类中的相关方法（具体用法请查看JDK帮助文档）：
length（ ）：
计算字符串长度，得到一个int型数值；
indexOf（ ）：
在字符串中定位某个子串，并返回位置编号
substring（ ）：
截取字符串中的一部分，并作为一个新字符串返回；
equals（ ）：
比较两个String内容是否完全相同。
String str = ”abckajbfhbbkhfgabkbjkdfasjkbdanjkasfbai”;
String chr = ”b”;
int count = 0;
for （int i = 0; i < str.length（）; i++） {
if （chr.equals（str.charAt（i））） count++;
}
System.out.println（“The count is ” + count）;
23. 创建一个桌子（Table）类，该类中有桌子名称、重量、桌面宽度、长度和桌子高度属性，以及以下几个方法：
（1） 构造方法：
初始化所有成员变量。
（2） area（ ）：
计算桌面的面积。
（3） display（ ）：
在屏幕上输出所有成员变量的值。
（4） changeWeight（int w）：
改变桌子重量。
在测试类的main（）方法中实现创建一个桌子对象，计算桌面的面积，改变桌子重量，并在屏幕上输出所有桌子属性的值。
package com.test;
public class Table {
String name;//名称
double weight;//重量
double width;//宽
double longth;//长
double height;//高
//构造方法
public Table（String name, double weight, double width, double longth,
double height） {
super（）;
this.name = name;
this.weight = weight;
this.width = width;
this.longth = longth;
this.height = height;
}
//计算桌面的面积
public void area（）{
System.out.println（“桌子面积是“+longth*width）;
}
// 在屏幕上输出所有数据成员的值
public void display（）{
System.out.println（“桌子名称:
”+name+”\n”+”重量:
”+weight+”\n”+”宽:
”+width+”\n”+”长:
”+longth+”\n高:
”+height）;
}
//改变桌子重量的方法
public void changeWeight（int i）{
this.weight=i;
System.out.println（“面积改为“+this.weight）;
}
public static void main（String[] args） {
Table table=new Table（“红木桌“,100.5,3.2,2.3,1.5）;
System.out.println（“创建一个桌子对象，属性如下“）;
table.display（）;
table.area（）;
table.changeWeight（100）;
System.out.println（“更改重量后，属性如下“）;
table.display（）;
}
}
24．编写一个程序，在主类中创建和调用方法sumf（），方法sumf（）的功能是进行两个浮点数的加法运算。
试将12.7和23.4两个数相加并显示运算结果。
import java.util.Scanner;
public class test {
static float sumf（float x,float y） {
return x+y;
}
public static void main（String[]args）{
Scanner sc = new Scanner（System.in）;
System.out.println（“输入2个浮点数求和表达式，如：
23.4+67.01″）;
String []str = sc.next（）.split（“\\+”）;
float m = Float.parseFloat（str[0]）;
float n = Float.parseFloat（str[1]）;
System.out.println（m+”+”+n+”=”+ sumf（m,n））;
}
}
习题5
1．接口与抽象类有哪些异同点？
在面向对象的概念中，我们知道所有的对象都是通过类来描绘的，但是反过来却不是这样。
并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。
抽象类往往用来表征我们在对问题领域进行分析、设计中得出的抽象概念，是对一系列看上去不同，但是本质上相同的具体概念的抽象。
正是因为抽象的概念在问题领域没有对应的具体概念，所以用以表征抽象概念的抽象类是不能够实例化的。
接口与抽象类的主要异同点如下：
（1） 接口定义了一组特定功能的对外接口与规范，而并不真正实现这种功能，功能的实现留待给实现这一接口的各个类来完成。
抽象类一般作为公共的父类为子类的扩展提供基础，这里的扩展包括了属性上和行为上的。
而接口一般来说不考虑属性，只考虑方法，使得子类可以自由的填补或者扩展接口所定义的方法。
抽象类表示的是“is-a”关系，接口着重表示的是“can-do”关系。
（2） abstract class 在 Java 语言中表示的是一种继承关系，一个类只能使用一次继承。
但是，一个类却可以实现多个interface，接口可以解决多重继承问题。
（3） 接口是抽象方法和常量值的定义的集合，从本质上讲，接口是一种只包含常量与抽象方法的特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有变量和方法的实现。
接口里面不能有私有的方法或变量，是用于让别人使用的，接口中的所有常量必须是public static final，且必须给其初值，其实现类中不能重新定义，也不能改变其值。
接口中的方法必须是public abstract，这是系统默认的，不管你在定义接口时，写不写修饰符都是一样的。
抽象类中是可以有私有方法或私有变量的，抽象类中的变量默认是 friendly 型，其值可以在子类中重新定义，也可以重新赋值。
（4） 实现抽象类和接口的类必须实现其中的所有方法。
在抽象类中可以有自己的数据成员，也可以有非abstarct的成员方法。
而在interface中，只能够有静态的不能被修改的数据成员，所有的成员方法都是abstract的。
实现接口的一定要实现接口里定义的所有方法，而实现抽象类可以有选择地重写需要用到的方法。
一般的应用里，最顶级的是接口，然后是抽象类实现接口，最后才到具体类实现。
2．区分接口与抽象类分别在什么场合使用？
如果预计要创建类的多个版本，则创建抽象类。
抽象类提供简单的方法来控制类版本。
如果创建的功能将在大范围的异类对象间使用，则使用接口。
如果要设计小而简练的功能块，则使用接口。
如果要设计大的功能单元，则使用抽象类。
如果要向类的所有子类提供通用的已实现功能，则使用抽象类。
抽象类主要用于关系密切的对象；而接口适合为不相关的类提供通用功能。
抽象类应主要用于关系密切的对象，而接口最适合为不相关的类提供通用功能。
接口多定义对象的行为；抽象类多定义对象的属性；
3．一个类如何实现接口？
实现某接口的类是否一定要重载该接口中的所有抽象方法？
一个类使用关键字implements实现某接口。
实现某接口的类如果不是抽象类，则需要通过重载来实现该接口中
升级会员 