java学习笔记

第一章：对象导论：

第一节：抽象过程：

    程序复杂性其实是对复杂性的管理：待解决问题的复杂性，以及用料解决该问题的工具的复杂性。

 

   “我们只所以将自然分解”，组成各种概念，并按其含义分类，主要是因为我们是整个口语交流社会共同遵守的协定与参与者。

 

    人们所能够解决的问题的复杂性直接取决于抽象的类型和质量。

    类型：指”抽象是什么“？

 

    程序员：必须建立起计算机模型和实际待解决问题模型的之间管理。

   

    面向对象程序设计：

        （1）万物皆为对象。他可以存储数据，也可以存储自身的其他操作。

        （2）程序是对象的集合，它通过发送消息来告知彼此所要作的。  消息：可以想象为对某个特定对象的方法的调用请求

        （3）每个对象都有自己的由其他对象所构成的存储。 可以通过创建包含现有对象的包的方式创建新类型的对象。

        （4）每个对象都拥有其类型。也就是说每个对象都是某个类的一个实例。

        （5）某一特定类型的所有对象都可以接收同样的消息。

 

对象具有状态、行为和标识（内存中都有一个唯一的地址）。

 

   类：描述了具有相同特性（数据元素）和行为（功能）的对象集合。所以一个类实际上就是一个数据类型。

   每个对象都提供服务。

第二节：每个对象都提供服务

对象：即服务的提供者。

每个对象都有一个它所提供服务的内聚的集合。

程序员按角色分为：类创建者和客户端程序员（在应用中使用数据类型的消费者）

访问控制的好处：

  （1）让客户端程序员无法接触他们不应该涉及的部分。

   （2）访问控制第二个好处：允许库设计者可以改变内部的工作方式而不用担心会影响到客户端程序员。

   

   java用三个关键字在类的内部设定边界：

   （1）public:紧随其后的元素对任何人都是可用的

   （2）private：表示除了累的创建者和类型的内部方法之外的任何人都不能访问的元素。

   （3）protected:类可以访问protected成员。

第三节：继承：

  is-a(是一个):继承应该值覆盖基类的方法（而不添加在基类中没有的新方法），纯粹替代。

  is-like-a(像是一个)：不单单只覆盖了基类的方法，而且海鸥添加新的接口元素。替代基类。

  所有的类最终都继承自单一的基类。单根继承结果保证所有对象都具有某些功能。

第二章：一切都是对象

第一节：存储数据：

（1）寄存器：最快存储器，位于处理器内部。但是寄存器数量极其有限，所以寄存器根据需求进行分配。

（2）堆栈：位于通用RAM(随机访问存储器)中，但通过堆栈指针可以从处理器那里获得直接支持。堆栈指针若向下移动，则分配新的内存；若向上移动，则释放哪些内存。速度仅次于寄存器。所以某些java数据存储于堆栈中，特别是对象引用。

（3）堆：一种通用的内存池（也位于RAM区），用于存放所有的java对象。堆不同于堆栈的好处是：编译器不需要知道存储的数据在堆里存活多长时间。因此，在堆里分配存储有很大的灵活性。

（4）常量存储：常量值通常直接存放在程序代码内部，这样做是安全的，因为他们永远不会被该表。有时，在嵌入式系统中，常量本身会和其它部分隔开，所以在这种情况下，可以选择将其存放在ROM中。

（5）非RAM存储：如果数据完全存活于程序之外，那么它可以不受程序的任何控制，在程序没有运行时也可以存在。如：流对象和持久化对象。在流对象中，对象转换成字节流，通常被发送给另一台机器。在持久化对象中，对象呗存放于磁盘上，因此，即使程序终止，他们仍可以保持之际的状态。

第二节：基本类型

  都存储于堆栈中，因此更加高效。1bit=1二进制数据、1byte=8 bit、1汉子=2byte=16 bit

基本类型	大小	最小值	最大值	包装器类型
boolean	----------	------------	-----	Boolean
char	16bit	unicode 0	unicode 2 16-1	Character
byte	8bits	-128	+127	Byte
short	16bits	-2 15	+2 15-1	Short
int	32 bit	-2 31	+2 31	Integer
long	64 bits	-2 63	+2 63-1	Long
float	32 bits	IEEE 754	IEEE 754	Float
double	64bits			Double
void	---	------	------	Void

 

