Java基础80问

1. 说说&和&&的区别

&和&&都可以用作逻辑与的运算符。&&还具有短路的功能，即如果第一个表达式为false，则不再计算第二个表达式；&还可以用作位运算符，当&操作符两边的表达式不是boolean类型时，&表示按位与操作。

2. 在JAVA中如何跳出当前的多重嵌套循环？

让外层的循环条件表达式的结果可以受到里层循环体代码的控制。

3. switch语句能否作用在byte上，能否作用在long上，能否作用在String上?

在switch（expr1）中，expr1只能是一个整数表达式或者枚举常量（更大字体），整数表达式可以是int基本类型或Integer包装类型，由于，byte,short,char都可以隐含转换为int，所以，这些类型以及这些类型的包装类型也是可以的。（long不行，String可以）

4. short s1 = 1; s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错?

由于s1+1运算时会自动提升表达式的类型，所以结果是int型，再赋值给short类型s1时，编译器将报告需要强制转换类型的错误; 由于+= 是java语言规定的运算符，java编译器会对它进行特殊处理，因此可以正确编译。

5. char型变量中能不能存贮一个中文汉字?为什么?

char型变量是用来存储Unicode编码的字符的，unicode编码字符集中包含了汉字，不包含的偏僻汉字就不行。（unicode编码占用两个字节，所以，char类型的变量也是占用两个字节。）

6. 用最有效率的方法算出2乘以8等于几?

2 << 3，将一个数左移n位，就相当于乘以了2的n次方，而位运算cpu直接支持的，效率最高。

7. 请设计一个一百亿的计算器。

一是要对计算机原理的底层细节要清楚，要知道加减法的位运算原理和计算机中的算术运算会发生越界的情况；二是要具备一定的面向对象的设计思想。

1）这个类内部有两个成员变量，一个表示符号，另一个用字节数组表示数值的二进制数；

2）有一个构造方法，把一个包含有多位数值的字符串转换到内部的符号和字节数组中；

3）提供加减乘除的功能；

public class BigInteger{int sign;byte[] val;public Biginteger(String val) {sign = ;val = ;}public BigInteger add(BigInteger other) {}public BigInteger subtract(BigInteger other)  {}public BigInteger multiply(BigInteger other){}public BigInteger divide(BigInteger other){}
}

8. 使用final关键字修饰一个变量时，是引用不能变，还是引用的对象不能变？

指引用变量不能变，引用变量所指向的对象中的内容还是可以改变的。

final StringBuffer a=new StringBuffer("immutable");
// 编译❌
a=new StringBuffer("");
// 编译✅
a.append(" broken!");

final的instant variable没有default value，必须在constructor (构造器)结束之前被赋予一个明确的值。

// ❌
final int i;

9. "=="和equals方法究竟有什么区别？

==操作符专门用来比较两个变量的值是否相等；equals方法是用于比较两个独立对象的内容是否相同。

// 创建两个不同的对象
String a=new String("foo");
String b=new String("foo");
// ❌
a==b;
// ✅
a.equals(b);

如果一个类没有自己定义equals方法，它默认的equals方法（从Object 类继承的）就是使用==操作符，也是在比较两个变量指向的对象是否是同一对象，这时候使用equals和使用==会得到同样的结果。

10. 静态变量和实例变量的区别？

语法定义：静态变量前要加static关键字，而实例变量前则不加。

程序运行时：实例变量必须创建对象后才可以通过这个对象来使用，静态变量则可以直接使用类名来引用（只要程序加载了类的字节码）。

11. 是否可以从一个static方法内部发出对非static方法的调用？

当一个static方法被调用时，可能还没有创建任何实例对象，逻辑无法成立。静态不能调用非静态。

12. Integer与int的区别

int是java提供的8种原始数据类型之一。Java为每个原始类型提供了封装类，Integer是java为int提供的封装类。int的默认值为0，而Integer的默认值为null，即Integer可以区分出未赋值和值为0的区别，int则无法表达出未赋值的情况。Integer提供了多个与整数相关的操作方法，例如，将一个字符串转换成整数，Integer中还定义了表示整数的最大值和最小值的常量。

13. Math.round(11.5)等于多少? Math.round(-11.5)等于多少?

Math类中提供了三个与取整有关的方法：ceil、floor、round。

ceil向上取整，floor向下取整，round四舍五入相当于Math.floor(x+0.5)。

所以，Math.round(11.5)的结果为12，Math.round(-11.5)的结果为-11。

14. 请说出作用域public，private，protected，以及不写时的区别

