软通第一次考核知识盲点

abstract关键字

异常包括内容

字符流与字节流的区别

多线程通信 使用的流

类及类成员的访问控制符

Java中的访问权限控制符有四个.
作用域         当前类          同一package           子孙类                其他package
public              √                    √                           √                             √

protected         √                    √                            √                            ×

friendly            √                    √                            ×                            ×

private             √                     ×                            ×                             ×


没有时默认为 friendly【package】，如构造函数等~

protected修饰符提供一个从包外部访问包（有限制）的方法。在域和方法前增加protected修饰符不会影响同一个包内其他类和方法对它们的访问。要从包外部访问包（其中含有protected成员的类），必须保证被访问的类是带有protected成员类的子类。也就是说，希望包中的一个类被包之外的类继承重用时，就可以使用这个级别。一般应该慎用。（包中类被包外类继承重用）

来源： http://blog.csdn.net/leilu2008/article/details/6719591

线程优先级

java 中的线程优先级的范围是1～10，默认的优先级是5。“高优先级线程”会优先于“低优先级线程”执行。

java 中有两种线程：用户线程和守护线程。可以通过isDaemon()方法来区别它们：如果返回false，则说明该线程是“用户线程”；否则就是“守护线程”。
用户线程一般用户执行用户级任务，而守护线程也就是“后台线程”，一般用来执行后台任务。需要注意的是：Java虚拟机在“用户线程”都结束后会后退出。

来源： http://www.cnblogs.com/skywang12345/p/3479982.html

在（　d　）可以设置线程的优先级 

a.当第一次创建线程时

b.创建线程后的任何时间

c.只有在线程启动后
d.以上都不对

线程start之前设置

super()、this()不能同时出现在同一构造函数

因为构造函数只能写在第一句，注定了只能选一个

【默认的，父类的或者本类的其它构造】

Object类的方法【没有hasNext方法】

 

重载(Overloading)

    （1） 方法重载是让类以统一的方式处理不同类型数据的一种手段。多个同名函数同时存在，具有不同的参数个数/类型。

重载Overloading是一个类中多态性的一种表现。

    （2） Java的方法重载，就是在类中可以创建多个方法，它们具有相同的名字，但具有不同的参数和不同的定义。

调用方法时通过传递给它们的不同参数个数和参数类型来决定具体使用哪个方法, 这就是多态性。

    （3） 重载的时候，方法名要一样，但是参数类型和个数不一样，返回值类型可以相同也可以不相同。无法以返回型别作为重载函数的区分标准

来源： http://www.cnblogs.com/bluestorm/archive/2012/03/01/2376236.html

重写（Overriding）

    （1） 父类与子类之间的多态性，对父类的函数进行重新定义。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。在Java中，子类可继承父类中的方法，而不需要重新编写相同的方法。但有时子类并不想原封不动地继承父类的方法，而是想作一定的修改，这就需要采用方法的重写。方法重写又称方法覆盖。

    （2）若子类中的方法与父类中的某一方法具有相同的方法名、返回类型和参数表，则新方法将覆盖原有的方法。如需父类中原有的方法，可使用super关键字，该关键字引用了当前类的父类。

    （3）子类函数的访问修饰权限不能少于父类的；

重写方法的规则：

1、参数列表必须完全与被重写的方法相同，否则不能称其为重写而是重载。

2、返回的类型必须一直与被重写的方法的返回类型相同，否则不能称其为重写而是重载。

3、访问修饰符的限制一定要大于被重写方法的访问修饰符（public>protected>default>private）

4、重写方法一定不能抛出新的检查异常或者比被重写方法申明更加宽泛的检查型异常。例如：

父类的一个方法申明了一个检查异常IOException，在重写这个方法是就不能抛出Exception,只能抛出IOException的子类异常，可以抛出非检查异常。

 

而重载的规则：

1、必须具有不同的参数列表；

2、可以有不同的返回类型，只要参数列表不同就可以了；

3、可以有不同的访问修饰符；

4、可以抛出不同的异常；

成员变量（实例变量）&局部变量区别：

(1)作用域
成员变量：针对整个类有效。
局部变量：只在某个范围内有效。(一般指的就是方法,语句体内)
(2)存储位置
成员变量：随着对象的创建而存在，随着对象的消失而消失，存储在堆内存中。
局部变量：在方法被调用，或者语句被执行的时候存在，存储在栈内存中。
当方法调用完，或者语句结束后，就自动释放。
(3)初始值
成员变量：有默认初始值。
局部变量：没有默认初始值，使用前必须赋值。

