基础知识

1.使用length属性获取数组长度

　　数组求长度用length属性

　　字符串求长度用length()方法

　　集合求长度用size()方法

2.

　　在说明这四个关键字之前，我想就class之间的关系做一个简单的定义，对于继承自己的class，base class可以认为他们都是自己的子女，而对于和自己一个目录下的classes，认为都是自己的朋友。

     1、public：public表明该数据成员、成员函数是对所有用户开放的，所有用户都可以直接进行调用

     2、private：private表示私有，私有的意思就是除了class自己之外，任何人都不可以直接使用，私有财产神圣不可侵犯嘛，即便是子女，朋友，都不可以使用。

     3、protected：protected对于子女、朋友来说，就是public的，可以自由使用，没有任何限制，而对于其他的外部class，protected就变成private。

　　　　　　　　　　作用域       当前类    同一package   子孙类     其他package

                public        √         √             √           √

               protected   　　√          √           √           ×

               friendly       √          √            ×           ×

               private        √          ×           ×           ×


2、Collection和Collections区别

　　1.Collection:

  　　是集合类的上层接口。本身是一个Interface，里面包含了一些集合的基本操作。

  　　Collection接口时Set接口和List接口的父接口

  2.Collections 

      Collections是一个集合框架的帮助类，里面包含一些对集合的排序，搜索以及序列化的操作。

      最根本的是Collections是一个类,

      Collections 是一个包装类，Collection 表示一组对象，这些对象也称为 collection 的元素。一些 collection 允许有重复的元素，        而另一些则不允许，一些 collection 是有序的，而另一些则是无序的。

3.String s=new String("xyz");创建了几个String Object？二者之前的区别是什么？

      两个。第一个对象是字符串常量"xyz" 第二个对象是new String("xyz")的时候产生的，在堆中分配内存给这个对象，只不过这个对象的内容是指向字符串常量"xyz" 另外还有一个引用s，

　　指向第二个对象。这是一个变量，在栈中分配内存。

 

4.short s1; s1=s1+1;是否有错

对于short s1=1; s1=s1+1; 由于s1+1运算的时候会自动提升表达式的类型，所以结果是int型，再赋值给short类型s1时候，编译器件将报告需要强制转换类型的错误。。。

对于short s1=1; s1+=1;;由于+=是java语言规定的运算符，java编译器会对它进行特殊的额处理，因此可以正确的编译。。

 

5.Overriding和Overloading区别

 

 

6、Set里面的元素不能重复，用什么方法区分重复与否。

==是用来判断两者是否是同一对象（同一事物），而equals是用来判断是否引用同一个对象。再看一下Set里面存的是

对象，还是对象的引用。根据java的存储机制可知，set里面存放的是对象的引用，所以当两个元素只要满足了equals()时就已经指向同一个对象，

也就出现了重复元素。所以应该用equals()来判断。

7、给出一个常见的runtime exception。　　

Java.lang.NullPointerException空指针异常
Java.lang.IndexOutOfBoundsException索引超出异常
Java.lang.ArithmeticException算术异常
Java.lang.ClassCastException类转换异常
IllegalArgumentException非法数据异常
IllegalStateException非法语句异常

8、error和exception区别。

Error（错bai误）表示系统级的错误和程序不必处理的异常，du是java运行zhi环境中的内部错误或者硬件问题。dao比如：内存资源不足等。对于这种错误，程序基本无能为力，除了退出运行外别无选择，它是由Java虚拟机抛出的。
Exception（违例）表示需要捕捉或者需要程序进行处理的异常，它处理的是因为程序设计的瑕疵而引起的问题或者在外的输入等引起的一般性问题，是程序必须处理的。
Exception又分为运行时异常，受检查异常。
运行时异常，表示无法让程序恢复的异常，导致的原因通常是因为执行了错误的操作，建议终止程序，因此，编译器不检查这些异常。
受检查异常，是表示程序可以处理的异常，也即表示程序可以修复（由程序自己接受异常并且做出处理）， 所以称之为受检查异常。