第三节：java中的数组。

   java的主要目标之一是安全性。java确保数组会被初始化，而且不能再它的范围之外被访问。

   当创建一个数组对象时，实际上就是创建了一个引用数组，并且每个引用都会被自动初始化为一个特定值，该值拥有自己的关键字null。一旦java看到null. 这就知道这个引用还没有指向某个对象。

第四节：永远不需要销毁的对象

    对象的作用域：用new 创建一个java对象时，它可以存活于作用域之外。

    类、字段（数据成员）、方法（成员函数）

 

基本类型默认值：

  

基本类型	默认值
boolean	false
char	'\u0000'(null)
byte	(byte)0
short	(short)0
int	0
long	0L
float	0.0f
double	0.0d

第五节：static关键字

当声明一个事务是static时，这久意味着这个域或方法不会与包含它的那个累的任何对象实例管理在一起。

类为：a

static i=100;

++ a.i=101;

static 字段对每个类来说都只有一份存储空间。

非static 字段则是对每个对象有一个存储空间。

第六节：注释和嵌入式文档：

多行注释:/*this is a comment

         * that continues;

         * across lines

         */

和/* this is a comment that

    continues across lines */一样。

 

单行注释： // abcdefg

 

文档注释 /**this is a comment that

          * continues;

          */

 

javadoc只能为public(公共)和protected(受保护) 成员进行文档注释。

             private 和包内可访问成员的注释会被忽略掉，所以输出结果看不到他们。

 

嵌入HTML

/**

 *<pre>

 *System.out.println(new Date());

 *</pre>

 */

 

javadoc的各种标签：

（1）@see:引用其他类  如：@see classname;  生成后未See Also目录

