java常见简答题

               

一、基础知识

1．简述使用文本编辑器和JDK创建并运行Java应用程序的基本步骤。

2. 对比分析Java与其它高级语言的编译和运行过程，说明Java具有平台独立性的原因？

3.简述break和continue语句在使用时的区别？

1、①打开文本编辑器输入Java源程序；②保存文件，文件名为源程序中public修饰类的类名，扩展名为.java；③打开命令行工具；④编译程序，在命令行输入：javac 源程序文件名；⑤运行程序，在命令行输入：java 源程序中public修饰的类名。

2、因为Java程序编译之后的代码不是能被硬件系统直接运行的代码，而是一种“中间码”——字节码。然后不同的硬件平台上安装有不同的Java虚拟机(JVM)，由JVM来把字节码再“翻译”成所对应的硬件平台能够执行的代码。因此对于Java编程者来说，不需要考虑硬件平台是什么。所以Java可以跨平台。 而C/C++不可以跨平台的原因就是编译后的代码在特定的硬件上可以直接执行，换个硬件平台这些代码就不能被执行了。不过正是因为可以直接执行，所以C/C++程序的执行效率要比Java程序高

4. Java对标识符命名有什么规定？

答：Java对标识符的命名规定如下：

1) Java语言的标识符必须由字母、下划线(“_”)或美元符号(“$”)开始，其余字符可以是上述三种符号或数字(0-9)。Java语言使用Unicode字符集，所以字母包括‘A’-‘Z’、‘a’-‘z’以及Unicode字符集中序号大于0xC0的所有符号。

2) 保留字不能用于标识符如：abstract boolean 等等。

3) 标识符区分大小写。

5. 请列出Java主要的基本数据类型。

答：Java主要的基本数据类型有：布尔型boolean、字节型byte、字符型char、短整型short、整型int、长整型long、浮点型(单精度型)float、双精度型double。

二、类和对象1

1.什么是类？什么是对象？类和对象有何联系？

2.方法的重载和方法的覆盖有什么不同？

3.类变量和实例变量有何区别？

4.Java的成员变量修饰符有哪几种？其中哪种修饰符限定的范围最大？

5.说明对象的基本概念和主要特征？

1. 答：在面向对象程序设计里，类是定义一个对象的属性和方法的蓝本。对象就是一组变量和相关方法的集合，其中变量表明对象的状态，方法表明对象所具有的行为。类是对象的模板，对象是类的实例，可以从一个类中创建许多对象。

2. 答：方法重载，指的是在类中创建多个具有相同名称，但使用不同参数的方法，Java虚拟机根据传递给方法的参数个数和类型决定调用哪个重载方法。方法的覆盖指在子类中重新定义父类中已有的方法，对于重写的方法，运行时系统根据调用该方法的实例的类型来决定选择哪个方法调用。

3．答：由static修饰的变量称为类变量，当系统在程序中第一次遇到一个类时，便会拷贝一份所有的类变量在内存里。然后那些由此类产生的实例便可分享这些类变量。

实例变量指不是用static修饰的变量，可供实例方法使用。实例变量会复制于每一个从类产生的实例中。

4. 答：成员变量的修饰符有public、protected、private、static、final、transient、volatile七种。Public修饰符的限定范围最大。

5.对象是对客观世界实体及其实体关系的抽象。特点：（1）以数据为中心；(2)实现了数据封装；（3）模块独立性好；（4）对象是主动的；（5）本质上具有并行性。

三、类和对象2

1.抽象类和抽象方法有什么特点？

2.接口和抽象类有什么区别？

3.什么是包？为什么要使用包？

4．简述在类的继承关系中，子类可以继承父类的哪些成员，不能继承的有哪些成员。

1.答：① 一个抽象类里可以没有抽象方法，但含有抽象方法的类必定为抽象类。

② 抽象类不能被实例化为对象，而只能作为其它类的超类，并且必须被继承。

③ 若某子类继承自一个抽象类，而该子类不是抽象类，则子类需用覆盖的方式来实例化超类中的所有抽象方法。抽象方法可再与public、protected复合使用，但不能与final、private和static复合使用。 ④ 抽象方法只有方法声明，不能有方法体。

2..答：从本质上讲，接口是一种特殊的抽象类，然而它们又有区别：

①接口只包含常量，而抽象类则不一定。

②接口中不能有非抽象的方法，但抽象类中可以有。

③一个类能实现多个接口，但只能有一个父类。

④接口并不属于继承结构，它实际与继承无关，无关的类可以实现同一个接口。

