java教程之javaSE面试题总结(2)

当前位置:

首页 > Python基础教程 >

java教程之javaSE面试题总结(2)

	for (int j = 0; j <a.length-i-1 ; ++j) {

	//如果后一个大于前一个

	if (a[j + 1] < a[j]) {

	//换位

	temp = a[j];a[j] = a[j + 1];a[j + 1] = temp;

}

}

}

	public static void sort2(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;} 

}

}

}

	请写出选择排序的代码

	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.....个，也可以是一个数组，数组的实参只能是数组

	第五章 面向对象

	类和对象的关系

	类是对象的抽象，而对象是类的具体实例。类是抽象的，不占用内存，而对象是具体的，占用存储空间。类是用于创建对象的蓝图，它是一个定义包括在特定类型的对象中的方法和变量的软件模板。

	类和对象好比图纸和实物的关系，模具和铸件的关系。

	比如人类就是一个概念，人类具有身高，体重等属性。人类可以做吃饭、说话等方法。

	小明就是一个具体的人，也就是实例，他的属性是具体的身高200cm，体重180kg，他做的方法是具体的吃了一碗白米饭，说了“12345”这样一句话。

	面向过程和面向对象的区别

	两者都是软件开发思想，先有面向过程，后有面向对象。在大型项目中，针对面向过程的不足推出了面向对象开发思想。

	比喻

	蒋介石和Mao泽东分别是面向过程和面向对象的杰出代表，这样充分说明，在解决复制问题时，面向对象有更大的优越性。

	面向过程是蛋炒饭，面向对象是盖浇饭。盖浇饭的好处就是“菜”“饭”分离，从而提高了制作盖浇饭的灵活性。饭不满意就换饭，菜不满意换菜。用软件工程的专业术语就是“可维护性”比较好，“饭” 和“菜”的耦合度比较低。

	区别

编程思路不同：面向过程以实现功能的函数开发为主，而面向对象要首先抽象出类、属性及其方法，然后通过实例化类、执行方法来完成功能。
封装性：都具有封装性，但是面向过程是封装的是功能，而面向对象封装的是数据和功能。
面向对象具有继承性和多态性，而面向过程没有继承性和多态性，所以面向对象优势是明显。

	方法重载和方法重写（覆盖）的区别

	英文	位置不同	作用不同
重载	overload	同一个类中	在一个类里面为一种行为提供多种实现方式并提高可读性
重写	override	子类和父类间	父类方法无法满足子类的要求，子类通过方法重写满足要求

	修饰符	返回值	方法名	参数	抛出异常
重载	无关	无关	相同	不同	无关
重写	大于等于	小于等于	相同	相同	小于等于

	this和super关键字的作用

	this是对象内部指代自身的引用

this可以调用成员变量，通常用于解决成员变量和局部变量同名冲突
this可以调用成员方法
this可以在构造方法中调用重载的构造方法，且必须是构造方法的第一条语句。

	super代表对当前对象的直接父类对象的引用

super可以调用直接父类的成员变量（注意权限修饰符的影响，比如不能访问private成员）
super可以调用直接父类的成员方法（注意权限修饰符的影响，比如不能访问private成员）
super可以调用直接父类的构造方法，只限构造方法中使用，且必须是第一条语句。

	static关键字的作用（修饰变量、方法、代码块）

	static可以修饰变量、方法、代码块和内部类