（2）{@link package.class#member label}：该标签与@see极其相识，只是它用于行内，并且是用"label"作为超链接文本，而不是用"See Also"

（3）{@docRoot} 该标签产生到文档目录的相对路径，用于文档树页面的显示超链接。

（4）{@inheritDoc}：该标签从当前这个类的最直接的基类中继承相关文档到当前文的文档注释中。

（5）@version：该标签的格式如下：@version version-information

（6）@author:显示姓名

（7）@since：该标签允许你指定程序代码最早使用的版本，可以在HTML Java文档中看到它被用来指定所用的JDK版本情况。

（8）@param：用于参数列表中  如：@param parameter-name description

（9）@return :用于描述返回值的含义，可以延续数行。

（10）@throws: 异常

第七节：编码风格

      类名首字母大写，如果类名由几个单词构成，那么把他们并在一起（不要用分割线分割名字），其中每个内部单词的首字母都采用大写。驼峰风格。

其它如：方法、字段（成员变量）以及对象引用名称等，公认的风格与类的风格一样，只标识第一个字母采用小写

第三章：操作符

第一节：优先级

   将一个对象赋值给另一个对象，实际上是将“引用”从一个地方复制到另一个对象。这意味着假若对象使用c=d,那么c和d都指向原来只有d指向的那个对象。

第二节：操作符

    （1） 算术操作符：加（+）、减（-）/、除（/）、乘（*）以及取模操作（%，它从整数除法中产生余数）。整数除法会直接去掉结果的小数位，而不是四舍五入地园整结果。

 

    （2）一元加、减操作符：

    

    （3）自动递增和递减：  对于前缀增和前缀递减，会先执行运算，再生成值。

                       对于后缀递增和后缀递减，先回生成值，再执行运算。

    （4）关系操作符：生成的是一个boolean(布尔)结果，它们计算的是操作数的值之间关系。

                关系操作符包括：小于（<）、大于(>)、小于或等于(<=)、大于或等于(>=)、

                                等于（==）以及不等于(!=)。等于和不等于适用于所有   的基本数据类型。而其他比较符不适用于boolean类型。 equas:适用于引用类型。

 

     （5） 逻辑操作符：与(&&)、或(||)、非（！）：根据参数的逻辑关系，生成ige布尔值(true或false)
 

     （6）  短路逻辑操作符：与(&)、或(|)。

 

      （7） 指数计算法：e:代表2.718

  

   按位操作符：用来操作整数基本数据类型中的单个"比特（bit）,即二进制位".按位操作符会对两个参数中对于的位执行布尔代数运算，并最终生成一个结果。

 

      （8） 移位操作符：可用来处理整数类型。左移位操作符（<<）能按照操作符右侧指定的位数将操作符左边的操作数向左移动（在低位补0）。“右位移”操作符（>>）则安装操作符右侧指定的位数将操作符左边的

      （9）三元操作符(if--else)  if(2>4) 

第四章 控制执行流程

 第一节：基本流程控制语句

                if--else基本流程语句

                迭代：while、do-while和for用来控制循环。

                for循环。
                逗号操作符：

                for循环

                foreach语法

 第二节：关键词介绍

           return:指定一个方法返回值、另一方面导致当前的方法退出。

           break：强行退出循环，不执行循环中的语句。

           continue：停止当前的迭代，然后退出起始处，瞌睡一个迭代。

           switch:划归为一种选择语句。(但它要求使用一个选择因子，因此必须是int或char那样的整数值。)

第五章：初始化与清理

第一节：初始化

    构造方法：用来初始化，没有返回值

    方法重载：参数列表、参数类型、返回值。

   

    this关键字只能在方法内部使用，表示对“调用方法的那个对象”的引用。但是如果要在方法内部调用同一个类的另一个方法，就不必使用this.直接调用即可。

   

    static:没有this的方法。在static 方法的内部不能调用非晶体方法。

第二节：清理：终结处理和垃圾回收。

    java的垃圾回收器只知道释放用New（）分配的内存，所以他不知道该如何释放该对象的这块“特殊内存”。

    为了应对这种情况，java允许在类中定义一个名为finalize()的方法。他的工作原理是这样的：一旦垃圾回收器准备好释放占用的存储空间，将首先调用finalize()方法，并在下一次垃圾回收动作发生时，才会真正回收对象的占用内存。

   （1）对象可能不被回收（2）垃圾回收并不等于“析构”（3）垃圾回收只与内存有关。

第三节：垃圾回收期如何工作

   垃圾回收的思想实事：对任何“活”的对象，一定能最终追溯到期存活在堆栈或静态存储区中的引用。这个引用链条可能会穿过数个对象层次，由此，如果从堆栈和静态存储区开始，遍历所有的引用，就能找到所有“活”的对象。访问过的所有对象必须都是“活”的。

   有一种方法名为：停止--复制。先暂停程序的运行，然后将所有存活的对象从当前堆复制到另一个堆中，没有被复制的全部都是垃圾。当对象呗复制到新堆时，他们是一个挨着一个的。所以新堆保存紧凑排列，然后就可以按前述方法简单、直接地分配新空间。

    当把对象从一处搬到另一处是，所有指向它额那些引用都必须修正。

    若程序稳定，产生很少垃圾，从一处复制到另一处，这很浪费。所以这时就会转换到另一种工作模式（即：“自适应”），这种模式被称为标记-清扫（方式速度相当慢）。但是当你知道会产生少量垃圾甚至不会产生垃圾时，它的速度更快。

    标记--清扫：所依据的思路同样是从堆栈和静态存储区出发，遍历所有的引用，进而找出存活的对象。每当它找到一个存活对象，就会给对象设一个标记，这个过程中不会回收任何对象。只有全部标记工作完成的时候，清理动作才会开始。在清理过程中，没有标记的对象将被释放，不会发生任何复制动作。所以剩下的堆空间是不连续的。垃圾回收器是希望得到连续空间的话，。

    JIT(即时编译器编译所有代码):缺陷：（1）这种加载动作散落在整个生命周期内，累加起来化更多时间（2）会增加可执行代码的长度（字节码要比即时编译器展开后的本地机器码小很多），这将导致页面跳读，从而降低程序熟读。

    惰性苹果（Lazy evaluation）:即时编译器只在必要的时候才编译代码。这样，不会被执行的代码页需就压根不会被JIT所编译。

第四节：成员的初始化

    （1）基本变量默认初始化都有值。

    （2）在类中定义一个对象引用时，如果不将其初始化，此引用就会获得一个特殊值null。

    （3） 指定初始化。

    （4）构造器初始化：可以调用方法或执行某些动作来确定初值，这为编程带来了更大的灵活性。但要牢记，无法阻止自动初始化的进行，它将在构造器被调用前发生。

    （5）初始化顺序：在类的内部，变量定义的先后顺序决定了初始化的顺序。及时变量定义散布与方法定义之间，他们仍会在任何方法（包括构造器）被调用之前得到初始化。

 第五节：静态数据的初始化

静态数据的初始化：无论创建多少个对象，静态数据只占用一份存储区域。static 关键字不能用于局部变量，因此它只能作用于域。128

第一百章：java基础

第一节：变量和作用域

(1)局部变量：

 范围：定义在一个方法内部的变量

 作用域：其作用域为所在的代码块，也称为临时变量、栈变量

 生命周期：从创建开始到方法（函数）结束为止。

 特点：在使用前必须要对其初始化。

 一律存放在栈中。

（2）实例变量：

     范围：定义在一个类内部，但不在方法中。

     作用域：其作用域为整个类，能被操作的范围是类的内部

     生命周期：对象被创建的时候开始，对象被垃圾回收的时间结束。

     特点：若未定义其初始值，系统会自动实例变量进行默认初始化（默认值为null），使用前必须创建类的实例。

     每一个对象的实例变量值是相互独立的。

      一律存放在堆中。

注意：局部变量要先赋值，再进行运算，而实例变量均已经赋初值。

      局部变量的作用域内局部变量优先，访问实例变量需用this.variableName.

第二节：数组

1、声明数组：

  （1）一组相同类型（可以是类）数据的有序集合，声明数组必须指定数组类型。

  （2）一个数组是一个对象：意味着数组一类存放于堆中。且必须用new创建出来才能使用。所有的对象都具有相同的属性length;

  （3）注意声明一个数组并没有创建一个对象。

  （4）数组能以下列形式声明：

       int[] i或 int i[]

       Car[] c 或Car c[]

2、创建数组：new

   （1）创建基本数据类型数组：int[]i=new int[2]

   （2）创建引用数据类型数组：Car[]c=new Car[100]

   （3）数组创建后有初始值：数字类型为0；布尔类型为false；引用类型为null

   （4）边界问题：索引号是以0开始的。

3、初始化数组：

   （1）初始化、创建和声明分开；

        int[] i;

        i=new int[2];

        i[0]=0; i[1]=1;

    （2）初始化、创建、声明在同一时间

       int[]i={0，1}；

       Car[] c={new Car(),new Car()}；

    

      （3）多维数组

第三节：对象的创建和初始化

（1）在堆去开辟对象本身所在的存储空间，返回对象在堆区所在的地址的引用。

（2）对对象的属性进行默认初始化。

（3）显示初始化: 第一：声明一个变量时同时对其进行赋值；第二：显示初始化可帮助我们改变默认值，并可以给人为的时间变量赋予具有实际意义的值。

（4）调用构造器对对象进行初始化。

第四节：作用域

（1）public :全部可见

     protected: 本类可见，同包可见，子类可见

     default:本类可见，同包可见

     private: 本类可见。

 

     切记：所有的属性取决于编译时期类型；

           所有的静态方法取决于编译时类型；

           所有的普通方法取决于运行时类型（多态）。

（2）多态三种表现形式

     第一：父类 引用=new 子类（）

           接口 引用=new 实现类（）

     第二：高内聚：最大限度地提高复用性

第五节：面向过程与面向对象思想

（1）面向过程思想：由过程、步骤、函数组成，以过程为核心。

     面向对象思想：以对象为中心、先开发类、得到对象、通过对象之间的相互通信实现功能。

（2）面向过程是先有算法、后有数据结构。

     面向对象时先有数据结构，再有算法。

第六节：高级语言特性

第一小部分：static

（1）修饰符static

     静态类变量（修饰成员变量）：static int data说明data为类变量，为一个类的共享变量，是所有对象共享的，它不属于任何对象，是属于整个类的。

          

      static 定义的是一块为整个类共有的一块存储区域。

  （2）静态方法： 表明此类为类方法，访问时再编译时期完成的，执行效率高。

  （3）静态方法中不能访问类的非静态成员，包括成员变量和方法。

  （4）静态方法不能被覆盖，如果子类中有何父类重命名的静态方法，虽然编译通过，但不能实现多态。

   （5）静态代码块（修饰没有名字的代码块）

      只被执行一次；初始化块在类被加载后首先运行，不管类是否实例化，而且只执行一次；一般初始化一些复杂类型的静态变量。

 （6）单例模式：可以保证一个类在整个系统中近有一个对象

   方法一：  

   public class ConnectionFactory{

          private static Connection conn;

          private Connection(){

            if(conn==null){

              conn=new Connection();

            }
           }

          public Connection getInstance(){

            return conn;

          }

      }

     方法二：

      public class ConnectionFactory{

         private static Connection conn;

         static{

           conn=new Connection();

          }

         public static Connection getInstance(){

            return conn;
         }

       }

第二小部分：final、Abstract、Interface

1、Final变量

（1）final 修饰一个变量（属性）的时候，此时变量为常量。常量的地址不可改变，但在地址中保存的值（即对象的属性）是可改变的。

（2）在JAVA中用public static final的组合方式对常量进行标示

（3）Final变量时在整个类被创建时被赋予值，之后不能被改变。

      a: 对于final变量，如果在声明和构造的时候均不进行赋值，将显示编译出错。

     b:对于利用构造器对final变量进行赋值的时候，此时在构造之前系统设置的默认值覆盖。

  （4）常量赋值（这是常量指的是实例，即成员变量)

       a:在初始化的时候通过显示声明赋值：Final int x=3;

       b:在构造的时候赋值。

