自学java整理出来的部分笔记，(*^__^*) 嘻嘻……（不喜乎喷哦。）

课堂3

1、JDK的下载和安装：下载地址：www.oracle.com   找到downloads  找到java对应的版本下载就好了。   安装JDK的环境配置：右击计算机->属性->高级系统设置->高级->环境变量->系统变量->新建   然后添加配置（1）JAVA_HOME 内容：安装JDK的路径（2）Path   

内容：%JAVA_HOME%\bin; %JAVA_HOME%\jre\bin;%JAVA_HOME%\bin  （3)CLASSPATHH  内容：%JAVA_HOME%lib\dt.jar;%JAVA_HOME%\lib\tools.jar（JDK 5.0版本以上可以不要配置，自动配置好的。）     检测配置的安装是否安装完成：java -version


课堂5
1、常用dos命令
cd 进入一个目录
dir 查看目录的内容
上下键  查找敲过的命令
Tab 命令自动补齐


课堂6
1、标识符：（1）必须以字母、下划线_、美元符$开头，其它部分可以加上数字。
（2）标识符区分大小写，且长度无限制  （3）不能用java的关键字来命名标识符（可以用汉字来做标识符，原因：java内部采用Unicode字符集）
2、  1字节=8位， 2^8=256
     2字节=16位， 2^16=65536


课堂7
1、java是一种强类型语言，每个变量都必须声明其类型
2、                                     * 整数类型（byte，short，int，long）
                              a 数值型
         （1）基本数据类型              * 浮点类型（float，double）
                              b 字符型（char）
                              
数据类型：                    c 布尔型（boolean）                
                              
                              a 类（class）
         
         （2）引用数据类型    b 接口（interface）


                              c 数组
3、byte  1字节   范围：-128——127
   short 2字节   范围：-2^15——2^15-1(-32768——32767)
   int   4字节   范围：-2^31——2^31-1 约21亿
   long  8字节   范围：-2^63——2^63-1
4、java语言的整型常数默认为int型，声明long类型常量可以后加L
如： long b=55555555555L；
课堂8
1、浮点型：（1）float类型又被称作单精度类型，尾数可以精确到7位有效数字。
           （2）double表示这种类型的数值精度是float类型的两倍，又称双精度类型
2、浮点数值默认为double类型。绝大部分应用程序都采用double类型。将double类型改为float类型需要在后面加上F。 如：float=1.23F
3、float  4字节   范围：-3.403e38——3.403e38
   double 8字节   范围：-1.798e308——1.798e308
4、使用总结：浮点数存在舍入误差，很多数字不能精确表示。如果需要进行不产生舍入误差的精确数字计算，需要使用BigDecimal类。（最好避免使用浮点数）


课堂9
1、字符型：单引号用来表示字符常量。例如：'A'是一个字符（输出ASCII码的数字），"A"表示含有一个字符的字符串
2、char类型用来表示在Unicode编码表中的字符。
3、Unicode编码被设计用来处理各种语言的所有文字，占2个字节，可允许有65536个字符
4、转义字符'\':用来将其后的字符转变为其它的含义。例如：char c2='\n';//代表换行符
5、转义符  \b   含义：退格 
           \n         换行
           \r         回车
           \t         制表符
           \"         双引号
           \'         单引号
           \\         反斜杠
6、boolean 类型（一位，不是一个字节）：有两个值，true和false   用处：用来判断逻辑条件，一般用于程序流程控制。


课堂10 
1、自动类型转换：容量小的数据类型可以自动转换为容量大的类型。


                      char
                        |
                        V 
      byte -> short -> int -> long
                        
                   
                      float   -> double
（int不能直接和float，long不能直接和float，long不能直接和double，int可以和double）【能自动转换的无数据丢失，不能自动转换但是可以转换的会有数据精度丢失，此时使用的就是强制转型了】
2、强制类型转换。(强制类型转换，小数部分舍去只取整)例如： double x=3.14；
                        int nx=（int）x；//输出的值为3