9、List和Set是否继承自Collection接口。

List，Set是，Map不是

Collection
     --List：将以特定次序存储元素。所以取出来的顺序可能和放入顺序不同。
           --ArrayList / LinkedList / Vector
     --Set ： 不能含有重复的元素
           --HashSet / TreeSet
      Map
     --HashMap
     --HashTable
     --TreeMap

详细介绍： 
List特点：元素有放入顺序，元素可重复 
Map特点：元素按键值对存储，无放入顺序 
Set特点：元素无放入顺序，元素不可重复（注意：元素虽然无放入顺序，但是元素在set中的位置是有该元素的HashCode决定的，其位置其实是固定的） 
List接口有三个实现类：LinkedList，ArrayList，Vector 
LinkedList：底层基于链表实现，链表内存是散乱的，每一个元素存储本身内存地址的同时还存储下一个元素的地址。链表增删快，查找慢 
ArrayList和Vector的区别：ArrayList是非线程安全的，效率高；Vector是基于线程安全的，效率低 
Set接口有两个实现类：HashSet(底层由HashMap实现)，LinkedHashSet 
SortedSet接口有一个实现类：TreeSet（底层由平衡二叉树实现） 
Query接口有一个实现类：LinkList 
Map接口有三个实现类：HashMap，HashTable，LinkeHashMap 
  HashMap非线程安全，高效，支持null；HashTable线程安全，低效，不支持null 
SortedMap有一个实现类：TreeMap 
其实最主要的是，list是用来处理序列的，而set是用来处理集的。Map是知道的，存储的是键值对 
set 一般无序不重复.map kv 结构 list 有序 

 

10、abstract class和interface 的区别。

含有abstract修饰符的class即为抽象类，abstract 类不能创建的实例对象。含有abstract方法的类必须定义为abstract class，abstract class类中的方法不必是抽象的。abstract class类中定义抽象方法必须在具体(Concrete)子类中实现，所以，不能有抽象构造方法或抽象静态方法。如果的子类没有实现抽象父类中的所有抽象方法，那么子类也必须定义为abstract类型。

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

下面比较一下两者的语法区别：

1.抽象类可以有构造方法，接口中不能有构造方法。

2.抽象类中可以有普通成员变量，接口中没有普通成员变量

3.抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。

4. 抽象类中的抽象方法的访问类型可以是public，protected和（默认类型,虽然

eclipse下不报错，但应该也不行），但接口中的抽象方法只能是public类型的，并且默认即为public abstract类型。

5. 抽象类中可以包含静态方法，接口中不能包含静态方法

6. 抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public static final类型，并且默认即为public static final类型。

 

11、是否可以继承String类。

String类是final类，不可以被继承。

 

13、最有效率的方法算2*8等于几

因为将一个数左移n位，就相当于乘以了2的n次方，那么，一个数乘以8只要将其左移3位即可，而位运算cpu直接支持的，效率最高，所以，2乘以8等於几的最效率的方法是2 << 3

 

14、两个对象值相同，x.equal(y)==true，但是却可有不同的hashcode，这句话对不对。

不对，如果两个对象x和y满足x.equals(y) == true，它们的哈希码（hash code）应当相同。Java对于eqauls方法和hashCode方法是这样规定的：

(1)如果两个对象相同（equals方法返回true），那么它们的hashCode值一定要相同；

(2)如果两个对象的hashCode相同，它们并不一定相同。

 

15、值传递和引用传递

• 值传递是对基本型变量而言的,传递的是该变量的一个副本,改变副本不影响原变量。
• 引用传递一般是对于对象型变量而言的,传递的是该对象地址的一个副本, 并不是原对象本身 。 所以对引用对象进行操作会同时改变原对象。

　　一般认为,java内的传递都是值传递。

 