作用域	当前类	同一package	子孙类	其他package
public	√	√	√	√
protected	√	√	√	×
friendly	√	√	×	×
private	√	×	×	×

4种访问权限，4个访问范围。protected专门给子类用。

局部变量前不能放置任何访问修饰符 。

15. Overload和Override的区别。Overloaded的方法是否可以改变返回值的类型?

重载Overload表示同一个类中可以有多个名称相同的方法，但这些方法的参数列表各不相同（即参数个数或类型不同）。

重写Override表示子类中的方法可以与父类中的某个方法的名称和参数完全相同，通过子类创建的实例对象调用这个方法时，将调用子类中的定义方法，这相当于把父类中定义的那个完全相同的方法给覆盖了。==子类小异常，大访问==。如果父类的方法是private类型，那么，子类则不存在覆盖的限制，相当于子类中增加了一个全新的方法。

几个Overloaded的方法参数列表不一样，它们的返回者类型当然也可以不一样；一样，不行。仅仅是返回类型不同，java就无法确定编程者倒底是想调用哪个方法了。

16. 接口是否可继承接口? 抽象类是否可实现(implements)接口? 抽象类是否可继承具体类(concrete class)? 抽象类中是否可以有静态的main方法？

都可以。

抽象类与普通类的唯一区别就是不能创建实例对象和允许有abstract方法。

17. 写clone()方法时，通常都有一行代码，是什么？

clone 有缺省行为，super.clone();因为首先要把父类中的成员复制到位，然后才是复制自己的成员。

18. 面向对象的特征有哪些方面

计算机软件系统是现实生活中的业务在计算机中的映射，而现实生活中的业务其实就是一个个对象协作的过程。面向对象编程就是按现实业务一样的方式将程序代码按一个个对象进行组织和编写，让计算机系统能够识别和理解用对象方式组织和编写的程序代码。

1）封装：软件开发中保证模块性的基础，实现了“高内聚、低耦合”，防止程序相互依赖的变动影响。在面向对象编程中，封装以对象为单位，将属性和行为封装在类中。私有成员变量只能通过类方法访问，确保了对象的封装。操作相同事物的方法和数据放在同一个类中。

2）继承：在定义和实现一个类的时候，可以在一个已经存在的类的基础之上来进行，把这个已经存在的类所定义的内容作为自己的内容，并可以加入若干新的内容，或修改原来的方法使之更适合特殊的需要。继承是子类自动共享父类数据和方法的机制，这是类之间的一种关系，提高了软件的可重用性和可扩展性。

3）抽象：找出一些事物的相似和共性之处，然后将这些事物归为一个类，避免考虑一些与目标无关的细节。善于划分问题的边界，当前系统需要什么，就只考虑什么。

4）多态：一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。不修改程序代码就可以改变程序运行时所绑定的具体代码，让程序可以选择多个运行状态，增强了软件的灵活性和扩展性。

19. abstract class和interface有什么区别?

含有abstract方法的类必须定义为abstract class，定义抽象方法必须在具体(Concrete)子类中实现，不能有抽象构造方法或抽象静态方法。

接口（interface）可以说成是抽象类的一种特例，接口中的所有方法都必须是抽象的，成员变量类型默认为public static final。

一个类可以实现多个接口，但只能继承一个抽象类。接口更多的是在系统架构设计方法发挥作用，主要用于定义模块之间的通信契约。而抽象类在代码实现方面发挥作用，可以实现代码的重用。（模板方法设计模式：父类方法中间的某段代码不确定，留给子类干。）

20. super.getClass()方法调用

由于getClass()在Object类中定义成了final，子类不能覆盖该方法，所以调用getClass().getName()方法，其实就是在调用从父类继承的getClass()方法，等效于调用super.getClass().getName()方法，super不起作用。

得到父类名：

getClass().getSuperClass().getName();

21. String s = "Hello";s = s + " world!";这两行代码执行后，原始的String对象中的内容到底变了没有？

没有。String被设计成不可变(immutable)类，所以它的所有对象都是不可变对象。原来那个对象还存在于内存之中，只是s这个引用变量不再指向它了。应该考虑使用StringBuffer类，它允许修改，而不是每个不同的字符串都要生成一个新的对象。

对于字符串常量，如果内容相同，Java认为它们代表同一个String对象。而用关键字new调用构造器，总是会创建一个新的对象，无论内容是否相同。

22. String s = new String("xyz");创建了几个String Object? 二者之间有什么区别？

两个或者一个。如果"xyz"这个String对象已经出现在字符串常量缓冲区，就直接从缓冲区拿，只会再创建new String的对象。否则就都要创建。