3、运算时类型提升问题：做所有的二原运算符（+-#/），都会有类型提升问题【从类型低到类型高的转换，也就是从容量小的转换为容量大的】
例：int a = 3；
    long b=4；
    int c=（int）（a+b）；


课堂11
1、JDK新增特性之一：二进制整数以及下划线分隔符
2、可以直接在代码中写二进制数（0b01；0b11····即以0b开头）
3、定义的数字比较长时，不好看清，可以利用下划线分隔符来把数字分隔开来，然后便于观看，不影响数字大小。


课堂12
1、java是一种强类型语言，每个变量都必须声明其类型。
2、java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。
3、变量在使用前必须对其声明，只有在变量声明以后，才能为其分配相应长度的存储单元，声明格式为： type varName [=value][{varName[=value]}](注：后面两个方框里面的是初始化，可有可无。前面的声明必须要有，但是方框里面的初始化可以放到下面，单独赋值。)
4、局部变量（local variable）：方法或语句块内部定义的变量。 【使用前必须声明和初始化】
5、实例变量：又称成员变量或者属性。（了解一下，后面会细讲的）
6、常量（Final）：只能被初始化一次    例如：final int A=1； 那么这个程序中的a的值就是1，不能被更改。     注：常量最好用大写来定义便于区分。同时如果遇到多个单词比较长，大写难以认出，可在单词之间加下划线，便于辨认。 
7、命名规则（规范）：（1）变量、方法名：首字母小写和驼峰原则   如：run（），runRun()，age  ageNew···   （2）常量：大写字母和下划线  如：MAX_VALUE    （3）类名：首字母大写和驼峰原则  如：Man   GoodMan   注：【驼峰原则就是当有两个单词连接在一起的时候，为了区分两个单词，第二个单词用大写字母，这样可与很好的区分】


课堂13
1、算术运算符:   +  -  *  /  %  ++  --
2、赋值运算符：  =
3、关系运算符：  >  <  <=  >=  ==  !=  instanceof
4、逻辑运算符：  &&  ||  ！
5、位运算符：    &  |  ^（相同的为0相异的为1）  ~  >>  <<  >>>(了解这个)
6、条件运算符：  ？（）：（），（）
7、扩展赋值运算符：  +=  -=  *=  /=
8、逻辑与和逻辑或采用短路的方式，从左到右计算，如果确定值，则不会再计算下去。
9、位运算符右移一位相当于除2取商，左移一位相当于乘2.


课堂14
1、字符串连接符：“+”运算符两侧的操作数中只要有一个是字符串类型，系统会自动将另一个操作数转换为字符串然后再进行连接。  如：System.out.println(4+"5");  输出结果为:45
2、三目运算符，语法格式： x？y：z   是boolean类型，如果x为真，则执行y否则执行z。
3、运算符优先级问题：大家不需要去刻意的记优先级关系，表达式里面优先使用小括号来组织
课堂15
1、eclipse开发环境的使用。 下载地址：http://www.eclipse.org/downloads/


课堂17
1、控制语句：（1）顺序结构 （2）选择结构 （3）循环结构
2、选择结构：（1）单选择结构：if选择结构   Math.random()在[0,1)的区间，即返回随机的一个小数（2）双选择结构: if-else结构      （3）多选择结构。


课堂18
1、switch语句：记住格式，一般在每个case后面都要加break，防止出现case穿透问题。


课堂19
1、JDK7.0新特性之：switch增强，JDK7之前，表达式结果只能是int（可以自动转换为int的byte、short、char），枚举类型。 而JDK的表达式结果增加了可以是字符串的问题。


课堂20
1、while循环：如果符合某个条件，则再来一次。在循环刚开始的时候，会计算一次“布尔表达式”的值，若条件为真，执行循环体。执行结束后，在运行下一步的代码。














课堂26
1、文档注释使用/**·····*/