2、final型方法（修饰方法时）

（1）final方法不能被覆盖（不能被改写），只能被继承

（2）为了保证方法一致性（即不被改变），可将方法用于final定义。

       a:如果在父类中有final定义的方法，那么在子类中继承同一个方法。

       b:如果一个方法前有修饰词private或static，则系统自动回在前面加上final.

       c:final并不涉及继承，继承取决于类的修饰符是否为private、default、protected还是public。也就是说，是否继承取决于这个类对于子类的可见性。

       Final和abstract永远不会同时出现。

（3）final类（修饰类时）：

     a:final类不能被继承，即final类没有子类。

     b:可以用final保证用户调用动作的一致性，可以防止子类覆盖情况的发生。

     c: final修改类时表明同时类中方法都是final型，但其变量不是。

3、修饰Abstract

（1）抽象方法（修饰方法时）：子类继承抽象类时必须实现其中的抽象方法。

                     当abstract用于修改方法时，此时该方法为抽象方法，此时方法不需要实现，实现留给子类覆盖，子类覆盖该方法后方法才能够生效。

                      抽象方法没有方法体，要求子类必须提供这个方法的实现。

        注意比较：private void print(){};此语句表示方法的空实现。

                  Abstract void print();此语句表示方法的抽象、无实现。

（2）抽象类（修饰类时）：

           a:如果将一个类声明为abstract,表明此类不能创建对象（不能实例化），只能声明变量。

            b:abstract类的设计是将子类的共性最大限度的抽取出来，以提高程序的统一性。

            c:带有抽象方法类一定是抽象类，但是抽象类可以没有抽象方法。

            d:Abstract类可以作为编译时类型，但不能作为运行时类型。

