Java三个体系
Java SE（Java Platform，Standard Edition）。Java SE 以前称为 J2SE。它允许开发和部署在桌面、服务器、嵌入式环境和实时环境中使用的 Java 应用程序。
Java EE（Java Platform，Enterprise Edition）。这个版本以前称为 J2EE。企业版本帮助开发和部署可移植、健壮、可伸缩且安全的服务器端 Java 应用程序。
Java ME（Java Platform，Micro Edition）。这个版本以前称为 J2ME。Java ME 为在移动设备和嵌入式设备（比如手机、PDA、电视机顶盒和打印机）上运行的应用程序提供一个健壮且灵活的环境。
Jdk环境变量配置
新建系统变量JAVA_HOME 和CLASSPATH
变量名：JAVA_HOME
变量值：C:\Program Files\Java\jdk1.7.0
变量名：CLASSPATH
变量值：.;%JAVA_HOME%\lib;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar
编辑变量Path
变量值：%JAVA_HOME%\bin;%JAVA_HOME%\jre\bin;
测试cmd输入JAVAC，出现帮助信息，即为配置正确 java -version可查看jdk版本
Tomcat配置
1新建变量名：CATALINA_BASE，变量值：C:\tomcat
2新建变量名：CATALINA_HOME，变量值：C:\tomcat
3打开PATH，添加变量
值：%CATALINA_HOME%\lib;%CATALINA_HOME%\bin
基本语法
编写Java程序时，应注意以下几点：
大小写敏感：Java是大小写敏感的，这就意味着标识符Hello与hello是不同的。
类名：对于所有的类来说，类名的首字母应该大写。如果类名由若干单词组成，那么每个单词的首字母应该大写，例如 MyFirstJavaClass 。
方法名：所有的方法名都应该以小写字母开头。如果方法名含有若干单词，则后面的每个单词首字母大写。
源文件名：源文件名必须和类名相同。当保存文件的时候，你应该使用类名作为文件名保存（切记Java是大小写敏感的），文件名的后缀为.java。（如果文件名和类名不相同则会导致编译错误）。
主方法入口：所有的Java 程序由public static void main(String []args)方法开始执行。
关键字
Java中有特殊用途的词被称作关键字，关键字区分大小写 所有的关键字都小写
标识符
Java所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符。
所有的标识符都应该以字母（A-Z或者a-z）,美元符（$）、或者下划线（）开始
首字符之后可以是字母（A-Z或者a-z）,美元符（$）、下划线（）或数字的任何字符组合
关键字不能用作标识符
标识符是大小写敏感的
Java转义字符
例子：
public class Test {
public static void main(String args[]) {
System.out.println("访问"菜鸟教程!"");
}
}
Sysout \t 相当于tab 缩进 可以对齐不同输出的文本对齐
类和对象
对象：对象是类的一个实例（对象不是找个女朋友），有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。
类：类是一个模板，它描述一类对象的行为和状态。确定对象将有的特征（属性）和行为（方法），用来确定对象信息，具有相同属性和方法的一组对象的集合
软件对象也有状态和行为。软件对象的状态就是属性，行为通过方法体现。
在软件开发中，方法操作对象内部状态的改变，对象的相互调用也是通过方法来完成。
属性：对象具有的特征
方法：对象执行的操作
定义类
类的首字母大写 创建类
定义对象
类名 对象名 = new 类名（）;
使用对象的属性
Phone.screen
使用对象的方法
Phone.sendMessage();
构造方法
每个类都有构造方法。如果没有显式地为类定义构造方法，Java编译器将会为该类提供一个默认构造方法。
public class Puppy{
public Puppy(){
}
public Puppy(String name){
// 这个构造器仅有一个参数：name
}}
创建一个新的对象 当创建对象的时候就是执行了一个构造方法
定义在java类中的一个用来初始化对象的方法
构造方法与类同名且没有返回值
构造方法还可以给对象赋一个合理的值
创建对象
声明：声明一个对象，包括对象名称和对象类型。
实例化：使用关键字new来创建一个对象。
初始化：使用new创建对象时，会调用构造方法初始化对象。
Puppy myPuppy = new Puppy( "tommy" );
访问实例变量和方法
通过已创建的对象来访问成员变量和成员方法，如下所示：
/* 实例化对象 /
ObjectReference = new Constructor();
/ 访问类中的变量 /
ObjectReference.variableName;
/ 访问类中的方法 */
ObjectReference.MethodName();
变量
内存中的一小块区域，需要变量名来访问
变量的命名： 变量类型 变量名=变量值 例：String stuName= “wangwei”;
java中的所有标点符号都是英文的
变量的使用规则
可以先声明后初始化 也可以声明的同时初始化 每次只能赋一个值可以
修改多次 变量的使用 String name; name=wangwei; 或 String name=”wangwei”;
变量赋值的时候 char类型的用单引号，String的用双引号
局部变量
局部变量声明在方法、构造方法或者语句块中；
局部变量在方法、构造方法、或者语句块被执行的时候创建，当它们执行完成后，变量将会被销毁；
访问修饰符不能用于局部变量；
局部变量只在声明它的方法、构造方法或者语句块中可见；
局部变量是在栈上分配的。
局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用。
成员变量（实例变量）
实例变量声明在一个类中，但在方法、构造方法和语句块之外，存储在堆中；
当一个对象被实例化之后，每个实例变量的值就跟着确定；
实例变量在对象创建的时候创建，在对象被销毁的时候销毁；
实例变量的值应该至少被一个方法、构造方法或者语句块引用，使得外部能够通过这些方式获取实例变量信息；
实例变量可以声明在使用前或者使用后；
访问修饰符可以修饰实例变量；
实例变量对于类中的方法、构造方法或者语句块是可见的。一般情况下应该把实例变量设为私有。通过使用访问修饰符可以使实例变量对子类可见；
实例变量具有默认值。数值型变量的默认值是0，布尔型变量的默认值是false，引用类型变量的默认值是null。变量的值可以在声明时指定，也可以在构造方法中指定；
实例变量可以直接通过变量名访问。但在静态方法以及其他类中，就应该使用完全限定名：ObejectReference.VariableName。
注意：
成员变量： 在类中定义，用来描述对象将有什么 在类中使用
局部变量： 在类的方法中定义，在方法中临时保存 在当前方法中使用
作用域不同，类中的所有方法都可以使用成员变量，局部变量只能在当前方法中使用
注意：
1java会给成员变量一个初始值 不会给局部变量赋予初始值
2同一个方法中不允许有同名的局部变量
3当局部变量和成员变量同名的时候，优先使用局部变量
静态变量（类变量）
类变量也称为静态变量，在类中以static关键字声明，但必须在方法构造方法和语句块之外。
无论一个类创建了多少个对象，类只拥有类变量的一份拷贝。
静态变量除了被声明为常量外很少使用。常量是指声明为public/private，final和static类型的变量。常量初始化后不可改变。
静态变量储存在静态存储区。经常被声明为常量，很少单独使用static声明变量。
静态变量在程序开始时创建，在程序结束时销毁。
与实例变量具有相似的可见性。但为了对类的使用者可见，大多数静态变量声明为public类型。
默认值和实例变量相似。数值型变量默认值是0，布尔型默认值是false，引用类型默认值是null。变量的值可以在声明的时候指定，也可以在构造方法中指定。此外，静态变量还可以在静态语句块中初始化。
静态变量可以通过：ClassName.VariableName的方式访问。
类变量被声明为public static final类型时，类变量名称一般建议使用大写字母。如果静态变量不是public和final类型，其命名方式与实例变量以及局部变量的命名方式一致。
注意：
静态变量 可以通过类名访问，也可以通过对象访问
静态方法（类方法） 可以通过类名来访问 也可以通过对象来访问
１）不能直接调用非静态成员 可以在方法中创建类的对象，通过对象来访问非静态常量
２）普通成员方法可以直接访问同类的非静态变量和静态变量
３）静态方法中不能直接调用非静态方法，需要通过对象来访问非静态方法
静态初始化块：
1）程序运行时，静态初始化最先被执行，然后执行普通初始化，最后才执行构造方法
2）静态方法只在类加载的时候执行，且只执行一次，同时静态初始化只能给静态变量赋值，不能初始化普通的成员变量
Java 中静态变量和实例变量区别
静态变量属于类，该类不生产对象，通过类名就可以调用静态变量。
实例变量属于该类的对象，必须产生该类对象，才能调用实例变量。
在程序运行时的区别：
实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被分配空间，才能使用这个实例变量。
静态变量不属于某个实例对象，而是属于类，所以也称为类变量，只要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间，静态变量就可以被使用了。
常量
特殊的变量 它的值在程序运行过程中不允许发生改变 变量名一般大写
final String LOVE=”love”
当使用常量的时候，前缀 0 表示 8 进制，而前缀 0x 代表 16 进制, 例如：
int decimal = 100;
int octal = 0144;
int hexa = 0x64;
字符串常量
char a = '\u0001';
String a = "\u0001";
注释
注释中的字符将被Java编译器忽略。
单行注释 多行注释 文档注释
单行注释以了//开头 行尾结束
多行注释以/开头 以/结束 每行*开头
文档注释以/**开头以/结束 每行开头
数据类型
分为基本数据类型和引用数据类型
基本数据类型变量存储的就是数据本身，引用数据类型的变量是保存数据的空间地址
四种基本数据类型：
逻辑型 boolean
文本型 char
整数型 byte short int long
浮点数型 float double
取值范围：
最高位为符号位为0为正 1为负
计算机存储的是补码 正数的补码为原码 负数的补码为原码的反码+1
反码和补码计算数值也需要转换成原码
byte：
byte 数据类型是8位、有符号的，以二进制补码表示的整数；
最小值是 -128（-2^7）；
最大值是 127（2^7-1）；
默认值是 0；
byte 类型用在大型数组中节约空间，主要代替整数，因为 byte 变量占用的空间只有 int 类型的四分之一；
例子：byte a = 100，byte b = -50。
short：
short 数据类型是 16 位、有符号的以二进制补码表示的整数
最小值是 -32768（-2^15）；
最大值是 32767（2^15 - 1）；
Short 数据类型也可以像 byte 那样节省空间。一个short变量是int型变量所占空间的二分之一；
默认值是 0；
例子：short s = 1000，short r = -20000。
int：
int 数据类型是32位、有符号的以二进制补码表示的整数；
最小值是 -2,147,483,648（-2^31）；
最大值是 2,147,483,647（2^31 - 1）；
一般地整型变量默认为 int 类型；
默认值是 0 ；
例子：int a = 100000, int b = -200000。
long：
long 数据类型是 64 位、有符号的以二进制补码表示的整数；
最小值是 -9,223,372,036,854,775,808（-2^63）；
最大值是 9,223,372,036,854,775,807（2^63 -1）；
这种类型主要使用在需要比较大整数的系统上；
默认值是 0L；
例子： long a = 100000L，Long b = -200000L。
"L"理论上不分大小写，但是若写成"l"容易与数字"1"混淆，不容易分辩。所以最好大写。
float：
float 数据类型是单精度、32位、符合IEEE 754标准的浮点数；
float 在储存大型浮点数组的时候可节省内存空间；
默认值是 0.0f；
浮点数不能用来表示精确的值，如货币；
例子：float f1 = 234.5f。
double：
double 数据类型是双精度、64 位、符合IEEE 754标准的浮点数；
浮点数的默认类型为double类型；
double类型同样不能表示精确的值，如货币；
默认值是 0.0d；
例子：double d1 = 123.4。
boolean：
boolean数据类型表示一位的信息；
只有两个取值：true 和 false；
这种类型只作为一种标志来记录 true/false 情况；
默认值是 false；
例子：boolean one = true。
char：
char类型是一个单一的 16 位 Unicode 字符；
最小值是 \u0000（即为0）；
最大值是 \uffff（即为65,535）；
char 数据类型可以储存任何字符；
例子：char letter = 'A';。
Double d= 12345.6 float f=12.3f long l2 = 30000000000L
引用类型
引用类型指向一个对象，指向对象的变量是引用变量。这些变量在声明时被指定为一个特定的类型，比如 Employee、Puppy 等。变量一旦声明后，类型就不能被改变了。
对象、数组都是引用数据类型。
所有引用类型的默认值都是null。
自动类型转换
整型、实型（常量）、字符型数据可以混合运算。运算中，不同类型的数据先转化为同一类型，然后进行运算。
1目标类型与源类型兼容 2目标类型大于源类型
基本的数据类型由低级到高级分别为：（byte、short、char）——int——long——float——double
byte、short、char不会相互装换，计算时会先转换为int
注意：
- 不能对boolean类型进行类型转换。
- 不能把对象类型转换成不相关类的对象。
- 在把容量大的类型转换为容量小的类型时必须使用强制类型转换。
- 转换过程中可能导致溢出或损失精度，例如：
int i =128;
byte b = (byte)i;
因为 byte 类型是 8 位，最大值为127，所以当强制转换为 int 类型值 128 时候就会导致溢出。 - 浮点数到整数的转换是通过舍弃小数得到，而不是四舍五入，例如：
(int)23.7 == 23;
(int)-45.89f == -45
强制类型转换
double avg1=65.8;
int avg2=int(avg1);
输出的avg2是65
强制类型转换可能会造成数据的丢失 谨慎使用
隐含强制类型转换 - 整数的默认类型是 int。
- 浮点型不存在这种情况，因为在定义 float 类型时必须在数字后面跟上 F 或者 f。
包装类
在实际开发过程中，我们经常会遇到需要使用对象，而不是内置数据类型的情形。为了解决这个问题，Java 语言为每一个内置数据类型提供了对应的包装类。
所有的包装类（Integer、Long、Byte、Double、Float、Short）都是抽象类 Number 的子类。
基本数据类型是不具有对象特征的，为了让基本数据类型也具备对象特征，提供了包装类
包装类的常用方法
使用：先使用包装类对象，再使用包装类对象装换类型
int score1 = 86;
创建Integer包装类对象，表示变量score1的值
Integer score2=new Integer(score1);
将Integer包装类转换为double类型
double score3=score2.doubleValue()；
基本类型和包装类
装箱就是自动将基本数据类型转换为包装器类型；拆箱就是自动将包装器类型转换为基本数据类型。
基本类型和字符串
1基本类型转换成字符串
1）使用包装类的toString方法
2）使用的String类的valueOf方法
3）使用一个空字符加上字符类型，得到基本类型的字符串
2字符转化为基本类型
1）调用包装类的parseXxx静态方法
2）调用包装类的valueOf()转化为基本类型的包装类
访问修饰符
default (即缺省，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）
public : 对所有类可见。使用对象：类、接口、变量、方法
protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。
默认访问修饰符
使用默认访问修饰符声明的变量和方法，对同一个包内的类是可见的。接口里的变量都隐式声明为 public static final,而接口里的方法默认情况下访问权限为 public。
非访问修饰符
为了实现一些其他的功能，Java 也提供了许多非访问修饰符。
static 修饰符，用来修饰类方法和类变量。
final 修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。
abstract 修饰符，用来创建抽象类和抽象方法。
synchronized 和 volatile 修饰符，主要用于线程的编程。
static修饰符
静态变量：
static 关键字用来声明独立于对象的静态变量，无论一个类实例化多少对象，它的静态变量只有一份拷贝。 静态变量也被称为类变量。局部变量不能被声明为 static 变量。
静态方法：
static 关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。静态方法从参数列表得到数据，然后计算这些数据。
Final修饰符
最终的含义 修饰类，方法属性，变量
Final修饰类 则该类不允许被继承
Final 修饰方法 则方法不允许被继承
Final 修饰属性 则该类不会进行隐式初始化（类的初始化属性必须有值）或者在构造方法中赋值
Final 修饰变量，则该变量的值只能赋一次值，即变为常量
abstract 修饰符
抽象类：
抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充。
一个类不能同时被 abstract 和 final 修饰。如果一个类包含抽象方法，那么该类一定要声明为抽象类，否则将出现编译错误。
抽象方法：
抽象方法是一种没有任何实现的方法，该方法的的具体实现由子类提供。
抽象方法不能被声明成 final 和 static。
任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类。
如果一个类包含若干个抽象方法，那么该类必须声明为抽象类。抽象类可以不包含抽象方法。
其他修饰符
synchronized 修饰符
synchronized 关键字声明的方法同一时间只能被一个线程访问。synchronized 修饰符可以应用于四个访问修饰符。
transient 修饰符
序列化的对象包含被 transient 修饰的实例变量时，java 虚拟机(JVM)跳过该特定的变量。
volatile 修饰符
volatile 修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。而且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。
运算符
算术运算符
++ -- 在前时先运算后取值；在后时先取值后运算
关系运算符
== !=也可以是引用类型
位运算符
逻辑运算符
赋值运算符
条件运算符 (?:)
布尔表达式 ？ 表达式1 ： 表达式2
布尔表达式的值为true则返回表达式1的值 否则返回表达式2的值
instanceof 运算符
该运算符用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型）。
( Object reference variable ) instanceof (class/interface type)
运算优先级
流程控制语句
If语句
if else 多重if 嵌套if
Switch语句
switch(表达式）{
Case 值1: 代码块1
break;
Case 值2: 代码块2
break;
default:
默认代码
}
注意：
switch小括号表达式的值必须是整型或字符型 case之后的值可以是常量或
常量表达式 case块可以合并 default块可以省略
3）while (判断条件) {} 先判断 后执行
4）do {
循环操作
} while(判断条件）;
注意： 先执行，后判断，do while保证语句至少执行一次
5）for(循环初始化; 循环条件;循环变量变化）{ } 三个表达式都可以省略但;不能省略
break关键字
break 主要用在循环语句或者 switch 语句中，用来跳出整个语句块。
break 跳出最里层的循环，并且继续执行该循环下面的语句
continue关键字
continue 适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代。
在 for 循环中，continue 语句使程序立即跳转到更新语句。
在 while 或者 do…while 循环中，程序立即跳转到布尔表达式的判断语句。
Java 增强 for 循环
Java5 引入了一种主要用于数组的增强型 for 循环。
ava 增强 for 循环语法格式如下:
for(声明语句 : 表达式)
{
//代码句子
}
声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。
表达式：表达式是要访问的数组名，或者是返回值为数组的方法。
例子:
public class Test {
public static void main(String args[]){
int [] numbers = {10, 20, 30, 40, 50};
for(int x : numbers ){
System.out.print( x );
System.out.print(",");
}
System.out.print("\n");
String [] names ={"James", "Larry", "Tom", "Lacy"};
for( String name : names ) {
System.out.print( name );
System.out.print(",");
}
}
}
数组
声明
数据类型[] 数组名;
或 数据类型 数组名[]
int[] scores; int scores[];
分配空间
数组名= new 数据类型[数组长度];
scores=new int[5];
声明和分配空间一起
int[] scores=new int[5];
赋值
scores[0]= 1;..
声明 分配空间 赋值一起
int[] scores={1,2,3,4}
或 int[] scores=new int[]{1,2,3,4}
4）foreach 操作数组
For(元素类型 元素变量 ：遍历对象）{ }
例 for(String score : scores){}
5)nums[i]=(int)(Math.random()*100)
随机生成100以内的整数元素
二维数组
1）声明并分配空间
数据类型[][] 数组名= new 数据类型[行的个数][列的个数]
Int[][] num=new int[2][3];
2)声明的同时为其赋值
数据类型[][] 数组名={{1,2,3},{1,2,3},{1,2,3}}
3)二维数组的二重循环输出
For(int i=0; i < num.length;i++){
For(int j=0;j < num[i].length;j++){}
}
方法
Java方法是语句的集合，它们在一起执行一个功能。
方法是解决一类问题的步骤的有序组合
方法包含于类或对象中
方法在程序中被创建，在其他地方被引用
注意：
在一些其它语言中方法指过程和函数。一个返回非void类型返回值的方法称为函数；一个返回void类型返回值的方法叫做过程。
方法的语法：
访问修饰符 返回值类型 方法名（参数列表）{
方法体
} 方法名的第一个单词的首字母小写 其他单词的首字母大写
2）方法的定义： 先创建类的对象，再通过 对象名.方法名（）; 来实现
3）方法的分类：
1无参无返回值方法 对象名.方法名（）调用
Public void show(){
System.out.println(‘welcome to imooc’)
}
2无参带返回值 方法中返回值类型 调用的时候处理返回值
Public int calcsum(){
Int a=5;
Int b=12;
Int sum=a+b;
Return sum:
}
注意： 方法的返回值最多有一个，返回值必须兼容
3 带参无返回值 参数数量类型形参顺序须一致 实参不需要数据类
型 多个参数用逗号分隔
Public void show (string name ){
System.out.println(‘欢迎您,’+name +’!’)
注意：实参的数目类型顺序与形参一一对应 实参在调用方法的时候加入
4 带参带返回值
Public string show(string name ){
Return ’欢迎您’+ name+’!’
}
注意： 返回值的类型 方法和方法体中要一致 返回值最多一个 形参和实参的类
型要一致 多个参数要逗号分隔 形参的基本数据引用数据都可以
4）方法的重载：一个类中包含两个或两个以上的方法名相同，方法参数的顺序类型个
数不同称作方法的重载 java会根据参数的的类型来判断该调用哪个方法。
命令行参数的使用
有时候你希望运行一个程序时候再传递给它消息。这要靠传递命令行参数给main()函数实现。
命令行参数是在执行程序时候紧跟在程序名字后面的信息。
$ javac CommandLine.java
$ java CommandLine this is a command line 200 -100