注释：就是对代码的解释和说明。其目的是让人们能够更加轻松地了解代码。为代码添加注释，是十分必须要的，它不影响程序的编译和运行。
Java中有 单行注释、多行注释和文档注释
单行注释 以 //开头 换行结束
多行注释 以 / 开头 以/结束
文档注释 以/ 开头 以/结束
关键字 keywords
关键字：是指在程序中，Java已经定义好的单词，具有特殊含义。例如：public 、 class 、 static 、void等，这些单词已经被 Java定义好，全部都是小写字母，eclipse中颜色为紫红色。
标识符
标识符：是指在程序中，我们自己定义内容。比如类的名字、方法的名字和变量的名字等等，都是标识符。
命名规则： 硬性要求 标识符可以包含 英文字母26个(区分大小写) 、 0-9数字、 $（美元符号） 和 _（下划线） 。 标识符不能以数字开头。标识符不能是关键字。
命名规范： 类名规范：首字母大写，后面每个单词首字母大写（驼峰式）。
方法名规范：首字母小写，后面每个单词首字母大写(驼峰式）。
变量名规范：全部小写。
常量
常量：是指在Java程序中固定不变的数据。
变量
变量：常量是固定不变的数据，那么在程序中可以变化的量称为变量。
Java中要求一个变量每次只能保存一个数据，必须要明确保存的数据类型。
数据类型
数据类型分类
Java的数据类型分为两大类：
基本数据类型：整数、浮点数 、字符 、布尔
引用数据类型：类、数组 、接口
基本数据类型
四类八种基本数据类型：
数据类型关键字内存占用取值范围
字节型byte1个字节-128~127
短整型short2个字节-32768~32767
整型int（默认）4个字节-2^31----2^31-1
长整型long8个字节-2^31----2^31-1
单精度浮点数float4个字节-2^63----2^63-1
双精度浮点数double（默认）8个字节
字符型char2个字节
布尔类型boolean1个字节true，false
Java中的默认类型：整数类型是 int 、浮点类型是double
数据类型转换
Java程序中要求参与的计算的数据，必须要保证数据类型的一致性，如果数据类型不一致将发生类型的转换。
自动转换：将取值范围小的类型 自动提升为 取值范围大的类型
byte 类型内存占有1个字节，在和int 类型运算时会提升为 int 类型 ，自动补充3个字节，因此计算后的结果还是 int 类 型。同样道理，当一个 int 类型变量和一个 double 变量运算时， int 类型将会自动提升为 double 类型进行运算。
转换规则
范围小的类型向范围大的类型提升， byte、short、char 运算时直接提升为int
强制转换
将 1.5 赋值到 int 类型变量会发生什么？产生编译失败，肯定无法赋值。
Int i = 1.5; //编译错误
double 类型内存8个字节， int类型内存4个字节。 1.5 是 double 类型，取值范围大于 int 。可以理解为 double 是8 升的水壶， int是4升的水壶，不能把大水壶中的水直接放进小水壶去。 想要赋值成功，只有通过强制类型转换，将 double 类型强制转换成 int 类型才能赋值。
强制类型转换：将取值范围大的类型 强制转换成 取值范围小的类型 。
比较而言，自动转换是Java自动执行的，而强制转换需要我们自己手动执行。
转换格式：
数据类型 变量名 = （数据类型）被转数据值；
将 1.5 赋值到 int 类型，代码修改为
int i = （int）1.5;
同样道理，当一个 short 类型与 1 相加，我们知道会类型提升，但是还想给结果赋值给short类型变量，就需要强制转换。
注意：
浮点转成整数，直接取消小数点，可能造成数据损失精度。 int 强制转成 short 砍掉2个字节，可能造成数据丢失
运算符 ：
算数运算符
算数运算符包括：
+加法运算，字符串连接运算
-减法运算
乘法运算
/除法运算
%取模运算，两个数字相除取余数
++ 、--自增自减运算
Java中，整数使用以上运算符，无论怎么计算，也不会得到小数。
++ 运算，变量自己增长1。反之， -- 运算，变量自己减少1，用法与++ 一致。
独立运算：
变量在独立运算时， 前++ 和 后++ 没有区别 。
混合运算：和其他变量放在一起， 前++ 和 后++ 就产生了不同。
变量 前++
public static void main(String[] args) {
int a = 1;
int b = ++a;
System.out.println(a);//计算结果是2
System.out.println(b);//计算结果是2
}
变量a自己加1，将加1后的结果赋值给b，也就是说a先计算。a和b的结果都是2。
变量 后++ ：
public static void main(String[] args) {
int a = 1;
int b = a++;
System.out.println(a);//计算结果是2
System.out.println(b);//计算结果是1
}
变量a先把自己的值1，赋值给变量b，此时变量b的值就是1，变量a自己再加1。a的结果是2，b 的结果是1。
+ 符号在字符串中的操作：
+ 符号在遇到字符串的时候，表示连接、拼接的含义。
"a"+"b"的结果是“ab”，连接含义。
赋值运算符：
赋值运算符，就是将符号右边的值，赋给左边的变量。
赋值运算符包括：
=等于号
+=加等于
-=减等于
=乘等于
/=除等于
%=取模等
比较运算符：
比较运算符包括：
==比较符号两边数据是否相等，相等结果是true。
< 比较符号左边的数据是否小于右边的数据，如果小于结果是true。
> 比较符号左边的数据是否大于右边的数据，如果大于结果是true。
<=比较符号左边的数据是否小于或者等于右边的数据，如果小于结果是true。
>=比较符号左边的数据是否大于或者等于右边的数据，如果小于结果是true。
！=不等于符号，如果符号两边的数据不相等，结果是true。
比较运算符，是两个数据之间进行比较的运算，运算结果都是布尔值 true 或者false
逻辑运算符：
逻辑运算符包括：
&& 短路与
1. 两边都是true，结果是true 2.一边是false，结果是false 短路特点：符号左边是false，右边不再运算
||
短路或
1. 两边都是false，结果是false 2.一边是true，结果是true 短路特点： 符号左边是true，右边不再运算
！
取反
1. ! true 结果是false
2. ! false结果是true
逻辑运算符，是用来连接两个布尔类型结果的运算符，运算结果都是布尔值 true 或者false
三元运算符：
三元运算符格式：数据类型 变量名 = 布尔类型表达式？结果1：结果2
三元运算符计算方式：布尔类型表达式结果是true，三元运算符整体结果为结果1，赋值给变量。布尔类型表达式结果是false，三元运算符整体结果为结果2，赋值给变量
面向对象
什么是面向对象？面向对象是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。
面向对象和面向过程：
面向过程： 强调每一个功能的实现步骤和实现细节。
面向对象： 强调的是对象，然后由对象去调用它的功能。对于功能是如何实现的我们不用管。
关系： 面向对象是基于面向过程的，没有面向过程，就没有面向对象。
面向过程与面向对象都是我们编程中，编写程序的一种思维方式。
面向过程的程序设计方式：是遇到一件事时，思考“我该怎么做”，然后一步步实现的过程。
例如：公司打扫卫生（擦玻璃、扫地、拖地、倒垃圾等），按照面向过程的程序设计方式会思考“打扫卫生我该怎么做，然后一件件的完成”，最后把公司卫生打扫干净了。
面向对象的程序设计方式：是遇到一件事时，思考“我该让谁来做”，然后那个“谁”就是对象，他要怎么做这件事是他自己的事，反正最后一群对象合力能把事就好就行了。
例如，公司打扫卫生（擦玻璃、扫地、拖地、倒垃圾等），按照面向对象的程序设计方式会思考“我该让谁来做，如小明擦玻璃、让小丽扫地、让小郭拖地、让小强倒垃圾等”,这里的“小明、小丽、小郭、小强”就是对象，他们要打扫卫生，怎么打扫是他们自己的事，反正最后一群对象合力把公司卫生打扫干净了。
java语言描述现实中的事物是通过类（class）来描述的，java中最基本的单位就是类（class 关键字 修饰的）。
类：是一个抽象的概念，是一组行为和属性（也就是方法和变量）的集合。
对象： 是一个具体的事物，或者说是一个类的具体的个体，具体的实现，具体存在的，属于这个类 的个体。
在java 中通过类和对象来描述现实中的抽象概念和具体事物 。
那么 如何来创建类呢？ 根据需求分析业务场景，需要什么对象。然后，根据这个对象来分析，把这个对象的共性抽取出来，抽象出一个概念，那这个概念用 java语言来表示，就是一个java类 。 体现形式就是创建了 一个class这个类用来描述事物。
如何来创建对象呢？先创建好类，也就是描述对象的一个抽象概念，然后根据这个类，来创建这个类的对象 （也叫创建这个类的实例。因为在类中定义的属性和行为（非静态的），是属于具体实例的， 需要由这个具体的实例访问属性和调用方法。 换句话说类中定义的属性和行为（非静态的） 离开对象就没有意义。
具体创建的语法：
类名 对象名 (引用变量) = new 类名();
类比int[] arr = new int[2];
= 左边： 类名 对象名 本质就是声明了一个类类型（引用类型）的变量类名就是类型。 对象名就是引用变量 引用一个对象它的值就是它引用的对象的内存地址值 。
= 右边： new 这个关键字 1.为创建的对象 分配内存空间 2. 并给对象的成员变量 赋初始值 3.把对象的内存地址值，返回给引用变量。
在这类名() 实际上是调用了类的无参构造方法 因为构造方法名和类名是一样的
new关键字：
1. 实例化：就是“创建一个Java对象”-----分配内存并返回指向该内存的引用。
2. 如果实例变量在声明时被显示初始化，那就把显示初始化的值，赋值给实例变量。
3. 初始化：就是调用构造方法，对类的实例数据赋初值。
4. 返回对象的引用，就是将对象的内存地址赋值给引用变量，我们就可以通过操作引用变量来操作对象了 ，引用变量不是对象。但是为了好描述我们可以把引用变量称为对象。
构造方法（构造函数 构造器）：
是一个在创建对象时被自动调用来完成对象初始化的特殊方法叫构造方法。
作用：
初始化对象
初始化对象的信息
1.如果没有显示的定义类的构造器的话，则系统默认提供一个空参的构造器。
2，定义构造器的格式：权限修饰符 类名（形参列表）{}。
3，一个类中定义的多个构造器，彼此构成重载。
4，一旦我们显示的定义了类的构造器之后，系统就不再提供提供默认的空参构造器。
5，一个类中至少有一个构造器。
6，虽然有返回值，但是不能定义返回值类型。
7，通过 new 关键字 调用
package com.glls.chap5;
/
static 关键字 静态的
可以修饰
变量 静态变量
方法 静态方法
对比学习
静态变量和非静态变量
int lhq; 实例变量
static int banfei; 静态变量
共同点： 都是成员变量 static不能修饰局部变量
不同点：
1.存储的位置不一样 静态变量 存储在方法区 非静态变量（实例变量） 存储在堆内存
2.份数不一样 静态变量就一份 非静态变量（实例变量） 是一个对象 一份
3.调用方式不一样 :静态变量通过类名来调用(虽然也可以通过对象名来调用 但是不建议使用)， 实例变量 要通过实例来调用
4.分配内存的时间不一样
静态变量 是在 类加载的时候 就分配内存 类加载的时间是在 对象创建之前
实例变量 是在创建对象的时候 分配内存
静态方法：static 修饰的方法 建议通过类名调用 工具类中的方法 常为静态方法
实例方法： 没有用static修饰的方法 需要通过对象调用
静态方法中不可以直接访问 非静态的成员变量（实例变量）
静态方法中不可以直接访问 非静态方法 （实例方法）
静态方法中 不能使用this
如何理解？ 加载类的时候 就加载了类的静态方法和静态变量 此时 还没有对象 所以 实例变量 实例方法 还没有分配内存 所以无法调用
静态方法 可以直接访问 静态变量和 静态方法
非静态方法 也可以直接调用静态方法
如何理解？ 加载类的时候 就加载了类的 静态变量 和静态方法 创建对象后 实例变量 和 实例方法 才分配内存 ，此时静态变量和静态方法已经分配好了内存 所以可以直接调用
总结： 静态变量 属于类 或者说 属于 所有的对象，所有的对象共享一份静态变量 ，实例变量 每个对象都有自己的一份
静态方法不能直接方法非静态的成员 （实例变量和实例方法）
/
public class _8StaticDemo {
int a =2;
static int b=5;
public static void main(String[]args) {
Student2 s1 = new Student2("凯",22,90);
Student2 s2 = newStudent2("小乔",21,92);
Student2 s3 = newStudent2("妲己",19,95);
s1.lhq+=1;
s1.banfei+=1;
System.out.println(s1.lhq); //1002
System.out.println(s1.banfei); // 103
System.out.println(s2.lhq); // 1001
System.out.println(s2.banfei); // 103
System.out.println(s3.lhq); //1001
System.out.println(s3.banfei); // 103
System.out.println(Student2.banfei);
//---------------
//System.out.println(a); 静态方法中不可以直接访问 非静态的成员变量（实例变量）
//method(); 静态方法中 不可以直接访问非静态方法 （实例方法）
System.out.println(b);//静态方法 可以直接访问 静态变量和 静态方法
method2(); //直接调用静态方法
}
/ void method() { //static不能修饰局部变量
static int a=2;
} /
void method() {
method2();
System.out.println("实例方法可以直接调用静态方法");
}
static void method2() {
System.out.println("静态方法可以直接调用静态方法");
}
}
class Student2{
String name;
int age;
double score;
int lhq = 1000;
static int banfei = 100;
static String classRoom;
public Student2() {
lhq++;
banfei++;
}
public Student2(Stringname,int age,double score) {
this();
this.name=name;
this.age=age;
this.score=score;
}
public void show() {
System.out.println("我叫"+this.name+"今年"+this.age+"岁了,班级"+Student2.classRoom);
}
}
抽象类
在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。也是因为这个原因，通常在设计阶段决定要不要设计抽象类。父类包含了子类集合的常见的方法，但是由于父类本身是抽象的，所以不能使用这些方法。在Java中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口。
没有使用抽象类作为父类时的一些缺陷 ：
父类是具体的类 ： 父类自身创建的实例，没有具体对象与之对应；父类的某些方法被子类重写，父类中的这些方法也没有什么意义；父类无法限制子类子类可以随意设计。
为什么需要抽象类? 如何定义抽象类?
是一种模版模式。抽象类为所有子类提供了一个通用模版，子类可以在这个模版基础上进行扩展。
通过抽象类，可以避免子类设计的随意性。通过抽象类，我们就可以做到严格限制子类的设计，使子类之间更加通用。
抽象类的定义语法：
修饰符 abstract class 类名{
}
抽象类的内部语法：
1. 普通类中有的元素抽象类也可以有，比如成员变量、构造方法、普通方法。
2.抽象类中可以定义抽象方法，使用 abstract 关键字，抽象方法没有方法体，抽象类中定义的抽象方法只是描述有这个功能，但是抽象类不提供具体的实现，具体实现由子类提供。
修饰符 abstract 返回值类型 方法名（方法参数）; 注意：没有方法体
3.抽象类不能创建自身的实例。
4.抽象类有构造方法，但是不能创建自身实例，构造方法的意义是创建子类实例的时候初始化父类的数据给子类实例使用。
5.含有抽象方法的类，只能定义成抽象类，也就是说一个类如果有抽象方法，那这个类一定是抽象类， 但是 一个抽象类不一定有抽象方法。
6. 抽象类对子类的限制。如果一个子类，没有实现抽象父类的所有的抽象方法，那么这个子类也要被定义成抽象类。换句话说： 一个子类继承了抽象类，要么要实现这个抽象类中的所有抽象方法 ，要么这个子类也要被定义成抽象类。
接
接口： 是专门描述具备某个功能或某种方法的一个概念，是一种引用数据类型，它只对外描述具备哪些功能却不提供具体的实现，具体的实现由接口的实现类来提供。
接口专门设计出来用来被实现的或者描述功能的，通过 interface 关键字来定义。如果某个类实现了这个接口，那么这个类就必须实现接口中定义的所有方法。
特点：
1、接口中可以定义变量，但是变量必须有固定的修饰符修饰，public static final 所以接口中的变量也称之为常量，其值不能改变。
2、接口中可以定义方法，方法也有固定的修饰符，public abstract
3、接口不可以创建对象。
4、子类必须覆盖掉接口中所有的抽象方法后，子类才可以实例化。否则子类是一个抽象类。
final关键字Java中的关键字final修饰变量、方法、类分别表示什么含义？
1. final类final类不能被继承，因此final类的成员方法没有机会被覆盖，默认都是final的。在设计类时候，如果这个类不需要有子类，类的实现细节不允许改变，并且确信这个类不会载被扩展，那么就设计为final类。
2. final方法如果一个类不允许其子类覆盖某个方法（即不允许被子类重写），则可以把这个方法声明为final方法。
使用final方法的原因有二：
①把方法锁定，防止任何继承类修改它的意义和实现。
②高效。编译器在遇到调用final方法时候会转入内嵌机制，大大提高执行效率。3. final变量(常量)用final修饰的成员变量表示常量，值一旦给定就无法改变！final修饰的变量有三种：静态变量、实例变量和局部变量，分别表示三种类型的常量。一旦给final变量初值后，值就不能再改变了。
另外，final变量定义的时候，可以先声明，而不给初值，这中变量也称为final空白，无论什么情况，编译器都确保空白final在使用之前必须被初始化。但是，final空白在final关键字final的使用上提供了更大的灵活性，为此，一个类中的final数据成员就可以实现依对象而有所不同，却有保持其恒定不变的特征。
补充：final参数当函数参数为final类型时，你可以读取使用该参数，但是无法改变该参数的值。
abstract关键字
abstract可以用来修饰类和方法，不能用来修饰属性和构造方法；使用abstract修饰的类是抽象类，需要被继承，使用abstract修饰的方法是抽象方法，需要子类被重写。final可以用来修饰类、方法和属性，不能修饰构造方法。
使用final修饰的类不能被继承，使用final修饰的方法不能被重写，使用final修饰的变量的值不能被修改，所以就成了常量。特别注意：final修饰基本类型变量，其值不能改变，由原来的变量变为常量；但是final修饰引用类型变量，栈内存中的引用不能改变，但是所指向的堆内存中的对象的属性值仍旧可以改变。
例如：Person类和Test类的代码如下所示，则代码中的错误语句是（ C ）。（选择一项）publicclassPerson {
public String name;
publicPerson(String name) {
this.name = name;
}}
publicclassTest {
publicstaticvoidmain(String[] args) {
finalPerson person =newPerson("欧欧");
person.name = "美美";
person =newPerson("亚亚");
}}
A.final Person person = new Person("欧欧");
B.person.name = "美美";
C. person = new Person("亚亚");
D.没有错误内部类
内部类：把类定义在其他类的内部，这个类就被称作内部类。
举例：在类A中定义一个类B，这样类B就是内部类，
内部类主要有四种：成员内部类，匿名内部类，静态内部类，局部内部类。
内部类的访问特点：
①内部类可以直接访问外部类的成员，包括私有
②外部类想要访问内部类的成员，必须创建对象。
静态内部类：静态内部类是指被static关键字修饰的内部类，不能访问外部类的普通成员变量，只能访问外部类的静态变量和静态方法。
成员内部类：成员内部类是指没有static关键字修饰的内部类，可以随意使用外部类的属性和方法。
局部内部类：局部内部类是指定义在代码块中的类，作用范围为所在的代码块；局部类类似于局部变量一样，不能使用public，protected，private，static修饰，只能访问方法中定义的定义的final的局部变量。
匿名内部类：匿名内部类是指是一种没有类名的内部类，不使用关键字class、extends、implements，它必须继承其他类或实现其它接口。
补充：实例内部类：在创建实例内部类的实例时，外部类的实例必须存在。实例内部类的实例，自动持有外部类的引用。所以内部类可以直接访问外部类的所有成员，包括变量和方法。
异常机制
异常是正常程序流程所不能处理或者没有处理的异常情况或异常事件，比如算术运算被0除，数组下标越界等。Java采用try-catch-finally语句捕获并处理异常并且处理异常。异常的分类
Error（错误）：程序在执行过程中所遇到的硬件或操作系统的错误。错误对程序而言是致命的，将导致程序无法运行。常见的错误有内存溢出，jvm虚拟机自身的非正常运行，calss文件没有主方法。程序本生是不能处理错误的，只能依靠外界干预。Error是系统内部的错误，由jvm抛出，交给系统来处理。
Exception（异常）：是程序正常运行中，可以预料的意外情况。比如数据库连接中断，空指针，数组下标越界。异常出现可以导致程序非正常终止，也可以预先检测，被捕获处理掉，使程序继续运行。EXCEPTION（异常）按照性质，又分为编译异常（可检测）和运行时异常（不可检测）。
编译时异常：又叫可检查异常，通常时由语法错和环境因素（外部资源）造成的异常。比如输入输出异常IOException，数据库操作SQLException。其特点是，Java语言强制要求捕获和处理所有非运行时异常。通过行为规范，强化程序的健壮性和安全性。
运行时异常：又叫不检查异常RuntimeException，这些异常一般是由程序逻辑错误引起的，即语义错。比如算术异常，空指针异常NullPointerException，下标越界IndexOutOfBoundsException。运行时异常应该在程序测试期间被暴露出来，由程序员去调试，而避免捕获。异常处理的方式
1. 捕获异常 try…catch…finallytry{可能出现问题的代码 ;}catch(异常名变量名){针对问题的处理 ;}finally{释放资源;}注意事项:1、try中的代码越少越好2、catch中要做处理,哪怕是一条输出语句也可以.(不能将异常信息隐藏)3、处理多个异常 ①能明确的尽量明确，不要用大的来处理。 ②平级关系的异常谁前谁后无所谓，如果出现了子父关系，父必须在后面。
2. throws 异常声明：在方法声明的小括号后面使用这个关键字对外声明，我这个方法可能会出现哪些异常，其后可以跟多个异常之间用逗号隔开。谁调用这个方法谁需要处理这些异常。
throws : 异常声明
throw ：异常抛出：相当于抓住了异常，又把异常释放了，会影响后续程序的执行。
区别： 1. 位置 throws 在方法声明处 throw 在方法内部手动抛出异常，其后跟的是异常对象。如果异常对象是检查时异常，需要处理 。一般是声明出去，让方法的调用者来处理。
2.后跟内容不同 throws 可以跟多个异常类型逗号隔开。 throw 后只能跟一个异常对象。
3.作用不同 throw 排除异常，相当于不做处理。 throws 声明异常，方法的调用者需要处理。
自定义异常使用Java内置的异常类可以描述在编程时出现的大部分异常情况。
除此之外，用户还可以自定义异常。用户自定义异常类，只需继承Exception类即可。在程序中使用自定义异常类，大体可分为以下几个步骤。
（1）创建自定义异常类。
（2）在方法中通过throw关键字抛出异常对象。
（3）如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理；否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作。
（4）在出现异常方法的调用者中捕获并处理异常。
常用类
基本类型的包装类
把基本数据类型包装了一下，包装成其所对应的类类型，基本数据类型8种 byte char short int long float double boolean
对应的包装类Byte Character Short Integer Long Float Double Boolean。
Integer 类
Integer 类在对象中包装了一个基本类型 int 的值,该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，还提供了处理 int 类型时非常有用的其他一些常量和方法。public Integer(int value) //构造一个新分配的 Integer 对象，它表示指定的 int 值。public Integer(String s) //构造一个新分配的 Integer 对象，它表示 String 参数所指示的 int 值。
String和int类型的相互转换int -- Stringa:和" ":public static String valueOf(int i)
String -- inta:String -- Integer -- intb:
public static int parseInt(String s)
Integer i1 = 97;
Integer i2 = 97;
System.out.println(i1 == i2);
System.out.println(i1.equals(i2));
System.out.println("-----------");
Integer i3 = 197;
Integer i4 = 197;
System.out.println(i3 == i4);
System.out.println(i3.equals(i4))
输出依次为true true false true 因为-128~127是byte的取值范围，如果在这个取值范围内，自动装箱就不会创建新的对象，而是从常量池中获取，超过了byte取值范围就会再创建新对象~这个就是 i1==i2 的结果为 true 的原因了。int b = 2;
String age = "18";
Integer b2 = new Integer(b); //基本类型转包装类
Integer age2 = new Integer(age); //字符串转包装类
Integer b4 = Integer.valueOf(3); // 基本类型转包装类
Integer b5 = Integer.valueOf("5"); // 字符串 转包装类
String s = String.valueOf(b6); // 基本数据类型转字符串
int age3 = Integer.parseInt(age); // 字符串 转为 intString类
java中的String类型不属于基本数据类型，而是属于引用数据类型。
java中的基本数据类型有8种,byte
,short, int , long, float, double, char, boolean。
引用类型有类，数组和接口，而java中String就属于字符串类。String类继承了Object类，Object类中，输出对象名输出的是对象的地址，采用equals方法比较的也是两个对象的地址，String中重写了toString方法，输出对象名输出的直接是内容，使用equals方法，比较的也是两个对象的内容string类的常用方法：
//public int length() 返回字符串的长度
//public char charAt(int index) 返回指定索引处的字符
//public int indexOf(String str) 返回指定子字符串第一次出现的字符串内的索引 如果没有找到 返回-1
//public boolean equals(Object anObject) 将此字符串与指定对象进行比较。其结果是true当且仅当该参数不是null并且是String对象，表示相同的字符序列作为该对象。//public String replace(char oldChar,char newChar) 替换掉“第一次出现的某个元素”
// public boolean startsWith(String prefix) 测试此字符串是否以指定的前缀开头//public String substring(int beginIndex) 返回一个字符串，该字符串是此字符串的子字符串。子字符串以指定索引处的字符开头，并扩展到该字符串的末尾。//public String toLowerCase(){public String toUpperCase()} 将指定字符串转换成小写{将指定字符串转换成大写}
//public String trim() 删除字符串的首尾空格//public boolean isEmpty() 判断字符串是否为空//public String[] split（String regex, int limit)将字符串按指定格式拆分//public int compareTo(String anotherString)比较两个字符串
//public String concat（String str)将指定字符串连接到字符串的末尾//public char[] toCharArray()将此字符串转换为新的字符数组//public int lastIndexOf(int ch, int fromIndex)返回指定字符的最后一次出现的字符串中的索引StringBufffer
String 不可变字符序列StringBuffer 可变字符序列，线程安全。
StringBuilder 可变字符序列，线程不安全。
append 追加一个字符串
insert 插入一个指定字符串
substring 返回一个新的String，其中包含此字符序列中当前包含的字符的子序列。
Dtae类
在标准Java类库中包含一个Date类。它的对象表示一个特定的瞬间，精确到毫秒。
日期的工具类 java.util.Date 年月日时分秒
子类 ：java.sql.Date 年月日
java.sql.Time 时分秒
java.sql.Timestamp 时间戳 年月日时分秒毫秒
构造方法： new Date(); 创建日期对象
表示当前时间 new Date(Long timeMillis) 参数是距离1970年1月1日 0时0分0秒的毫秒值
[if !vml]
[endif]
实际开发中经常需要日期类型和字符串互相转换，需要 DateFormatpublic final String format(Date date)将日期格式化成日期/时间字符串。public Date parse(String source) throws ParseExceptionCalendar 日历抽象类 通过
public static Calendar getInstance() 获取对象
Calendar cd = Calendar.getInstance();
public int get(int field)返回给定日历字段的值。
public final void set(int year,int month,int date)设置日历字段中的值YEAR，MONTH和DAY_OF_MONTH。
public abstract void add(int field, int amount)根据日历的规则，将指定的时间量添加或减去给定的日历字段。Math类
public static int abs(int a)求绝对值public static double ceil(double a)：向上取整，返回的是doublepublic static double floor(double a)：
向下取整：返回的是doublepublic static long round(double a) ：
四舍五入，返回的是longpublic static double sqrt(double a) ：
求平方根public static double random()：
求随机值[0,1)public static double pow(double a,double b)：
求a的b次幂public static int max(int a,int b)：
求a和b的最大值public static int min(int a,int b)：
求a和b的最小值public static final double PI：常量π枚举类枚举类就是class，而且是一个不可以被继承的final类。所有枚举值都是public , static , final的。注意这一点只是针我们可以和在普通类里面定义变量一样定义其它任何类。