4、接口

 （1）接口是抽象类的另外一种形式。

 （2）在一个接口中所有方法都是抽象方法。

 （3）接口中所有变得都必须被定义为final static

 （4）接口可以继承多个接口。

 （5）接口只有两种语法成分：静态常量和公有的抽象方法。

     备注：接口中的方法自动为public ,因此在接口中声明方法，但不需要提供public关键字。但在实现接口方法时，必须声明为public .s

5.Object类：JAVA中有一个特殊的类，它是JAVA 体系中所有类的父类（直接父类或者间接父类，此类中的方法可以使所有的类均能继承）。

    （1）操作符“==”方法(equals)

        a: ==:比较的是引用，表示其引用值是否相等，即指向同一对象。

            注：“==”在任何时候都是比较地址，这种比较永远不会被覆盖。

         b: equals:比较的是对象，其默认比较规则是“==”

           注意：基本类型没有equals().只有复杂类型才有。

           附加知识：字符串类为JAVA中的特殊类（String在java中为final类型），一个字符串的值不可重复。因此在JVM(虚拟机)中有一个字符串池，专门用来存储字符串。

第七节：异常

第一部分：异常基础知识

   异常捕获处理有两种方法消极（throws）和积极（try--catch）两种处理方法。

第八章：线程

第一节：线程基础知识讲解：

