javaSE精选面试题之基础篇

1、String类可以被继承吗？
String类在声明时使用final关键字修饰，被final修饰的类是不可以被继承的。
源码如下：

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    private final char value[];

    /** Cache the hash code for the string */
    private int hash; // Default to 0

    /** use serialVersionUID from JDK 1.0.2 for interoperability */
    private static final long serialVersionUID = -6849794470754667710L;

2、java开发者为什么把String类型定义成final类型呢？
（1） 从设计安全上来讲：String类被final修饰，这意味着String不允许任何人定义String的子类，如果有一个String类的引用，能保证引用的一定是一个String对象，而不是其他。
（2）从效率上来讲：被final修饰后，JVM才不会对相关方法在虚拟列表中查询，而是直接定位到String类上。
总体来说，就是要保证要引用java.lang.String时，引用的一定就是java.lang.String，而不是其他，这样才能保证效率和安全。
当然，自己也可以写一个类叫做java.lang.String，不过需要注意的是，需要使用自己写的这个类的时候需要使用自己的类加载器去加载，否则lava永远只会加载jre.jar包中的java.lang.String
3、final关键字除了修饰类外，还有其他什么用法呢？
● final修饰的变量，一旦赋值，不可重新赋值。
● final修饰的方法无法被覆盖。
● final修饰的实例变量，必须手动赋值，不能采用系统默认值
● fianl关键字一般和static联合使用，用来声明常量
注意，final关键字不能和关键字abstract同时使用。
总之，final表示最终的，不可变的
4、& 和 && 的区别？
● &运算符是逻辑与；&&运算符是短路与；
● &和&&的运算结果是一致的，只不过&&存在着短路现象，当&&左边的表达式的运算结果为false时，&&右边的表达式不会在执行，此时就发生了短路现象。而使用&运算时，不论左边的结果是false还是true，右侧的表达式是一定会执行的。这就是&和&&本质上的区别。
● 当然，&运算符还可以使用到二进制位运算上，例如按位与操作。

5、两个对象值相同equals结果为true，但却可有不同的 hashCode，这句话对吗？
不对，假设有两个对象x和z，满足x.equals(z) == true，那么这两个对象的hashCode值一定相等，在java中关于equals和hashCode的定义是这样来说的：
● 如果两个对象相同（即x.equals(z) == true），那么他们的hashCode值一定要相同的。
● 如果两个对象的hashCode值相同，那么这两个对象可能不同。
6、在java中如何跳出当前的多重循环？
在循环前边加上标志，break后面跟上循环前的标志，可以指定跳出循环示例代码如下：

public class Test {
    public static void main(String[] args) {
        out:for (int i = 0;  i<= 10; i++){
            for(int x = 0; x <=8; x++){
                if(x == 6){
                    break out;
                }
                System.out.println("测试数据x:"+x);
            }
        }
    }
}
运行结果：
测试数据x:0
测试数据x:1
测试数据x:2
测试数据x:3
测试数据x:4
测试数据x:5

