Java学习笔记

基础语法

Java标识符：

1.由字母，下划线，美元或数字组成；
2.应以字母，下划线，美元符开头；
3.大小写敏感，长度无限制；

变量：

变量必须先声明，再赋值，才能使用。

局部变量：方法(包括形参)或语句块内部定义的变量；

成员变量：方法外部，类内部定义的变量；类外面不能声明变量。大括号外不能识别大括号内的变量。

数据类型

引用类型3种(类，接口，数组)；

基本类型4类8种(boolean,byte(1字节),char，short(2字节),int(4字节),long(8字节),float(4字节),double(8字节))字段长度不受操作系统影响。

java中没有无符号类型，所有整数类型都是带符号的
boolean:只有true和false;char:Unicode编码，不能转换成其他类型;
字符常量 单引号括起来的单个字符例如 char eChar='a'; char cChar='中'.

java采用Unicode编码，每个字符占两个字节，因而可用16进制编码形式表示，例如char c1 = '\u0061'。

虽然char型是2个字节；但是string对象(比如"java")所占字节数和编码方式有关，未指定时根据系统的默认编码方式。

整型常量默认为int，long类型后面需加“l”或“L”；

浮点常量默认为double，float类型后面需加“f”或“F”；

数据类型转换

boolean不能和其他数据类型转换
整型，字符型，浮点型的数据在混合运算中相互转换并遵循以下原则：
容量小的类型自动转换为容量大的数据类型，容量指的是表示数的多少，转换排序为：
byte,short,char>int>long>float>double
byte short char之间不会互相转换，三者在计算时首先转换为int类型
容量大的向容量小的转换，要进行强制转换，加上强制转换符，但可能精度降低或者溢出。
有多种类型的数据混合运算时，系统首先自动将所有数据类型换成容量最大的那一种数据类型，然后在计算。
实数常量（如：1.2）默认为double
整数常量（如：123）默认为int

运算符：

逻辑运算符：!逻辑非，&逻辑与（执行所有判断 才返回结果），|逻辑或，^逻辑异或，&&短路与(第一个表达式为false则不再后面表达式)，||短路或

位运算符：&,|,^,~,>>,<<,>>>

"+"两侧中有一个是字符串(String)类型，系统将另一个操作数转换为字符串后进行连接；

数组：java中的数组是引用类型，它的元素相当于成员变量；多维数组的声明和初始化应该按从高维到低维的顺序进行。数组的拷贝最好使用java.lang.sysytem 中的arraycopy();

容器：

set没有顺序不可以重复，list有顺序可重复(两个对象互相equals)。
Collection接口定义了存取一组对象的方法，其子接口Set和List分别定义了存储方式。LinkedList和ArrayList实现了List;

例：Collection c = new ArrayList();(父类引用指向子类对象)

ArrayList可看作是能够自动增长容量的数组。

所有实现了Collection接口的容器都有一个iterator方法用以返回一个实现了Iterator接口的对象。Iterrator对象称作迭代器.

利用ArrayList的toArray()返回一个数组;Arrays.asList()返回一个列表;

容器类对象在调用remove contains等方法时，需要比较对象是否相等，这涉及到对象类型的equals方法，对于自定义的类型需要重写equals方法和hashCode（map索引时会用）方法，相等的对象应该具有相同的hash codes

内存管理：

1.heap-new出来的东西；2.stack-局部变量；3.data segment-静态变量，字符串常量；4.code segment-存放代码；

引用：

(1)强引用(StrongReference):强引用是使用最普遍的引用。如果一个对象具有强引用，那垃圾回收器绝不会回收它。当内存空间不足， Java 虚拟机宁愿抛出 OutOfMemoryError 错误，使程序异常终止，也不会靠随意回收具有强引用的对象来解决内存不足的问题。
  