3.答：包（package）是类的容器。由于Java编译器为每个类生成一个字节码文件，且文件名与类名相同，因此同名的类有可能发生冲突。为了解决这一问题，Java提供包来管理类名空间。此外一旦创建了一个类，并想重复地使用它，那么把它放在一个包中将是非常有效的。

4.答：可继承：①父类中公开级的成员；②父类中保护级的成员；③如果子类和父类在同一个包中，则子类继承父类中缺省的包访问级的成员。

不可继承：④父类中私有级的成员；⑤不在同一包的缺省成员和父类的同名成员。

5.多态

多态：相同类型的变量，调用相同的方法，执行的具体代码却不同的现象称为多态

继承与多态表现形式：变量隐藏 (属性的不同表现)方法重写(方法的不同表现) 上转型对象(实例的不同表现)

方法的覆盖

规则：父类和子类方法同名；返回值类型形同；参数类型顺序相同；子类方法的权限不小于父类方法权限；子类方法只能抛出父类方法声明抛出的异常或异常子类。（异常应比父类方法更具体）p119 继承关系图 注意：子类只有在能够访问到父类方法时才能对该方法进行重写

函数重载：函数名称相同，函数的参数个数不同或参数类型不同或参数顺序不同

四、异常

1.Error类和Exception类有什么区别？

2.什么是异常？为什么要进行异常处理？

3.简述异常处理的过程。

4.写出下列关键字的意义和运用场合：①final；②finalize；③finally。

1.答：Error类及Exception类是Throwable类的两个直接子类。Error类描述的是内部系统错误，包括动态链接失败、虚拟机错误等，Java程序不做处理。Exception类描述的是程序和外部环境引起的错误，这些错误能通过程序捕获和处理，Exception类是Java程序中需要大量处理的。

3.答：程序运行时出现错误时，创建异常对象，抛出异常对象，捕获该异常对象并进行处理。

4. 答：final, finally, finalize的区别如下：

final 用于声明属性、方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。

finally是异常处理语句结构的一部分，表示总是执行。

finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源回收，例如关闭文件等。

1.答：异常，是指由于程序运行时发生错误，从而导致程序错误结束。

在进行程序设计时，错误的产生是不可避免的，没有异常处理代码的程序，在运行时发生错误则可能非正常结束，引起严重问题。因此，Java给程序员提供了处理运行时错误的功能，称为异常处理。

五、常用类库

1.Vector对象的大小与容量之间有什么区别？

2.String类和StringBuffer类的主要区别是什么？

1.答：一个Vector对象的大小是包含的Object引用的实际数量。而容量是指为Object引用分配的存储空间的数量。

2.答：String类：用于比较两个字符串，查找和抽取串中的字符或子串，字符串与其他类型的转换等，String类对象的内容一旦被初始化就不能再改变。StringBuffer类：用于内容可以改变的字符串，可以将其他各种类型的数据增加、插入到字符串中，也可以翻转字符串中原来的内容。

七、输入输出流

1．简述读写文本文件的基本步骤。

①导入输入/输出包；②创建文件对象；③创建读出/写入操作的对象；④数据文件的读/写操作；⑤关闭文件。

1. 编写一个Application，接受用户从键盘输入的10个整数，并输出这10个整数的最大值和最小值。 import java.io.* ;

public class abc

{

public static void main(String args[ ])

{ int i , n = 10 , max = 0 , min = 0 , temp = 0;

try {

BufferedReader br = new BufferedReader( new InputStreamReader(System.in)); max = min = Integer.parseInt(br.readLine( ));

} catch ( IOException e ) { } ;

for ( i = 2 ; i <= n ; i ++ ) {

try {

BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); temp = Integer.parseInt(br.readLine( ));

if (temp > max ) max=temp;

if (temp < min) min=temp;

} catch ( IOException e ) { } ;

}

System.out.println("max="+max+"\nmin="+min);

}

}

1. 编写一个Application，从键盘输入整数n，并计算从1到n的累加和。

import java.io.*;

public class Application1 {

public static void main(String[] args) {

String s = "";

int n, sum = 0;

System.out.println("计算从 1 到 n 的累加和。");

System.out.print("请输入 n 的值：");

// 从键盘读入字符串 s

try {

InputStreamReader isr = new InputStreamReader(System.in);

BufferedReader br = new BufferedReader(isr);

s = br.readLine();

}

catch(Exception e) { }

// 将字符串 s 转为整型数 n

n = Integer.parseInt(s);

// 计算 1 到 n 的累加和

for(int i=1; i<=n; i++)

sum += i;

// 输出结果

System.out.println("你刚才的输入是：" + n);

System.out.println("1 到 n 的累加和是：" + sum);

}

}