7、重载（overload）和重写（override）的区别？
重载发生在一个类体当中方法名相同，参数列表不同（参数顺序不同、参数类型不同、参数个数不同）。
重写发生在父类与子类之中，子类对父类的方法进行重写，要求方法名、返回值类型、参数列表必须和父类保持一直，访问修饰符不能严于父类。
方法重载的规则：
● 方法名相同，参数类表不同
● 重载的方法和返回值类型无关
● 可以抛出不同的异常，可以使用不同的修饰符
方法重写的规则：
● 方法名、参数类表、返回值类型必须和父类保持一致
● 访问修饰符不能严于父类
● 构造器不能被重写
● 声明final的方法不可以被重写
● 被static修饰的方法不存在重写（重写和多态联合才有意义）
● 重写之后的方法不能抛出更广泛的异常
8、java中的switch可以使用什么数据类型？
基本数据类型：byte、short、int
字符型：char
引用数据类型：String （是自java1.7之后才可以使用）
9、谈谈你对java中native关键字的看法？
native关键字修饰的方法说明是一个原生态方法，方法对应的实现不是在当前文件，而是使用其他语言实现的，java本身不能对操作系统的底层进行操作访问，但是可以通过JNI（java native interface）接口调用其他语言来实现对操作系统底层的操作和访问。
10、是否可以在static环境中访问非static变量？
被static修饰的方法和变量称之为类成员，非static修饰的变量和方法称之为实例成员。
实例成员访问类成员是没有限制的，而类成员是不能直接访问实例成员的，需要先实例化对象才能访问实例成员。
实例化成员初始化出成一个类的实例后才可以使用，而类成员是在类中单独的占有一块存储空间，只要这个类存在，那么这个类成员也就存在，所以说，类成员是不能直接调用实例成员的，因为这个时候实例成员还不存在。
11、static关键字是什么意思？java中能不能重写一个被private修饰或static修饰的方法？
static修饰的变量称之为类变量，static修饰的方法称之为类方法，统称为类成员。
被static修饰的方法和变量，可以不实例化就可以直接调用，因为类成员是直接存在类中的，只要这个类存在，这个类成员就存在。
被static修饰的方法不可被重写，重写是基于运行时动态绑定的，而被static修饰过的方法是静态的方法
被private修饰的方法不可以被重写，因为重写是发生在继承当中的，而被private修饰的方法是父类的私有方法，子类只能继承父类非私有的属性和方法，被private修饰的方法子类是继承不到的，所以也就不存在着重写。
12、当父类中的方法被子类重写之后，子类还能不能调用父类当中被重写的方法？
可以调用，使用super关键字
13、简述java当中的继承？
单根性：只能单继承，但是可以实现多个接口，而且对于接口来说，接口是可以继承多个接口的。
传递性：其继承的作用主要是提高代码的复用性，但是继承关系一般不会超过三层，一旦超过三层，效率就会变低
14、数组中有没有length（）方法？String中有没有length（）方法？
数组中没有length（）方法，只有length属性，用来获取数组的长度。
String中有length（）方法，用来获取字符串的额长度。
在JavaScript中，获取String和数组都是使用length属性的。
15、什么是自动拆封箱？
自动拆封箱就是java编译器把基本数据类型转换为对用的包装类型，如下：
int（4字节） Integer
byte（1字节） Byte
short（2字节） Short
long（8字节） Long
float（4字节） Float
double（8字节） Double
char（2字节） Character
boolean Boolean
包装类是基本数据类型和字符串之前相互转换的桥梁。
16、java中可以通过几种方式来创建对象？
（1）通过new的方式，这种方式是我们最常用也是最简单的创建对象的方式，通过此方法我们也可以调用构造方法，比如：String str = new String（）；
（2）通过反射机制创建对象，在反射机制中class是一个非常重要的类，共有三种方法可以获取到class类
class.forName(“完整类名”);
类名.class;
实例.getClass();
（3）通过clone（）方法创建一个对象，无论何时我们调用clone（）方式时，JVM就会创建一个新的对象，会把前一个对象的内容全部拷贝进去，使用clone（）方法创建对象，并不会调用任何构造方法，要使用clone（）方法，必须要实现cloneable接口并实现其定义的clone（）方法。
（4）使用反序列化的方式创建对象，当我们使用序列化和反序列化一个对象，JVM会给我们创建一个单独的对象，在反序列化时，JVM创建对象并不会调用任何构造函数，为了反序列化一个对象，我们需要让我们的类实现Serializable接口。
17、String str = “Hello”; str = str + “world”; 这两行代码执行过后，原始的String对象中的内容有没有改变？
原始的String对象的内容“Hello”，并没用发生任何改变，String对象是不可变的，第一段代码执行过后，String对象的内容为"Hello"，执行完第二段代码后，String相当于又创建了一个对象，对象的内容为"Hello World"，此时的str指向的是"Hello World"，String是不可变的，每一次改变，其实都是在内存中新开辟了一个地址。
18、在子类中能不能重写父类中的构造方法？
不能，重写的前提是建立在继承关系中的，子类只能继承父类中的非私有的方法和属性，不能继承父类中的构造方法，只能调用父类中的构造方法。
19、abstract class和interfa的区别？
abstract class是抽象类，interface是接口
相同点：
（1）都不可以被实例化。
（2）都可以定义抽象方法。
（3）都可以定义常量、静态方法。
（4）抽象方法都需要被重写。
不同点：
（1）意义不同：
接口是对功能的封装。
抽象类是对事物更高层级的抽象。
（2）定义方式不同：
接口使用interface定义。
抽象类使用abstract class定义。
（3）内容不同：
接口中只能存在静态方法、抽象方法、defudefault方法、常量
抽象类中不仅可以存在接口中的所有内容，还可以存在变量、普通方法、构造方法等。
（4）使用方式不同：
接口的实现是通过implements实现的。
抽象类是通过extens继承。
（5）接口支持继承，而且可以多继承。
抽象类只能单继承
（6）应用场景不同：
如果只是完成功能的封装，那么使用接口。
如果除了功能之外，还需要保存数据，那么就使用抽象类，抽象类中的方法需要子类重写，抽象类约束了所有子类都具有某种相同的功能。
20、java中实现多态的机制是什么？
重写和重载
重写是子类与父类中的一种多态性实现
重载是一个类中的多态性的一种体现
21、面向对象的特征有那些？
封装、继承、多态、抽象
22、请写出public、protected、private、以及不写时的区别？
public ： 公共的，可以被所有人访问
protected ： 受保护的，本包、本类、子类能够访问
默认 ： 本包、本类可以访问
private ： 私有的，本类访问
23、Math.round(11.5)和Math.round(-11.5)的结果是多少？
Math.round(11.5) = 12；
Math.round(-11.5) = 11；
Math类中的round函数，表示四舍五入的意思，是在原有的基础上加上0.5
24、静态变量和实例变量的区别？
静态变量：被static修饰的变量，被称之为静态变量，也称之为类变量。
实例变量：没有加static修饰的变量。
在调用上，访问实例变量的时候需要先实例化对象才可以调用实例变量，访问静态变量的时候不需要实例化对象也可以调用，通过类名.的方式调用，因为静态变量是随着类一起加载的，存在于类内存中。
在实例方法中，可以直接调用实例成员和静态成员，没有什么限制
在静态方法中，可以直接调用静态成员，但不可以直接调用实例成员，需要先创建对象。
25、== 和 equals（）的区别？
== 比较运算符，equals（）是一个方法。
== 用于基本数据类型，用于比较两个数据是否相等
用于引用数据类型，用于比较两个引用是否指向同一个地址，也就是说是否指向同一个对象。
equals（）：比较两个对象的内容是否相同，也就是比较两个对象的属性是否完全相同，equals是先比较两个对象的内存地址是否相同，如果不相同，在比较对象内容是否相同。
26、String类为什么一旦创建则无法修改？
（1）Sring类中有一个char[]类型的属性，这个属性是被final修饰的。
（2）String类中没有提供修改char[]属性的方法。
27、覆盖hashCode（）/equals（）方法的规则是什么？
（1）覆盖equals()时可以不覆盖hashCode()
（2）覆盖hashCode()时必须要覆盖equals()
（3）通常情况下，两种方法是同时覆盖的
（4）无论是覆盖那种方法，都要遵循相同的规则
28、说出常见的五个java异常？
类型转换异常、空指针异常、数组下标越界异常、算术异常、解析异常
29、异常在实际开发中是怎么使用的？请举例说明？
在service中有一个处理登录的方法，用来验证用户名和密码是否正确，当不正确的时候向使用者抛出异常，调用者controller捕捉到异常后将异常返回给前端
30、error和exception的区别是什么？
error表示恢复不是不可能但是很困单的一种严重问题。比如内存溢出，不可能指望程序能处理这样的情况
exception表示一种设计或实现问题。也就是说，它表示如果程序能够正常执行，从不会发生的情况
31、异常处理finally的重要性是什么？
try{}catch中，无论执行那个代码块，finally中的语句一定会被执行的，一般用来释放系统资源。
32、throw和throws的区别？
throw是在程序中明确的抛出异常，throws是表明方法不能处理的异常，每个方法都要指定哪些异常不能处理
所有方法的调用者才能确保处理可能发生的异常，多个异常之间使用逗号分割。
33、简述final、finally、finalize的区别？
final：关键字、修饰符，有三种用法：如果用来修饰类，意味着这个类不能被派生出子类，即不能被继承，将变量声明为final，可以保证它们在使用中不被改变，被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取不可修改。被声明为final的方法也同样只能使用，不能在子类中被重写。
finally：通常放在try…catch…的后面构造总是执行代码块，这就意味着程序无论正常执行还是发生异常，这里的代码只要JVM不关闭都能执行，可以将释放外部资源的代码写在finally块中。
finalize：Object类中定义的方法，java中允许使用finalize（）方法在垃圾收集器把对象从内存中清理出去之前做必要的清理工作。finalize（）方法是在垃圾收集器销毁对象时调用的，可以通过重写finalize（）方法来整理系统资源或做其他的清理工作。
34、java语言如何进行异常处理？throw、throws、try、catch、finally分别如何使用？
java中通过面向对象的方法进行异常处理，把各种不同的异常对象进行分类，并提供了良好的接口。在java中，每一个异常都是一个对象，它是Throwable或其子类实例。当一个方法出现异常后便抛出一个异常对象，该对象包含有异常信息，调用这个异常对象的方法可以捕捉异常并对其进行处理。java中的异常是通过5个关键字进行实现的：try、catch、finally、throw、throws，一般情况下是用try来执行一段程序，如果系统会抛出（throw）一个异常对象，可以通过它的类型来捕获（catch）它，或通过总是执行代码块（finally）来处理；try用来指定一块预防所有异常的程序；catch子句紧跟在try块后面，用来指定你想要捕获的异常的类型；throw语句用来明确地抛出一个异常；throws用来声明一个方法可能抛出的各种异常（当然声明异常时允许无病呻吟）；finally为确保一段代码不管发生什么异常状况都要被执行；try语句可以嵌套，每当遇到一个try语句，异常的结构就会被放入异常栈中，直到所有的try语句都完成。如果下一级的try语句没有对某种异常进行处理，异常栈就会执行出栈操作，直到遇到有处理这种异常的try语句或者最终将异常抛给JVM。
35、HashMap的实现原理？
HashMap是以键值的方式来存储数据的，它的底层是哈希表，其实哈希表就是一个数组，数组的每一个元素都是一个单向链表，当我们调用HashMap的put（）方法的时候，根据键的哈希码，即hashCode的返回值，计算数组的下标，然后对整个数组进行遍历，如果有某个单向链表的节点的key与当前键的key的equals（）相等，那么就使用新的value来覆盖掉原来的，如果没有与当前key的equals（）相等，那么就会创建一个新的节点，节点插入到链表的头部。
调用HashMap的get（）方法时，会根据当前传入的键的hashCode的值来计算数组的下标，之后就是访问该数组的这个下标的元素，如果该元素为null，则返回null，如果不为null，则遍历单向链表的每个节点，如果某个节点的key与当前键的equals（）相等，则返回该值，如果没有equals（）相等，则返回null。
36、collection接口中的remove（）方法和Iterator中的remove（）方法的区别？
（1）性能方面：
collection接口中的remove（）方法，必须要首先找出需要删除的项，找到该位置的查询方法使用的是单链表查询方法，单链表的查询效率比较低，需要从集合中一个一个的遍历才行，Iterator中的remove（）方法结合了next（）使用，比如集合中每隔一项删除一项，所以Iterator的效率相对较高。
（2）容错方面：
在使用Iterator遍历时，如果使用Collection的remove则会报异常，会出现ConcurrentModificationException，因为集合中对象的个数会改变而Iterator 内部对象的个数不会，不一致则会出现该异常
在使用Iterator遍历时，不会报错，因为iterator内部的对象个数和原来集合中对象的个数会保持一致
37、ArrayList和LinkedList区别？
ArrayList：数组结构，查询速度快，插入和删除效率低
LinkedList：链表结构，插入和删除快，查询效率低
数组和链表的区别
数组是将元素在内存中连续存储的；它的优点：因为数据是连续存储的，内存地址连续，所以在查找数据的时候效率比较高；它的缺点：在存储之前，我们需要申请一块连续的内存空间，并且在编译的时候就必须确定好它的空间的大小。在运行的时候空间的大小是无法随着你的需要进行增加和减少而改变的，当数据两比较大的时候，有可能会出现越界的情况，数据比较小的时候，又有可能会浪费掉内存空间。在改变数据个数时，增加、插入、删除数据效率比较低。链表是动态申请内存空间，不需要像数组需要提前申请好内存的大小，链表只需在用的时候申请就可以，根据需要来动态申请或者删除内存空间，对于数据增加和删除以及插入比数组灵活。还有就是链表中数据在内存中可以在任意的位置，通过应用来关联数据（就是通过存在元素的地址来联系）
38、怎样获取到一个线程安全的ArrayList？
使用集合工具类Collections.synchronizedList(list);
39、HashMap、HashTable、ConcurrentHashMap相关面试题
1、HashMap是线程非安全的，HashTable是线程安全的
2、因为线程安全的问题，HashMap的效率比HashTable的效率高
3、HashMap的键值都允许有null值的存在，而HashTable不允许
4、HashTable里使用的是synchronized关键字，这其实是对对象加锁，锁住的都是对象整体，当Hashtable的大小增加到一定的时候，性能会急剧下降，因为迭代时需要被锁定很长的时间。
ConcurrentHashMap引入了分割(Segment)，可以理解为把一个大的Map拆分成N个小的HashTable，在put方法中，会根据hash(paramK.hashCode())来决定具体存放进哪个Segment，如果查看Segment的put操作，我们会发现内部使用的同步机制是基于lock操作的，这样就可以对Map的一部分（Segment）进行上锁，这样影响的只是将要放入同一个Segment的元素的put操作，保证同步的时候，锁住的不是整个Map（HashTable就是这么做的），相对于HashTable提高了多线程环境下的性能，因此HashTable已经被淘汰了。
40、要想用Collections.sort()方法对Java对象排序，对这个java对象有什么要求？
需要实现接口Comparable
41、List、Set、Map是否都是继承Collection接口？
List、Set是，Map不是
42、java集合类的框架的基本接口都有那些？
collection、List、Set、SortedSet、Map、SortedMap、Iterator等
43、Set里的元素是不允许重复的，那是使用什么方法来区分重复与否呢？是 == 还是equals（）？他们有和区别？
在Set集合里是使用equals（）方法来判定是否重复的，equals()和==方法决定引用值是否指向同一对象，equals()在类中被覆盖，为的是当两个分离的对象的内容和类型相配的话，返回真值。
44、Collection框架中实现比较要实现什么接口?
实现Comparable或者单独编写一个比较器实现Comparator
45、Collection和Collections的区别？
Collection是集合类的上级接口，继承它的接口的主要有List、Set，Collections是针对集合类的一个帮助类，它提供一系列的静态方法来实现对集合的排序、查找、线程安全化等操作
46、说出ArrayList,Vector, LinkedList的存储性能和特性
ArrayList和Vector都是使用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，它们都允许直接按序号索引元素，但是插入元素要涉及数组元素移动等内存操作，所以索引数据快而插入数据慢，Vector由于使用了synchronized方法（线程安全），通常性能上较ArrayList差，而LinkedList使用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快。
LinkedList也是线程不安全的，LinkedList提供了一些方法，使得LinkedList可以被当作堆栈和队列来使用。
47、说出ArrayList,Vector, LinkedList的存储性能和特性
ArrayList和Vector都是使用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，它们都允许直接按序号索引元素，但是插入元素要涉及数组元素移动等内存操作，所以索引数据快而插入数据慢，Vector由于使用了synchronized方法（线程安全），通常性能上较ArrayList差，而LinkedList使用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快。
LinkedList也是线程不安全的，LinkedList提供了一些方法，使得LinkedList可以被当作堆栈和队列来使用。
48、Vector,ArrayList的相同点与不同点是什么?
相同点: Vector,ArrayList底层都是用数组来实现的 。不同点: Vector :老集合; 速度慢; 线程安全的; ArrayList :新集合; 速度快;非线程安全的;
49、TreeSet如何保证数据不可重复并且可以排序？
有两种方式：
1: 我们创建TreeSet对象的时候,调用TreeSet无参数的构造方法.这就要求向TreeSet中添加的数据的类型必须要实现Comparable接口，并且要实现其中的compareTo()方法.则这个方法中实现数据的比较规则 。如果compareTo()方法返回0,则不让数据进入集合，返回正数/负数来对数据进行排序 方式。
2: 我们可以把比较规则从数据类型中提取出来,做到一个单独的比较器类中,这个比较器要实现Comparator()接口,并且实现其中的compare()方法.在这个方法中实现数据的比较规则 在我们创建TreeSet对象的时候,让TreeSet对象使用制定的比较器对象 具体的规则和第一种方式类型 注意:向TreeSet中添加数据,从TreeSet中查询数据,从TreeSet中删除数据都要调用对象的比较规则。
50、如何启动一个线程？run（）和start（）有什么区别？
启动一个线程使用的是start（）方法，run（）方法只是普通方法的调用，start（）的方法是启动一个线程
51、ThreadLocal是要解决什么问题？在什么应用场景下使用呢？
在同一个线程当中共享一个数据的时候，可以将该数据绑定到ThreadLocal上，比如一个线程一个连接对象Connection，一个线程一个SqlSession对象，为了保证在同一个线程中使用的对象是同一个，需要把这个对象绑定到ThreadLocal上。
52、java中的++运算符是线程安全的吗？
非线程安全的，因为它涉及到多个指令，比如读取变量值、进行增加、然后在存回到内存中，这个过程可能会出现多个线程交差。可以使用线程同步机制保证线程的同步。
53、终止线程包括那些方法？
（1）使用退出标志，使线程正常退出，也就是说当run（）方法完成后线程终止。
（2）使用stop（）方法强行终止线程，但是不推荐使用，因为这可能会发生一些不可预料的后果。
（3）使用interrupt方式中断线程。
54、sleep（）和wait（）有什么区别？
sleep是线程类（Thread）的方法，导致线程暂停执行指定时间，执行机会个其他线程、但是监控状态依然存在，到时会自动恢复，wait是Object类中方法，对此对象调用wait方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象发出notify方法(或notifyAll)后本线程才进入对象锁定池准备获得对象锁进入运行状态。
55、同步方法和同步代码块的区别是什么？
在Java语言中，每一个对象有一把锁。线程可以使用synchronized关键字来获取对象上的锁。synchronized关键字可应用在方法级别(粗粒度锁)或者是代码块级别(细粒度锁)。
56、线程声明周期中有那些状态？
就绪(Runnable):线程准备运行，不一定立马就能开始执行。
运行中(Running)：进程正在执行线程的代码。 等待中(Waiting):线程处于阻塞的状态，等待外部的处理结束。
睡眠中(Sleeping)：线程被强制睡眠。
I/O阻塞(Blocked on I/O)：等待I/O操作完成。 同步阻塞(Blocked on Synchronization)：等待获取锁。
死亡(Dead)：线程完成了执行。
57、进程和线程的区别是什么？
进程是一个执行程序，而线程是继承内部的一个执行序列。一个进程可以包含多个线程。线程也被称之为轻量级进程
58、GC线程是够为守护线程？
是。 解析：线程分为守护线程和非守护线程（即用户线程）。 只要当前JVM实例中尚存在任何一个非守护线程没有结束，守护线程就全部工作；只有当最后一个非守护线程结束时，守护线程随着JVM一同结束工作。 守护线程最典型的应用就是 GC (垃圾回收器)。
59、java中notify和notifyAll有什么区别？
因为多线程可以等待单监控锁，Java API 的设计人员提供了一些方法当等待条件改变的时候通知它们，但是这些方法没有完全实现。notify()方法不能唤醒某个具体的线程，所以只有一个线程在等待的时候它才有用武之地。而notifyAll()唤醒所有线程并允许他们争夺锁确保了至少有一个线程能继续运行
60、java语言当中什么样的变量可能会存在线程安全的问题？
（1）JVM中一个线程一个栈内存，每个栈内存是独立的，栈内存当中存储的是局部变量，所以局部变量不会存在线程安全的问题。
（2）JVM中只有一个堆，堆内存是多线程共享的，堆中存储的是java对象，java对象中存储的是成员变量，所以成员变量存在着线程安全的问题
（3）JVM中只有一个方法区，方法区是多线程共享的，方法区中存储的是静态变量，所以静态变量存在线程安全的问题
综上：java中存在线程安全问题的变量是成员变量和静态变量。
61、什么情况下我们需要考虑线程安全的问题？
（1）多线程并发
（2）有共享数据
（3）共享数据涉及到修改操作