16、switch是否作用在byte、long、string上。

• switch可作用于char byte short int

• switch可作用于char byte short int对应的包装类

• switch不可作用于long double float boolean，包括他们的包装类

• switch中可以是字符串类型,String(JDK1.7之后才可以作用在string上)

• switch中可以是枚举类型(JDK1.5之后)

 

17、ArrayList和Vector区别，HashMap和Hashtable区别（了解这几个类的底层jdk中的编码方式）

　　

ArrayList和Vector都是以数组的形式存储。ArrayList可以存null值，Vector是不可以的，vector是线程安全的，ArrayList是线程不安全的，但是可以用collections.sychronizedList()实现线程同步，ArrayList在容器充满时会自动扩容50%，而vector则扩容100%，ArrayList则更节省空间；

hashMap：key和value可以为null值，非线程安全，继承abstractMap接口，重新计算hash值

hashTable：key和value不能为null值，线程安全，继承dictionary接口，hash值直接使用key.hashCode（）

现在推荐使用concurrentHashMap替代hashTable，因为concurrentHashMap使用的是局部锁技术，吧map分为多个segment，而hashtable锁的机制是对整个对象的加锁，concurrenthashmap的性能优于hashTable。

 

 

 

18、GC是什么，为什么要有GC，简单介绍GC。

GC是垃圾回收，内存处理是开发人员容易出现问题的地方，错误或忘记内存回收都可能会使得系统不稳定或者崩溃。而Java就提供了一个垃圾回收功能，可以监测对象是否超过作用域或者说是不可达的状态，从而达到自动回收内存的目的。

垃圾回收可以有效的防止内存泄漏，垃圾回收器是一个单独的低优先级的线程，在不可预知的情况对已经死亡或者很久没有使用的对象进行回收，程序是不能实时的调用垃圾回收器对某个对象进行回收。

垃圾回收的实现有很多方法，其中有一种是用分代回收算法实现的。分代回收是将堆空间划分为三个区：年轻代、年老代和永久代。年轻代和年老代存储的是动态产生的对象，而永久代存储的是类的信息，包括解析到的方法、变量等，永久带几乎是不参与垃圾回收的。

年轻代又分为三个区，一个eden区，两个相同的survivor区，这样分主要是为了让生命周期短的对象尽量留在年轻代。新创建的对象都会先存放到eden区，直到eden申请不到空间时，进行minorGC，将存活的对象拷贝到survivor区，年老代一般存储的是生命周期比较长的对象。

垃圾回收过程如下：

1.在eden区完成内存分配

2.eden区满了再创建对象时，会因为申请不到空间而出发minorGC，对eden+1survivor进行垃圾回收

3.minorGC时，将eden区不能回收的对象拷贝到空的survivor区，另一个survivor中不能回收的对象也会放到这个空的survivor区，最后会清空eden区并保证一个survivor是空的

4.执行到第3步的时候，若survivor满的，则这些对象会被拷贝到年老代（old）区，或者是survivor并没有满，但有些对象足够old，则这些对象会被放到年老代区

5.当年老代满了以后，会进行fullGC

 

19、float f=3.4是否正确。

不正确。在Java中，没有小数点的默认是int型，有小数点的默认是double型，若要定义一个float型的数应该强制转换类型，或者在数字后面加个“f”。

 

20、介绍Java中的Collection framework。

collection framework是Java的集合框架，是Java提供的工具包，包括了常用的数据结构：集合、数组、链表、队列、栈和映射等。

Java的集合主要划分为四个部分：list列表、set集合、map映射和工具类（collections、arrays等）。

collection主要的实现接口有list和set。

list是一个队列，根据下标索引，从0开始，实现类主要有linklist、ArrayList、vector、stack。list是有序的队列，可以存放重复值。

set是一个集合，set的值是唯一的，也就是说set当中不能存放重复值，list去重的问题可以把list转换成set，set的实现类主要有treeset和hashset，其中treeset是有序的。