2、常用的java注释标签：
@Author 作者
@version 版本
@param 参数
@return 返回值的含义
@throws 抛出异常描述
@deprecated 废弃（建议用户不在使用该方法）


3、使用JAVADOC生成API文档解决的问题：代码和文档的分离


4、生成API文件的步骤：右击项目->Export->Java->Javadoc->next都选择默认，然后选中放的位置，最后finish。
5、寻找生成的API文件：找到所存位置，打开index.htm
6、JDK中主要的包：（1）java.lang 包含一些java语言的核心类，如String、Math、Integer、System和Thread，提供常用功能。
（2）java.awt 包含了构成抽象窗口工具集（abstract window toolkits)的多个类，这些类被用来构建和管理应用程序的图形用户界面（GUI）。
（3）java.net 包含执行与网络相关的操作的类
（4）java.io 包含能提供多种输入 /输出功能的类
（5）java.util 包含一些实用工具类，如定义系统特性、使用与日期日历相关的函数。


课堂27
1、接受键盘输入：Scanner类的使用  
如：Scanner s=new Scanner(System.in);
    int a=s.nextInt();     //程序运行到next会阻离，等待键盘的输入！
                                        


课堂30
1、面向对象的本质：以类的方式组织代码，以对象的方式组织（封装）数据。
2、对象：具体的事物
3、类：是对对象的抽象（抽象  抽出象的部分）
4、先有具体的对象，然后抽象各个对象之间象的部分，归纳出类通过类再认识其他对象。
5、对象和类的关系：特殊到一般，具体到抽象
6、类：我们叫做class  
7、对象：我们叫做Object，instance（实例）。
8、类可以看成一类对象的模版，对象可以看成该类的一个具体实例。
9、类是用于描述同一类形的对象的一个抽象的概念，类中定义了这一类对象所应具有的静态和动态属性。
10、对象是java程序的核心，在java程序中“万事万物皆成对象”。
11、JDK提供了很多类供编程人员使用，编程人员也可定义自己的类。


课堂31
1、java语言中除基本类型之外的变量类型都称之为引用类型。
2、java中的对象是通过引用reference对其操作的。
3、类的属性：属性（field），或者叫成员变量
4、属性用于定义该类或该对象包含的数据或者说静态属性
5、属性作用范围是整个类体
6、在定义成员变量时可以对其初始化，如果不对其初始化，Java使用默认的值对其初始化（数值：0，0.0  char：\u0000（实际上还是0）， boolean:false,所有引用类型：null）【注：局部变量是不会帮你初始化的！！】
7、属性定义格式：   [修饰符]  属性类型  属性名 =[默认值]
8、类的方法：面向对象中，整个程序的基本单位是类，方法是从属于类的。
9、方法定义格式：   [修饰符]  方法返回值类型  方法名（形参列表）｛
                         //n条语句
                     ｝
10、java中方法参数传递是：值传递！
11、内存分析   栈：存放局部变量【自动分配连续的空间，后进先出】   堆：存放new出来的对象【不连续】  方法区：存放类的信息（代码）、static变量、常量池（字符串常量）等。【也是堆】
注：方法区是堆的一部分！！


课堂33
1、垃圾回收机制（Garbage Collection）  对象空间的分配：使用new关键字创建对象即可。
2、对空间的释放：将对象赋值null即可。垃圾回收器将负责回收所有“不可达”对象的内存空间。
3、要点：（1）程序员无权调用垃圾回收器。（2）程序员可以通过System.gc（）。通知GC（垃圾回收器的缩写）运行，但是JAVA规范不能保证立刻运行。 （3） finalize方法，是JAVA提供给程序员用来释放对象或资源的方法，但是经量少用。


课堂34
1、构造器：又称为构造方法，constructor 
2、构造器用于构造该类的实例。
3、格式：
    [修饰符] 类名（形参列表）{
      //n条语句
    }