⑵软引用(SoftReference):如果一个对象只具有软引用，则内存空间足够，垃圾回收器就不会回收它；如果内存空间不足了，就会回收这些对象的内存。只要垃圾回收器没有回收它，该对象就可以被程序使用。软引用可用来实现内存敏感的高速缓存。软引用可以和一个引用队列（ ReferenceQueue ）联合使用，如果软引用所引用的对象被垃圾回收器回收，虚拟机就会把这个软引用加入到与之关联的引用队列中。
  
⑶弱引用(WeakReference):如果一个对象只具有弱引用，那就类似于可有可物的生活用品，弱引用与软引用的区别在于：只具有弱引用的对象拥有更短暂的生命周期。在垃圾回收器线程扫描它所管辖的内存区域的过程中，一旦发现了只具有弱引用的对象，不 管当前内存空间足够与否，都会回收它的内存。不过，由于垃圾回收器是一个优先级很低的线程，因此不一定会很快发现那些只具有弱引用的对象。弱引用可以和一个引用队列（ ReferenceQueue ）联合使用，如果弱引用所引用的对象被垃圾回收，虚拟机就会把这个弱引用加入到与之关联的引用队列中。
  
⑷虚引用(PhantomReference):“ 虚引用 ” 顾名思义，就是形同虚设，与其他几种引用都不同，虚引用并不会决定对象的生命周期。如果一个对象仅持有虚引用，那么它就和没有任何引用一样，在任何时候都可能被垃圾回收器回收。虚引用主要用来跟踪对象被垃圾回收器回收的活动。虚引用与软引用和弱引用的一个区别在于：虚引用必须和引用队列 （ ReferenceQueue ）联合使用。当垃圾回收器准备回收一个对象时，如果发现它还有虚引用，就会在回收对象的内存之前，把这个虚引用加入到与之关联的引用队列中。程序可以通过判断引用队列中是否已经加入了虚引用，来了解被引用的对象是否将要被垃圾回收。程序如果发现某个虚引用已经被加入到引用队列，那么就可以在所引用的对象的内存被回收之前采取必要的行动.

   在 java.lang.ref包中提供了三个类：SoftReference类、WeakReference类和PhantomReference类，分别代表软引用、弱引用和虚引用。ReferenceQueue类表示引用队列，它可以和这三种引用类联合使用，以便跟踪Java虚拟机回收所引用的对象的活动。举例：

//强引用

String str = new String("hello"); 

//引用队列
ReferenceQueue<String> rq = new ReferenceQueue<String>();

//创建一个弱引用，它引用"hello"对象，并且与rq引用队列关联
WeakReference<String> wf = new WeakReference<String>(str, rq); 

内存中引用与对象的关系如图（"hello"对象同时具有强引用和弱引用 ）：

        "hello"对象同时具有强引用和弱引用

str=null; //取消"hello"对象的强引用，内存中引用与对象的关系如下图所示，此 时"hello"对象仅仅具有弱引用，因此它有可能被垃圾回收。假如没有回收：

String str1=wf.get(); //假如"hello"对象没有被回收，str1引用"hello"对象  ，

rq.poll()返回null，ReferenceQueue的poll()方法用于返回队列中的引用，如果没有则返回null。

                 hello"对象只具有弱引用

此时hello"对象仅仅具有弱引用。接下来两次调用System.gc()方法，催促垃圾回收器工作，从而提 高"hello"对象被回收的可能性。假如"hello"对象被回收，那么WeakReference对象的引用被加入到ReferenceQueue 中，接下来wf.get()方法返回null，并且rq.poll()方法返回WeakReference对象的引用。
System.gc(); 
System.gc(); 
String str1=wf.get(); // 假如"hello"对象被回收，str1为null
Reference<? extends String> ref=rq.poll(); //

内存中引用与对象的关系如下图所示

             "hello"对象被垃圾回收，弱引用被加入到引用队列

出处：http://blog.youkuaiyun.com/hecker385/article/details/6689333

关键字

synchronized

synchronized用来修饰一个非静态方法，表示执行这个方法，必须获取该方法所属对象的锁；  

synchronized用来修饰静态方法，表示要执行该方法必须获取该类的类锁；

