Java基础整理，常见面试题总结

此篇介绍Java基础

1、Java的8大基本数据类型和对应包装类（涉及到自动装箱和拆箱）、字符串String

	1）、整数类数值类型
		byte：对应包装类Byte，1字节8位数，默认值0，取值范围-128~127
		short：对应包装类Short，2字节16位数，默认值0，取值范围-32768~32767（-2^15~2^15-1）
		int：对应包装类Integer，4字节32位数，默认值0，取值范围-2^31~2^31-1
		long：对应包装类Long，8字节64位数，默认值0l(L)，取值范围-2^63~2^63-1
	2）、浮点类数值类型
		float：对应包装类Float，4字节32位数，默认值0f(F)，取值范围-1.4E-45 ~ 3.4028235E38
		double：对应包装类Double，8字节64位数，默认值0d(D)，取值范围4.9E-324 ~ 1.7976931348623157E308
		注：直接使用浮点类型计算数据会出现精度错误，一般使用BigDecimal来解决浮点类精度丢失问题
	3）、布尔类型
		Boolean：对应包装类Boolean，1位数，默认值false，取值范围false、true
	4）、字符型
		char：对应包装类Character，2字节16位数，默认值'u0000'，取值范围0~65535
	5）、字符串类型String(注意：不属于8大基本类型数据，后面也会介绍String、			StringBuilder、StringBuffer区别)
		这里需要注意和char类型的区别，char类型代表字符型、使用单引号''，String类型代表字符串、使用双引号""
		例如：char char = 'A';        String str = "ABC";
	6）、自动装箱和拆箱(举例为证)
		自动装箱(基本数据类型使用对应包装类包装起来)：Integer index1 = 20;
		自动拆箱(包装类型转换成基本数据类型)：int index2 = index1;
		
注：像long、float、double类型数据需要加后缀，不然将作为整数类型解析或者无法编译

2、Java语法要求、注释

	1）、语法要求：标识符由字母、数字、下划线_、$组成，数字不能作为标识符的开头，且标识符不能是关键字和保留字
		1-1）、类名、接口名：首字母大写(大驼峰命名)，例如：AaaBbbCcc
		1-2）、变量名、方法名：首字母小写(小驼峰命名)，例如：aaaBbbCcc
		1-3）、包名：所有字母都是小写，例如：aaabbbccc
		1-4）、常量：所有字母都是大写、多个用_连接，例如：AAA_BBB_CCC
	2）、注释：
		2-1）、单行注释：//，例如//Hello World!!!；用于解释方法内某行代码使用
		2-2）、多行注释：/*    */，例如/*Hello World!!!*/；用于解释一段代码使用
		2-3）、文档注释：/**    */，例如/**    *Hello World!!!        */；用于进行文档注释，生成开发文档

3、JAVA中jdk、jre、jvm之间的关系（具体如图）

	Java代码是先编译、在解释、后运行的（.java->编译成.class->解释器解释成机器可理解代码，后运行）
	jdk包含jre、jre包含jvm
		1）、jvm：Java虚拟机
		2）、jre：Java运行时环境，包含jvm和Java基础类库
		3）、jdk：Java开发工具包，包含jre、编译java源码的编译器javac等，例如：javadoc(帮助文档)、javap(反编译工具)、jdb(调试器)等

4、成员变量和局部变量、重写和重载

	1）、成员变量和局部变量
		成员变量：属于类的，在堆中，随类创建而存在，有默认值(注：final修饰的成员变量必须赋值，且不可更改，一般都直接使用final static 变量名 = XXX;)
		局部变量：属于方法、代码块的，在栈中，随着方法调用自动生成、随着方法调用结束消亡

public class Test {
    //成员变量
    private String name;
    private int number;
    private static final int ZERO = 0;

    //提供的构造方法，无参构造和有参构造
    public Test() { }
    public Test(String name, int number) { this.name = name;this.number = number; }

    //在栈中分配的局部变量
    public void method() {
        int index = 10;
        String str = "Hello World!!!";
        System.out.println(index);
        System.out.println(str);
    }

    //提供set和get方法，私有变量，外部类可通过访问get方法得到变量，set方法设置值
    public void setName(String name) { this.name = name; }
    public void setNumber(int number) { this.number = number; }

    public String getName() { return name; }
    public int getNumber() { return number; }
}

	2）、重写(Override)和重载(Overload)
		重写：子类付父类的重写，方法名、参数必须相同，返回值可以不同，返回值类型<=父类、抛错范围<=父类、修饰符>=父类；构造方法无法被重写，例如父类经过private、final、static等修饰的子类不能重写，但static修饰的方法可以再次声明
		重载：同一类中，方法名相同、参数类型不同、个数不同、顺序不同，返回值和修饰符可以不同

class Animal {
    public void eat() { System.out.println("在吃饭！！！"); }
    long drink() { System.out.println("喝了10杯水");return 10L; }
}
class Dog extends Animal {
    @Override
    public void eat() { System.out.println("狗狗要吃狗粮！！！"); }