4、构造器是一种特殊的方法：（1）通过new关键字调用！（2）构造器虽然有返回值，但是不能定义返回类型（返回值的类型肯定是本类），不能在构造器里调用return。（3）如果我们没有定义构造器里调用return。（4）构造器的方法名必须和类名一致（5）作用：构造该类的对象，经常也用来初始化的对象，经常也用来初始化对象的属性。


课堂35
1、重载（overload）：方法的重载是指一个类中可以定义有相同的名字，但参数不同的多个方法。调用时，会根据不同的参数表选择对应的方法。
2、两同三不同：同一个类，同一个方法名；不同：参数列表不同（类型、个数、顺序不同）
3、只有返回值不同不构成方法的重载
4、只有形参的名称不同，不构成方法的重载
5、与普通方法一样，构造方法也可以重载。


课堂36
1、static关键字：在类中，用static声明的成员变量为静态成员变量，或者叫做：类属性，类变量。static中不能使用非静态的和方法。
2、它为该类的公用变量，属于类，被该类的所有实例共享，在类被载入时被显式初始化。
3、对于该类的所有对象来说，static成员变量只有一份。被该类的所有对象共享！
4、可以使用"对象.类属性"来调用。不过，一般都是用"类名.属性名"。
5、static变量置于方法区中！
6、用static声明的方法为静态方法（1）不需要对象，就可以调用（类名.方法名）（2）在调用该方法时，不会将对象的引用传递给它，所以在static方法中不可访问非static的成员。非静态的成员可以访问静态的东西。类只能使用类的方法，而对象却可以使用类和对象的方法。


课堂37
1、this关键字：（1）普通方法中，this总是指向调用该方法的对象（不能在方法中写出来，写出来就错了）  如public void study（）是对的。 public void study（this）就是错的。【虽然想要表达的意思一样】（2）构造方法中，this总是指向正要初始化的对象。（3）this不能用static方法。
2、 this();   //通过this调用其它构造方法。必须位于第一句。


课堂38
1、面向对象的三大特征：继承、封装（隐藏）、多态
2、继承（extands）：类是对对象的抽象，继承是对某一批类的抽象，从而实现对现实世界更好的建模。同时能提高代码的复用性！   extends的意思是“扩展”。子类是父类的扩展。
3、小结：（1）子类继承父类，可以得到父类的全部属性和方法（除了父类的构造方法）。
         （2）java中类只有单继承，没有像c++那样的多继承。【一个类只能有一个直接父类】多继承会引起混乱，使得继承链过于复杂，系统难以维护。
         （3）java中的多继承可以通过接口来实现
         （4）如果定义一个类时，没有调用 extends，则它的父类是：java.lang.Object。
         （5）不同的叫法：超类、父类、基类、子类、派生类


课堂39
1、方法的重写（override）：在子类中可以根据需要对从基类中继承来的方法进行重写。
2、重写方法必须和被重写方法具有相同方法名称、参数列表和返回类型。
3重写方法不能使用比被重写方法更严格的访问权限（由于多态）


课堂40
1、Object类是所有java类的根基类，如果在类的声明中未使用extends关键字指明其基类，则默认基类为Object类  如：public class Person 和public class Person extends Object效果一样。
2、重写：toString方法【把一个对象转换成字符串】：   默认返回：包名+类名+@+哈希码（根据对象内存位置生成，唯一不重复）
                          可以重写！
3、hierarchy 层次结构
4、查看类型层次结构 对着类名按ctrl+T 【记不得就右击】查看类的寄存结构，看父类什么的
课堂41
1、super关键字：super是直接父类对象的引用。可以通过super来访问父类中被子类覆盖的方法或属性。
2、在普通方法中：没有顺序限制，可以随便调用。
3、构造函数中：任何类的构造函数中，若是构造函数的第一行代码没有显式的调用super（...）；那么java默认都会调用super（）；作为父类的初始化函数。所以你这里的super（）；加不加都无所谓。【注：引用就是地址的意思】


