最近比较烦，点背的时候，喝凉水都是塞牙的，其实我也很想赶项目，把后台接口写好，但是我还是姥姥实实的把基础语法搞个大概在说吧；

做什么还是理解着做才比较有效率，最近我也是够了，说我笔记本内存太小，太慢，影响工作，我自己加了条8G金士顿；你说之前突然我的本不能上网，说是我win8.1系统的问题，我重装了win10企业版，谁知道不兼容，一装软件就崩；后来换成win10 专业版，好家伙照样崩；最后又装了win 8家庭版，在windows上从win8升win10专业版，换没弄公司软件，这次看着到挺像那么回事，我特么终于体会到了隔壁小伙笔记本天天崩的痛楚了；

昨天下班，自行车爆了，补个胎就算了，今天内外胎一起崩，要不是我气场还行，早跳车了，然后换了个里外胎，大爷咱俩可是老熟人了，以后修车全靠您老人家了，虽然我听不懂这个上海老大爷说的话，还好咱能比划，也是醉了；

我上后台，关键靠理解，不然今天会明天忘，到时候搞不定，不用人说我自个挖个坑把自个埋了，这点危机意识还是怼有的；

闲话不多说，看Java基础语法吧，本人学Java通过imooc，以下知识点均来自慕课网教程，如有不足之处，请指正，我的邮箱: zhouminghang@baosight.com

理解Java中的标识符？

标识符就是用于给 Java 程序中变量、类、方法等命名的符号;

诸如：

使用标识符时，需要遵守几条规则：

1. 标识符由字母、数字、下划线（_）、美元符（$）组成;
   不能包含 @、%、空格等其它特殊字符;
   不能以数字开头;

譬如：123name 就是不合法de

2. 标识符不能是 Java 关键字和保留字，但可以包含关键字和保留字;
   保留字：Java 预留的关键字，以后的升级版本中有可能作为关键字；

如：不可以使用 void 作为标识符，但是 Myvoid 可以

3. 标识符严格区分大小写;

例如： admin和 Admin是两个不同的标识符！

4. 标识符的命名最好能反映出其作用，做到见名知意；

java中变量的使用规则

变量：故名思意，就是能够变化的值，它就相当于一个存储空间，用来存放我们想要存放的东西，你可以随便存什么都行；

在 Java 中，变量是由：变量类型、变量名以及变量值三部分组成；

变量的声明写法：

// 第一种： 声明 + 赋值；
 变量类型 变量名 = 变量值；
    或
// 第二种： 先声明，后赋值；
  变量类型 变量名；
  变量名 = 变量值；

举个例子：

String myName = "adminZz";
// or
int myAge;
myAge= 23;

注意：

java是强类型语言，声明变量前，必须指明变量类型；
它不像JavaScript（弱类型语言），所有类型的变量通过var声明即可,而不必指明变量的类型；

Java中的数据(变量/常量)类型有哪些：

其实和JavaScript中的数据类型是差不多的，都包含基本数据类型和引用数据类型，只不过Java分的更加细致；

Java 语言是一种强类型语言。通俗点说就是，在 Java 中存储的数据都是有类型的，而且必须在编译时就确定其类型;

Java 中有两类数据类型：

在 Java 的领域里，基本数据类型变量存的是数据本身，而引用类型变量存的是保存数据的空间地址;

说白了，基本数据类型变量里存储的是直接放在抽屉里的东西，而引用数据类型变量里存储的是这个抽屉的钥匙，钥匙和抽屉一一对应;

插个题外话：

类似着比较，JavaScript中的基本数据类型存放是数据本身，而相对复杂的引用数据则存放的是它所对应的内存地址,有点像C语言中的指针，前者存放在栈内存中，后者存放在堆内存中,后者在声明的时候，会在空间中开辟一个内存，然后通过物理地址，对其所要存放的数据进行读取或者修改操作（个人拙见）;

常用的数据类型如下：

举个栗子如下：

int myAge = 23;//整型进行算数运算时，结果也为整形，只保留整数位，不进行四舍五入操作；
double myWeight = 130.0;//带小数位
float myHeight = 172.2f;// 以f结尾
char mySex = '男';//char类型的值，用单引号，注意字节长度不能超过2字节，不然会报错；
String myName = "zmh"; //String首字符大写，值要加双引号；
boolean iLikePrograming = true;//布尔不二，true OR false；

注意：

