Java面试-基础与语法（1）

Java的跨平台原理

Java编程的原理
Java源程序（.java）->Java字节码文件（.class）->Java虚拟机（JVM）->Java运行程序
Java不同的虚拟机提供了相同的接口
Java具有一次编译，到处运行的特点

Java的安全性

语言层次的安全性主要体现在：
1.Java取消了强大但危险的指针，取而代之的是Java的引用机制。
由于指针可进行移运算，指针可以随便指向任意一个内存区域，而不用管这个区域是否可用，这样的情况是危险的。
原来的内存地址可能存储着重要数据或被其他程序运行所占用，同时指针也易于引起数组的越界。
2.Java的垃圾回收机制：
不需要程序员直接控制内存的回收，由垃圾回收机制来自动进行内存的回收。避免程序忘记及时回收，导致内存的泄露，避免程序错误回收重要的程序内存，导致系统崩溃。
3.异常处理机制：
Java的异常处理机制只要依赖于try，catch，finally，throw，throws五个关键字
4.Java的强制类型转换：
只有满足强制转换的规则的情况下才能强制转换成功
5.底层的安全：
Java在字节码的传输环节中使用了公共密钥加密机制（PKC）
在运行环境提供了四级安全性保障机制：
字节码校验器 -类装载器 -运行时内存布局 -文件访问限制

什么是JVM？什么是JRE？ 什么是JDK？

JVM ：JVM是Java Virtual Machine（Java虚拟机）的缩写。
它是整个java实现跨平台的最核心的部分。

JRE：JRE是java runtime environment（java运行环境）的缩写。

JDK：JDK是java development kit（java开发工具包）的缩写。

JDK,JRE,JVM三者关系概括如下：

JDK是JAVA程序开发时用的开发工具包，其内部也有JRE运行环境JRE。
JRE是JAVA程序运行时需要的运行环境，就是说如果你光是运行JAVA程序而不是去搞开发的话，只安装JRE就能运行已经存在的JAVA程序了。
JDk、JRE内部都包含JAVA虚拟机JVM，JAVA虚拟机内部包含许多应用程序的类的解释器和类加载器等等。

简单概括：
Java虚拟机是JVM（底层）， java运行环境是JRE（环境），java开发工具包是JDK（开发）。

Java三种注释类型

单行注释，采用“//”方式.只能注释一行代码。
多行注释，采用“/…/”方式，可注释多行代码，其中不允许出现嵌套。如：
文档注释，采用“/**…*/”方式。

8种基本数据类型及其字节数

数据类型		关键字	字节数
数值型	整数型	byte	1
		short	2
		int	4
		long	8
	浮点型	float	4
		double	8
布尔型		boolean	1（位）
字符型		char	2

i++和++i的异同之处

共同点：
1、i++和++i都是变量自增1，都等价于i=i+1
2、如果i++,++i是一条单独的语句，两者没有任何区别
3、i++和++i的使用仅仅针对变量。 2++和++2会报错，因为2不是变量。

不同点：
如果i++,++i不是一条单独的语句，他们就有区别
i++ ：先运算后增1。如：

int x=5;
int y=x++;
System.out.println("x="+x+", y="+y);
//以上代码运行后输出结果为：x=6, y=5

++i ： 先增1后运算。如：

int x=5;
int y=++x;
System.out.println("x="+x+", y="+y);
//以上代码运行后输出结果为：x=6, y=6

&和&&的区别和联系，|和||的区别和联系

&和&&的联系(共同点)：

&和&&都可以用作逻辑与运算符，但是要看使用时的具体条件来决定。

操作数1 & 操作数2，操作数1 && 操作数2，

表达式1 & 表达式2，表达式1 && 表达式2，

情况1：当上述的操作数是boolean类型变量时，&和&&都可以用作逻辑与运算符。

情况2：当上述的表达式结果是boolean类型变量时，&和&&都可以用作逻辑与运算符。

表示逻辑与(and)，当运算符两边的表达式的结果或操作数都为true时，整个运算结果才为true，否则，只要有一方为false，结果都为false。

&和&&的区别(不同点)：

(1)、&逻辑运算符称为逻辑与运算符，&&逻辑运算符称为短路与运算符，也可叫逻辑与运算符。

对于&：无论任何情况，&两边的操作数或表达式都会参与计算。

对于&&：当&&左边的操作数为false或左边表达式结果为false时，&&右边的操作数或表达式将不参与计算，此时最终结果都为false。

&还可以用作位运算符。当&两边操作数或两边表达式的结果不是boolean类型时，&用于按位与运算符的操作。

|和||的区别和联系与&和&&的区别和联系类似

用最有效率的方法算出2乘以8等于多少

使用位运算来实现效率最高。
位运算符是对操作数以二进制比特位为单位进行操作和运算，操作数和结果都是整型数。
对于位运算符“<<”, 是将一个数左移n位，就相当于乘以了2的n次方，那么，一个数乘以8只要将其左移3位即可，位运算cpu直接支持的，效率最高。
所以，2乘以8等于几的最效率的方法是2 << 3

基本数据类型的类型转换规则

基本类型转换分为自动转换和强制转换。

自动转换规则：容量小的数据类型可以自动转换成容量大的数据类型

也可以说低级自动向高级转换。这儿的容量指的不是字节数，而是指类型表述的范围。

强制转换规则：高级变为低级需要强制转换。

如何转换：

（1）赋值运算符“=”右边的转换，先自动转换成表达式中级别最高的数据类型，再进行运算。

（2）赋值运算符“=”两侧的转换，若左边级别>右边级别，会自动转换；若左边级别 == 右边级别，不用转换；若左边级别 < 右边级别，需强制转换。