课堂42
1、继承VS组合：（1）“is-a”关系使用继承！：通过在Audi类中增加一个Car属性虽然也复用了代码，但是不合逻辑不容易理解。（2）“has-a”关系使用组合！：计算机类，主板类。可以通过在计算机类中增加主板属性来复用主板类的代码！


课堂43
1、final关键字（1）修饰变量：常量（2）修饰方法：该方法不可被子类重写，但是可以被重载！（3）修饰类：修饰的类不能有子类，不能被继承。比如：Math、String。


课堂44
1、封装/隐藏（encapsulation）：作用和含义：隐藏对象内部的复杂性，只对外公开简单的接口。便与外界调用，从而提高系统的可扩展性、可维护性。
2、程序设计要追求“高内聚，低耦合”：高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。
3、封装的几个关键字：private  私有的，只在自己的类中可以看到。
                     default  默认的，同一个类和同一个包中都可以看到
                     protected 受保护的，增加了不同包的其它子类也可看到
                     public 公共的， 增加了所有类都可以访问
4、封装要点中类的属性的处理：（1）一般使用private（除非本属性确定会让子类继承）
（2）提供相应的get/set方法来访问相关属性。这些方法通常是public，从而提供对属性的读取操作。【注：boolean变量的get方法是用：is开头！】
5、封装要点中一些只用于本类的辅助性方法可以用private，希望其他类调用的方法用public
6、开发set/get方法时，通过现有命令添加。（右击—Source—GenerateGetters and Setters。。。单击—然后选中你要添加的属性。）


课堂45
1、多态（polymorphism）是OOP中的一个重要特性，主要是用来实现动态联边的，就是程序的最终状态只有在执行过程中才被决定而非在编译期间就决定了。这对于大型系统来说能提高系统的灵活性和扩展性。
2、java中引用变量的两种类型：（1）编译时类型（模糊一点，一般是一个父亲）
                                  ·由声明时的类型决定
                             （2）运行时类型（运行时，具体是哪个子类就是哪个子类）
                                  ·由实际对应的对象类型决定。
3、多态【指方法的多态】的存在要有3个必要条件：要有继承，要有方法的重写，父类引用指向子类对象
4、多态中，当一个继承类有自己的特性，在test类中要访问时，编译器只认基类，这时候就要用到强制类型转换。但是不能乱强制转换，动物的同一类不能乱转。
   如： Cat a2=（Cat）a；  此处把Cat强制转换Animal。    
        a2.catchMouse（）；


课堂48
1、抽象类：是一种模版模式。抽象类为所有子类提供了一个通用模版，子类可以在这个模版基础上进行扩展。
2、通过抽象类，可以避免子类设计的随意性。通过抽象类，我们就可以做到严格限制子类的设计，使子类之间更加通用。
3、要点：（1）有抽象方法的类智能定义能抽象类。
         （2）抽象类不能实例化，及不能用new来实例化抽象类
         （3）抽象类可以包含属性、方法、构造方法。但是构造方法不能用来new实例，智能用来被子类调用。
         （4）抽象类只能用来继承
         （5）抽象方法必须被子类实现
4、抽象类把设计和实践分开了。


课堂49
1、接口（interface）为什么需要接口：接口就是比“抽象类”还“抽象”的“抽象类”，可以更加规范的对子类进行约束。全面地专业地实现了：规范和具体实现的分离。
2、接口是规范，定义的是一组规则，体现了现实世界中“如果你是。。则必须能。。”的思想3、接口的本质是契约，就像我们人间的法律一样。制定好后大家都遵守。
4、项目的具体需求是多变的，我们必须以不变应万变才能从容开发，此处的“不变”就是“规范”。因此我们开发项目往往都是面向接口编程！
5、定义接口  格式：
              [访问修饰符] interface接口名 [extends 父接口1，父接口2...]{
                -常量定义   //总是public static final
                -方法定义   //总是：public abstract
              }
6、子类通过implements来实现接口中的规范
7、接口不能创建实例，但是可用于声明引用变量类型
8、一个类实现了接口，必须实现接口中所有的方法，并且这些方法只能是public的。
9、接口支持多继承


