JAVA面试总结

时间  2019-12-18 标签 java 面试 总结

**0、关于JAVA java

  1. ——封装

封装性就是把类（对象）的属性和行为结合成一个独立的相同单位，并尽量隐蔽类（对象）的内部细节，对外造成一个边界，只保留有限的对外接口使之与外部发生联系。封装的特性使得类（对象）之外的部分不能随意存取类（对象）的内部数据（属性），保证了程序和数据不受外部干扰且不被误用。算法

l  经过访问修饰符来限制对类的属性和方法的访问，各修饰符含义以下：设计模式

**Private：**成员变量和方法只能在类内被访问，具备类可见性 默认： 成员变量和方法只能被同一个包里的类访问，具备包可见性。 Protected：能够被同一个包中的类访问，被同一个项目中不一样包中的子类访问 **Public：**能够被同一个项目中全部的类访问，具备项目可见性，这是最大的访问权 限.数组

  1. ——继承

1)、继承是面向对象的三大特征之一，也是实现代码复用的重要手段。Java的继承具备单继承的特色，即只能继承自一个父类，每一个子类只有一个直接父类，可是其父类又能够继承于另外一个类，从而实现了子类能够间接继承多个父类，但其本质上划分仍然是一个父类和子类的关系。安全

2)、Java的继承经过extends关键字来实现，实现继承的类被称为子类，被继承的类称为父类(有的也称其为基类、超类)，父类和子类的关系，是一种通常和特殊的关系。就像是水果和苹果的关系，苹果继承了水果，苹果是水果的子类，水果是苹果的父类，则苹果是一种特殊的水果。 值得指出的是：Java的子类不能得到父类的构造器。多线程

注:异步

子类能够继承父类的全部特性，但其可见性，由父类成员变量、方法的修饰符决定。对于被private修饰的类成员变量或方法，其子类是不可见的，也即不可访问；对于定义为默认访问（没有修饰符修饰）的类成员变量或方法，只有与父类同处于一个包中的子类能够访问；对于定义为public或protected 的类成员变量或方法，全部子类均可以访问。ide

子类中能够声明与父类同名的成员变量，这时父类的成员变量就被隐藏起来了，在子类中直接访问到的是子类中定义的成员变量。 子类中也能够声明与父类相同的成员方法，包括返回值类型、方法名、形式参数都应保持一致，称为方法的覆盖。 若是在子类中须要访问父类中定义的同名成员变量或方法，须要用的关键字super。Java中经过super来实现对被隐藏或被覆盖的父类成员的访问。函数

super 的使用有三种状况：ui

l  访问父类被隐藏的成员变量和成员方法: super.成员变量名;

l  调用父类中被覆盖的方法，如：super.成员方法名([参数列]);

l  调用父类的构造函数，如：super([参数列表]); super( ):只能在子类的构造函数中出现，而且永远都是位于子类构造函数中的第 一条语句。

3.——多态

多态性是指在继承关系中的父类中定义的属性或方法被子类继承以后，能够具备不一样的数据类型或表现出不一样的行为。这使得同一个属性或方法在父类及其各子类类中具备不一样的含义。

Java引用变量有两个类型：一个是编译时类型，一个是运行时类型。编译时的类型由声明该变量时使用的类型决定，运行时的类型由实际赋给该变量的对象决定。若是编译时类型和运行时类型不一致，就会出现所谓的多态（Polymorphism）

在Java中，多态指如下语法现象：

▲重载（Overload）——方法容许重名

▲覆写(Override)——容许子类重写父类的方法

▲泛型

二、给数组排序的方法：

public class sort{
public static void main(String args[]){
int data[] = new int[]{1,2,8,6,4,9,3,7,5};
sort(data);
print(data);
}
//专门给数组排序的方法
public static void sort(int arr[]){
for(int x = 0; x < arr.length; x ++){
	for(int y = 0; y < arr.length - 1; y ++){
		if(arr[ y ] > arr[ y + 1]){
			int t = arr[ y ];
			arr[ y ] = arr[ y +1 ];
			arr[ y + 1 ] = t;	
		}
	}
}
}
public static void print(int temp[]){
	for(int x = 0;x < temp.length; x++){
		System.out.print( temp[ x ]+"、");
	}
	System.out.println();
}

} 三、比较&、&&和|、||的区别：

当&与&&同为逻辑运算符时，它们都用于链接两个Boolean类型的表达式，当&和&&的两端表达式同时为真时，表达式的结果为真，只要有一端为假，那么表达式结果为假。

逻辑运算符&与&&的区别是：

& 不管左边结果是什么，右边仍是继续运算；
   &&当左边为假，右边再也不进行运算。

当|和||的两端表达式同时为假时，表达式的结果为假，只要有一端为真，那么表达式结果为真。

逻辑运算符|与||的区别：

| -- 不管左边结果是什么，右边仍是继续运算；
  ||-- 当左边为真，右边再也不进行运算。

四、利用算法在一个数组里完成转置操做：

public class reverse{
public static void main(String args[]){
	int data[] = new int[]{1,2,3,4,5,6,7,8,9};
	reverse(data);
	print(data);
}
//专门给数组转置操做的方法
public static void reverse(int arr[]){
	int center = arr.length / 2;  //转置的次数
	int head = 0;                      //头部索引
	int tail = arr.length - 1;       //尾部索引
	for(int x = 0; x < center; x ++){
		int temp = arr[head];
		arr[head]=arr[tail];
		arr[tail] = temp;
		head++;
		Tail --;	
	}
}
public static void print(int temp[]){
	for(int x = 0;x < temp.length; x++){
		System.out.print( temp[ x ]+"、");
	}
	System.out.println();
}
}