• Java 中的标点符号都是英文的；
• 在写标点符号的时候要特别注意单双引号和分号，不然你就等着一行一行调试代码吧；

在定义变量类型是你不得不考虑的溢出问题===》字节问题

这个可以在程序里面运行，看结果就可以了；

Java中 变量名 的命名规则：

其实和标识符的规则是一样的：

• 由字母，数字，下划线（_），美元符($)组成，数字不能开头；
• 不能包含其他特殊字符，如%, @ 等等；
• 不能使用保留字和关键字,但可以包含保留字和关键字（一般取得变量名都有意义，没人无聊会去包含两者的字段）；
• 不限长度，区分大小写；

建议养成以下编码习惯：

1、变量名由多单词组成时，第一个单词的首字母小写，其后单词的首字母大写，俗称骆驼式命名法（也称驼峰命名法）;

如 myAge;

2、变量命名时，尽量简短且能清楚的表达变量的作用，做到见名知意;

如：定义变量名 stuName 保存“学生姓名”信息

注意： Java 变量名的长度没有限制，但 Java 语言是区分大小写的，所以 price 和 Price 是两个完全不同的变量;

Java中的关键字：

Java 语言中有一些具有特殊用途的词被称为关键字;

关键字对 Java 的编译器有着特殊的意义，在程序中应用时一定要慎重;

Java 中常用关键字(不必死记硬背，大概知道有这个东西就行，命名变量的时候不要冲突)：

注意：Java 关键字是区分大小写的；

变量值需要注意的地方：

• 1、Java 中的变量需要先声明后使用;

• 2、变量使用时，可以声明变量的同时进行初始化(赋初值)；

  • 也可以先声明后赋值;

• 3、变量中每次只能赋一个值，但可以修改多次;

• 4、main 方法中定义的变量必须先赋值，然后才能输出;

• 5、虽然语法中没有提示错误，但在实际开发中，变量名不建议使用中文，容易产生安全隐患，譬如后期跨平台操作时出现乱码等等;

总结如下可能会报错的几种情况：

public static void main(String[] args){
   
     System.out.println("我的名字是" + myName); // 报错，变量未声明就使用；
    
     
     String myName_Test = "zmh";  // 变量：声明的同时赋值   
 

     char sex ;
     sex = '男';// 或者：先声明后赋值；
     System.out.println("我叫" + myName_Test + "，我是个" + sex +"孩子。");//我叫zmh，我是个男孩子。
        
  
    String myHobby = "啤酒炸鸡"，"漂移板"；
    System.out.println("我喜欢" + myHobby); // 报错 变量一次只能赋一个值，不能一次赋多个值；
   
  
    String myFruit = "apple";
    myFruit = "pitaya";  // 但可以多次修改变量的值，如下：
    System.out.println("我喜欢吃" + myFruit);//我喜欢吃pitaya
 
    
    String myHome;
    System.out.println("我的故乡是" + myHome)； // 报错：变量输出前未赋值



    String 姓名 = "adminZz";// 不建议使用中文来命名变量，虽然不会报错，但在跨平台是会出现乱码问题；
   };

java中的自动类型转换

在 Java 程序中，不同的基本数据类型的数据之间经常需要进行相互转换；

  int price = 20;
  double price_change = price;
  System.out.println(price_change);//20.0

代码中 int 型变量 price 可以直接为 double 型变量 price_change 完成赋值操作，运行结果为： 20.0

这种转换称为自动类型转换;

自动类型转换需要满足如下特定条件：

1. 目标类型能与源类型 兼容;

如 : double 型兼容 int 型，但是 char 型不能兼容 int 型;

2. 目标类型字节长度大于源类型;

如: double 类型长度为 8 字节， int 类型为 4 字节，因此 double 类型的变量里直接可以存放 int 类型的数据，但反过来int里面放double就不可以了，因为溢出了;

Java中的强制类型转换

例如，当程序中需要将 double 型变量的值赋给一个 int 型变量，该如何实现呢？

显然，这种转换是不会自动进行的！

因为 int 型的存储范围比 double 型的小。此时就需要通过强制类型转换来实现了。

语法：

使用小括号，小括号里面标清要强制转换成那种类型的数据；

( 数据类型 ) 数值

举个栗子：

// 将double转换成int
double num1 = 125.6;
int num2 = (int) num1;
System.out.println(num1);//125.6
System.out.println(num2);//125

注意：
由上可知，通过强制类型转换将 125.6 赋值给 int 型变量后，结果为 125，数值上并未进行四舍五入，而是直接将小数位截断;