课堂50
1、回调的实现：CallBack、  Hook、  模板方法模式
2、hook（钩子） 自己写代码时，一行行写下去，当遇到不太确定怎么实现的时候，利用hook，然后交给别人实现，别人怎么写就是什么。你用hook之后实现了功能的分离。属于多态的一个应用。


课堂51
1、内部类：一般情况下，我们把类定义成独立的单元。有些情况下，我们把一个类放在另一个类的内部定义，成为内部类。
2、作用：（1）内部类提供了更好的封装。智能让外部类直接访问。不允许同一个包中的其他类直接访问。（2）内部类可以直接访问外部类的私有属性，内部类被当成其外部类的成员。但外部类不能访问内部类的内部属性。
3、内部类的使用场合：由于内部类提供了更好的封装特性，并且可以很方便的访问外部类的属性。所以，通常内部类在只为所在外部类提供服务的情况下优先使用。
4、内部类的分类:(1)成员内部类（2）匿名内部类
5、成员内部类：非静态内部类、静态内部类
成员内部类可以使用private、protected、public任意进行修饰。类文件：外部类$内部类.class
6、局部内部类：定义在方法内部（用的极少）
7、匿名内部类：适合那种只需要使用一次的类。
new  父类构造器（实参类表）实现接口（）{
       //匿名内部类类体
}                       //格式
8、非静态内部类必须寄存在一个外部类的对象里。因此，如果有一个非静态内部类对象那么一定存在对应的外部类对象。非静态内部类对象单独属于外部类的某个对象。
9、非静态内部类可以使用外部类的成员，但是外部类不能直接访问非静态内部类成员。
10、非静态内部类不能有静态方法、静态属性、静态初始化块
11、静态成员不能访问非静态成员：外部类的静态方法、静态代码块不能访问非静态内部类，包括不能使用非静态内部类定义变量、创建实例。
12、成员变量访问要点：（1）内部类里方法的局部变量：变量名（2）内部类属性：this.变量名（3）外部类属性：外部类名.this.变量名
13、内部类的访问：（1）外部类中定义内部类：newInner（） （2）外部类意外的地方使用非静态内部类： Outer.inner  varname=OuterObject.newInner（）
14、静态内部类定义方式：static  class  ClassName{
                               //类体
                        }
15、使用要点（1）当一个静态内部类对象存在，并不一定存在对应的外部类对象。因此，静态内部类的实例方法不能直接访问外部类的实例方法。（2）静态内部类看做外部类的一个静态成员。因此，外部类的方法中可以通过：静态内部类.名字  访问静态内部类的静态成员。通过new静态内部类（）访问静态内部类的实例。（3）在外部类的外面创建静态内部类：
Face.TestStaticInner  aInner=new Face.TestStaticInner（）；
16、总结：（1）普通成员内部类可以访问外部类的普通的属性和方法
          （2）普通成员内部类可以看做外部类的一个普通的属性一样。他可以直接访问里面的内容，调用的时候，普通内部类对象必须寄宿在外部类对象里面。（3）静态内部类存在外部类对象不一定要存在，不能直接访问外部类的普通属性。但是静态内部类，可以直接访问静态类的属性和方法。


课堂52
1、数组（array）的概述：数组是相同类型数据的有序集合，数组描述的是相同类型的若干个数据，按照一定的小猴次序排列组合而成。其中，每一个数据称作一个数组元素，每个素组元素可以通过一个下标来访问它们。
2、数组有三个特点：（1）其长度是确定的。数组一旦被创建，它的大小就是不可以改变的。（2）其元素必须是相同类型，不允许出现混合类型。（3）数组中的元素可以是任何数据类型，包括基本类型和引用类型。
3、数组属于引用类型
4、assigned：指定


课堂53
1、一位数组的声明方式有两种：  type[]  arr_name;
                               type  arr_name[];
2、java中使用关键字new创建数组对象
3、数组元素相当于对象的成员变量