五、请解释String类对象两种实例化方式的区别：

**直接赋值（String str = “字符串”;）：**只会开辟一块堆内存空间，而且会自动保存在对象池之中，以便下次重复使用；

**构造方法（String str = new String(“字符串”);）：**会开辟两块堆内存空间，其中有一块空间会成为垃圾，而且不会自动入池，可是用户可使用intern()方法手工入池。

六、实现首字母大写其他字母小写的方法

public static String initcap(String str){
	return 	str.substring(0,1).toUpperCase()+str.substring(1).toLowerCase();
}

七、请解释重载与覆写的区别？（请解释Overloading与Overrid的区别?）、在使用Overloading的时候方法的返回值可否不一样？

八、请编写一个Factory程序(工厂设计模式) --见课程第96课时

九、请编写一个Proxy程序(代理设计模式)

// 	接口的应用-代理模式（Proxy）
	中心思想：一个对象只关注本身想作的事情，其它事情交给别人去作，也就是说找了个代理去作。
interface Subject {
public void make() ;
}
class RealSubject implements Subject {
public void make() {
	System.out.println("核心主题正在操做!") ;
}
}
class ProxySubject implements Subject {
private Subject subject ;
public ProxySubject(Subject subject) {
	this.subject = subject ;
}
public void prepare() {
	System.out.println("核心主题操做前的准备工做！") ;
}
public void make() {
	this.prepare() ;
	this.subject.make() ;
	this.destory() ;
}
public void destory() {
	System.out.println("核心主题操做后的收尾工做！") ;
}
}
public class TestProxy {
public static void main(String args[]) {
	Subject sub = new ProxySubject(new RealSubject()) ;
	sub.make() ;
}
}

十、抽象类与接口的区别

总结：

抽象类比接口功能要多，只有一点，接口不受单继承局限，因此在抽象类和接口所有可使用时，咱们会优先考虑使用接口

参考：

1.在进行公共操做时必需要定义出接口

2.有了接口必须使用子类完善方法 3.若是是你本身所定义的接口，绝对不可使用关键字new去建立接口的子类实例化对象，必须使用工厂类去构建这个实例化对象。

掌握的知识点：

1).抽象类和接口的定义区别

2).接口做为标准用于解耦合以及不一样层之间的链接桥梁

3).必定要将工厂模式和代理模式的结构记下来。

十一、请解释String、StringBuffer、StringBuilder的区别: String的内容一单生成就不可改变；而StringBuffer、StringBuilder申明的内容能够改变；

StringBuffer类中提供的方法都是同步方法，属于安全的线程操做 StringBuilder类中的方法都属于异步方法，是非线程安全的操做。

十二、Thread与Runnable实现多线程的区别

一、Thread类是Runnable接口的子类，使用Runnable接口实现多线程能够避免单继承的限制

二、Runnable接口实现的多线程能够比Thread类实现的多线程更加清楚的描述数据共享的概念

1三、解释多个线程访问同一资源时，须要考虑到哪些状况？有可能带来哪些问题？

多个资源访问同一资源时必定要处理好同步，可使用同步代码块或者同步方法来解决：

同步代码：synchronized(锁定对象，通常为当前对象){代码}
	同步方法：public synchronized 返回值 方法名称（参数）{代码}

注意:可是过多的使用同步有可能形成死锁问题。

1四、sleep（）与wait（）的区别：

sleep（）是Thread类定义的方法；
wait（）是Object类定义的方法。
sleep（）方法能够设置休眠时间，时间一到自动唤醒；wait（）须要等待notify（）方法进行唤醒。

1五、请解释Runnable与Callable的区别:

Runnable是在JDK1.0提出的多线程实现接口;Callable是在JDK1.5以后提出的
java.lang.Runnable接口之中提供有一个run()方法,而且没有返回值

java.util.concurrent.Callable接口之中提供有call()方法,有返回值

1六、请解释什么叫GC？如何处理？

⑴ GC（Garbage Collector）垃圾收集器，指的是释放无用的内存空间；
⑵ GC会由系统不按期进行自动的回收，或者调用Runtime类中的gc()方法手工回收。

1七、请解释final、finally、finalize的区别？

final：关键字，定义不能被继承的类、不能被覆写的方法、变量；
finally：关键字，是异常处理语句结构的一部分，表示老是执行。
finalize： 由Object类提供的方法（protected void finalize()throws Throwable），指的是对象回收前的收尾方法，即便出现了异常也不会致使程序中断执行。

1八、BigDecimal四舍五入

1九、Class类无构造方法，获取Class类的实例有三种方法

a、 利用对象调用getClass()方法获取该对象的Class实例。
b、 使用Class类的静态方法forName()，用类的名字获取一个Class	 实例：forName()方法定义以下：
 public static Class forName(String name, boolean initialize, 	 ClassLoader loader) throws ClassNotFoundException
c、 运用 .class 的方式来获取Class实例，对于基本数据类型的封装类，还能够采用 .TYPE 来获取相应的基本数据类型的Class实	例。

后续请小伙伴们自行get...

联系我们 沪ICP备2021010478号-7