synchronized修饰代码块synchronized(obj) { //code.... }表示执行该代码块必须获取obj这个对象的对象锁。这样做的目的是减小锁的粒度，保证当不同块所需的锁不冲突时不用对整个对象加锁。利用零长度的byte数组对象做obj非常经济。

volatile

Volatile修饰的成员变量在每次被线程访问时，都强迫从主内存中重读该成员变量的值,而且，当成员变量发生变化时，强迫线程将变化值回写到主内存。

但需要注意的是对于volatile修饰的变量，jvm虚拟机只是保证从主内存加载到线程工作内存的值是最新的（加载过后如果主内存中的值又被修改，则虚拟机栈中的值不会发生相应变化，多线程操作时有可能达不到预期效果）。

http://www.cnblogs.com/aigongsi/archive/2012/04/01/2429166.html

throw

throw关键字通常用在方法体中，并且抛出一个异常对象。程序在执行到throw语句时立即停止，它后面的语句都不执行。即语句抛出一个异常。
throws
throws关键字通常被应用在声明方法时，用来指定可能抛出的异常。多个异常可以使用逗号隔开。即方法可能抛出异常声明。
static：

1：仅包含静态成员。

2：无法实例化。
3：是密封的。
4：不能包含实例构造函数。
5：非静态类可以包含静态的方法、字段、属性或事件；
6：静态方法和属性不能访问其包含类型中的非静态字段和事件
7：静态方法只能被重载，而不能被重写，因为静态方法不属于类的实例成员；
final的方法不能白重写

final

final的变量值不能被修改
final的方法不能白重写
final的类不能被继承

面向对象

访问权限

继承：

子类的构造过程中必须调用父类的构造方法，可使用super(),如果没有显示调用，系统默认调用父类无参数的构造方法(如果父类没有，则编译出错)；

子类虽然继承父类的私有成员，但是不可见，并不能访问（没有使用权）

子类重写父类方法时：1必须使用相同名称，返回值，参数列表；2重写方法不能使用比被重写方法给严格的权限

抽象类：

1含有抽象方法(只有方法的声明没有实现)的类必须声明为抽象类，

2.抽象类必须被继承，抽象方法必须被重写；

3.抽象类不能实例化；

4.抽象方法只需声明，不需实现

接口

从本质上讲，接口是一种特殊的抽象类，其中只包含常量(只能是public static final)和方法(只能是public)的定义(没有实现)。接口可以多重实现(一个类实现多个接口)，接口和实现类之间存在多态性

(实现接口的类所生成对象，可以作为参数传入到以该接口为形参的函数中；类实现多个接口(重写其中的抽象方法)，然后这些方法就可以通过接口引用指向这个类生成的对象来访问)；

异常处理

异常

java异常是java提供的用于处理程序中错误的一种机制。

所谓错误是指程序在运行的过程中发生的一些异常事件（如，除0溢出，数组下标越界，所要读取的文件不存在）
设计良好的程序应该子啊异常发生时提供处理这些方法，使得程序不会因为异常的发生而阻断或产生不可预见的结果。
java程序的执行过程中如出现异常事件，可以生成一个异常类对象，该异常对象封装了异常事件的信息并提交给java运行时系统这个过程称为抛出(throw)异常。
当java运行时系统接收到异常对象时，会寻找处理这一异常的代码并把当前异常对象交给其处理，这一个过程称为捕获异常(catch)异常。

Error

称为错误，由java虚拟机生成并抛出，包括动态链接失败，虚拟机错误等，程序对其不处理，出现这类错误，除了尽量使程序安全退出外，在其他方面是无能为力的。

Exception:

所有异常类的父类，其子类对应了各种各样可能出现的异常事件，一般需要用户显示的声明或捕获，无法编译通过。

Runtime Exception:一类特殊的异常，一般是外部错误，如被0整除，数组下标范围，其产生比较频繁，处理麻烦，如果显示的声明或捕获将会对程序可读性和运行效率影响很大。因此由系统自动检测并将它们交给缺省的异常处理程序（用户可不比对其处理），控制台一旦报RuntimeException，就必须要修改代码，没有例外的，因为这属于程序员的错误。而且，处理RuntimeException，不是try-catch能解决的。try-catch在这里使用毫无意义。即RuntimeException可以“不处理”是指可以不用try--catch不捕获它照样可以编译通过，而不是说真的出现这种异常时可以抛出一个异常之后继续往下执行。

进程和线程

线程

简单定义：程序里不同的执行路径。

线程可以赋予名字、优先级、标识是否是守护线程等。在Java中有两类线程：User Thread(用户线程)、Daemon Thread(守护线程)。守护线程和用户线程唯一的区别就是守护线程会随着用户线程的（被守护的）结束而结束。

线程就绪，运行和阻塞时属于Alive()情形,sleep()指定线程睡眠时间(是Thread的静态方法，别的线程不可以访问锁定对象)；join()调用某线程的该方法，将当前线程与该线程"合并"，即等待该线程结束再回复当前线程的运行(有点像方法调用)；yield()让出cpu，当前线程进入就绪队列等待调度；wait()当前线程进行对象的wait pool（属于Object的方法，别的线程可以访问锁定对象）,notify()/notifyAll()唤醒对象的wait pool中的一个/所有等待线程。
B．每个对象只有一个锁（lock）和之相关联。（ 同一对象在同一时间段只能被锁一次。）
C．实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。
http://developer.51cto.com/art/200908/143504.htm

1.定义线程类实现Runnable接口，在实现Runnable接口的类的run方法中可以使用Thread静态方法获取当前线程的引用。

2.定义一个Thread的子类并重写run方法，然后实例对象。

java中引入的对象“互斥锁”的概念，保证共享数据操作的完整性，每个对象都对应于一个可称为“互斥锁”的标记，它保证任意时刻只有一个线程可以访问该对象。使用关键字synchronized来锁定某一个对象，synchronized(某个对象){do something} 或者 public synchronized void function(){do someting}//

A．无论synchronized关键字加在方法上还是对象上，他取得的锁都是对象，而不是把一段代码或函数当作锁――而且同步方法很可能还会被其他线程的对象访问。（当没有明确的对象作为锁，只是想让一段代码同步时，可以创建一个特别的instance变量来充当锁private byte[] lock = new byte[0];synchronized(lock) { //… }）

join

Join方法实现是通过wait（小提示：Object 提供的方法）。 当main线程调用join时候，main线程会获得线程对象t的锁（wait 意味着拿到该对象的锁),调用该对象的wait(等待时间)，直到该对象唤醒main线程，比如退出后。wait的时间实际上是从拿到对象锁开始计时。

http://www.blogjava.net/vincent/archive/2008/08/23/223912.html

AWT

两大核心类：component，container;

container有两种：window(可作为应用程序的独立窗口显示)；panel(不能独立显示)
5个布局管理器：FlowLayout,BorderLayout,GridLayout,CardLayout;GridBagLayout
FlowLayout是Panel的默认布局管理器；BorderLayout是Frame的默认布局管理器；

每个component都有一个paint(Graphics g)用于实现绘画，每次重画component时自动调用该函数；repaint()->update()->paint()

 

Serializable：标识一个类的对象可以被序列化(把一个对象的状态写入一个字节流的过程,这些字节序列可以被完全存储以备以后重新生成原来的对象)，

Externalizable：控制序列化的具体实现。

使用transient修饰符来标识一个成员变量在序列化子系统中应被忽略。

TEMP：

重写方法需要抛出与原方法所抛出类型一致的异常（不能大也不能小），或者不抛出异常。
------------------------------------------------------------------------------------------

                    -------------------------------------------------------------------------------------------------------

 

常用代码：

窗口居中:
Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize(); 
Dimension tempSize = this.getSize();
if (tempSize.height > screenSize.height)  tempSize.height = screenSize.height;
if (tempSize.width > screenSize.width)     tempSize.width = screenSize.width; 
setLocation((screenSize.width - tempSize.width)/2, (screenSize.height - tempSize.height)/2);