2．import java.io.* ;

public class Reverse

{ public static void main(String args[ ])

{ int i , n =10 ;

int a[ ] = new int[10];

for ( i = 0 ; i < n ; i ++ )

try {

BufferedReader br = new BufferedReader(

new InputStreamReader(System.in));

a[i] = Integer.parseInt(br.readLine( )); // 输入一个整数

} catch ( IOException e ) { } ;

for ( i = n－1 ; i >= 0 ; i ―― )

System.out.print(a[i]+" ");

System.out.println( );

}

}

答：从标准输入(即键盘)读入10个整数存入整型数组a中，然后逆序输出这10个整数。

4． import java.io.*;

public class Class1

{

public static void main(String args[ ]){

int i , Max , Min ;

int a[ ] = { 12,67,8,98,23,56,124,55,99,100 }; Max = Min = a[0]; for ( i = 1 ; i < a.length; i ++ ) { } System.out.println( Max+" "+Min ); if ( a[i]<Min ) Min = a[i]; if ( a[i]>Max ) Max = a[i];

System.out.println( );

}

}

答：在数组中查找并输出最大值和最小值

3． 编写一个完整的Java Applet 程序使用复数类Complex验证两个复数 1+2i 和3+4i 相加产生一个新的复数 4+6i 。

复数类Complex必须满足如下要求：

(1) 复数类Complex 的属性有：

RealPart : int型，代表复数的实数部分

ImaginPart : int型，代表复数的虚数部分

(2) 复数类Complex 的方法有：

Complex( ) : 构造函数，将复数的实部和虚部都置0

Complex( int r , int i ) : 构造函数，形参 r 为实部的初值，i为虚部的初值。

Complex complexAdd(Complex a) : 将当前复数对象与形参复数对象相加，所得的结果仍是一个复数值，返回给此方法的调用者。

String ToString( ) : 把当前复数对象的实部、虚部组合成 a+bi 的字符串形式，其中a 和 b分别为实部和虚部的数据。

答：参考程序如下：

import java.applet.* ;

import java.awt.* ;

public class abc extends Applet

{

Complex a,b,c ;

public void init( )

{

a = new Complex(1,2);

b = new Complex(3,4);

c = new Complex();

}

public void paint(Graphics g)

{

c=a.complexAdd(b);

g.drawString("第一个复数："+a.toString(),10,50);

g.drawString("第二个复数："+b.toString(),10,70);

g.drawString("两复数之和："+c.toString(),10,90);

}

}

class Complex

{

int RealPart ; // 复数的实部

int ImaginPart ; // 复数的虚部

Complex() { RealPart = 0 ; ImaginPart = 0 ; }

Complex(int r , int i)

{ RealPart = r ; ImaginPart = i ; }

Complex complexAdd(Complex a)

{

Complex temp = new Complex( ); // 临时复数对象

temp.RealPart=RealPart+a.RealPart;

temp.ImaginPart=ImaginPart+a.ImaginPart;

return temp;

}

public String toString( )

{ return ( RealPart+" + "+ImaginPart+" i "); }

}

4． 编写一个学生类 Student ，要求：

(1) 学生类 Student 属性有：

id : long型，代表学号

name : String类对象，代表姓名

age : int型，代表年龄

sex : boolen型，代表性别（其中：true表示男，false表示女）

phone : String类对象，代表联系电话

(2) 学生类 Student的方法有：

Student(long i , String n , int a , boolean s , long p)

: 有参构造函数，形参表中的参数分别初始化学号、姓名、

年龄、性别和联系电话。

int getAge() ( ) : 获取年龄作为方法的返回值。

boolean getSex( ) ( ) : 获取性别作为方法的返回值。

long getPhone ( ) : 获取联系电话作为方法的返回值。

public String toString( ) : 以 姓名：联系电话 的形式作为方法的返回值。

答：参考程序段如下：

class Student {

long id;

String name;

int age;

boolean sex;

long phone;

Student( long i , String n , int a , boolean s , long p ){

id = i;

name = n;

age = a;

sex = s;

phone = p;

}

int getAge(){ return age; }

boolean getSex(){ return sex; }

long getPhone() { return phone; }

public String toString(){ return name+" : "+phone; }

}

1. 什么叫构造函数重载？

答：是指同一个类中存在着若干个具有不同参数列表的构造函数。

2. Java语言有什么特点？

答：平台无关性、面向对象、安全稳定、支持多线程、简单易学

3. Java Applet的基本工作原理是什么？