23. 数组有没有length()这个方法? String有没有length()这个方法？

数组没有length()这个方法，有length的属性。String有有length()这个方法。

24. 下面这条语句一共创建了多少个对象? String s="a"+"b"+"c"+"d";

被编译器在编译时优化后，相当于直接定义了一个”abcd”的字符串，所以，上面的代码应该只创建了一个String对象。

String s = "a" + "b" + "c" + "d";
// true
System.out.println(s == "abcd");

注意：

String s1 = "a";
String s2 = s1 + "b";
String s3 = "a" + "b";
// false
System.out.println(s2 == "ab");
// true
System.out.println(s3 == "ab");

javac编译可以对字符串常量直接相加的表达式进行优化，不必要等到运行期去进行加法运算处理，而是在编译时去掉其中的加号，直接将其编译成一个这些常量相连的结果。

25. 下面含finally的程序代码输出的结果是多少？

public class SmallT {public static void main(String args[]) {SmallT t = new SmallT();int b = t.get();// 2System.out.println(b);}
​public int get() {try {return 1;} finally {return 2;}}
}

try中的return语句调用的函数先于finally中调用的函数执行，return并不是让函数马上返回，而是return语句执行后，将把返回结果放置进函数栈中，此时函数并不是马上返回，它要执行finally语句后才真正开始返回。

public class Test {/*** @param args add by leixiaoshuai 爱笑的架构师*/public static void main(String[] args) {System.out.println(new Test().test());}
​int test() {try {return func1();} finally {return func2();}}
​int func1() {System.out.println("func1");return 1;}
​int func2() {System.out.println("func2");return 2;}
}

-----------执行结果----------------- 
​
func1
​
func2
​
2

所以 finally中的代码比try中的return 和break语句后执行。

26. final, finally, finalize的区别。

final 用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。

finally是异常处理语句结构的一部分，表示总是执行。

finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源回收，例如关闭文件等。JVM不保证此方法总被调用。

27. 运行时异常与一般异常有何异同？

异常表示程序运行过程中可能出现的非正常状态，运行时异常表示虚拟机的通常操作中可能遇到的异常，是一种常见运行错误。java编译器要求方法必须声明抛出可能发生的非运行时异常，但是并不要求必须声明抛出未被捕获的运行时异常。

28. error和exception有什么区别?

error 表示恢复不是不可能但很困难的情况下的一种严重问题。比如说内存溢出。不可能指望程序能处理这样的情况。 exception 表示一种设计或实现问题。也就是说，它表示如果程序运行正常，从不会发生的情况。

29. Java中的异常处理机制的简单原理和应用。

异常是指java程序运行时（非编译）所发生的非正常情况或错误。

Java对异常进行了分类，分为Error和Exception两个子类，它们都继承自java.lang.Throwable。 Error表示严重问题（内存溢出、线程死锁），应用程序无法自我恢复；Exception则表示程序可能能够克服和恢复的问题。 Exception又分为系统异常（NullPointerException、ArrayIndexOutOfBoundsException、ClassCastException）和普通异常（网络断线，硬盘空间不够），系统异常由软件缺陷引起，而普通异常则由运行环境变化导致。 普通异常必须由try..catch处理或throws声明继续抛给上层调用方法处理，因此称为checked异常；而系统异常则可以处理也可以不处理，不需要强制处理，因此称为unchecked异常。

error：虚拟机必须宕机的错误； RuntimeException子类：程序可以死掉也可以不死掉的错误； 普通：程序不应该死掉的错误；

30. java中有几种方法可以实现一个线程？用什么关键字修饰同步方法? stop()和suspend()方法为何不推荐使用？

有两种实现方法，分别是继承Thread类与实现Runnable接口以调用run()方法，用synchronized关键字修饰同步方法。

反对使用stop()，是因为它不安全。它会解除由线程获取的所有锁定，而且如果对象处于一种不连贯状态，那么其他线程能在那种状态下检查和修改它们。 suspend()方法容易发生死锁。调用suspend()的时候，目标线程会停下来，但却仍然持有在这之前获得的锁定。

应在自己的Thread类中置入一个标志，指出线程应该活动还是挂起。若标志指出线程应该挂起，便用wait()命其进入等待状态。若标志指出线程应当恢复，则用一个notify()重新启动线程。

31. sleep() 和 wait() 有什么区别?

sleep方法是Thread类的方法，用于使当前线程暂停执行指定时间，让出CPU给其他线程执行，但监控状态依然保持（synchronized关键字管辖的代码范围），到时间后自动恢复。调用sleep不会释放对象锁，因此其他线程无法获得该对象锁。

wait方法是Object类的方法，调用此方法会使当前线程放弃对象锁，进入等待该对象的等待锁定池。只有其他线程调用了notify方法（或notifyAll）后，本线程才能进入对象锁定池准备获得对象锁并继续运行。

在sleep中，线程主动让出CPU，但不释放锁，其他线程仍无法获得锁。而在wait中，线程暂时放弃锁，让其他等待该锁的线程可以获取锁并运行。需要注意，notify方法并不释放锁，只是告知等待该锁的线程可以竞争获取锁，但不会立即释放锁。

public class MultiThread {public static void main(String[] args) {new Thread(new Thread1()).start();try {Thread.sleep(10);} catch (InterruptedException e) {e.printStackTrace();}new Thread(new Thread2()).start();}
​private static class Thread1 implements Runnable {@Overridepublic void run() {//由于这里的Thread1和下面的Thread2内部run方法要用同一对象作为监视器，我们这里不能用this，因为在Thread2里面的this和这个Thread1的this不是同一个对象。我们用MultiThread.class这个字节码对象，当前虚拟机里引用这个变量时，指向的都是同一个对象。synchronized (MultiThread.class) {System.out.println("enter thread1...");System.out.println("thread1 is waiting");try {//释放锁有两种方式，第一种方式是程序自然离开监视器的范围，也就是离开了synchronized关键字管辖的代码范围，另一种方式就是在synchronized关键字管辖的代码内部调用监视器对象的wait方法。这里，使用wait方法释放锁。MultiThread.class.wait();} catch (InterruptedException e) {e.printStackTrace();}System.out.println("thread1 is going on...");System.out.println("thread1 is being over!");}}}
​private static class Thread2 implements Runnable {@Overridepublic void run() {synchronized (MultiThread.class) {System.out.println("enter thread2...");System.out.println("thread2 notify other thread can release wait status..");//由于notify方法并不释放锁， 即使thread2调用下面的sleep方法休息了10毫秒，但thread1仍然不会执行，因为thread2没有释放锁，所以Thread1无法得不到锁。MultiThread.class.notify();System.out.println("thread2 is sleeping ten millisecond...");try {Thread.sleep(10);} catch (InterruptedException e) {e.printStackTrace();}System.out.println("thread2 is going on...");System.out.println("thread2 is being over!");}}}
}

-----------执行结果----------------- 
enter thread1...
thread1 is waiting
enter thread2...
thread2 notify other thread can release wait status..
thread2 is sleeping ten millisecond...
thread2 is going on...
thread2 is being over!
thread1 is going on...
thread1 is being over!

32. 同步和异步有何异同，在什么情况下分别使用他们？举例说明。

如果数据将在线程间共享。例如正在写的数据以后可能被另一个线程读到，或者正在读的数据可能已经被另一个线程写过了，那么这些数据就是共享数据，必须进行同步存取。

当应用程序在对象上调用了一个需要花费很长时间来执行的方法，并且不希望让程序等待方法的返回时，就应该使用异步编程，在很多情况下采用异步途径往往更有效率。网络通信。

33. 同步有几种实现方法?

两种，分别是synchronized、wait与notify。

wait(): 使一个线程处于等待状态，并且释放所持有的对象的lock。

sleep(): 使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要捕捉InterruptedException异常。

notify(): 唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM确定唤醒哪个线程，而且不是按优先级。

Allnotity(): 唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们竞争。

34. 启动一个线程是用run()还是start()？

启动一个线程是调用start()方法，使线程就绪状态，以后可以被调度为运行状态，一个线程必须关联一些具体的执行代码，run()方法是该线程所关联的执行代码。

35. 当一个线程进入一个对象的一个synchronized方法后，其它线程是否可进入此对象的其它方法?

如果其他个方法都加了synchronized关键字，并且内部没有调用wait，则不能。

如果其他方法是static，它用的同步锁是当前类的字节码，与非静态的方法不能同步，因为非静态的方法用的是this。

36. 线程的基本概念、线程的基本状态以及状态之间的关系。

一个程序中可以有多条执行线索同时执行，一个线程就是程序中的一条执行线索，每个线程上都关联有要执行的代码，即可以有多段程序代码同时运行，能够执行程序代码的一个执行单位，每个程序至少都有一个线程，即main方法执行的那个线程。

wait必须在synchronized内部调用。

6种状态：new, runnable, blocked, waiting, time waiting, terminated.

37. 设计4个线程，其中两个线程每次对j增加1，另外两个线程对j每次减少1。

public class ThreadTest1 {// j
private int j;public static void main(String[] args){ThreadTest1 tt=new ThreadTest1();Inc inc=tt.new Inc();Dec dec=tt.new Dec();// start threadfor(int i=0;i<2;i++){Thread t=new Thread(inc);t.start();t=new Thread(dec);t.start();}}// inc
private synchronized void inc(){j++;System.out.println(Thread.currentThread().getName()+"-inc:"+j);}// dec
private synchronized void dec(){j--;System.out.println(Thread.currentThread().getName()+"-dec:"+j);}// inner class for inc
class Inc implements Runnable{public void run(){inc();}
}// inner class for dec
class Dec implements Runnable{public void run(){dec();}
}}

38. 说说 List, Set, Queue, Map 四者的区别？

一个是 Collection接口，主要用于存放单一元素；另一个是 Map 接口，主要用于存放键值对。

List(对付顺序的好帮手): 存储的元素是有序的、可重复的。

Set(注重独一无二的性质): 存储的元素不可重复的。

Queue(实现排队功能的叫号机): 按特定的排队规则来确定先后顺序，存储的元素是有序的、可重复的。

Map(用 key 来搜索的专家): 使用键值对（key-value）存储。key 是无序的、不可重复的，value 是无序的、可重复的，每个键最多映射到一个值。

对于Vector&ArrayList、Hashtable&HashMap，要记住线程安全的问题，记住Vector与Hashtable是旧的，是java一诞生就提供了的，它们是线程安全的，ArrayList与HashMap是java2时才提供的，它们是线程不安全的。

39. Collection 和 Collections的区别。

Collection是集合类的上级接口，继承与他的接口主要有Set 、Lis和Queue。

Collections是针对集合类的一个工具类，他提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。

40. java中有几种类型的流？JDK为每种类型的流提供了一些抽象类以供继承，请说出他们分别是哪些类？

字节流继承于InputStream、OutputStream，字符流继承于InputStreamReader、OutputStreamWriter。在java.io包中还有许多其他的流，主要是为了提高性能和使用方便。

底层设备永远只接受字节数据，有时候要写字符串到底层设备，需要将字符串转成字节再进行写入，而字符流是字节流的包装。（注意编码）

41. 什么是java序列化，如何实现java序列化？

将一个java对象变成字节流（序列化）的形式传出去或者从一个字节流中恢复成一个java对象（反序列化）。被传输的对象必须实现serializable接口，这样，javac编译时就会进行特殊处理，编译的类才可以被writeObject方法操作， 没有实现的方法，标注该对象是可被序列化的。

42. heap和stack有什么区别。

Java的内存分为两类，一类是栈内存，一类是堆内存。

栈内存是指程序进入一个方法时，会为这个方法单独分配一块私属存储空间，用于存储这个方法内部的局部变量，当这个方法结束时，分配给这个方法的栈会释放，这个栈中的变量也将随之释放。

堆是与栈作用不同的内存，一般用于存放不放在当前方法栈中的那些数据。例如，使用new创建的对象都放在堆里，所以，它不会随方法的结束而消失。方法中的局部变量使用final修饰后，放在堆中，而不是栈中。

43. GC是什么? 为什么要有GC?

垃圾收集（Gabage Collection）。忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃，Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的，Java语言没有提供释放已分配内存的显示操作方法。

回收机制有分代复制垃圾回收、标记垃圾回收、增量垃圾回收。

GC采用有向图的方式记录和管理堆(heap)中的所有对象，确定哪些对象是“可达的”，哪些对象是“不可达的”。当GC确定一些对象为“不可达”时，GC就有责任回收这些内存空间。

所谓内存泄露就是指一个不再被程序使用的对象或变量一直被占据在内存中。

44. 什么时候用assert。

assertion(断言)在软件开发中是一种常用的调试方式（开发、测试）。对一个boolean表达式进行检查，一个正确程序必须保证这个boolean表达式的值为true；如果该值为false，说明程序已经处于不正确的状态下，assert将给出警告或退出。一般来说，assertion用于保证程序最基本、关键的正确性。

45. 能不能自己写个类，也叫java.lang.String？

可以，但在应用的时候，需要用自己的类加载器去加载，否则，系统的类加载器永远只是去加载jre.jar包中的那个java.lang.String。

46. 获得一个类的类对象有哪些方式？

方法1：类型.class，例如：String.class

方法2：对象.getClass()，例如：”hello”.getClass()

方法3：Class.forName()，例如：Class.forName(“java.lang.String”)

✅本小节完毕！！！