问答题：
1.请详细描述Java语言的特征（至少6项）
简单、结构中立、面向对象、分布式、可移植、高性能、多线程、健壮、动态、安全
简单性：它是由C ++衍生而来，保留C++语言中面向对象的特点，但是也抛弃了较为的复杂的指令 ，结构体，联合体，头文件，析构函数等不必要的东西；
Java语言历史悠久，前辈多，先人广，资料论坛，问题解决站点非常多。
面向对象：万物皆为对象，相比于C语言中的面向过程，更加的简单；
结构中立|跨平台|支持分布式|可移植：因为Java语言在不同的操作系统，有不同的JVM虚拟机，从而做到跨平台的支持，结构相对中立，支持分布式；
健壮安全：Java抛弃了较为的复杂的指令 ，结构体，联合体，头文件，析构函数等不必要的东西，程序员不必再去关注内存的释放，由底层的GC机制去完成内存的管理。从而保证内存的安全性；并且提供的异常处理机制，提升了Java代码的健壮性；
支持多线程： 基本上的编程语言都应该支持多线程，但是Java支持多线程非常的简单，实现非常的容易；
2. 如下代码的输出结果是_____B_____________
Pattern p = Pattern.compile("x.y");
String [] values = {"xy", "xay", "xaby", "xa"};
for(String value : values) {
if(p.matcher(value).matches()) {
System.out.println(value);
}
}
A. xy B. xay C. xaby D. xa E.都不是
3. 如下代码的输出结果是______D____________
Pattern pattern = Pattern.compile("(\\d[a-z])+\\s\\w?");
String [] values = {"9a4b x", "3a z", "a", "1a2b3c "};
int counter = 0;
for(String value : values) {
if(pattern.matcher(value).matches()) {
counter++;
}
}
System.out.println(counter);
A. 0 B. 1 C. 2 D. 3 E. 4
4. 如下代码的输出结果是__________C__________
StringBuilder sb = new StringBuilder();
sb.append("aaa").insert(1, "bb").insert(4, "ccc");
System.out.println(sb);
A. bbaaaccc B. abbaaccc
C. abbaccca D. bbaaccca
E.代码不能通过编译
5.假如有如下代码，那么下面的陈述哪两项是对的_______CE_________
try {
DateFormat df = DateFormat.getDateInstance(DateFormat.SHORT,
Locale.US);
String s = "10/19/1987";
Date d = df.parse(s);
System.out.println(d.getTime());
}catch(ParseException e) {
System.out.println("Something failed");
}
A. 第5行抛出一个ParseException异常，因为"10"是一个无效的月份。
B. 第5行将产生一个编译错误。
C. 第5行成功将字符串s解析为java.util.Date对象，代表October 19, 1987。
D. US地区不支持SHORT日期样式。
E. 输出一个代表从1970.1.1到1987.10.19日的long型毫秒数。
6.如下哪些语句是正确的（选三个）___ABE
A. 所有字符串常量自动实例化为String对象。
B. StringBuilder和StringBuffer类定义了相同的public方法。
C.在多线程环境中，应该使用StringBuilder代替StringBuffer。
D. StringBuilder对象是不可修改的。
E. StringBuffer对象在添加字符时可以增加长度。
7.java技术的组成，并详细说明每个组成部分的含义以及作用
JVM:将字节码文件转成具体系统平台的机器指令。
JRE:JVM+Java语言的核心类库。
JDK:JRE+Java的开发工具。
8.请详细描述Java标识符的含义，以及需要遵循的4大硬性规则以及常见的潜规则
Java标识符是指在Java代码中具有一定特殊含义的符号，分为：系统预定义的标识符（关键字|保留字），用户自定义的标识符（类的类名，方法的方法名，变量名，常量名……）
硬性规则：
1、 标识符必须由字母，数字，下划线，以$组成
2、 标识符不能以数字开头
3、 标识符严格区分大小写，但是对长度不限制
4、 标识符中不能使用关键字，以及系统的保留字
潜规则：
1、“见名知意”
2、 遵循对应的“驼峰命名法”
3、 接口必须以I开头，或者以able结尾
4、 常量名必须全部大写，多个单词之间使用_分隔，力求语义完整，不要在乎长度
9.简述Java所支持的数据类型的种类，以及说明基本数据类型与引用数据类型的区别
两大类：
基本数据类型：boolean,char,byte,short,int,long,float,double
引用数据类型：数组，接口，类
区别：
两种赋予的初值不一样
基本数据类型中boolean为false,char为空, （byte,short,int,long,float,double）为0
引用数据类型为null
储存位置不一样
基本数据类型存放在栈
引用数据类型放在堆中
10.请详细描述Java程序运行期数据区是如何分布的，哪些是线程共享，哪些是线程独享？
方法区、堆、虚拟机栈、程序计数器、本地方法栈
虚拟机栈：存储的是正在执行的一些方法集合，当前正在执行的方法永远在栈的最上方
并且方法内部定义的变量，形参都在栈中
堆：存储的是通过new关键字产生的对象
方法区：类的类代码，静态常量池，也是一种特殊的堆
本地方法栈：跟操作系统有关的底层方法
程序计数器：存储的是代码的执行顺序
线程共享：方法区、堆、本地方法栈
线程独享：虚拟机栈、程序计数器
11.请详细说明布尔运算符中的&和&&符号的区别，并代码举例
&代表的是按位与，它可以作用在数值运算，以及布尔表达式
&& 代表的是短路与，它只能作用在布尔表达式中，并且有短路效果（之前靠前的表达式中出现false，后面的表达式直接不用执行，返回false即可）
int a=0,b=0;
System.out.println((a = 1 < 0)&(b = 1 ) < 0);//输出为false
System.out.println(a);//a =1
System.out.println(b);//b=1
int c=0,d=0;
System.out.println((c = 1 < 0)&&(d = 1 ) < 0);//输出为false
System.out.println(c);//c =1
System.out.println(d);//d=0
12.请用代码结构描述选择语句中的单分支，双分支，多分支，并说明switch变量表达式的变量类型有哪些？
//单分支
if{}
//双分支
if{}else{}
//多分支
if{}elseif(){}else{}
switch变量表达式的变量类型有byte short int char 以及JDK1.7之后新增的String
13.请详细描述continue和break在循环结构中的区别
continue：跳出当前循环
break ：结束循环
14.请分别说说对结构化编程思维和对象化编程思维的理解
结构化编程：由上至下的方式进行设计，这种设计方法的主要思路是将一个大问题分解为多个小问题进行解决，再针对每个小问题编写方法。再由一个主方法把这些大方法由上至下进行运行。
面向对象编程：围绕着要解决的问题中的对象来设计，通过对象和对象间的调用，来解决问题。
15.请详细说明this，this（），super，super（）的区别
this代表对象本身 this()代表本类的其他构造器
super表示子类继承父类的那一部分属性或者方法 super()表示父类的构造器
16.面向对象的特征有几个，并详细说明你对它们的理解
封装：封装给对象提供了隐藏内部属性和方法的能力。
对象提供一些能被其他对象访问的方法来改变它的内部数据。
继承：继承给对象提供了从父类获取属性和方法的能力。
继承提供了代码的重用性，也可以在不修改类的情况下给现存的类添加新特性。
多态：多态是编程语言给不同的底层数据类型做相同的接口展示的一种能力。
一个多态类型上的操作可以是应用到其他类型的值上面。
抽象：抽象是把想法从具体的示例中分离出来的步骤，因此，要根据他们的功能而不是实现细节来创建类。
Java支持创建只暴露接口而不包含方法的抽象的类，这种抽象技术的主要目的是把类的行为和实现的细节分离开。
17.Java语言在通过new构建一个对象时，构造器干了什么事？
构造器在产生对象的时候，分为以下步骤：
1、 去堆中，为对象申请内存空间，申请的空间大小为：对象那么大
2、 在内存空间中，为对象的属性分配空间
3、 为对象的属性赋初值，基本数据类型赋值为0，引用数据类型赋值为null
4、 运行构造器中的其他代码
18.为什么说Java语句中的对象传递方式只有按值传递，而没有引用传递，请说明
Java中在调用对象时，传递给对象的是实参的地址的拷贝（如果实参在栈中，则直接拷贝该值）
private static void meth06() {
// TODO Auto-generated method stub
String a = "张三";
printStr(a);
}
private static void printStr(String b) {
// TODO Auto-generated method stub
System.out.println(b);
}
分析上述代码：“张三”是一个存储在方法区中的字符串对象，a是一个变量，b也是一个变量，当调用printStr(a)传递a变量的时候。Java实现的方式是：将a的值，复制一份，然后将复制的值传递给b。而不是直接将a的值给b。我们把通过复制值传递出去的方式，称为：“按值传递”。在Java中没有引用传递，只有值传递。
19.什么是方法的重载，什么又是方法的重写？相同的方法名与参数，返回类型不一样算不算重载？
方法的重载：方法名字一样，参数的个数、数据类型、顺序不同
方法的重写：子类继承父类，从新改写继承至父类的方法
相同的方法名与参数，返回类型不一样不算重载
20.谈谈你对数组的理解，以及数组的特征是什么？如何规避数组越界的问题？
数组：一个放置相同数据类型的一个容器
数组的特征：数组中只能存放一种数据类型，数组一旦创建成功，那么长度不可变
通过数组的length属性，获取数组的长度，在获取数组单个值得时候，应该小于length-1
21.请详细说明Java访问修饰符的种类，以及控制的访问权限是什么？（可画图说明）
| 位置 | 本类 | 子类 | 同包 | 其他包 |
|---|---|---|---|---|
| Public | √ | √ | √ | √ |
| Protected | √ | √ | √ | |
| 默认 | √ | √ | ||
| Private | √ |
22.请详细说明接口与抽象类的区别与联系
接口的意义：规范、扩展、回溯
抽象类的意义：
1.为其他子类提供一个公共的类型
2.封装子类中重复定义的内容
3.定义抽象方法，虽然子类有不同的实现，但是定义时一致的
区别：
| 接口 | 抽象类 |
|---|---|
| 只包含抽象方法、静态方法和默认方法，不能为普通方法提供方法实现 | 完全包含普通方法； |
| 只能定义静态常量，不能定义普通成员变量 | 既可以定义普通成员变量，也可以定义静态常量 |
| 不能包含构造器 | 可以包含构造器（让抽象类的子类调用这些构造器来完成属于抽象类的初始化操作） |
| 不能包含初始化块 | 可以包含初始代码块 |
联系：
1.都不能被实例化；
2.都位于继承树的顶端，用于被其他类实现和继承；
3.都可以包含抽象方法，实现接口或继承抽象类的普通子类都必须实现这些抽象方法。
23.如下程序的运行结果是_______A_______
import java.util.*;
public class MyComparator implements Comparator < String > {
public int compare(String a, String b) {
return a.toLowerCase().compareTo(b.toLowerCase());
}
public static void main(String [] args) {
String [] values = {"abc", "Abb", "aab"};
Arrays.sort(values, new MyComparator());
for(String s : values) {
System.out.print(s + " ");
}
}
}
A. aab Abb abc B. Abb aab abc C. abc Abb aab D. aab abc Abb E.代码不能通过编译
24.如下语句的结果是______A__________。
int [] random = {6, -4, 12, 0, -10};
int x = 12;
int y = Arrays.binarySearch(random, x);
System.out.println(y);
A. 2 B.4 C.结果是undefined. D. 第3行在运行时抛出一个异常 E.第3行编译错误
25.如下语句的结果是_________D____________
List < Integer > list = Arrays. < Integer > asList(10, 4, -1, 5);
Collections.sort(list);
Integer [] array = list. < Integer > toArray(new Integer[4]);
System.out.println(array[0]);
A. 第1行出现编译错误 B. 第2行在运行时抛出一个异常
C. 第3行出现编译错误 D. -1 E. 10
26.如下程序的输出结果是__________B__________________
import java.util.*;
public class StringSearch {
static class ReverseLexi implements Comparator < String > {
public int compare(String a, String b) {
return b.compareToIgnoreCase(a);
}
}
public static void main(String [] args) {
List < String > list = new ArrayList < String > ();
list.add("ab");
list.add("ba");
list.add("bd");
list.add("aa");
ab ba bd aa
ReverseLexi comparator = new ReverseLexi();
Collections.sort(list, comparator);
bb ba ab Aa
int index = Collections.binarySearch(list, "ab", comparator);
System.out.println(index);
}
}
A. 1 B. 2 C. 3 D. 4 E.代码不能通过编译
27.假如有如下语句：
Map < String, Double > map = new HashMap < String, Double > ();
如下哪些语句是有效的？__ E___
A. map.add( " pi " , 3.14159); B. map.add( " e ", 2.71828D);
C. map.add( " log(1) " , new Double(0.0)); D.map.add(‘x’, new Double(123.4));
E. 全部都无效
28.手写代码实现等腰三角形的输出，用*代表各边（让用户输入行数）代码实现
Scanner scanner = new Scanner(System.in);
System.out.println("请输入行：");
int in = scanner.nextInt();
for (int i = 0; i <in ; i++) {
int k = in;
for(; k > i; k--) {
System.out.print(" ");
}
System.out.print("*");
for (int j = 0; j <i*2-1 ; j++) {
if(!(i == in-1)) {
System.out.print(" ");
}else {
System.out.print("*");
}
if(j == i*2-2){
System.out.print("*");
}
}
System.out.println();
}
29.请说明先验循环与后验循环的区别，并详细说明for循环的执行步骤
先验循环：
例如：
do{
代码块
}while(布尔逻辑)
至少运行一次代码块
后验循环：
例如：
while(布尔逻辑){
代码块
}
布尔逻辑不满足，一次都不会执行
for循环的执行步骤：
例如：
for(int i = 0; i < 10; i ++){
代码块
}
第一步：初始化i
第二步：判断条件 条件满足
第三步：执行代码块
第四步：执行i++
第五步：判断条件 …
.
.
.
第N步：判断条件 条件不满足 循环结束
30.Java中的异常有哪两种类型，它们之间的区别是什么？并代码实现自定义两种异常代码实现
编译时异常： Exception
在编译的时候就会提醒，出现异常
运行时异常：RunTimeException
在运行过程中，代码出现异常
异常的分类：编译时异常，运行时异常，错误。区别在于：编译时异常，一般在编写的代码的时候，由编译器给程序员提醒的异常；
运行时异常，在编写代码时不会报错，但是在程序运行时会抛出的异常；
错误：程序员没办法通过代码来解决的问题
实现编译时异常的方式：继承Exception，并重写父类的构造器，只不过编译时异常在使用时，需要采用throws进行方法声明。
实现运行时异常的方式：继承RuntimeExceptiion，并重写父类的构造器
public class NoNumberException extends Exception{
private static final long serialVersionUID = -3682624280249349176L;
public NoNumberException() {
super();
// TODO Auto-generated constructor stub
}
public NoNumberException(String message) {
super(message);
// TODO Auto-generated constructor stub
}
}
public class NoNumberRunTimeException extends RuntimeException {
private static final long serialVersionUID = 3701271681073853481L;
public NoNumberRunTimeException() {
super();
// TODO Auto-generated constructor stub
}
public NoNumberRunTimeException(String message) {
super(message);
// TODO Auto-generated constructor stub
}
}
代码题
31.判断以下代码是否可以正常执行，并说明其理由
null类型(null(空)引用是这种类型的唯一的一个值)，可以赋值给任意类型
将null强转为Null类型，而haha()被静态修饰是个类方法和对象无关，可通过类名直接调用
则可以正常运行
32.说明以下代码的执行结果是什么？
static A
static B
I’m A class
HelloA
I’m B class
HelloB
33.请用代码实现下列数组之间的交换 代码实现
int[] a = {6,4,7,0};
int[] b = {3,5,2,1};
int[] temp ;
temp = a;
a = b;
b = temp;
System.out.println(Arrays.toString(a));
34.请用代码实现下列数组排序（升），并输出数组中的偶数 代码实现
int[] a = {3,5,7,2,4,5,4,10,12};
Arrays.sort(a);
int length = a.length;
//冒泡排序
// for (int i = 0; i < length; i++) {
// for(int j = 0;j<length - 1;j++) {
// if(a[j] > a[j+1]) {
// int temp = a[j];
// a[j] = a[j + 1];
// a[j + 1] = temp;
// }
// }
// }
//选择排序
// int mixIndex = 0;
// int maxIndex = a.length -1;
// for (int i = 0; i < length; i++) {
// mixIndex = i;
// for(int j = i;j<length ;j++) {
// if(a[i] > a[j]) {
// maxIndex = j;
// }
// }
// int temp = a[mixIndex];
// a[mixIndex] = a[maxIndex];
// a[maxIndex] = temp;
// }
System.out.println(Arrays.toString(a));
System.out.print("数组中偶数有：");
for (int i : a) {
if(i%2 == 0) {
System.out.print(i+"、");
}
}
35.判断这段代码的输出结果
true
false
Integer的底层：
如果不是通过new进行int转换为Integer
传入的int数值在-128~127 之间
Integer变量指向的是静态常量池中cache数组中存储的指向了堆中的Integer对象
扫一扫
465
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