    @Override
    public long drink() { return super.drink(); }
}
class Cat extends Animal {
    @Override
    public void eat() { System.out.println("猫猫要吃猫粮！！！"); }

    public void play(int age) { System.out.println("我的年龄是：" + age); }
    public String play(int age, String name) { return  "我的名字是：" + name + "，我的年龄是：" + age; }
}

5、equals和的区别==的区别

	equals()一般是比较值是否相等，==比较内存地址和比较数值类型数据是否相等
	注：hashCode()相等，equals()不一定相等；equals()相等，hashCode()一定相等

String s1 = "abc";
String s2 = "abc";
String s3 = new String("abc");
System.out.println(s1.equals(s2));//true
System.out.println(s1.equals(s3));//true
System.out.println(s1 == s2);//true
System.out.println(s1 == s3);//false

6、Java的三大特性（封装、继承、多态）、接口和抽象类区别

	1）、Java的三大特性
		1-1）、封装：提供setter和getter方法，上述代码块有写
		1-2）、继承：extends
			1-2-1）、子类拥有父类所有的方法(包含私有属性和方法，但是无法访问，只是拥有)和属性
			1-2-2）、子类可以对父类进行扩展，能拥有自己的方法和变量等
		1-3）、多态：一个事物的多种形态，例如：水可以是液体水、也可以是冰等，具体表现是父类引用指向子类的实例

	2）、接口(interface)和抽象类(abstract修饰的类)的区别
		2-1）、相同点：都不能直接被实例化-》需要通过实现(implements)接口和继承(extends)抽象类实现后创建实例对象；都可以包含抽象方法，抽象方法没有方法体必须在子类或实现类中实现方法；
		2-2）、不同点：
			接口：接口中的抽象方法默认是public（默认public static final修饰），jdk1.8之后可以定义default和static方法；可以多实现
			抽象类：抽象类可以包含抽象方法和非抽象方法(抽象类中抽象方法不是必须要有的)；可以有构造方法(此构造需在子类中实现，即向上转型)、成员变量等；只能被单继承
		注：抽象类不能final、private、static共存，抽象类需要被继承不能用final修饰、不能被private修饰只能	用public和protected，抽象类中外部抽象类不可以用static修饰，但是内部抽象类可以使用static修饰

interface Q {
    public void test();
    default void eat() { System.out.println("在接口中吃饭饭！！！");}
    static void sleeping() { System.out.println("在接口中睡觉觉！！！"); }
}

abstract class A {
    public abstract void play();
    //static修饰的内部类属于外部类
    static abstract class B {
        public abstract void eat();
    }
    public void sleeping() { System.out.println("睡觉觉！！！"); }
}

class C extends A implements Q {
    @Override
    public void play() { System.out.println("打豆豆!!!"); }
    @Override
    public void sleeping() { super.sleeping(); }
    @Override
    public void test() { System.out.println("在做一个吃饭饭、打豆豆、睡觉觉的事情！！！"); }
}

class D extends A.B {
    @Override
    public void eat() { System.out.println("在B类中吃饭饭！！！"); }
}

7、String和StringBuilder与StringBuffer区别、final和finally与finalize区别

	1）、String和StringBuilder与StringBuffer区别
		1-1）、String：不可变长度，内部经过final修饰，其实算是常量，线程安全
				举个例子：String str = new String("abc")会创建几个字符串对象-》1个或2个，字符串常量池中如果已存在abc的引用，则在堆中就创建一个abc的字符串对象，创建的对象地址指向字符串常量池中的abc
		1-2）、StringBuilder：可变长度，线程不安全，使用append()方法进行拼接加长度
		1-3）、StringBuffer：可变长度，线程安全(方法经过synchronized修饰)，使用append()方法进行拼接加长度

	2）、final和finally与finalize区别
		2-1）、final：可修饰类、变量、方法，表示类不可被继承、变量不可被修改、方法不可被重载
		2-2）、finally：常与try-catch-finally一起被使用，如果在try-catch中被使用了-》总是要被执行的
		
衍生：try-catch-finally(也涉及到了return使用，一般不建议在finally中或者try-catch-finally中使用return)

try {
    System.out.println("我是try啊！！！");
    return 0;
} catch (Exception e) {
    System.out.println("我是catch啊！！！");
    return 1;
} finally {
    System.out.println("我是finally啊！！！");
    return 2;
}
以上输出结果为：
    我是try啊！！！
    我是finally啊！！！
    2
    
//有一种特殊情况finally不会被执行   
try {
    System.out.println("我是try啊！！！");
    return 0;
} catch (Exception e) {
    //程序报错执行到catch中
    System.out.println("我是catch啊！！！");
    //此下声明，终止程序
    System.exit(1);
} finally {
    System.out.println("我是finally啊！！！");
    return 2;
}

	3）、finalize：Object中方法，垃圾回收机制时调用该方法，将对象从内存中清除前调用

