内部类

内部类，4中内部类： 成员内部类、局部内部类、静态内部类、匿名内部类。

成员内部类：作为外部类的一个成员存在，与外部类的属性，方法并列。

• 成员内部类中不能定义静态变量，但可以访问外部类的所有成员
• 内部类作为外部类的成员，可以访问外部类的私有成员或属性
• 用内部类定义在外部类中不可访问的属性，这样就在外部类中实现了比外部类的private还要小的访问权限
• 内部类是一个编译时的概念，一档编译成功，就会成为完全不同的两个类，对于一个名为outer的外部类和其内部定义为Inner的内部类，出现outer.class和outer$inner.class两个类。
• 内部类中不允许定义静态变量
• 内部类中可以定义和外部类相同的变量
• 外部类的变量如果和内部类的变量没有同名的，则可直接用变量名访问外部类的变量
• 如果同名的内部类中访问内部类自己的变量直接用变量名或this.，内部类访问外部类同名变量采用”外部类名.this.变量名“
• 内部类可直接访问外部类的静态方法
• 访问外部类的非静态方法，必须使用外部类的实例

实例

Outer.this.outer_f2();
```* 外部类非静态方法访问成员的内部类

实例

Inner inner = new Inner();
inner.inner_f1();

* 外部类静态方法访问成员内部类

实例

Outer out = new Outer();
Inner inner = out.new Inner();
inner.inner_f1();

#####局部内部类：在方法中定义的内部类，与局部变量类似，在局部内部类前不加修饰符public或private，其范围为定义它的代码块

* 内部类中有和外部类同名的变量，访问内部类变量，直接使用或“this.变量名“。访问外部变量使用”外部类类名.this.变量名“
* 在类外不可直接生成局部内部类(保证局部内部类对外不可见)，要想使用局部内部类时需生成对象调用方法，在方法中才能调用其局部内部类，通过内部类和接口达到一个强制的弱耦合，用局部内部类来实现接口，并在方法中返回接口类型，使局部内部类不可见，屏蔽实现类的可见性。

#####静态内部类：静态内部类定义在类中，任何方法外，用static定义

* 静态内部类中可以定义静态或非静态成员
* 静态内部类可以用public、protected、private修饰
* 静态内部类只能访问外部类的静态成员、内部类、静态成员

例子：

Inner.inner_i;
Inner.inner_f1();

* 外部类访问内部类的非静态成员，实例化内部类即可

例子：

Inner inner = new Inner();
inner.inner_f2();

* 生成一个静态内部类不需要外部类成员，这是静态内部类和成员内部类的区别
* 静态内部类对象可直接生成`Outer.Inner in = new Outer.Inner()`

#####匿名内部类：一种特殊的局部内部类，通过匿名类实现接口

特点:

* 一个类用于继承其他类或是实现接口，并不需要增加额外的方法，只是对继承方法的实现或是覆盖。
* 只是为了获得一个对象实例，不需要知道其实际类型
* 类名没有意义，也就是不需要使用到
* 他是局部内部类，局部内部类所有限制都对其生效
* 匿名内部类是唯一一种无构造方法类
* 大部分匿名内部类都用于接口回调的
* 编译时由系统自动起名Out$1.class
* 如果一个对象编译时的类型是接口，那么其运行的类型为实现这个接口的类。

类方法

类方法： 静态的，被虚拟机加载的时候内存中仅存在一份独一无二的拷贝
实例方法： 实例化某个对象的同时，会为对象中得该方法分配一段内存，每个实例一个

接口

• 实现一个接口必须重写接口中得所有方法
• 接口的特性：

① 接口可以多重实现，即一个类可以实现多个接口

② 接口中声明的属性默认为public static final，也只能是public static final，当不写时默认为这个。

③ 接口中只能定义抽象方法，而且这些方法默认为public，也只能是public

④ 接口可以继承其他接口，并添加新的属性和抽象方法

⑤ java接口可以有public、静态和final属性

⑥ Java接口中的方法默认都是public、abstract类型的，没有方法体，不能被实例化。

⑦ Java接口中只能包含public、static、final类型的成员变量和public、abstract类型的成员方法。

⑧ 当类实现了某个Java接口时，它必须实现接口中得所有抽象方法，否则这个类必须声明为抽象类。 **抽象类可以实现接口**。

接口分类

接口分类：

① 普通接口

② 标识接口：没有任何方法和属性的接口，仅仅表明实现它的类属于一个特定的类型

③ 常量接口：由实现这个接口的类使用这些常量

访问权限控制列表

访问权限	同一个类内部	同一个包内部	不同包子类	不同包非子类
public	yes	yes	yes	yes
protected	yes	yes	yes	yes
default	yes	yes	no	no
pricate	yes	no	no	no

Java线程

线程阻塞

• sleep() : 指定以毫秒为单位的一段时间作为参数，他使得线程在指定的时间进入阻塞状态
• suspend() ：使线程进入阻塞状态，并且不会自动恢复，必须使用resume()对其进行resume()调用们才能使得线程重新进入可执行状态
• yield()： 使线程放弃当前分得得CPU时间，但不使线程进入阻塞状态，随时可能再次分得CPU时间
• notify() , wait():

wait()：使得线程进入阻塞状态，它有两种形式，一种允许指定以毫秒为单位的一段时间作为参数，另一种无参数。当对应notify()被调用或者超出指定的时间线程重新进入可执行状态

两个要求：1 直接隶属于Object类，所有对象拥有这一方法。 2 必须在synchronized方法或块中调用。

wait() 导致线程阻塞，并且该对象上的锁被释放。

notify() 导致因调用该对象的wait()方法而阻塞的线程中随机选择一个接触阻塞。(但要等到获得锁后才真正被执行)

① 调用notify()方法导致解除阻塞的线程因调用该对象的wait()方法而阻塞的线程中随机选取的，我们无法预料哪一个线程将被选择。

② notifyAll()方法将把因调用该对象的wait()方法而阻塞的所有线程一次性全部解除阻塞。

• join()： 将几个并行线程的线程合并为一个单线程执行。

当一个线程必须等待另一个线程执行完毕才能执行可使用join方法。

join(): 等待线程终止

join(ling mills): 等待线程终止的时间最长为mills 毫秒

join(long mills, int nanos)

线程基本问题

• run() 的访问控制符必须是public，返回值必须是void run() 不带参数。
• Java是面向对象的程序设计语言，不同的对象的数据是不同的，r1,r2有各自的run方法，而synchronize使同一对象的多个线程，在某个时刻只有其中一个线程可以访问这个对象的synchronize数据

代码如下

public class ThreadTest implements Runnable
{
    public synchronized void run()
    {
        for(int i=0; i<10;i++)
        {
            System.out.print(" " + i);
        }
    }

    public static void main(String[] args)
    {
        Runnable r1 = new ThreadTest();
        Runnable r2 = new ThreadTest();
        Thread t1 = new Thread(r1);
        Thread t2 = new Thread(r2);
        t1.start();
        t2.start();
    }
}

或者

public static void main(String[] args)
{
    Runnable r = new ThreadTest();
    Thread t1 = new Thread(r);
    Thread t2 = new Thread(r);
    t1.start();
    t2.start();
}

• Thread 提供方法 setProperity(Thread.MAX_PRIORITY) 优先级并不代表一个执行完再执行下一个，而是优先开始
• 一个线程在sleep的时候，并不会释放对象的锁标识
• join()方法，能够使调用该方法的线程在此之前执行完毕
• sleep方法可以使低优先级的线程得到执行机会，当然也可以让同优先级和高优先级的线程有执行的机会，而yield()方法只能使同优先级的线程有执行的机会。
• wait()、notify()、notifyAll() 这三个方法用于协调多个线程对共享数据的存取，所以必须在synchronized语句块内使用者三个方法。
• wait() 可以释放锁标识
• 当线程执行了对一个特定对象的wait()调用时，那个线程被放到与那个对象相关的等待池中，此外，调用wait()的线程会自动释放对象的锁标识
• 对一个特定的对象执行notify()调用时，将从对象的等待池中移走任意一个线程，并放到锁标识等待池中，那里的线程一直等待，直到可以获得对象的锁标识。
• notifyAll()方法将从对象等待池中移走所有等待那个对象的线程并放到锁标识等待池中。
• 不管是否有线程等待都可以调用notify()

方法继承

• 当sub类和Base类在同一个包时Sub类继承Base类中得public、protected、default级别的变量和方法
• 在不同包时继承public、protected级别的变量和方法

方法重载

• 方法名相同
• 方法的参数类型、个数顺序至少有一项不同
• 方法的返回类型可以不相同
• 方法的修饰符可以不相同
• main方法也可以被重载

方法覆盖

• 名称、返回类型、参数签名
• 子类的方法名称、返回类型、参数类型必须与父类一致
• 子类方法不能缩小父类方法的访问权限 (但可以增大)
• 父类的静态方法不能被子类覆盖为非静态方法
• 子类可以定义与父类的静态方法同名的静态方法，以便在子类中隐藏父类的静态方法(满足覆盖约束)，静态方法会继承的
• 父类的非静态方法不能被子类覆盖为静态方法
• 父类的私有方法不能被子类覆盖
• 父类的抽象方法可以被子类通过两种途径覆盖(实现和覆盖)
• 父类的非抽象方法可以被覆盖为抽象方法
• 异常的抛出： 子类方法抛出的异常只能是父类的子类，或和父类相同

super关键字

super和this关键字可用来覆盖Java的默认作用域，使被屏蔽的变量和方法变为可见。

• 父类的成员变量和方法为private使用super访问编译出错。
• 在子类中访问父类的被屏蔽的方法和属性
• 只能在构造方法或实力方法内使用super关键字，而在静态方法和静态代码块中不能使用super

try-finally中return的执行顺序

• finally始终执行，如果在finally中有return，始终返回这个值
• 当不抛错和try中return a，finally中没有return语句时，try的return方法会先执行，finally的方法最后执行，然后再返回到主方法
• finally中得return级别最高
• return的值会保存下来，不受后面finally的影响

abstract方法

• abstract方法不可以是private的
• 接口方法只接受2个修饰符，public和abstract
• 接口中变量默认为final static
• 一个类继承父类，实现接口，如果其中有相同的成员变量，在调用时如果有直接调用会出错。

ArrayList 和 Vector

• 可按索引号来获取元素，二者中数据是可重复的。
• 区别：

① 同步性： Vector线程安全， Hashtable线程安全， ArrayList线程不安全， HashMap线程不安全。
② 数据增长： Vector增长原来的一倍， ArrayList 增长为原来的0.5倍。

HashMap 和 Hashtable

• HashMap是Hashtable的轻量级实现(非线程安全的实现)
• HashMap允许空(null)键值(key)，Hashtable不允许。

List、Set继承自Collection， Map不是

• Map继承自java.util.AbstractMap
• Hashtable继承自java.util.Dictionary

ArrayList 和 Vector都是使用数组方式存储数据，索引数据快而插入数据慢。

ArrayList、LinkedList

• ArrayList：以索引值访问对象效率高，插入和移走元素效率较低。优点在于随机访问。
• LinkedList：顺序数据访问，插入、移走元素效率高

HashSet、TreeSet、LinkedHashSet

• HashSet 不允许插入重复值，使用了一个HashMap实例
• TreeSet 实现了SortedSet接口，自动排序，使用TreeMap实例
• LinkedHashSet 迭代顺序和插入顺序一致

HashMap、TreeMap、WeekHashMap、LinkedHashMap

• HashMap Map基于散列表的实现
• TreeMap 基于红黑树顺序存放关键字来实现SortedMap接口

Vector、Stack、Hashtable

• Vector线程安全
• Stack是Vector的子类
• Hashtable同步化

最近把之前在公司内部考试的复习资料进行整理一下，也顺便回顾一下之前的知识。

java 经典基础知识

对象的声明和初始化

• static函数只能访问static变量或static函数。

• 对象饮用唯一的缺省值是null

char : '\u0000'
boolean : false
Reference : null

• 
  刚构造的数组中的元素总是设为默认值

声明一个数组仅产生了一个数组引用，但未分配数组的存储空间，一个数组的大小在分配数组内存时才确定的。
System.arrayCopy() 拷贝数组比循环要快很多。

• 
  final变量

声明为final的成员变量必须在构造对象的过程中完成初始化：1.定义处 2.初始化快中 3.构造函数中
声明为final的静态变量不必在构造函数中初始化，但必须在静态上下文中初始化一次(定义时)静态区段即可。
声明为final的局部变量必须(且只能)在使用前初始化一次，不使用的话可以不用初始化。

• 
  final用法

final类： 不能再派生新的子类
final函数：不能被子类覆写
final参数：只能引用，不能修改

• 
  常量： 不是所有的final数据都是常量，只有再编译期间能确定数字的才能算是常量

final static也可以声明常量

• 构造函数： 在构造函数中避免调用子类可以覆写的函数

• 有继承关系的类之间的初始化顺序是先静态后非静态，先父后子

类的初始化：

① 父类的类初始化

② 类变量分配存储空间

③ 类变量显示赋值

④ 执行static块
1步如果类在初始化中需要使用其他未加载的类，则对未加载的类也会执行上述过程。
2步在给类变量分配存储空间时，由于新分配的存储空间都被虚拟机初始化过了，所以自动取得了默认值，虚拟机会通过某些方法，如调用memset()函数将一大块内存全部置为默认值，这在java代码中不可见，编译出来的字节码也没有相关的内容，如果没有显示赋值则声明变量的地方不能设置断点便是这个原因

对象的初始化：

① 给对象分配存储空间

② 父类的对象初始化过程

③ 给对象变量显示赋值

④ 执行构造函数

• instance of 运算符

getClass() 用于获取对象的真是类型，两个有继承关系的类分别调用getClass获得的类是不同的。
instance of用来判断一个对象是否是某种类型的，即IS-A关系，子类对象是父类对象的实例。
null对象不是任何类的实例

• 对象是通过引用传递的，引用变量是通过值传递的。
• 覆写equals()函数须遵循一下约定：

① 不同类型的对象的equals函数总返回false

② 对于任意的非空引用值x, x.equals(null)返回false

③ 自反性原则： 和自己比较返回true

④ 对称性原则： `x.equals(y)=true ~ y.equals(x)=true`

⑤ 传递性： 

⑥ 一致性原则：多次调用结果相同。
```* 覆写hashCode()注意事项