线程原理：

（1）概念：线程是在一个时间段看到的 CPU的多个执行流程。

            线程在语言层面上以对象的形式而存在。

 （2）与进程区别：进程是数据独占的，而线程是数据共享的（所以需要处理数据并发）；

 （3）并发原理：宏观并行、微观串行。

      OS(操作系统)将一段时间分为多个时间片，每个时间片CPU只能运行一个任务

 （4）线程组成要素：处理机（独立的）；代码（即可共享也可不共享）；数据（可共享也可不共享）

 

构建线程的方式：

（1）继承java.lang.Thread；符合面向对象的思想

   

class MyThread extends Thread{

  public void run(){

  }

}

启动线程 ：

public class TestThread{

  public static void main(){

   Thread t1=new MyThread();

   t1.start()
 }

}

 

（2）实现java.lang.Runnable接口：解决了单继承的限制（这种实现可再继承其它类）

class MyThread implements Runnable{

   public void run(){

   }

}

  public static void main(){

   Runnable myThread=new MyThread()

   Thread t=new Thread(myThread);

   t.start();

 }

第二节：Thread方法

（1）public static void sleep(long millis) throws InterruptedException{};

     a:括号中以毫秒为单位，使线程停止一段时间，间隔期满后，线程不一定立即恢复执行。

      b:当main()运行完毕，即使在结束时间片还为用完，CPU也放弃此时间片，继续运行其他程序。

（2）public  final void  join() throws InterruptedException{}

     a:表示其它运行线程放弃执行权，进入阻塞状态，直到调用线程结束。

     b:实际把并发的线程变为串行运行。

     c:线程的优先级：1-10,越大优先级越高，优先级越高被OS选中的几率越高，因为不用操作系统的优先级并不相同，使得程序不具备跨平台。

（3）public static void field()

    使当前线程马上交出执行权，回到可运行状态，等待OS再次调用

（4）pulbic final Boolean isActive()

     验证当前线程是否活动的，不管它是否正在运行。

（5）互斥（共享数据并发处理）

    a:概念上：两个线程修改共享资源时会出现数据的不一致性，产生排斥。

    b:解决方法：为避免这种现象采用对访问的线程做限制的方法。利用每个对象都有一个monitor(锁标记)，当线程拥有这个锁标记时才能访问这个资源，没有锁标记便进入锁池。java中任何一个对象上有一个对象上有且仅有一把锁。

   c:synchronized:修饰代码块：对括号内的对象加锁，只有拿到锁标记的对象才能执行代码块。

public  void  push(char c){

  synchronized(this){

  }

}

d:synchronized修饰方法：对当前对象的加锁，只有拿到锁标记的对象才能执行该方法。

public synchronized void push(char c){

  ....

}

备注：方法的synchronized的特性本身不会被继承，只能覆盖；解决互斥问题的核心是一定要找到共享对象；线程因为未拿到锁标记而发生阻塞进入锁池，每个对象都有自己的一个锁池的空间，用于放置等待运行的线程。而系统决定哪个线程拿到锁标记并运行。

（6）死锁：

     a:概念：若干个线程共享有限资源，某个线程只能获得一部分共享对象的锁，而拿不到足够的锁，导致每个线程都无法正常运行。

     注意：锁标记如果过多，就会出现线程等待其它线程释放锁标记，而又都不释放自己的锁标记供其它线程运行的状况，就是死锁。

     避免死锁的两种处理方法：统一排列锁的顺序。