答：编译好的字节码文件保存在特定的WWW服务器上，当某一个浏览器向服务器请求下载嵌入了Applet的HTML文件时，该文件下载到客户端由浏览器解释HTML标记；当遇到HTML特殊的Applet标记时，浏览器回自动根据Applet的名字和位置把字节码下载到本地，由浏览器本身拥有的Java解释器直接执行。

4. 什么叫多线程？Java支持多线程有何意义？

答：多线程是指同时存在几个执行体，按几条不同的执行路线共同工作的情况。Java支持多线程使得编程人员可以方便地开发同时处理多任务的功能强大的程序，更好地解决现实世界的具体问题。

5. 什么是接口？如何定义接口？

答：接口是用来定义类间多重继承功能的结构。接口声明的语法：

[public] interface 接口名 [extends 父接口名列表]

{ //接口体

//常量域说明

[public] [static] [final] 域类型 域名 = 常量名；

//抽象方法声明

[public] [abstract] [native] 返回值 方法名（参数列表） [throw异常列表]；

1．设计一个圆类，将圆的位置(圆心坐标和半径）作为属性（提供任意圆的设置），并能计算圆的面积。 public class MyCircle {

}

平台无关性与可移植性

程序的可移植性指的是程序不经修改而在不同硬件或软件平台上运行的特性，可移植性在一定程度上决定了程序的可应用性。可移植性可分两个层次：源代码级可移植性和二进制可移植性。Java不仅是源代码级可移植的，甚至源代码经过编译之后形成的二进制代码——字节码，也同样是可移植的。 Java采用了多种机制来保证可移植性，其中最主要的有两条：

第一，Java既是编译型又是解释型的。Java将源程序编译成字节码——二进制代码，这种字节码通过Java解释器来解释执行。任何一台机器，只要配备了Java解释器，就可以运行Java字节码，而不管这种字节码是在何种平台上生成的。这不仅使开发的Java源代码是可移植的，甚至源代码经过编译之后形成的二进制代码——字节码，也同样是可移植的。Java源程序编译生成的字节码不是直接在操作系统平台上运行，而是在一个称为Java虚拟机（JVM）的平台上运行。利用JVM把Java字节码跟具体的软硬件平台分隔开来，就能保证在任何机器上编译的Java字节码文件都能在该机上运行。

第二，Java采用的是基于国际标准——IEEE标准的数据类型。Java的数据类型在任何机器上都是一致double x,y,r; final double pi = 3.1415926; MyCircle(double x, double y, double r) { } public double getArea() { } } public static void main(String[] args) { return pi*r*r; this.x = x; this.y = y; this.r = r;

的，它不支持特定于具体的硬件环境的数据类型，它还规定同一种数据类型在所有各种实现中必须占据相同的空间大小。此外，Java的可移植性还体现在Java的运行环境上。Java编译器是用Java语言本身所编写的，而其他运行时环境则是用ANSI C编写的，整个运行时环境体现了一个定义良好的可移植性接口。最后，Java语言规范遵循POSIX标准，这也是使Java具有良好可移植性的重要原因。

强制类型转换

强制类型转换是指在一个表达式中出现的各种变量或常量的数据类型不同时，所进行的数据类型转换（casting conversion）。Java程序中的类型转换可分为显式类型转换和隐式类型转换两种形式。

（1）隐式类型转换。对于由双目运算中的算术运算符组成的表达式，一般要求运算符两边的两个操作数的类型一致，如果两者的类型不一致，则系统会自动转换为较高（即取值范围较大）的类型，这便是隐式数据类型转换。根据操作数的类型，隐式转换的规则如下：

(byte或short)与int型运算，转换为int型；

(byte或short或int)与long型运算，转换为long型；

(byte或short或int或long)与float型运算，转换为float型

(byte或short或int或long或float)与double型运算，转换为double型；

char型或int型运算，转换为int型。

（2）显式类型转换。隐式类型转换只能由较低类型向较高类型转换，但是在实际工作中，有时也可能需要由较高类型向较低类型转换。例如，我们在计算数值时为了保证其精度，为某些变量取了较高的数据类型（如double型），但在输出时，往往只需要保留两、三位小数或者只输出整数，这时只能进行显式类型转换。显式类型转换需要人为地在表达式前面指明所需要转换的类型，系统将按这一要求把某种类型强制性地转换为指定的类型，其一般形式如下：

(<类型名>)<表达式>

Java免费学习资料直播公开课加老师QQ578024144

           

再分享一下我老师大神的人工智能教程吧。零基础！通俗易懂！风趣幽默！还带黄段子！希望你也加入到我们人工智能的队伍中来！https://blog.csdn.net/jiangjunshow