在每个覆写了equals函数的类中，必须要改写hashcode函数

① 如果一个对象的equals函数比较所用到的对象的信息没有修改的话，那么该对象多次调用hashCode()，必须返回同一个整数 (多次调用值唯一)

② 如果两个对象根据equals函数是相等的，那么调用这两个对象中任意一个对象的hashcode函数必产生相同的整数结果

③ 如果equals步相等，则不需要要求必须产生相同的结果

Object.clone()函数仅实现浅层拷贝————只把基本数据类型和引用类型值复制给新对象。

① 各自拥有数值相同的基本数据类型的值

② 共享引用类型对象成员
正③覆写clone()函数

① 要支持克隆必须实现Cloneable接口

② 实现clone函数时要记得调用super.clone()函数，实现浅层克隆

③ 如果缺省的浅克隆步符合要求，再实现深层克隆

* String对象一旦被创建，它就不能再被改变

不要使用new String("...")来创建对象，这样会创建两次造成浪费。
从byte[]数组创建字符串时，应使用new String(byte[])。构建bytep[]数组的toString实际上是Object的toString
大量字符串相加，应该使用StringBuilder,StringBuffer

* Switch

switch语句必须配套default分支(良好的编程风格)
各分支之间不能遗漏break
switch 语句只能用byte,char,short,int做参数。或者Integer,Chacter,Short,Byte类型 （java 1.7版本好像可以支持用String作为switch参数了）
case的表达式必须是常量，不能是变量。