• 所以强制类型转换可能会造成数据的丢失，一定要慎重！

Java常量的应用

常量，就是一种特殊的变量，它的值被设定后，在程序运行过程中不允许改变；

语法：

final 常量类型 常量名 = 常量值;

使用常量的好处：

程序中使用常量可以提高代码的可维护性;

例如，在项目开发时，我们需要指定用户的性别，此时可以定义一个常量 SEX，赋值为 "男"，在需要指定用户性别的地方直接调用此常量即可，避免了由于用户的不规范赋值导致程序出错的情况。

注意：

常量名一般使用大写字符;

Java中de注释

在编写程序时，经常需要添加一些注释，用以描述某段代码的作用。

一般来说，对于一份规范的程序源代码而言，注释应该占到源代码的 1/3 以上。

因此，注释是程序源代码的重要组成部分，一定要加以重视！

Java 中注释有三种类型：单行注释、多行注释、文档注释;

三种注释的写法如下：

• 单行注释：
  • 单行注释以//开头，行末结束；

    // 这是单行注释  

• 多行注释：
  • 多行注释以/*开头，*/结束；

/*
* 这是多行注释；
* 可以包含多行内容；
*/

• 文档注释：
  • 文档注释以/**开头，以*/结束；

/**
* 这是文档注释
* @author zmh
* @version v1.0
*/

可以使用快捷键，ctrl+/是（将选中行）单行注释，ctrl+shift+/是（将选中部分）多行注释;

注意：

被注释的代码块在程序运行时是不会被执行的;

我们可以通过 javadoc 命令从文档注释中提取内容，生成程序的 API 帮助文档。

打开首页，查看下生成的 API 文档

PS：使用文档注释时还可以使用 javadoc 标记，生成更详细的文档信息：

     @author 标明开发该类模块的作者

       @version 标明该类模块的版本

       @see 参考转向，也就是相关主题

       @param 对方法中某参数的说明

       @return 对方法返回值的说明

       @exception 对方法可能抛出的异常进行说明

什么是运算符

运算符是一种“功能”符号，用以通知 Java 进行相关的运算;

例如，我们需要将变量 age 的值设置为 20 ，这时候就需要一个“=”，告诉程序需要进行赋值操作。

Java 语言中常用的运算符可分为如下几种：

• Ø 算术运算符

• Ø 赋值运算符

• Ø 比较运算符

• Ø 逻辑运算符

• Ø 条件运算符

Java中的算术运算符

算术运算符主要用于进行基本的算术运算，如加法、减法、乘法、除法等;

Java 中常用的算术运算符：

其中，++ 和 -- 既可以出现在操作数的左边，也可以出现在右边，但结果是不同的；
记住口诀：同JavaScript类似，前则后，后则前(符号在前，则使用运算后的值；符号在后，则使用运算前的值；无论在前在后，这个数值一定改变)

例1：

 int a = 1;
 int b = ++a;
 System.out.println(a);//2
 System.out.println(b);//2
 
 int c = 1;
 int d = c++;
 System.out.println(c);//2
 System.out.println(d);//1

注意：
自增和自减运算符只能用于操作变量，不能直接用于操作数值或常量;

例如 : 5++ 、 8-- 等写法都是错误的;

PS：
%用来求余数，也称为取模运算符;

Java中的比较运算符

• 比较运算符用于判断两个数据的大小，例如：大于、等于、不等于;
• 比较的结果是一个布尔值（ true 或 false ）;

Java 中常用的比较运算符如下表所示：

注意：

1. > 、 < 、 >= 、 <= 只支持左右两边操作数是数值类型;

2. ==、!= 两边的操作数既可以是数值类型，也可以是引用类型;

3. = 是赋值， ==才是等于；

   • 在JavaScript中判断值相等用==,判断值与类型相等用===；

Java中的逻辑运算符

逻辑运算符主要用于进行逻辑运算；

Java 中常用的逻辑运算符如下表所示：

我们可以从“投票选举”的角度理解逻辑运算符：

1、 与：要求所有人都投票同意，才能通过某议题;

2、 或：只要求一个人投票同意就可以通过某议题;

3、 非：某人原本投票同意，通过非运算符，可以使其投票无效;

4、 异或：有且只能有一个人投票同意，才可以通过某议题

• 当使用逻辑运算符时，我们会遇到一种很有趣的“短路”现象;