成员变量（实例变量）&静态变量（类变量）区别：

A：调用方式
静态变量也称为类变量，可以直接通过类名调用。也可以通过对象名调用。这个变量属于类。static
成员变量也称为实例变量，只能通过对象名调用。这个变量属于对象。
B：存储位置
静态变量存储在方法区长中的静态区。
成员变量存储在堆内存。
C：生命周期
静态变量随着类的加载而存在，随着类的消失而消失。生命周期长。
成员变量随着对象的创建而存在，随着对象的消失而消失。
D：与对象的相关性
静态变量是所有对象共享的数据。
成员变量是每个对象所特有的数据

泛型类不能继承Throwable类

异常发生在底层实现，捕获异常在上层。
泛型，用于使用某个类的时候限制相关类型。
显然限制相关类型这个工作应该是哪里用哪里直到。
如果异常支持泛型，那捕获异常的地方就要知道异常的泛型，也就必要知道了功能实现。
假设可以抛出有泛型的异常，如果说一个方法被声明为 throws SomeException<String>,SomeException<Number>
那么对于外界来说String的意义是什么，外界是否要捕获 分别SomeException<String> 和 SomeException<Number>?
还是只要捕获 SomeException<?>？
这无疑增加了异常处理的复杂度。
异常，最初设计就是为了把异常处理的代码和业务逻辑的代码分开，不会粘粘到一起。
这样可以在写业务逻辑的时候抛开泛型暂时不管，先把完整的业务逻辑写完，然后单独处理异常情况。
现在如果异常支持泛型，那么就会导致异常处理的复杂度增加。不能专心与业务逻辑。

TreeSet

1、TreeSet 是二差树实现的,Treeset中的数据是自动排好序的，不允许放入null值。

2、HashSet 是哈希表实现的,HashSet中的数据是无序的，可以放入null，但只能放入一个null，两者中的值都不能重复，就如数据库中唯一约束。

3、HashSet要求放入的对象必须实现HashCode()方法，放入的对象，是以hashcode码作为标识的，而具有相同内容的 String对象，hashcode是一样，所以放入的内容不能重复。但是同一个类的对象可以放入不同的实例 。

来源： http://blog.csdn.net/micheal100/article/details/39287919

StringBuffer 

length

public int length()

返回长度（字符数）。

指定者：

接口  CharSequence 中的  length

返回：

此对象表示的当前字符序列的长度。

---

capacity

public int capacity()

返回当前容量。容量指可用于最新插入的字符的存储量，超过这一容量就需要再次进行分配。

返回：

当前容量。

String、StringBuffer与StringBuilder的区别

String和StringBuffer / StringBuilder，它们可以储存和操作字符串。

1，String是只读字符串,String引用的字符串内容是不能被改变的。

2，StringBuffer和StringBulder类表示的字符串对象可以直接进行修改。StringBuilder是JDK1.5引入的，它和StringBuffer的方法完全相同，区别在于它是单线程环境下使用的，因为它的所有方面都没有被synchronized修饰，因此它的效率也比StringBuffer略高。

3，StringBuffer线程不安全，StringBuilder线程安全。

List 默认长度10

switch（x） x的数据类型

byte、char、short、int、枚举

以上是JDK1.6以前的版本。JDK1.7时，又增加了String，所以相对于JDK1.7而言就是六种了

LinkedList ArrayList的优劣

List是个接口，ArrayList和LinkedList都是List的实现类。

          ArrayList是基于数组实现的，而LinkedList是基于链表实现的；

          数组是将元素在内存中连续存放，由于每个元素占用内存相同，可以通过下标迅速访问数组中任何元素。但是如果要在数组中增加一个元素，需要移动大量元素，在内存中空出一个元素的空间，然后将要增加的元素放在其中。同样的道理，如果想删除一个元素，同样需要移动大量元素去填掉被移动的元素。                                                                                                     

          链表恰好相反，链表中的元素在内存中不是顺序存储的，而是通过存在元素中的指针联系到一起。比如：上一个元素有个指针指到下一个元素，以此类推，直到最后一个元素。如果要访问链表中一个元素，需要从第一个元素开始，一直找到需要的元素位置。但是增加和删除一个元素对于链表数据结构就非常简单了，只要修改元素中的指针就可以了。

    　　(1) 从逻辑结构角度来看

    　　 a, 数组必须事先定义固定的长度（元素个数），不能适应数据动态地增减的情况。当数据增加时，可能超出原先定义的元素个数；当数据减少时，造成内存浪费。

    　　 b,链表动态地进行存储分配，可以适应数据动态地增减的情况，且可以方便地插入、删除数据项。（数组中插入、删除数据项时，需要移动其它数据项）

    　　(2)从内存存储角度来看

    　　a,(静态)数组从栈中分配空间, 对于程序员方便快速,但自由度小。

    　　b, 链表从堆中分配空间, 自由度大但申请管理比较麻烦.