* 异常处理

语法上允许：
try... catch
try... finally
try... catch... finally
对于资源的释放建议放在finally中进行处理，只有一种情况下finally子句不会被执行，那就是在try或者catch块中执行了System.exit()函数。
在子类中覆写函数时只能抛出父类中声明过的异常或异常的子类

* 循环的性能

避免在循环体中创建对象
循环的嵌套层次———— 小的写在外面
尽量避免在循环体中使用try catch块，最好在循环体外使用try catch提高性能。
建议使用局部变量保存循环测试。

* 接口中声明的属性默认为public static final的，实现该接口的类，可通过类名直接调用接口中的变量。
* 接口中函数定义默认为public abstract的
* 内部类的特征：

①可使用包含他的类的静态和实例成员变量，即使他们在外围时private的

②若被声明为static，就不能再访问其外部类得非静态成员

③若想在Inner Class中声明任何static成员，则该Inner Class必须声明为static

对于局部变量，只有final的才能被内部类使用。

* 一个接口可以继承多个借口
* static函数不能被覆写，所以static函数没有多态性
* 非静态内部类不能持有外部类对象的引用，可以访问外部类的所有成员。而静态内部类则不持有其外部类对象的引用，只能访问其外部类的静态成员。
* 线程

① 用一个类实现java.lang.Runnable接口，构造这个类的实例，然后通过这个实例构造一个java.lang.Thread类的实例，覆写run函数。