课堂54
1、java字符串就是Unicode字符序列，例如：串“java”就是4个Unicode字符j，a，v，a组成的。
2、java没有内置的字符串类型，而是在标准java类库中提供了一个预定义的类String，每个用双引号括起来的字符串都是String类的一个实例。


课堂60
1、二维数组举例： int[][] a={{1,2},{3,4,0,9},{5,6,7}}
2、java中多维数组不必须是规则矩阵形式。
3、java中多维数组的声明和初始化应按从高维到低维的顺序进行。


课堂62
1、数组常见的操作：System类里也包含了一个static void arraycopy（object src，int srcpos，object dest， int destpos ，int length）方法，该方法可以将src数组里的元素值赋给dest数组的元素，其中srcpos指定从src数组的第几个元素开始赋值，length参数指定将src数组的多少个元素赋给dest数组的元素。
         String[] s={"Mircosoft","IBM","Sun","Oracle","Apple"};
               string[] sBak=new String[6];
               System.arraycopy(s,o,sBak,o,s.length);


课堂63
1、基本数据类型的包装类
2、字符串相关类   不可变字符序列：String
                  可变字符序列：StringBuffer、StringBuilder
3、时间处理相关类 Date  DateFormat、SimpleDateFormat  Calendar


4、Math类
5、File类
6、枚举类
7、基本数据类型的包装类：为什么需要包装类？java并不是纯面向对象的语言。java语言是一个面向对象的语言，但是java中的基本数据类型却是不面向对象的。但是我们在实际使用中经常需要将基本数据转化成对象，便于操作。 例如：集合的操作中，这时，我们就需要将基本类型数据转化成对象！
8、包装类均位于java.lang包，包装类和基本数据类型的对应关系：
          基本数据类型              包装类
              byte                   Byte
             Boolean                Boolean
              short                  Short
              char                  Character
               int                   Integer
              long                    Long
              float                  Float
              double                 Double     
9、如何使用包装类？ 包装类的作用：
（1）提供：字符串、基本类型数据、对象之间互相转化的方式！
（2）包含每种基本数据类型的相关属性如最大值、最小值等
10、所有的包装类（WrapperClass）都有类似的方法，掌握一个其他都类似！以Integer为例！   代码：TestWrapperClass1.java


课堂64
1、自动装箱：基本类型就自动地封装到与它相同类型的包装中，
如：Integer i=100；
  本质上是，编译器编译时为我们添加了：
  Integer i= new Integer（100）；
2、自动拆箱：包装类对象自动转换成基本类型数据。
如：int a= new Integer（100）；
    本质上，编译器编译时为我们添加了：
    int a= new Integer（100）.intValue（）；
3、缓存问题


课堂65
1、Date时间类（java.util.Date）:在标准java类库中包含一个Date类。它的对象表示一个特定的瞬间，精确到毫秒。
2、java中时间的表示说白了也是数字，是从：标准纪元1970.1.1  0点开始的到某个 时刻的毫秒数，类型是long。
3、代码：TestDate.java




课堂67
1、GregorianCalenda公历是Calendar的一个具体子类，提供了世界上大多数国家/地区使用的标准日历系统
2、注意：
       月份：一月是0，二月是1，···
       星期：周日是1，周一是2，。。。
3、代码：TestCalendar.java 


课堂70
1、File类  java.io.File类：文件和目录路径名的抽象表示形式
2、通过File对象可以访问文件的属性。
      public boolean canRead()  public boolean canWrite()
      public boolean exists() public boolean isDirectory()
      public boolean isFile() public boolean isHidden()
      public long lastModified() public long length()
      public String getName() public String getPath()
3、通过File对象创建空文件或目录（在该对象所指的文件或目录不存在的情况下）。
   public boolean createNewFile()throws IOException
   public boolean delete()
   public boolean mkdir(), mkdirs()  注意两者的区别！