map是一个接口，以键值对的形式存储，map中的每一个元素包含一个key和一个key对应的值value。abstractMap实现了map中大部分的api，而hashmap、treemap都是继承于abstractMap

 

21、Collection框架中实现比较方法

Comparable和Comparator接口
如果一个类的不同对象需要比较大小，那么就需要实现这两个接口，根据业务需求定义规则。
使用区别:
(1)Comparable接口
是需要比较的类实现自己实现，例如：定义的Student类需要比较,需要Student类自己实现这个接口，实现ComParaTo()方法。
(2)Comparator接口
自己定义一个比较容器，去实现这个接口（实现compare方法），然后在集合生成的时候，用一个比较对象做参数，跟集合绑定。
例：
Class A implements Comparator{}//定义比较容器，实现compare方法
A a = new A();//生成比较对象
Set set = new TreeSet(a);//构造集合对象时，传入比较器。

 

22、String和Stringbuffer的区别

String:

1.是对象不是原始类型。
2.为不可变对象,一旦被创建,就不能修改它的值。
3.对于已经存在的String对象的修改都是重新创建一个新的对象,然后把新的值保存进去。
4.String是final类,即不能被继承。

StringBuffer:

1.是一个可变对象,当对它进行修改的时候不会像String那样重新建立对象。
2.它只能通过构造函数来建立，StringBuffer subffer=new StringBuffer();
3.对象被建立以后,在内存中就会分配内存空间,并初始保存一个null,通过它的append方法向其赋值 subffer.append(“hello word”);

字符串连接操作中StringBuffer的效率要明显比String高;
String对象是不可变对象,每次操作String都会建立新的对象来保存新的值。
StringBuffer对象实例化后,只对这一个对象操作。

 

23、final、finally、finalize区别

一、final ：

1、修饰符bai（关键字） 如果一个类被声明为dufinal,意味着它不能再派生新的zhi子类，不能作为dao父类被继承。因此一个类不能及被声明为abstract，又被声明为final的。

2、将变量或方法声明为final,可以保证他们使用中不被改变。被声明为final的变量必须在声明时给定初值，而以后的引用中只能读取，不可修改，被声明为final的方法也同样只能使用，不能重载。
二、finally:

在异常处理时提供finally块来执行清楚操作。如果抛出一个异常，那么相匹配的catch语句就会执行，然后控制就会进入finally块，如果有的话。

三、finalize：

是方法名。java技术允许使用finalize()方法在垃圾收集器将对象从内存中清除之前做必要的清理工作。这个方法是在垃圾收集器在确定了，被清理对象没有被引用的情况下调用的。

finalize是在Object类中定义的，因此，所有的类都继承了它。子类可以覆盖finalize()方法，来整理系统资源或者执行其他清理工作。

 

24、面向对象的特征

抽象：提取现实世界中某事物的关键特性，为该事物构建模型的过程。对同一事物在不同的需求下，需要提取的特性可能不一样。得到的抽象模型中一般包含：属性（数据）和操作（行为）。这个抽象模型我们称之为类。对类进行实例化得到对象。

封装：封装可以使类具有独立性和隔离性；保证类的高内聚。只暴露给类外部或者子类必须的属性和操作。类封装的实现依赖类的修饰符（public、protected和private等）

继承：对现有类的一种复用机制。一个类如果继承现有的类，则这个类将拥有被继承类的所有非私有特性（属性和操作）。这里指的继承包含：类的继承和接口的实现。

多态：多态是在继承的基础上实现的。多态的三个要素：继承、重写和父类引用指向子类对象。父类引用指向不同的子类对象时，调用相同的方法，呈现出不同的行为；就是类多态特性。多态可以分成编译时多态和运行时多态。

抽象、封装、继承和多态是面向对象的基础。在面向对象四大基础特性之上，我们在做面向对象编程设计时还需要遵循有一些基本的设计原则。

 