（7）同步：

      a:概念：若干个线程中一个线程必须依赖另一个线程运行到一定的程度才能执行。

      注意：线程间通信使用的空间称之为对象的等待池，该列的对象也属于对象的空间

      b:解决办法

         第一：找共享对象；第二：独立去看每个线程内部情况；

         第三：必须确立线程的wait发生在notify之前（使用标志变量）

      c:流程：

          第一：进入等待池：使用object类中的wait()的方法，在运行状态中，线程调用wait()，此时表示线程将释放自己所有的标记和CPU的占用，同时进入这个对象的等待池。等待池的状态也是阻塞状态，只不过线程释放自己的锁标记。

          wait():交出锁和CPU的占用。

          第二：退出等待池进入锁池：

              首先：notify():将从对象的等待池中移走一个任意的线程；并放到锁池中，那里的对象一直在等待，直到可以获得对象的锁标记。

               其次：notifyAll()将从等待池中移走所有等待那个对象的线程并放到锁池中，只有锁池中的线程才能获取对象的锁标记，锁标记运行线程从上次因为调用wait()而中断的地方开始继续运行。

       注意：只能对枷锁的资源进行wait(0和notify();

 

第三节：线程的优先级：

       Thread.yield():把资源让给比它高的优先级线程，如果它的优先级是10无用。

       setPrioirity():设置优先级1—10，如字越大优先级越高，默认为5

第九节：JDK新特性

第一节：JDK1.5新特性：

（1）泛型（Generics）:参数化类型

       List<Student> list;

       list.add(Student);

（2）自动装箱/拆箱

        Integer i=new Integer(10);

        Integer j=10;//自动装箱

        int a=i.intValue();    int b=i;//JDK5.0自动拆箱

        自动装箱：将基本数据类型转换成包装数据类型。

        自动拆箱：将包装类型转换成基本数据类型。

（3）对for 循环功能的增强

     for(Student s: list){

     };

 （4）增加了类型安全的枚举类型

      class, interface , enum

      enum:可以定义一个类型，而且还可以限制该类型的取值在某个范围内。

            语法：enum enumName{枚举值1，...，枚举类型};、

            适用位置：包中、类中，但不能再方法中。

            注意：所有enum类都继承自java.lang.Enum;

                  自定义的enum类型不能再由子类；

                  枚举类型的取值默认为public static final;

                  枚举类型可以定义属性和方法；

                  构造器必须是私有的。

                  枚举类型的取值就是实例对象，他会调用该枚举类型的构造器，还要

                      枚举类型中的所有的抽象方法。

         

 （5）可变参数所

      sum(int... args){

          int total=0;

          for(int i-0;i<args.length;i++){

            total+=i;
           } 

           return total;

      }

     main(){

      sum(1,3,5);

     }

 

    (6)静态导入

       import java.io.*

       import static java.lang.System.*;导入包中静态的属性和方法

       import static java.lang.Math.*

       out.println();

       random();

      (7)元数据（Metadata）:用来描述其它数据的数据类型。

         Annotation(标注、注释)——》EJB3.0

  第二节：java的集合框架。

        根据集合存放数据的特点,分为两类：

        （1）只存单值：List，Set

           ArrayList:以数组的方式管理数据，线程不安全的，适合做大量的查询。

                   思考：怎么变成线程安全的。

                   -----> synchronized  List(List<T> list)方法；

           LinkedList:线程安全的，以双向链表的方式管理数据，适合于做大量的增加、删除操作。的增加、删除操作。

           Vector:不适合查询，线程安全的，适合处理多线程的集合。

       （2）存Key—Value键值对：Map

            HashMap(线程不安全的)；

            Hashtable(线程安全的);

            TreeMap(根据HashCode进行排序)

       （3）重载与重写区别：

            重载：发生在同一个类中；相同的方法方法名；不关心返回类型；参数列表必须有所不同；构造器也可以被重载。

            重写：发生在父子类之间；相同的方法名；相同的返回值类型；相同的参数列表；可见性不能被缩小；异常不能被扩大；final方法不能被重写；静态方法不能被覆盖，但可以被子类中同名的方法锁隐藏。

 String、StringBuffer,StringBuilder的区别：

  String:不可变字符串，在大量字符串进行连接时不适用。

  StringBuffer:java5中的可变字符串，线程安全的，不考虑线程的时候适用。

  StringBuilder:线程不安全，性能高，考虑多线程的情况下进行大量字符串连接时适用；

  第三节：Annotation:

      概念：是对Java中注释功能的增强，可以用来对类、属性、方法等进行标注；

      功能：适用Annotation可以改变我们的编程风格，运行我们进行声明式编程，我们只要给出声明，大量的代码可以由攻击帮助我们自动生成；

      sun公司推出的标准Annotation:

      a: @Deprcated:用来标识类、属性、方法等，已经过时，不建议使用了。

      b:@Override:用来标识某一个方法是重写父类中的方法，编译器会看到此标识会自动检查该方法是否满足重写要求。

      c: @SuppressWarnings('unchecked');禁止产生警告信息。