结论：

    如果应用需要快速访问数据，很少或不插入和删除元素，就应该用数组，也就是ArrayList;

    如果应用需要经常插入和删除元素你就需要用链表数据结构了，也就是LinkedList。

abstract class与interface的区别

http://blog.csdn.net/morandas/article/details/70186575

线程sleep() 与 wait()的区别

1，sleep()是Thread的方法，wait()是Object类中的方法

2，调用sleep()不会释放对象锁，只是暂停执行，让出cpu给其他线程，时间过了自动运行

3，wait()是放弃对象锁，必须notify()唤醒才能继续执行

http://www.cnblogs.com/hongten/p/hongten_java_sleep_wait.html

List Map Set 特点

一、List：有顺序 线性  可重复 插入删除慢

线程安全方法：List list = Collections.synchronizedList(new LinkedList(…));

LinkedList：双向链表实现存储　　索引数据慢插入数度较快　　线程不安全（比安全性能好）

ArrayList:数组方式存储数据　　索引数据快插入数据慢　　线程不安全

Vector:数组方式存储数据　　索引数据快插入数据慢　　线程安全

Stack：继承自Vector，实现一个后进先出的堆栈

 

二、Set：无顺序,不重复

HashSet：为快速查找设计的Set。存入HashSet的对象必须定义hashCode()。  

TreeSet： 保存次序的Set, 底层为树结构。使用它可以从Set中提取有序的序列。  

LinkedHashSet：具有HashSet的查询速度，且内部使用链表维护元素的顺序(插入的次序)。于是在使用迭代器遍历Set时，结果会按元素插入的次序显示。

 

三、Map：键必须是唯一

同步方法：Map m = Collections.synchronizedMap(new TreeMap(…));

Hashtable:基于散列表的实现　　允许空键空值　　线程安全

HashMap:基于散列表的实现　　允许空键空值　　线程不安全　　(与Hashtable基本一致)

TreeMap: 基于红黑树数据结构的实现　　不允许空键空值　　线程不安全

WeakHashMap：改进的HashMap，它对key实行“弱引用”，如果一个key不再被外部所引用，那么该key可以被GC回收。

在除需要排序时使用TreeSet,TreeMap外,都应使用HashSet,HashMap,因为他们的效率更高。

 

四、SparseArray<E>：采用了二分法方式存储数据（安卓的一个集合类）

android系统建议我们用SparseArray<E>来代替HashMap<Integer, E>

来源： http://www.cnblogs.com/Mr-Mo/archive/2015/07/01/4612769.html

静态、初始化代码块、构造函数

对于静态变量、静态初始化块、变量、初始化块、构造器，它们的初始化顺序依次是：
（静态变量、静态初始化块）>（变量、初始化块）> 构造器。
对于静态变量和静态初始化块之间、变量和初始化块之间的先后顺序又是怎样呢？
是否静态变量总是先于静态初始化块，变量总是先于初始化块就被初始化了呢？
实际上这取决于它们在类中出现的先后顺序。
注意，变量必须先定义再使用，所以静态变量、变量必须放在使用它们的静态初始化块、初始化块前面！

总结如下：
(1)先静态。具体是先父静态->子静态(参考下面2）

(2)先父后子。先父的全部，然后子的全部。

(3)优先级：父类 > 子类 。静态代码块 > 非静态代码块 > 构造函数 （与位置的前后无关系）

先静态，可以这么理解，只要出现了某类的关键字，那么这个类的类变量或方法就要初始化，否则引用的时候就没有初始化的时机了；

先父后子，可以这样理解，子类会引用父类的东西，那么必须先父后子。

来源： http://blog.csdn.net/xuxurui007/article/details/7749671