25、String是最基本的数据类型吗。

Java 中的基本数据类型只有 8 个：byte、 short、 int、 long、 float、 double、
char、 boolean；

除了基本类型（primitive type）和枚举类型（enumeration type），剩下的都是引用类型（reference type）

java.lang.String类是final类型的，因此不可以继承这个类、不能修改这个类。为了提高效率节省空间，我们应该用StringBuffer类 

 

26、运行时异常和一般异常的区别

运行时异常：由java虚拟机抛出的异常。用户不必处理。 而一般异常是用户可以抛出的异常，如果抛出调用必须进行处理。

1，从机制角度来讲:
运行时异常:
　　在定义方法时不需要声明会抛出runtime exception;
　　在调用这个方法时不需要捕获这个runtime exception;
　　runtime exception是从java.lang.RuntimeException或java.lang.Error类衍生出来的。

一般异常:
　　定义方法时必须声明所有可能会抛出的checked exception;
　　在调用这个方法时，必须捕获它的checked exception，不然就得把它的exception传递下去;
　　checked exception是从java.lang.Exception类衍生出来的。
2，从逻辑的角度来说，
运行时异常和一般异常是有不同的使用目的的。一般异常用来指示一种调用方能够直接处理的异常情况。而运行时则用来指示一种调用方本身无法处理或恢复的程序错误。

 

27、说出ArrayList、Vector、Linkedlist的存储性能和特性

ArrayList 和 Vector 都是使用数组方式存储数据，此数组元素数大于实际存储的数据以便增加和插入元素，它们都允许直接按序号索引元素，但是插入元

素要涉及数组元素移动等内存操作，所以索引数据快而插入数据慢，Vector 由于使用了 synchronized 方法（线程安全），通常性能上较 ArrayList 差，而

LinkedList 使用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但是插入数据时只需要记录本项的前后项即可，所以插入速度较快。

 

28、heap和stack区别

java 的内存分为两类，一类是栈内存，一类是堆内存。栈内存是指程序进入一个方法时，
会为这个方法单独分配一块私属存储空间，用于存储这个方法内部的局部变量，当这个方法
结束时，分配给这个方法的栈会释放，这个栈中的变量也将随之释放。
堆是与栈作用不同的内存，一般用于存放不放在当前方法栈中的那些数据，例如，使用 new
创建的对象都放在堆里，所以，它不会随方法的结束而消失。 方法中的局部变量使用 final
修饰后，放在堆中，而不是栈中。 

 

 

 

区别：

1.heap是堆，stack是栈。

2.stack的空间由操作系统自动分配和释放，heap的空间是手动申请和释放的，heap常用new关键字来分配。

3.stack空间有限，heap的空间是很大的自由区。

在Java中，

若只是声明一个对象，则先在栈内存中为其分配地址空间，

若再new一下，实例化它，则在堆内存中为其分配地址。

4.举例：

数据类型 变量名；这样定义的东西在栈区。

如：Object a =null; 只在栈内存中分配空间

new 数据类型();或者malloc(长度);    这样定义的东西就在堆区

如：Object b =new Object(); 则在堆内存中分配空间

 

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

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

java对异常进行了分类，不同类型的异常使用了不同的java类，所有异常的根类为java.lang.Throwable.Throwable派生了2个子类：Error和Exception.

Error表示程序本身无法克服和恢复的一种严重错误，程序只有死的份，如内存溢出和死锁问题等系统问题。

Exception表示还能克服和恢复，其中又分为系统异常和普通异常。系统异常是软件本身缺陷导致的问题，也就是软件开发问题考虑不周所导致的问题，软件使用者无法克服和恢复这种问题，但这种情况下可以选择让软件继续运行或死掉。如数组越界问题（ArrayIndexOutOfBoundsException）,空指针异常（NullPointerException),类转换异常（ClassCastException);普通异常是运行环境的变化或异常导致的问题，是用户能够克服的问题，如网路掉线、硬盘空间不足、IO异常发生这种异常后程序不应该死掉。

 

