Java基础概念小结

1、String str = new String（“hello”）;
答：上面的语句中str放在栈中，用new 创建出来的字符串对象放在堆上，而"hello"这个字面量放在静态存储区

2、Switch是否能作用在byte上，是否能作用在long上，是否能作用在String上？
答：早期的JDK中，Switch（expr）中，expr可以是byte、short、char、int;从1.5，enum;1.7 还可以是String。 长整型（long）是不可以的

3、String是最基本的数据类型吗？
答：不是，Java中基本数据类型只有8个：byte/short/int/long/float/double/char/boolean;除了基本类型和枚举（enum type）,剩下的都是引用类型。

4、Float和float区别？
答：Float是float 基本数据类型的包装类，其中包含了对于float的方法，而float是没有方法的属性。
Float f1 = new Float(128);
float f2 = 128; //f1,f2保存在栈中， 关键字new的对象保存在堆中。

5、数组有没有length()方法？String有没有length()方法？
答： 数组没有length()方法,有length属性。String 有length()方法，而在javaScript中，获得字符串的长度是通过length属性得到的。

6、构造器不能被继承，因此不能被重写，但可以被重载。

7、equals方法和hashCode方法二者规定？
a>如果两个对象相同（equals方法返回true），那么它们的hashCode值一定要相同；
b>如果两个对象的hashCode相同，它们并不一定相同。

8、char型变量中能不能存储一个中文文字？
char类型可以存储一个中文汉字，因为java中使用的编码是Unicode，一个char类型占2个字节。
编码不同，占的字节不同。
ASCII码：一个英文字母（不分大小写）占一个字节的空间，一个中文汉字占两个字节的空间
UTF-8编码：一个英文等于两个字节，一个 中文等于两个字节 ，中文标点占两个字节，英文标点占两个字节
Unicode编码：一个英文等于两个字节，一个中文等于两个字节，中文标点占两个字节，英文标点占两个字节。

9、java中会存在内存泄漏吗？
答： 理论上java因为有垃圾回收机制（GC）不会存在内存泄漏问题；然而在实际开发中，可能会存在无用但可达的对象，这些对象不能被GC回收也会发生内存泄漏。
例子说明：Hibernate的SESSION（一级缓存）中的对象属于持久态，垃圾回收器是不会收这些对象的，然而这些对象中可能存在无用的垃圾对象。

10、静态变量和实例变量的区别？
静态变量是被static修饰符修饰的变量，也称为类变量，它属于类，不属于类的任何一个对象，一个类不管创建多个对象，静态变量在内存中有且仅有以一个拷贝；实例变量必须依存于某一实例，需要先创建对象然后通过对象才能访问到它。静态变量可以实现让多个对象共享内存。

11、GC是什么？为什么要有GC？
答：GC是垃圾收集的意思，内存处理是编程人员容易出现的问题，忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃，java提供的GC功能可以自动检测对象是否超过作用域从而达到自动回收内存的目的，java语言没有提供释放已分配内存的显示操作方法。Java程序员不用担心内存管理，因为垃圾收集器会自动进行管理要请求垃圾收集，可以调用下面的方法之一：System.gc()或Runtime.getRuntime().gc(),但JVM可以屏蔽显示垃圾回收调用。
垃圾回收可以有效的防止内存泄漏，有效的使用可以使用的内存。垃圾回收器通常是作为一个单独的低优先级的线程运行，不可预知的情况下对内存堆中已经死亡的或者长时间没有使用的对象进行清除和回收，程序员不能实时的调用垃圾回收器对某个对象或所有对象进行垃圾回收。

12、一个".java"源文件中是否可以包含多个类（不是内部类）？有什么限制？
答：可以，但是一个源文件中最多只能有一个公开类（public class）而且文件名必须和公开的类名完全保持一致。

13、Java中的final关键字有哪些用法？
答：（1）修饰类：表示该类不能被继承；
（2）修饰方法：表示方法不能被重写；
（3）修饰变量：表示变量只能一次赋值以后值 不能被修改（常量）。

14、获得下面代码的执行结果

class A{
 
    static{
        System.out.print("1");
    }
    public A(){
        System.out.print("2");
    }
}
 
class B extends A{
 
    static{
        System.out.print("a");
    }
 
    public B(){
        System.out.print("b");
    }
}
public class Hello{
 
    public static void main(String[] args){
        A ab = new B();
        ab = new B();
    }
}

答：执行结果：1a2b2b.创建对象是构造器的调用顺序是：先初始化静态成员，然后调用父类构造器，再初始化非静态成员，最后调用自身构造器。

15、如何实现字符串的反转及替换？
代码实现：

public static String reverse(String originStr){
	  			if(originStr == null   ||  orginStr.length() <= 1)
	  					return orginStr;
	  			return reverse(orginStr.subString（1）) + orginStr.charAt(0);
          	}

16、日期和时间
<1> 如何取得年月日、小时分钟秒？
创建java.util.Calendar实例，调用其get()方法传入不同的参数即可获得参数所对应的值。
<2>如何获得系统的毫秒值？

Calendar.getInstance().getTimeInMillis();
System.currentTimeMillis();

	<3>如何获取某月的最后一天？

Calender time = Calendar.getInstance();
time.getActualMaximum(Calendar.DAY_OF_MONTH);

	<4>如何格式化日期？
	   利用java.text.DataFormat的子类（如SimpleDateFormat类）中的format（Date）方法可将日期格式化。

17、打印昨天的当前时刻：

public class YesterdayCurrent {
    public static void main(String[] args){
        Calendar cal = Calendar.getInstance();
        cal.add(Calendar.DATE, -1);
        System.out.println(cal.getTime());
    }
}