8、Throwable(包含Exception和Error)、浅拷贝和深拷贝、双亲委派机制

	1）、Throwable（java.lang包下面的，包含2个子类）
		1-1）、Exception：程序本身可以处理的异常，可通过try-catch捕获错误，可以分为Checked Exception(受检查异常，必须处理)和Unchecked Exception(不受检查异常，可以不处理)。涉及到try-catch上述代码有说！
		1-2）、Error：程序无法处理的错误，不能通过try-catch捕获，错误发生时候，一般会选择终止程序
	2）、浅拷贝和深拷贝(实现Cloneable接口，重写clone()方法)
		2-1）、浅拷贝：创建一个新的对象，然后复制内存地址指向值

class Animal implements Cloneable {
    private String name;

    public void setName(String name) { this.name = name; }
    public String getName() { return name; }
    public Animal() { }
    public Animal(String name) { this.name = name; }

    @Override
    protected Animal clone() throws CloneNotSupportedException {
        return (Animal) super.clone();
    }
}

class Dog implements Cloneable {
    private Animal animal;

    public Animal getAnimal() { return animal; }
    public void setAnimal(Animal animal) { this.animal = animal; }
    public Dog() { }
    public Dog(Animal animal) { this.animal = animal; }

    @Override
    protected Dog clone() throws CloneNotSupportedException {
        Dog dog = (Dog) super.clone();
        return dog;
    }
}

//具体实现如下
Animal animal = new Animal(new Dog("旺财"));
Animal animalCopy = animal.clone();
System.out.println(animal.getAddress() == animalCopy.getAddress()); //true，复制内存地址(等于算是公用一个内存地址))

		2-2）、深拷贝：完全复制整个对象，包括对象所包含的内部对象

class Animal implements Cloneable {
    private String name;

    public void setName(String name) { this.name = name; }
    public String getName() { return name; }
    public Animal() { }
    public Animal(String name) { this.name = name; }

    @Override
    protected Animal clone() throws CloneNotSupportedException {
        return (Animal) super.clone();
    }
}

class Dog implements Cloneable {
    private Animal animal;

    public Animal getAnimal() { return animal; }
    public void setAnimal(Animal animal) { this.animal = animal; }
    public Dog() { }
    public Dog(Animal animal) { this.animal = animal; }

    @Override
    protected Dog clone() throws CloneNotSupportedException {
        Dog dog = (Dog) super.clone();
        dog.setAnimal(dog.getAnimal().clone());
        return dog;
    }
}

Animal animal = new Animal(new Dog("旺财"));
Animal animalCopy = animal.clone();
System.out.println(animal.getAddress() == animalCopy.getAddress()); //false

	3）、Java加载类时采用双亲委派机制，将请求交给父类处理的一种任务委派机制
		收到类加载请求时，不会先行加载，会将请求委托给父类加载器执行，如果父类还有父类继续向上委托直到启动类加载器(Bootstrap ClassLoader)，如果父类加载成功就返回结果，反之由子类自行尝试加载，失败则抛错

9、continue、break、return三者区别（具体以代码进行讲解）

	continue：接触本次循环，进行下一个循环
	break：结束循环，跳出
	return：结束方法或者返回某值

int index = 5;
Boolean flag = false;
for (int i = 0; i < index; i++) {
    if (i == 0) {
        System.out.println("1111111111");
    } else if (i == 1) {
        System.out.println("2222222222");
        continue;
    } else if (i == 3) {
        System.out.println("3333333333");
        flag = true;
        break;
    } else if (i == 4) {
        System.out.println("4444444444");
        return;
    } else if (i == 5) {
        System.out.println("5555555555");
    }
    System.out.println("!!!!!!!!!!!!!!!!!!");
}
if (flag) {
    System.out.println("break终止了循环！！！");
}

输出结果：
    1111111111
    !!!!!!!!!!!!!!!!!!
    2222222222
    !!!!!!!!!!!!!!!!!!
    3333333333
    break终止了循环！！！

10、this和super、访问符（public、protected、default、private）

	1）、this和super
		super()：访问父类的无参构造---this()：访问本类的无参构造
		super(参数)：访问父类的有参够着---this(参数)：访问本类的有参构造
		super.方法名：访问父类中的方法---this.方法名：访问本类中的方法
		super.属性：访问父类中的属性---this.属性：访问本类中的属性
		注：this和super使用在构造方法中时，要求放在首行中


	2）、访问符（public、protected、default、private）
		访问权限修饰符：private《- default《-protected《-public
		private：私有的，仅在本类中
		default（默认的）：注意，啥修饰符都不写，就是默认的。本类，同包下可以访问
		protected：受保护的，本类、同包、不同包（子类使用）
		public：没有限制的
		使用原则：
			1）、修饰类：只能是public和default
			2）、修饰成员：变量和方法，四个修饰符都可以
			3）、局部变量：不能使用这些修饰符
	本类同包非同包子类其他private允许否否否default允许允许否否protected允许允许允许否public允许允许允许允许