java为系统异常和普通异常提供了不同的解决方案，编译器强制普通异常必须try..catch处理或throws声明继续抛给上层调用方法处理。所以普通异常为checked异常，而系统异常可以处理也可以不处理。编译器不强制用try..catch或throws声明，所以系统异常成为uncheckde异常。

请写出你最常见到的5个runtime exception。 常见异常见：http://www.runoob.com/java/java-exceptions.html

5个RuntimeException:

NullPionterException

ArrayIndexOutOfBoundsException

StringIndexOutOfBoundsException

ClassCastException

NumberFormatException

 

 

30、垃圾回收的原理和特点，并考虑2种回收机制

1、java语言最显著的特点就是引入了垃圾回收机制，它使java程序员在编写程序时不再考虑内存管理的问题。
2、由于有这个垃圾回收机制，java中的对象不再有“作用域”的概念，只有引用的对象才有“作用域”。
3、垃圾回收机制有效的防止了内存泄露，可以有效的使用可使用的内存。
4、垃圾回收器通常作为一个单独的低级别的线程运行，在不可预知的情况下对内存堆中已经死亡的或很长时间没有用过的对象进行清除和回收。
5、程序员不能实时的对某个对象或所有对象调用垃圾回收器进行垃圾回收。

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

 

31、说出一些常用的 集合类和方法

 

 

 

32、描述一下JVM加载Class文件的原理和机制

https://www.cnblogs.com/mengchunchen/p/7845163.html

 

33、排序的几种方法，了解。

https://www.cnblogs.com/diligentYe/p/6675339.html

 

34、Java语言如何进行异常处理，throws，throw，try catch finally代表什么意义，try块中可以抛出异常吗

Java通过面向对象的方法进行异常处理，把各种不同的异常进行分类，并提供了良好的接口。在Java中，每个异常都是一个对象，它是Throwable类或其它子类的实例。当一个方法出现异常后便抛出一个异常对象，该对象中包含有异常信息，调用这个对象的方法可以捕获到这个异常并进行处理。Java的异常处理是通过5个关键词来实现的：try、catch、throw、throws和finally。一般情况下是用try来执行一段程序，如果出现异常，系统会抛出（throws）一个异常，这时候你可以通过它的类型来捕捉（catch）它，或最后（finally）由缺省处理器来处理。

用try来指定一块预防所有”异常”的程序。紧跟在try程序后面，应包含一个catch子句来指定你想要捕捉的”异常”的类型。

throw语句用来明确地抛出一个”异常”。

throws用来标明一个成员函数可能抛出的各种”异常”。

Finally为确保一段代码不管发生什么”异常”都被执行一段代码。

可以在一个成员函数调用的外面写一个try语句，在这个成员函数内部写另一个try语句保护其他代码。每当遇到一个try语句，”异常”的框架就放到堆栈上面，直到所有的try语句都完成。如果下一级的try语句没有对某种”异常”进行处理，堆栈就会展开，直到遇到有处理这种”异常”的try语句。

35、一个’.java’源文件是否可以包括多个类，有什么限制。

　　可以有多个类，但只能有一个public的类，并且public的类名必须与文件名相一致。一个文件中可以只有非public类，如果只有一个非public类，此类可以跟文件名不同。

　　问题一：为什么类之中只能有一个public的类？

　　每个编译单元（文件）都只有一个public 类。因为每个编译单元都只能有一个公共接口，用public类来表现。该接口可以按照要求包含众多的支持包访问权限的类。如果有一个以上的public 类，编译器就会报错。 并且public类的名称必须与文件名相同（严格区分大小写）。 当然一个编译单元内也可以没有public类。在PUBLIC类中找程序的入口 main函数 你想想如果很多PUBLIC 类，那程序从何运行！