② 尽管run函数是线程代码执行的起点，但要启动一个线程只能调用start函数。

③ 在代码直接调用run()并不会新生线程，只是在原来的线程中执行run函数中的代码

④ 实现runnable接口不等于生成了线程

⑤ 只有线程运行结束了，线程对象的引用资源才能被回收。

* 三种声明互斥代码的方法：

① 同步块(对象锁)： synchronized(对象){互斥代码}

② 成员函数锁(实例锁)：成员函数加上synchronized修饰

③ 静态函数锁(类锁)：静态函数上加

synchronized块应该尽可能的小

* Collections是java.util下的类，包含各种有关集合操作的静态函数实现对各种集合的搜索、排序、线程安全等操作，但Collections不允许被继承。

Collections 是 java.util下的接口，是各种集合结构的父接口。
HashMap非线程安全，HashTable是线程安全的。 HashMap效率较高，允许null作为key和value
Vectory是线程安全的，ArrayList不是
当需要增长时，vectory增加一倍，ArrayList增长0.5倍
Map中不允许重复key，多次存入时，最后一次的有效。
ArrayList、Vectory、LinkedList

* Set

Set拒绝持有重复的元素，另外不能通过任何索引的函数来操作Set对象
HashSet、TreeSet、LinkedSet

* JVM在加载类的时候，如果没有给出classpatch则使用当前路径，如果给出了则使用classpatch。