譬如：( one > two ) && ( one < three ) 中，如果能确定左边 one > two 运行结果为 false , 则系统就认为已经没有必要执行右侧的 one < three ;

===========

同理，在( one > two ) || ( one < three ) 中，如果能确定左边表达式的运行结果为 true , 则系统也同样会认为已经没有必要再进行右侧的 one < three 的执行啦！

对比JavaScript中的逻辑运算：

• 与： 都真才真，有假则假；
• 或： 有真则真，全假才假；
• 非： 真则假，假则真；

对应俩侧的条件表达式执行情况：

• 与： 左真，才执行右侧条件；左假，右不执行；
• 或： 左为真，右不执行；左为假，右才执行；

Java中的条件运算符

条件运算符（ ? : ）也称为 “三元运算符”,类似JavaScript中的三目运算（也相当于变相的if...else）;

语法：

布尔表达式 ？ 表达式1 ：表达式2;

解析（与JavaScript同理）：

如果布尔表达式（条件表达式）的值为 true ，则执行并返回 表达式1 的值，否则执行并返回 表达式2 的值;

举个栗子：

int a = 3;
int b = 4;
String result_test = a > b? "a大于b": "a不大于b"；
System.out.println(result_test);//a不大于b

因为3>4 为false，输出 "a不大于b";

Java中运算符的优先级

所谓优先级，就是在表达式中的运算顺序;

Java 中常用的运算符的优先级如下表所示：

级别为 1 的优先级最高，级别 11 的优先级最低;

对比JavaScript中的优先级：

小括号 > 自增/自减/非 > 算术运算符（ 乘/除/取余 > 加/减；同级之间按从左到右顺序执行） > 关系运算符 > 逻辑运算符 > 赋值运算符（=）；

注意：

• 赋值运算符和算术运算符一起使用，会降低算术运算符的优先级，优先级同赋值运算相同；

PS：大家没必要去死记运算符的优先级顺序，实际开发中，一般会使用小括号(能够更直观的指明运算优先级)辅助进行优先级管理;

举个栗子：

    public static void main(String[] args) {
        int m = 5;
        int n = 7;
        int  x = ( m * 8 / ( n + 2 ) ) % m ;
        System.out.println("m:" + m);//5
        System.out.println("n:" + n);//7
        System.out.println("x:" + x);//4
    }

注意：

• int是整型数，所以要取整；
• 两个整型相除结果为整型；

Java条件语句之 if

if 条件语句:

先判断条件，条件满足后才执行的情况;

语法：

if(条件){
    // 条件为真时，执行的代码；
}

注意：

• 如果 if 条件成立时的执行语句只有一条，是可以省略大括号;
• 但如果执行语句有多条，那么大括号就是不能省略；
• 建议：都不省略大括号；

System.out.println(用双引号还是用单引号，看字节长度)；

• 单引号--char--2字节；
• 上引号--String；

System.out.println("wo shi shei1");//wo shi shei1
System.out.println('wo shi shei2');//报错
System.out.println('w');//w

Java中无论是汉字还是英文字母都是用Unicode编码来表示的;
一个Unicode码是16位，每字节是8位，所以一个Unicode码占两字节。
但是英文字母比较特殊，源自于8位（1字节）的ASCII码，于是在Unicode码仅使用了低8位（1字节）就可以表示，高8位的话不使用也无所谓。

====

所以char c='a';System.out.println(c.getBytes().lenth()),得到的是1（字节）但汉字就完整地使用了16位（2字节）的Unicode，所以char c='中';System.out.println(c.getBytes().lenth()),得到的是2（字节）
综上，c='a'在内存中确实只占1字节，但这不意味着String s="abc"在内存中只占3字节。
应该这么说，String s="abc"至少在内存中占3字节。这是因为char是基本数据类型，而String确是对象类型。对象是一种很复杂的数据类型，你要看一个对象具体占多少字节，可以把这个对象序列化后存入一个文本文件来看它具体占用了多少字节，当然这也不是精确的，因为序列化需要写入少量系统信息，但大致是对的。

Java条件语句之 if...else

if...else 语句的操作比 if 语句多了一步:

• 当条件成立时，则执行 if 部分的代码块；
• 条件不成立时，则执行else部分的代码块;

语法：

if(条件的布尔表达式){
    为真，执行代码块1；
}else{
    为假，执行代码块2；
}

等价于：三目运算(如果限制代码的精简性，建议使用三目运算,有的面试题会有这种要求的)；