　　问题二：public 类的名称为什么要与文件名相等？

　　首先Java是被解释执行的。它在运行时并不是将所有的class文件全都放到内存中。而是在遇到import的时候才去相应的文件目录找相应的class文件。对于一个public类，它是可以被项目中任何一个类所引用的，只需在使用它前import一下它所对应的class文件即可。将类名与文件名一一对应就可以方便虚拟机在相应的路径（包名）中找到相应的类的信息。如果不这么做的话，就很难去找，而且开销也会很大。

 

36、Java中有几种类型流，jdk为每种类型的流提供了一些抽象类以供继承，请分别说出它们是哪些类。

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

 

 

37、Java中会存在内存泄漏吗，请简单描述。

https://blog.csdn.net/smile0198/article/details/21650339

 

38、静态变量和实例变量的区别。

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

    在程序运行时的区别：实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被分配空间，才能使用这个实例变量。

    静态变量不属于某个实例对象，而是属于类，所以也称为类变量，只要程序加载了类的字节码文件，不用创建任何实例象，静态变量就会被分配空间，静态变量就可以被使用了。

   总之，实例变量必须创建对象后才可以通过这个对象来使用，静态变量则可以直接使用类名来引用。

 

39、什么是Java序列化，如何实现java序列化。

https://www.cnblogs.com/shoshana-kong/p/10538661.html

 

40、是否可以从一个static方法内部发生对非static方法调用。

不可以。因为非static方法是要与对象关联在一起的，必须创建一个对象后，才可以在

该对象上进行方法调用，而static方法调用时不需要创建对象，可以直接调用。也就是

说，当一个static方法被调用时，可能还没有创建任何实例对象，如果从一个static方法中

发出对非static方法的调用，那个非static方法关联到那个对象上的呢？这个逻辑无法成

立，所以，一个static方法内部不能发出对非static方法的调用。

static方法是静态方法，是属于类的方法

非static方法是属于对象的方法，所以在static方法中想要调用非static方法，要先新创建一个对象，再有这个对象来调用非static方法。

41、写clone方法，通常都有一行代码。

super.clone()

https://blog.csdn.net/river66/article/details/87859605

 

42、Java中如何跳出多重嵌套循环

方法一：可以在需要的循环语句前定义一个标号，
然后在里层循环体的代码中使用带有标号的break语句，即可跳出外层循环

方法二：可以在需要的循环条件内加入一个boolean类型的判断，需要的时候将此变量值反转，再break当前循环即可跳出。

https://www.cnblogs.com/Xieyang-blog/p/8488612.html

 

43、说出常用类、包、接口，各举5个。

https://blog.csdn.net/XueBaiBaiBai/article/details/81175702

 

44、Java中实现线程的方法，用关键字修饰同步方法。

有两种实现方法，分别是继承Thread类与实现Runnable接口
用synchronized关键字修饰同步方法
反对使用stop()，是因为它不安全。它会解除由线程获取的所有锁定，而且如果对象处于一种不连贯状态，那么其他线程能在那种状态下检查和修改它们。结果很难检查出真正的问题所在。suspend()方法容易发生死锁。调用suspend()的时候，目标线程会停下来，但却仍然持有在这之前获得的锁定。此时，其他任何线程都不能访问锁定的资源，除非被"挂起"的线程恢复运行。对任何线程来说，如果它们想恢复目标线程，同时又试图使用任何一个锁定的资源，就会造成死锁。所以不应该使用suspend()，而应在自己的Thread类中置入一个标志，指出线程应该活动还是挂起。若标志指出线程应该挂起，便用wait()命其进入等待状态。若标志指出线程应当恢复，则用一个notify()重新启动线程

 

45、同步和异步区别。

同步：