(3)可以将整型常量直接赋值给byte, short, char等类型变量，而不需要进行强制类型转换，前提是不超出其表述范围，否则必须进行强制转换。

if多分支语句和switch多分支语句的异同之处

相同之处：都是分支语句，多超过一种的情况进行判断处理。

不同之处：

switch更适合用于多分支情况，就是有很多种情况需要判断处理，判断条件类型单一，只有一个入口，在分支执行完后（如果没有break跳出），不加判断地执行下去;
而if—elseif—else多分枝主要适用于分支较少的分支结构，判断类型不是单一，只要一个分支被执行后，后边的分支不再执行。
switch为等值判断（不允许比如>= <=）
而if为等值和区间都可以，if的使用范围大

while和do-while循环的区别

while先判断后执行，第一次判断为false,循环体一次都不执行

do while先执行 后判断，最少执行1次。

如果while循环第一次判断为true, 则两种循环没有区别。

break和continue的作用

break: 结束当前循环并退出当前循环体。

break还可以退出switch语句

continue: 循环体中后续的语句不执行，但是循环没有结束，继续进行循环条件的判断（for循环还会i++）。continue只是结束本次循环。

请使用递归算法计算n！

public static Interage factorial(Interage n){
	if(n<0){
		return 0;
	}
	if(n==1){
		return 1;
	}
	return n * factorial(n-1);
}
public static void main(String[] args){
	//计算5的阶层factorial(阶乘)
	System.out.println(factorial(5));
}

递归的定义和优缺点

递归算法是一种直接或者间接地调用自身算法的过程。在计算机编写程序中，递归算法对解决一大类问题是十分有效的，它往往使算法的描述简洁而且易于理解。

递归算法解决问题的特点：

(1) 递归就是在过程或函数里调用自身。

(2) 在使用递归策略时，必须有一个明确的递归结束条件，称为递归出口。

(3) 递归算法解题通常显得很简洁，但运行效率较低。所以一般不提倡用递归算法设计程序。

(4) 在递归调用的过程当中系统为每一层的返回点、局部量等开辟了栈来存储。递归次数过多容易造成栈溢出等。所以一般不提倡用递归算法设计程序。

数组的特征

数组是（相同类型数据）的（有序）（集合）

数组会在内存中开辟一块连续的空间，每个空间相当于之前的一个变量，称为数组的元素element

元素的表示 数组名[下标或者索引]: scores[7] ,scores[0] ,scores[9]

索引从0开始

每个数组元素有默认值: double 0.0 ,boolean false, int 0

数组元素有序的，不是大小顺序，是索引的顺序

数组中可以存储基本数据类型，可以存储引用数据类型；
但是对于一个数组而言，数组的类型是固定的，只能是一个length:数组的长度

数组的长度是固定的，一经定义，不能再发生变化（数组的扩容）

冒泡排序代码

思想:每一轮循环，前一个数和后一个数进行比较，小的数和大的数换位，大的在小的右边，直到循环不在发生改变时停止循环。

public class TestBubbleSort{
	public static void sort(int[] a){
		int temp = 0;
		// 外层循环，它决定一共走几趟
		for(int i=0;i<a.length-1;i++){
			//通过符号位可以减少无谓的比较，如果已经有序了，就退出循环
			int flag = 0;
			//内层循环，它决定每趟走一次
			for(int j=0;j<a.length-1-i;j++){
				//如果后一个大于前一个
				if(a[j+1]<a[j]){
					//换位
					temp = a[j];
					a[j] = a[j+1];
					a[j+1] = temp;
					flag = 1;
				}
			}
			if(flag == 0){
				break;
			}
		}
	}
}

选择排序的代码

思想:每轮循环，当前数和后面所有数进行比较，标记最小数的下标，找到最小值后，当前数和最小值交换，当前数下标+1，再和+1后当前数的后面所有数进行比较，直到循环结束。

public class TestSelectSort {
	public static void sort(int arr[]) {
		int temp = 0;
		for (int i = 0; i < arr.length - 1; i++) {
			// 认为目前的数就是最小的, 记录最小数的下标
			int minIndex = i;
			for (int j = i + 1; j < arr.length; j++) {
				if (arr[minIndex] > arr[j]) {
					// 修改最小值的下标
					minIndex = j;
				}
			}
			// 当退出for就找到这次的最小值
			if (i != minIndex) {
				temp = arr[i];
				arr[i] = arr[minIndex];
				arr[minIndex] = temp;
			}
		}
	}
}

插入排序的代码

思想:从第二个数开始，如果当前数小于前一个数，当前数和前一个数交换，直到循环结束。

public class TestInsertSort {
	public static void sort(int arr[]) {
		int i, j;
		for (i = 1; i < arr.length; i++) {
			int temp = arr[i];
			for (j = i; j > 0 && temp < arr[j - 1]; j--) {
				arr[j] = arr[j - 1];
			}
			arr[j] = temp;
	}
}

可变参数的作用和特点

总结1：可变参数

1.可变参数的形式 …

2.可变参数只能是方法的形参

3.可变参数对应的实参可以0,1,2…个，也可以是一个数组

4.在可变参数的方法中，将可变参数当做数组来处理

5.可变参数最多有一个，只能是最后一个

6.可变参数好处：方便 简单 减少重载方法的数量

7.如果定义了可变参数的方法，不允许同时定义相同类型数组参数的方法

总结2：数组做形参和可变参数做形参联系和区别

联系：

1.实参都可以是数组；2.方法体中，可变参数当做数组来处理

区别：

1.个数不同 可变参数只能有一个数组参数可以多个

2.位置不同 可变参数只能是最后一个数组参数，位置任意

3.实参不同 可变参数实参可以0,1,2…个，也可以是一个数组，数组的实参只能是数组