static属性属于这个类所有，即由该类创建的所有对象共享同一个static属性。可以对象创建后通过对象名.属性名和类名.属性名两种方式来访问。也可以在没有创建任何对象之前通过类名.属性名的方式来访问。

	.static变量和非static变量的区别(都是成员变量，不是局部变量)

	1.在内存中份数不同

	不管有多少个对象，static变量只有1份。对于每个对象，实例变量都会有单独的一份

	static变量是属于整个类的，也称为类变量。而非静态变量是属于对象的，也称为实例变量

	2.在内存中存放的位置不同

	静态变量存在方法区中， 实例变量存在堆内存中 * 

	3.访问的方式不同

	实例变量： 对象名.变量名 stu1.name="小明明";

	静态变量：对象名.变量名 stu1.schoolName="西二旗小学"; 不推荐如此使用

	类名.变量名 Student.schoolName="东三旗小学"; 推荐使用

	4.在内存中分配空间的时间不同

	实例变量：创建对象的时候才分配了空间。静态变量：第一次使用类的时候 

	Student.schoolName="东三旗小学";或者Student stu1 = new Student("小明","男",20,98);

static方法也可以通过对象名.方法名和类名.方法名两种方式来访问
static代码块。当类被第一次使用时（可能是调用static属性和方法，或者创建其对象）执行静态代码块，且只被执行一次，主要作用是实现static属性的初始化。
static内部类：属于整个外部类，而不是属于外部类的每个对象。不能访问外部类的非静态成员（变量或者方法），.可以访问外部类的静态成员

	final和abstract关键字的作用

	final和abstract是功能相反的两个关键字，可以对比记忆

abstract可以用来修饰类和方法，不能用来修饰属性和构造方法；使用abstract修饰的类是抽象类，需要被继承，使用abstract修饰的方法是抽象方法，需要子类被重写。
final可以用来修饰类、方法和属性，不能修饰构造方法。使用final修饰的类不能被继承，使用final修饰的方法不能被重写，使用final修饰的变量的值不能被修改，所以就成了常量。
特别注意：final修饰基本类型变量，其值不能改变。但是final修饰引用类型变量，栈内存中的引用不能改变，但是所指向的堆内存中的对象的属性值仍旧可以改变。例如

	class Test {

	public static void main(String[] args) {

	final Dog dog = new Dog("欧欧");

	dog.name = "美美";//正确

	dog = new Dog("亚亚");//错误

}

}

	final、finally、finalize的区别

final修饰符（关键字）如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改。被声明为final的方法也同样只能使用，不能重载。
finally在异常处理时提供 finally 块来执行任何清除操作。如果有finally的话，则不管是否发生异常，finally语句都会被执行。
finalize方法名。Java 技术允许使用 finalize() 方法在垃圾收集器将对象从内存中清除出去之前做必要清理工作。finalize() 方法是在垃圾收集器删除对象之前被调用的。它是在 Object 类中定义的，因此所有的类都继承了它。子类覆盖 finalize() 方法以整理系统资源或者执行其他清理工作。

	写出java.lang.Object类的六个常用方法

public boolean equals(java.lang.Object) 比较内容
public native int hashCode() 哈希码
public java.lang.String toString() 变成字符串
public final native java.lang.Class getClass() 获取类结构信息

protected void finalize() throws java.lang.Throwable 垃圾回收前执行的方法
protected native Object clone() throws java.lang.CloneNotSupportedException 克隆

public final void wait() throws java.lang.InterruptedException 多线程中等待功能
public final native void notify() 多线程中唤醒功能
public final native void notifyAll() 多线程中唤醒所有等待线程的功能

	private/默认/protected/public权限修饰符的区别

访问控制	public	protected	默认	private
同一类中成员	是	是	是	是
同一包中其它类	是	是	是
不同包中的子类	是	是
不同包中对非子类	是

	类的访问权限只有两种

	public 公共的 可被同一项目中所有的类访问。 (必须与文件名同名)

	default 默认的 可被同一个包中的类访问。

	成员（成员变量或成员方法）访问权限共有四种：

	public 公共的 可以被项目中所有的类访问。(项目可见性)

	protected 受保护的 可以被这个类本身访问；同一个包中的所有其他的类访问；被它的子类（同一个包以及不同包中的子类）访问。（子类可见性）

	default 默认的 被这个类本身访问；被同一个包中的类访问。（包可见性）

	private 私有的 只能被这个类本身访问。（类可见性）

栏目列表