在使用Java8新特性的代码实现：

import java.time.LocalDateTime; 
class YesterdayCurrent { 
	public static void main(String[] args) {
	 LocalDateTime today = LocalDateTime.now();
	  LocalDateTime yesterday = today.minusDays(1); 
	  System.out.println(yesterday);
	} 
}

18、如何实现对象克隆？
答：有两种方式：
1、实现Cloneable接口并重写Object类的clone方法。
2、实现Serializable接口，通过对象的序列化和反序列化实现克隆，可以实现真正的深度克隆。
代码如下。

package com.lovo;
 
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
 
public class MyUtil {
 
	private MyUtil() {
		throw new AssertionError();
	}
 
	public static <T> T clone(T obj) throws Exception {
		ByteArrayOutputStream bout = new ByteArrayOutputStream();
		ObjectOutputStream oos = new ObjectOutputStream(bout);
		oos.writeObject(obj);
 
		ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
		ObjectInputStream ois = new ObjectInputStream(bin);
		return (T) ois.readObject();
		
		// 说明：调用ByteArrayInputStream或ByteArrayOutputStream对象的close方法没有任何意义
		// 这两个基于内存的流只要垃圾回收器清理对象就能够释放资源
	}
}

测试代码：

package com.lovo;
 
import java.io.Serializable;
 
/**
 * 人类
 * @author 骆昊
 *
 */
class Person implements Serializable {
	private static final long serialVersionUID = -9102017020286042305L;
 
	private String name;	// 姓名
	private int age;		// 年龄
	private Car car;		// 座驾
 
	public Person(String name, int age, Car car) {
		this.name = name;
		this.age = age;
		this.car = car;
	}
 
	public String getName() {
		return name;
	}
 
	public void setName(String name) {
		this.name = name;
	}
 
	public int getAge() {
		return age;
	}
 
	public void setAge(int age) {
		this.age = age;
	}
 
	public Car getCar() {
		return car;
	}
 
	public void setCar(Car car) {
		this.car = car;
	}
 
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + ", car=" + car + "]";
	}
 
}
 
/**
 * 小汽车类
 * @author 骆昊
 *
 */
class Car implements Serializable {
	private static final long serialVersionUID = -5713945027627603702L;
 
	private String brand;		// 品牌
	private int maxSpeed;		// 最高时速
 
	public Car(String brand, int maxSpeed) {
		this.brand = brand;
		this.maxSpeed = maxSpeed;
	}
 
	public String getBrand() {
		return brand;
	}
 
	public void setBrand(String brand) {
		this.brand = brand;
	}
 
	public int getMaxSpeed() {
		return maxSpeed;
	}
 
	public void setMaxSpeed(int maxSpeed) {
		this.maxSpeed = maxSpeed;
	}
 
	@Override
	public String toString() {
		return "Car [brand=" + brand + ", maxSpeed=" + maxSpeed + "]";
	}
 
}
 
class CloneTest {
 
	public static void main(String[] args) {
		try {
			Person p1 = new Person("Hao LUO", 33, new Car("Benz", 300));
			Person p2 = MyUtil.clone(p1);	// 深度克隆
			p2.getCar().setBrand("BYD");
			// 修改克隆的Person对象p2关联的汽车对象的品牌属性
			// 原来的Person对象p1关联的汽车不会受到任何影响
			// 因为在克隆Person对象时其关联的汽车对象也被克隆了
			System.out.println(p1);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

注意点：
基于序列化和反序列化实现的克隆不仅仅是深度克隆，更重要的是通过泛型限定，可以检查出要克隆的对象是否支持序列化，这项检查是在编译完成的，不是的话在运行时抛出异常，这种方案明显是优于使用Object类的clone方法克隆对象。

19、Error和Exception二者区别？
答：Error表示系统级的错误和程序不必处理的异常；比如内存溢出，不可能指望程序能处理这样的情况；
Exception表示需要捕捉或者需要程序进行处理的异常；换句话说，表示如果程序运行正常，从不会反生的情况。

20、try{}里面有一个return语句，那么紧跟在这个try后的finally{}里面的代码会不会执行，什么时候执行，在return前还是后？
答：会执行，在方法返回调用者前执行。
注意：
在finally中改变返回值的做法是不好的，因为如果存在finally代码块，try中的return语句不会立马返回给调用者，而是记录下返回值，等到finally代码块执行完毕之后再向调用者返回其值，然后如果在finally中修改了返回值，就返回修改后的值。显然，在finally中返回或者修改返回值会对程序造成很大的困扰，Java中也可以通过提升编译器的语法检查级别来产生警告或错误，Eclipse中可以在如图所示的地方进行设置，强烈建议将此项设置为编译错误。

21、super和this的区别？
调用super()必须写在子类构造方法的第一行，否则编译不通过，每个子类构造方法的第一条语句，都是隐含的调用super，如果父类没有这种形式的构造函数，那么在编译时就会报错。
区别：
1、super从子类中调用父类的构造方方法，this在同一类内调用其他方法。
2、super和this均需放在构造方法内的第一行。
3、尽管可以用this调用一个构造器，但却不能调用两个、
4、this和super不能同时出现在一个构造函数里面。
因为this必然会调用其他的构造函数，其它的构造函数必然也会有super语句的存在，所以在同一个构造函数里面有相同的语句，就失去意义了，编译器也不会通过。
5、this和super都指的是对象，所以，均不可以在static环境中使用。包括static变量，static方法，static语句块。
6、super就是一个指向父类对象的引用，this就是指向当前对象的引用。