条件的布尔表达式？(为true，代码块1) ：(为false，代码块2)；

Java条件语句之多重 if

多重 if 语句，在条件 1 不满足的情况下，才会进行条件 2 的判断；
当前面的条件均不成立时，才会执行 else块内的代码；

语法：

if(条件1){
    条件1为真，执行代码块1；
}else if(条件2){
    条件1为假，条件2为真，执行代码块2；
}else if(...){
    .....
}else if(条件n){
    条件1~（n-1）为假，条件n为真，执行代码块n；
}else{
    条件1~n都为假，才执行代码块（n+1）；
}

注意：条件表达式之间不能有交集，也不能写的太冗余，防止跳楼事件；

举个栗子：
假设年龄大于 60 岁，则提示“老年”；如果年龄介于 40 岁至 60 岁之间，则提示“中年”；如果年龄介于 18 岁至 40 岁之间，则提示“少年”； 18 岁以下则提示“童年”

• 条件表达式无冗余：

public static void main(String[] args) {
        int age=25;
        if(age >= 60){
            System.out.println("老年人");
        }else if( age >= 40){
            System.out.println("中年人");
        }else if(age >= 18){
            System.out.println("少年人");
        }else{
            System.out.println("童年人");
        }
    }

• 冗余的表达式(表达式中有无用的表达式，增加了判断的次数，尽量避免该写法)：

        if(age >= 60){
            System.out.println("老年人");
        }else if( age >= 40 && age < 60){
            System.out.println("中年人");
        }else if(age >= 18 && age < 40){
            System.out.println("少年人");
        }else{
            System.out.println("童年人");
        }

• 无冗余且 精简的代码：

System.out.println(age>60 ? "老年" :age>=40 ? "中年" : age>=18? "少年" : "童年");

Java条件语句之嵌套 if

嵌套 if 语句，只有当外层if的条件成立时，才会判断内层 if 的条件；

语法：

if(条件1){
    if(条件2){
        在条1为真前提下，条2为真，执行代码块1；
    }else{
        在条1为真前提下，条2为假，执行代码块2；
    }
}else{
    条1为假，执行代码块3；
}

流程图：

举个栗子：

注意：判断字符串内容是否相同不能使用==，要使用equals（）；

equals("字符串内容")用于判断字符串的内容是否相同，相同返回true，不相同返回false；

这个我印象贼深刻，因为我第一次写后台接口，通过判断传过来的params上的参数，是否为某个字符串时，怎么怎么样，当时我写的==，报错了，然而我并不知道怎么个回事，哈哈；

if(eiInfo.getString("selected"))后面忘记了

举个栗子(String的equals())：
预赛成绩大于 80 分的可进入决赛，然后根据性别再划分为男子组决赛和女子组决赛。

public static void main(String[] args) {
    int score = 94;
        String sex = "女";
        if(score > 80){
            if(sex.equals("女")){
               System.out.println("进入女子组决赛");
            }else{
               System.out.println("进入男子组决赛");
            }
        }else{
             System.out.println("你被淘汰了");
        }
}

针对java中if语句的总结：

• if 后小括号里必须是一个条件表达式，结果为布尔值，如果为 true ，则执行后面大括号中的代码，如果为 false ，则不执行；

• if语句后可跟else语句，也可不跟；

• if语句可实现深层嵌套；

Java条件语句之 switch

当需要对选项进行等值判断时，使用switch 语句更加简洁明了;

语法：

switch(){
    case 值1：
        执行代码块1;
        break;
    case 值2：
        执行代码块2;
        break;
        
        ...
        
    case 值n：
        执行代码块n;
        break;
    default:
        默认执行的代码；
}

执行过程：

1. 当 switch 后表达式的值和 case 语句后的值相同时，

2. 从该位置开始向下执行，直到遇到 break 语句或者 switch 语句块结束；

3. 如果没有匹配的 case 语句则执行 default块的代码;

注意：

1. switch 后面小括号中表达式的值必须是整型或字符型;

2. case 后面的值可以是常量数值，如1、2；
   也可以是一个常量表达式，如 2+2 ；
   但不能是变量或带有变量的表达式，如 a * 2;

3. case 匹配后，执行匹配块里的程序代码，如果没有遇见 break 会继续执行下一个的 case 块的内容，直到遇到 break 语句或者 switch 语句块结束,如下：

   
   

4. 可以把功能相同的 case 语句合并起来，举栗子如下：

   • 通过月份，判断对应的季节；