　　同步的思想就是用户首先发送一个请求，那么服务器将要把用户的请求都处理完成后，在会通知用户，那么这样就会造成用户等待实践太长，比如说我们在浏览器点了一个功能，那么点击了以后用户没有反应，其实这时候服务器正在处理用户发送的请求，暂时没回应用户，这种情况对于用户来说就是 卡死了.... 其实它还是正在工作中，那么如果用户关闭了浏览器，那么它正在执行中的操作将会断开。

异步：

    将用户发送的请求放入消息队列，并反馈给用户已经执行成功，这时候并不是真正的执行成功了，而是先通知用户执行成功了，当用户看到执行成功的结果，那么它肯定不会在执行一次了，这时候消息队列在慢慢的把用户发送的请求写到服务器中。

总结：

        同步：是所有的操作都做完，写入服务器数据库当中才会通知用户执行成功，这样的话会造成服务器压力过大，而且用户的体验效果也不是很好。

        异步：不用等待服务器数据库是否写入，而是先通知用户执行成功，随后在慢慢的写入服务器数据库，这样会减轻服务器的压力，同时对用户的体验效果很好。

46、线程同步的方法。

一、synchronized关键字

https://blog.csdn.net/jiangshangchunjiezi/article/details/88118063

此关键字修饰方法，当方法体规模很大时，会影响程序的执行效率，为了提高效率，出现了synchronized块

二、wait（）方法与notify（）方法

wait、notify使用：https://blog.csdn.net/jiangshangchunjiezi/article/details/97168265

三、lock

https://blog.csdn.net/jiangshangchunjiezi/article/details/88670906

四、volatile

特殊域变量(volatile)实现线程同步

https://blog.csdn.net/jiangshangchunjiezi/article/details/88662511

1. 新建状态(New)         : 线程对象被创建后，就进入了新建状态。例如，Thread thread = new Thread()。
2. 就绪状态(Runnable): 也被称为“可执行状态”。线程对象被创建后，其它线程调用了该对象的start()方法，从而来启动该线程。例如，thread.start()。处于就绪状态的线程，随时可能被CPU调度执行。
3. 运行状态(Running) : 线程获取CPU权限进行执行。需要注意的是，线程只能从就绪状态进入到运行状态。
4. 阻塞状态(Blocked)  : 阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况分三种：
    (01) 等待阻塞 -- 通过调用线程的wait()方法，让线程等待某工作的完成。
    (02) 同步阻塞 -- 线程在获取synchronized同步锁失败(因为锁被其它线程所占用)，它会进入同步阻塞状态。
    (03) 其他阻塞 -- 通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。
5. 死亡状态(Dead)    : 线程执行完了或者因异常退出了run()方法，该线程结束生命周期。
 

wait（）：作用是让当前线程进入等待状态，同时，也会将当前线程释放它所持有的锁。直到其他线程调用此对象的notify()方法或notifyAll方法，当前线程被唤醒（进入就绪状态）

notify（）：唤醒当前对象上的线程

wait（long timeout）：让当前线程处于“阻塞状态”，直到其他线程调用此对象的notify（）或notifyAll（）方法，或者超过指定时间量，当前线程被唤醒（进入就绪状态）

①直接隶属于Object类，即所有对象都会有这一对方法。因为这一对方法阻塞时要释放占用的锁

最后，关于 wait() 和 notify() 方法再说明三点：

调用 notify() 方法导致解除阻塞的线程是从因调用该对象的 wait() 方法而阻塞的线程中随机选取的，我们无法预料哪一个线程将会被选择，所以编程时要特别小心，避免因这种不确定性而产生问题
除了 notify()，还有一个方法 notifyAll() 也可起到类似作用，唯一的区别在于，调用 notifyAll() 方法将把因调用该对象的 wait() 方法而阻塞的所有线程一次性全部解除阻塞。当然，只有获得锁的那一个线程才能进入可执行状态。
wait()和notify()必须成对存在。

 

原文：https://www.cnblogs.com/chdchd/p/13136792.html