课堂72
1、异常的概念：java异常时java提供的用于处理程序中错误的一种机制。
2、java是采用面向对象的方式来处理异常的。处理过程：
（1）抛出异常：在执行一个方法时，如果发生异常，则这个方法生成代表该异常的一个对象，停止当前执行路径，并把异常对象提交给JRE。
（2）捕获异常：JRE得到该异常后，寻找相应的代码来处理该异常。JRE在方法的调用栈中查找，从生成异常的方法开始回溯，知道找到相应的异常处理代码为止。


课堂74
1、异常的处理办法之一捕获异常（try,catch,finally）
未遇到异常：沿着try执行结束，跳过catch直接执行finally
遇到异常：try语句中遇到异常的语句块执行catch语句，try中剩下的语句不执行了，执行完catch语句，执行finally语句。
2、try块：try语句指定了一段代码，该段代码就是一次捕获并处理的范围。在执行过程中，当任意一条语句产生异常时，就会跳过该段中后面的代码。代码中可能会产生并抛出一种或几种类型的异常对象，它后面的catch语句要分别对这些异常做相应的处理。【一个try语句必须带有至少一个catch语句块或一个finally语句块。。且当异常处理的代码执行结束以后，是不会回到try语句去执行尚未执行的代码。】
3、catch（1）每个try语句块可以伴随一个或多个catch语句，用于处理可能产生的不同类型的异常对象。
（2）常用方法：
toString（）方法，显式异常的类名和产生异常的原因
getMessage（）方法，只显式产生异常的原因，但不显示类名
printStackTrace（）方法，用来跟踪异常事件发生时堆栈的内容
注：这些方法均继承自Throwable类
（3）Catch捕获异常时的捕获顺序：如果异常类之间有继承关系，在顺序安排上需要注意。越是顶层的类，越是放在下面。再不然就直接把多余的catch省略掉。
4、finally：有些语句，不管是否发生了异常，都必须要执行，那么就可以把这样的语句放到finally语句块中。
注：通常在finally中关闭程序块已打开的资源。


课堂75
1、异常的处理办法之二声明异常：throws子句
（1）当Checked Exception产生时，不一定立刻处理它，可以再把异常Throws出去。
（2）如果一个方法抛出多个已检查异常，就必须在方法的首部列出所有的异常，之间以逗号隔开。
2、代码：TestException3.java
3、方法重写中声明异常原则：子类声明的异常范围不能超过父类声明的范围。包含如下意思：
        父类没有声明异常，子类也不能；
        不可抛出原有方法抛出异常类的父类或上层类
        抛出的异常类型的数目不可以比原有的方法抛出的还多（不是指个数）
4、代码：A.java
5、异常的处理办法之三，手动抛出异常，throw子句
6、java异常类对象除在程序执行过程中出现异常时由系统自动生成并抛出，也可根据需要手工创建并抛出。
7、在捕获一个异常前，必须有一段代码先生成异常对象并把它抛出。这个过程我们可以手工做，也可以由JRE来实现，但是他们调用的都是throw子句。
8、对于一个已经存在的异常类，抛出该异常对象过程如下：
     找到一个合适的异常类
     创建一个该类的对象
     将对象抛出


课堂76
1、自定义异常：在程序中，可能会遇到任何标准异常类都没有充分的描述清楚的问题，这种情况下可以创建自己的异常类
2、从Exception类或者它的子类派生一个子类即可
3、习惯上，定义的类应该包含2个构造器：一个是默认的构造器，另一个是带有详细信息的构造器
4、示例代码：MyExceptionTest.java
5、异常总结：一个图、五个关键字（try，catch，finally，throws，throw）、先逮小的，再逮大的、异常和重写的关系、自定义异常
6、使用异常机制建议：（1）要避免使用异常处理代替错误处理，这样会降低程序的清晰性，并且效率低下。
（2）处理异常不可以代替简单测试——只在异常情况 下使用异常机制
（3）不要进行小粒度的异常处理——应该将整个任务包装在一个Try语句块中
（4）异常往往在高层处理