int month = 1； 
switch(month){
    case 3:
    case 4:
    case 5:
        System.out.println("春季");
        break;
    case 6:
    case 7:
    case 8:
        System.out.println("夏季");
        break;
    case 9:
    case 10:
    case 11:
        System.out.println("秋季");
        break;
    case 12:
    case 1:
    case 2:
        System.out.println("冬季");
        break;
    default:
        System.out.println("输入月份有误！");
}// 冬季

5. default 块可以出现在任意位置，也可以省略;

Java循环语句之 while

Java 常用的 3 种循环：

• while
• do...while
• for

while语法：

while(判断条件){
    执行的循环操作;
}

执行过程：

• 第1步： 判断 while 后面的条件是否成立( true / false )

• 第2步： 当条件成立时，执行循环内的操作代码 ，然后重复执行步骤1,2， 直到循环条件不成立为止；

特点： 先判断，后执行，可能循环体一次都不会执行；

举个栗子：

 public static void main(String[] args) {
        int i = 1; // 代表 1 - 5 之间的数字
        // 当变量小于等于 5 时执行循环
        while (   i<=5    ) {
            // 输出变量的值，并且对变量加 1，以便于进行下次循环条件判断
            System.out.println(i);
            // 该变量日益趋近条件为假，否则是死循环
            i++;
        }
        // 输出结果为：1 2 3 4 5 
}

注意：

• 必须有一个动态变化的变量，日益趋近能够使while后面的表达式为假，否则程序将进入死循环；

Java循环语句之 do...while

do...while 循环与 while 循环语法有些类似，但执行过程差别比较大;

语法：

do{
    循环操作
}while(判断条件)

执行过程：

• 1. 先执行一遍循环操作，然后判断循环条件是否成立；
• 2. 如果条件成立，继续执行1和2，直到循环条件不成立为止；

特点：

• 先执行，后判断；

• do...while 语句保证循环至少被执行一次！

Java循环语句之 for

Java 的循环结构中除了 while 和 do...while 外，还有 for 循环，三种循环可以相互替换;

语法：

for(循环变量初始化； 循环条件； 循环变量变化) {
    //  循环体，要重复执行的操作；
}

执行过程：

1、 执行循环变量初始化部分，设置循环的初始状态，此部分在整个循环中只执行一次；

2、 进行循环条件的判断，如果条件为 true ，则执行循环体内代码；如果为 false ，则直接退出循环；

3、 执行循环变量变化部分，改变循环变量的值，以便进行下一次条件判断；

4、 依次重新执行 2 、 3 、 4 ，直到退出循环；

特点：相比 while 和 do...while 语句结构更加简洁易读;

弯弯绕，注意留心的几个小细节：
1、 for 关键字后面括号中的三个表达式必须用; 隔开;
比较腻害的：三个表达式都可以省略，但 “;” 不能省略；

• 省略循环变量初始化，可以在 for 语句之前由赋值语句进行变量初始化操作，如:

int i = 0; // 循环变量i在for语句之前赋值
for( ; i < 10; i++){//省略初始化变量
  System.out.println(i);
}

• 省略循环条件，可能会造成循环将一直执行下去，也就是我们常说的死循环现象，如:

for( int i = 0;  ; i++){//省略循环条件（死循环）
  System.out.println(i);
}

在编程过程中要避免“死循环”的出现，因此，对于上面的代码可以在循环体中使用break 强制跳出循环；

• 省略循环变量变化，可以在循环体中进行循环变量的变化，如：

for( int i = 0;   i < 10;){//按顺序，依次匹配 初始值，判断条件，变化值
  System.out.println(i);
  i++；//变化值放循环体内部
}

2、 for 循环变量初始化和循环变量变化部分，可以是使用 ,同时初始化或改变多个循环变量的值，如：

for(int i =1, j = 5; i<=5; i++, j--){
     System.out.println(i + "+" + j + "=" + (i + j));
}

代码中，初始化变量部分同时对两个变量 i 和 j 赋初值，循环变量变化部分也同时对两个变量进行变化，运行结果：

for(int i = 1; i <10 && i != 5; i++) {
    System.out.println(i);
}

代码中，必须同时满足变量 i 小于 10 ，并且 i 不等于 5 时才会进行循环，输出变量 i 的值;

其实java中for循环和JavaScript中的for循环没什么两样，区别就在于Java指定了变量类型,其他的地方两者同样适用

熬夜有害健康，建议你通宵熬！