如果classpath中没有说明当前路径，即没有包含(.)，则JVM不会在当前路径搜索。
在classpath中如果有重名类，JVM只加载第一个找到的类，其他被忽略。

* 换行

windows "\r\n" Linux "\n"
平台无关 System.getproperty("line.seperator");
分隔符 System.getproperty("file.seporator");
建议无论何时都使用"/"作为文件分隔符

* web服务器跟踪客户状态的四种

① 建立含有隐藏数据的隐藏表单字段(hidden field)

② 重写包含额外参数的URL (URL rewritting)

③ 使用持续的cokkie

④ 使用session会话机制

* Get请求的参数添加在URL后面会有安全问题，对于提交的数据大小有限制。Post请求的参数封装在请求体中较安全，可支持大数量的提交。

java移位详解

<< 左移位 >>带符号右移位 >>>无符号右移

移位的类型转换* 移位运算时，byte、short和char类型移位后的结果会变成int类型。

• int和上述三种类型移位时，规定实际的移动次数是移动次数和32的余数
• 移动long型数值时，规定实际移动的次数是移动次数和64的余数

移位方式* << ： 按二进制形式把所有的数字向左移动对应的位数，高位移出(舍弃)，地位的空位补空

• > > ： 按二进制形式把所有的数字向右移动对应的位数，地位移出(舍弃)，高位的空位补符号位，即正数补0，负数补1。

位数操作

+=、-=、&= 此类操作符和 +、-、/、&的区别

例子：

double d = 23.234D;
d/=5;    //d = 4.8468
d = d/5  //d = 4.8468

byte number = -23;
number = number & 0xf0; //number=-32
(number & 0xf0) = 224  // 它为int型

此处0xf0为无符号整形，所以number也将转换为无符号整形进行计算。

`byte number = -23; (number & 0xF0)此时这个字段为int类型，也就是说number被默认转换为了0xF0的类型，而int默认为无符号类型，所以number为补码：

源码： 10010111 反码：11101000 补码：11101001

转换为int 类型： 11111111 11111111 11111111 11101001

0xF0： 0000 ...... 11110000

相与： 0000 ...... 11100000 (224)

注意此处是进行的直接用补码和0xF0相与。

而如果使用number &= 0xF0, 则此时number依然为byte类型，且根据前面的为带符号的，而且此时为将number转化为0xF0类型进行运算，运算之后再强制转化为原类型。

结果 ： 11100000 (补)
值 ： 11011111 原： 10100000 (-32)