java运算：数据类型 + 运算符 + 流程控制 + 循环语句

水深无声 2022-12-02 13:43 239阅读 0赞

# java基础篇 #

## 命令提示符–常用命令 ##

1.启动：  		  		win + R,输入cmd
    2.切换盘符	    	   盘符名称:
    3.进入文件夹		      cd 文件夹
    4.进入多级文件夹		 cd 文件夹1\文件夹2\文件夹3
    5.返回上一级			  cd ..
    6.直接回根路径		 cd \
    7.查看当前内容         dir
    8.清屏				cls
    9.退出				exit

## 常量的概念与分类 ##

> 常量：在程序运行期间，固定不变的量。

常量的分类：

<table> 
 <thead> 
  <tr> 
   <th>分类名</th> 
   <th>说明</th> 
   <th>举例</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>字符串常量</td> 
   <td>凡是用双引号引起来的部分</td> 
   <td>“abc”、“Hello"、”123“</td> 
  </tr> 
  <tr> 
   <td>整数常量</td> 
   <td>直接写上的数字，没有小数点</td> 
   <td>100、0、-60</td> 
  </tr> 
  <tr> 
   <td>浮点数常量</td> 
   <td>直接写上的数字，有小数点</td> 
   <td>2.5、-3.14、0.0</td> 
  </tr> 
  <tr> 
   <td>字符常量</td> 
   <td>凡是用单引号引起来的单个字符；<br>（两个单引号中间有且只有一个字符，没有不行！！）<br>错误写法：‘AB’、’’</td> 
   <td>‘A’、‘b’、‘中’、‘9’</td> 
  </tr> 
  <tr> 
   <td>布尔常量</td> 
   <td>只有量中取值</td> 
   <td>true、false</td> 
  </tr> 
  <tr> 
   <td>空常量</td> 
   <td>null，代表没有任何数据。<br>注意：空常量不能直接用来打印输出</td> 
   <td></td> 
  </tr> 
 </tbody> 
</table>

## 数据类型分类 ##

Java的数据类型分为两大类：

*  基本数据类型：整数、浮点数、字符、布尔
 *  引用数据类型：类、数组、接口

### 基本数据类型 ###

> 四类八种基本数据类型：

<table> 
 <thead> 
  <tr> 
   <th>数据类型</th> 
   <th>关键字</th> 
   <th>内存占用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>字节型</td> 
   <td>byte</td> 
   <td>1个字节</td> 
  </tr> 
  <tr> 
   <td>短整型</td> 
   <td>short</td> 
   <td>2个字节</td> 
  </tr> 
  <tr> 
   <td>整型</td> 
   <td>int</td> 
   <td>4个字节</td> 
  </tr> 
  <tr> 
   <td>长整型</td> 
   <td>long</td> 
   <td>8个字节</td> 
  </tr> 
  <tr> 
   <td>单精度浮点数</td> 
   <td>float</td> 
   <td>4个字节</td> 
  </tr> 
  <tr> 
   <td>双精度浮点数</td> 
   <td>double（默认）</td> 
   <td>8个字节</td> 
  </tr> 
  <tr> 
   <td>字符型</td> 
   <td>char</td> 
   <td>2个字节</td> 
  </tr> 
  <tr> 
   <td>布尔型</td> 
   <td>boolean</td> 
   <td>1个字节</td> 
  </tr> 
 </tbody> 
</table>

注意事项：

1.  字符串不是基本类型，而是引用类型。
2.  浮点型可能只是一个近似值，并非精确的值。
3.  `数据范围与字节数不一定相关`，例如：float数据范围比long更加广泛，但是float是4字节，long是8字节。
4.  浮点数当中默认类型是double。如果一定要使用float类型，需要加上一个`后缀F`。
    
    如果是整数，默认为int类型。如果一定要使用long类型，需要加上一个`后缀L`。`推荐使用大写字母后缀`。

### 引用数据类型 ###

## 数据类型转换 ##

当数据类型不一样时，将会发生数据类型转换。

*  自动类型转换（隐式）
    
    1.  特点：代码不需要进行特殊处理，自动完成
    2.  规则：数据范围从小到大。
        
         *  int --> long
         *  float --> double
         *  特殊记忆：`long --> float`，简单记忆：`老夫`

public class HelloWorld { 	
    	public static void main(String[] args) { 
    		System.out.println(1024); // 这就是一个整数，默认就是int类型
    		System.out.println(3.14); // 这就是一个整数，默认就是int类型
    		
    		/* 左边是long类型时，右边是默认的int类型，左右不一样 一个等号代表赋值，将右侧的int常量，交给左侧的long变量进行存储 int --> long,符合数据范围从小到大的要求 这一行代码发生了自动类型转换 */
    		long num1 = 100;
    		System.out.println(num1); // 100
    		
    		/* 左边是double类型，右边是float类型，左右不一样 float --> double，符合从小到大的规则，也发生了自动类型转换 */
    		double num2 = 2.5F;
    		System.out.println(num2); // 2.5
    		
    		/* 左边是float类型，右边是long类型，左右不一样 long --> float，范围是float更大一些，符合从小到大的规则，也发生了自动类型转换 */
    		float num3 = 30L;
    		System.out.println(num3); // 30.0
    		
    	}
    }

*  强制类型转换（显式）

/* 强制类型转换： 1.特点：代码需要进行特殊的格式处理，不能自动完成。 2.格式：范围小的类型 范围小的变量名 = （范围小的类型） 原本范围大的数据 注意事项： 1.强制类型转换一般不推荐使用，因为有可能发生精度损失、数据溢出。 2.byte/short/char这三种类型都可以发生数学运算，例如：加法“+” 3.byte/short/char这三种类型在运算的时候，都会被首先提升成为int类型，然后再计算。 4.boolean类型不能发生数据类型转换。 */
    
    public class HelloWorld { 	
    	public static void main(String[] args) { 
    	
    		/* 左边是int类型，右边是long类型，不一样 long --> int，不是从小到大，不能发生自动类型转换！ 但是可以通过强制类型转换： 格式：范围小的类型 范围小的变量名 = （范围小的类型） 原本范围大的数据 */
    		int num = (int) 100L;
    		System.out.println(num); // 100
    		
    		// long强制转换为int类型
    		int num2 = (int) 6000000000L;
    		System.out.println(num2); // 1705032704
    		
    		// double --> int，强制类型转换
    		int num3 = (int) 3.99;
    		System.out.println(num3); // 3 注意：这并不是四舍五入，所有的小数位都会被舍弃。
    		
    		/* 运算 计算机的底层会用一个数字（二进制）来代表字符A，就是65 一旦char类型进行了数学运算，那么字符就会按照一定的规则翻译成为一个数字 */
    		char zifu1 = 'A';
    		System.out.println(zifu1 + 1); // 66 也就是大写字母A被当做65进行处理
    		
    		byte num4 = 40; // 注意：右侧的数值大小不能超过左侧的类型范围
    		byte num5 = 50;
    		// btye + byte --> int + int --> int
    		int result1 = num4 + num5;
    		System.out.println(result1); // 90
    		
    		short num6 = 60;
    		// btye + short --> int + int --> int
    		// int 强制转换为short
            // 注意：必须保证逻辑上真实大小本来就没有超过short范围，否则会发生数据溢出
    		short result2 = (short) (num4 + num6);
    		System.out.println(result2); // 100
    	}
    }

## ASCII编码表 ##

只需要记住特殊的3个含义，就可以了

<table> 
 <thead> 
  <tr> 
   <th>ASCII 值</th> 
   <th>控制字符</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>48</td> 
   <td>‘0’</td> 
  </tr> 
  <tr> 
   <td>65</td> 
   <td>‘A’</td> 
  </tr> 
  <tr> 
   <td>97</td> 
   <td>‘a’</td> 
  </tr> 
 </tbody> 
</table>

## 算术运算符 ##

### 四则与取模运算 ###

/* 运算符：进行特定操作的符号。例如：+ 表达式：用运算符连接起来的式子叫做表达式。例如：20 + 5。又如：a + b 四则运算： 加：+ 减：- 乘：* 除：/ 取模(取余数)：% 首先计算得到表达式的效果,然后再打印输出这个结果。 复习一下小学一年级的除法公式：被除数 / 除数 = 商 .....余数 对于一个整数的表达式来说，除法用的是整除，整数除以整数，结果仍然是整数。只看商，不看余数。 只有对于整数的除法来说，取模运算符才有余数的意义。 注意事项： 1.一旦运算当中有不同类型的数据，那么结果将会是数据类型范围大的那种。 */
    
    public class HelloWorld { 	
    	public static void main(String[] args) { 
    	
    		// 两个常量之间可以进行数字运算
    		System.out.println(20 + 30); // 50
    		
    		// 两个变量之间也可以进行数字运算
    		int a = 20;
    		int b = 30;
    		System.out.println(a - b); // -10
    		
    		// 变量和常量之间可以；混合使用
    		System.out.println(a * 10); // 200
    		
    		int x = 10;
    		int y = 3;
    		int result = x / y;
    		System.out.println(result); // 3
    		
    		/* 取模（取余数）运算 */
    		int result1 = x % y;
    		System.out.println(result1); // 取模（取余数），结果是：1
    		
    		/* 不同类型的数据运算：首先先转化数据类型，然后再运算。 int + double --> double + double --> double */
    		double result2 = x + 2.5;
    		System.out.println(result2); // 结果是：12.5
    	}
    }

### 加号的多种用法 ###

/* 四则运算中的加号“+”，有常见的三种用法 1.对于数值来说，那就是加法 2.对于字符char类型来说，在计算机之前，char会被提升为int，然后再计算 char类型字符，和int类型数字，之间的对照关系表：ASCII、Unicode 3.对于字符串String(首字母大写，并不是关键字)来说，加号代表字符串连接操作。 注意：任何数据类型和字符串进行连接的时候，结果都会变成字符串。 */
    
    public class HelloWorld { 	
    	public static void main(String[] args) { 
    	
    		/* 字符串类型的变量基本使用：数据类型 变量名称 = 数据值; */
    		String str = "Hello";
    		System.out.println(str); // Hello
    		System.out.println(str + "World"); // HelloWorld
    		
    		/* 任何数据类型和字符串进行连接的时候，结果都会变成字符串 String + int --> String */
    		String str1 = "java";
    		System.out.println(str1 + 20); // java20
    		
    		/* 优先级问题：小括号的优先级高于一切 String + int + int 第一步计算前两个数据类型，得到String。 例如：String + int --> String 第二步：将第一步计算的String和后面的int，再进行运算。得到String 例如：String + int --> String */
    		System.out.println(str1 + 20 + 30); // java2030
    		System.out.println(str1 + (20 + 30)); // java50
    	}
    }

### 自增自减运算符 ###

/* 自增运算符：++ 自减运算符：-- 基本含义：让一个变量涨一个数字1，或者让一个变量降一个数字1。 使用格式：写在变量名称之前，或者写在变量名称之后。例如：++num。也可以num++ 使用方式： 1.单独使用：不和其他任何操作混合，自己独立成为一个步骤。 2.混合使用：和其他操作混合，例如：与赋值混合，或者与打印混合，等。 使用区别： 1.在单独使用的时候：前++和后++没有任何区别。也就是 ++num 和 num++ 是完全一样的。 2.在混合的时候，有【重大区别】 A：如果是【前++】，那么变量【立刻马上+1】，然后拿着结果进行使用。 【先加后用】 B：如果是【后++】，那么首先使用变量本来的数值，【然后再让变量+1】。【先用后加】 注意事项： 只有变量才能使用自增、自减运算符。常量不可发生改变，所以不能用。 */
    
    public class HelloWorld { 	
    	public static void main(String[] args) { 
    	
    		/* 字符串类型的变量基本使用：数据类型 变量名称 = 数据值; */
    		int num = 10;
    		System.out.println(num); // 10
    		
    		++num;// 单独使用，前++
    		System.out.println(num); // 11
    		
    		num++;// 单独使用，后++
    		System.out.println(num); // 12
    		System.out.println("================");
    		
    		/* 与打印操作混合的时候 */
    		int num1 = 20;
    		// 混合使用，先++，变量立刻马上变为21，然后打印结果21
    		System.out.println(++num1); // 21
    		System.out.println(num1); // 21
    		System.out.println("================");
    		
    		int num2 = 30;
    		// 混合使用，后++，首先使用变量本来的30，然后再让变量+1得到31
    		System.out.println(num2++); // 30
    		System.out.println(num2); // 31
    		System.out.println("================");
    		
    		/* 和赋值操作混合 */
    		int num3 = 40;
    		int result = --num3; // 混合使用：前--，变量立刻马上-1变成39，然后将结果39交给result变量
    		System.out.println(result); // 39
    		System.out.println(num3); // 39
    		System.out.println("================");
    		
    		int num4 = 50;
    		int result4 = num4--; // 混合使用：后--，首先把变量本来的50交给result4，然后再让变量-1得到49
    		System.out.println(result4); // 50
    		System.out.println(num4); // 49
    		System.out.println("================");
    		
    		int x = 10;
    		int y = 20;
    		// 11 + 20 = 31
    		int result5 = ++x + y--;
    		System.out.println(result5); // 31
    		System.out.println(x); // 11
    		System.out.println(y); // 19
    		System.out.println("================");
    		
    		// 30++; // 错误写法：常量不可以使用++或者--
    	}
    }

### 复合赋值运算符 ###

/* 复合赋值运算符： += a += 3 相当于 a = a + 3 -= b -= 4 相当于 b = b - 4 *= c *= 5 相当于 c = c * 5 /= d /= 6 相当于 d = d / 6 %= e %= 7 相当于 e = e % 7 注意事项： 1.只有变量才能使用赋值运算符，常量不能进行赋值。 2.复合赋值运算符其中隐含了一个强制类型转换。 */
    
    public class HelloWorld { 	
    	public static void main(String[] args) { 
    		int a = 10;
    		/* 按照公式进行翻译：a = a + 5 a = 10 + 5; a = 15; a本来是10，现在重新赋值得到15 */
    		a += 5;
    		System.out.println(a); // 15
    		
    		int x = 10;
    		/* x = x % 3; x = 10 % 3; x = 1; x本来是10，现在重新赋值得到1 */
    		x %= 3;
    		System.out.println(x); // 1
    		
    		// 50 = 30; // 常量不能进行赋值，不能写在赋值运算符的左边。错误写法！
    		
    		byte num = 30;
    		/* num = num + 5; num = byte + int num = int + int num = int num = (byte) int */
    		num += 5;
    		System.out.println(num); // 35
    	}
    }

### 比较运算符 ###

/* 比较运算符 大于： > 小于： < 大于等于： >= 小于等于： <= 相等： == 【两个等号连写才是相等，一个等号代表的是赋值】 不相等： != 注意事项： 1.比较运算符的结果一定是一个boolean值，成立就是true，不成立就是false 2.如果进行多次判断，不能连着写。 数学当中的写法，例如：1 < x < 3 程序当中 【不允许】 这种写法。 */
    
    public class HelloWorld { 	
    	public static void main(String[] args) { 
    	
    		System.out.println(10 > 5); // true
    		int num1 = 10;
    		int num2 = 12;
    		System.out.println(num1 < num2); // true
    		System.out.println(num2 >= 100); // false
    		System.out.println(num2 <= 100); // true
    		System.out.println(num2 <= 12); // true
    		System.out.println("============="); 
    		
    		System.out.println(10 == 10); // true
    		System.out.println(20 != 25); // true
    		System.out.println(20 != 20); // false
    		
    		int x = 2;
    		// System.out.println(1 < x < 3); // 错误写法！编译报错！不能连着写。
    	}
    }

### 逻辑运算符 ###

/* 逻辑运算符： 与（并且） && 全都是true,才是true；否则就是false 或（或者） || 至少一个是true,就是true；全都是false，才是false 非（取反） ! 本来是true，变成false;本来是false,变成true。 与 "&&",或 "||"，具有短路效果：如果根据左边已经可以判断得到最终结果，那么右边的代码将不再执行，从而节省一定的性能。 注意事项： 1.逻辑运算符只能用于boolean值 2.与、或需要左右各有一个boolean值，但是取反只要有唯一的一个boolean值即可。 3.与、或两种运算符，如果有多个条件，可以连着写。 两个条件：条件A && 条件B 多个条件：条件A && 条件B && 条件C TIPS： 对于 1<x<3的情况：应该拆成两个部分，然后使用与运算符连接起来。 int x = 2; 1<x && x<3 */
    
    public class HelloWorld { 	
    	public static void main(String[] args) { 
    	
    		System.out.println(true && false); // false
    		
    		// true && true --> true
    		System.out.println(3 < 4 && 10 > 5); // true
    		System.out.println("=============");
    		
    		System.out.println(true || false); // true
    		System.out.println(true || true); // true
    		System.out.println(false || false); // false
    		System.out.println("============="); 
    		
    		System.out.println(true); // true
    		System.out.println(!true); // false
    		System.out.println("============="); 
    		
    		int a = 10;
    		// false && ...
    		System.out.println(3 > 4 && ++a < 100); // false
    		System.out.println(a); // 10
    		System.out.println("============="); 
    		
    		int b = 20;
    		// true || ...
    		System.out.println(3 < 4 || ++b < 100); // true
    		System.out.println(b); // 20
    	}
    }

### 三元运算符 ###

/* 一元运算符：只需要一个数据就可以进行操作的运算符。例如：取反!、自增++、自减-- 二元运算符：需要两个数据才可以进行操作的运算符。例如：加法+、赋值= 三元运算符：需要三个数据才可以进行操作的运算符。 格式： 数据类型 变量名称 = 条件判断？表达式A：表达式B； 流程： 首先判断条件是否成立： 如果成立为true,那么将表达式A的值赋值给左侧的变量； 如果不成立为false,那么将表达式B的值赋值给左侧的变量。 二者选其一。 注意事项： 1.必须同时保证表达式A和表达式B都符合左侧数据类型的要求。 2.三元运算符的结果必须被使用。 */
    
    public class HelloWorld { 	
    	public static void main(String[] args) { 
    	
    		int a = 10;
    		int b = 20;
    		/* 数据类型 变量名称 = 条件判断？表达式A：表达式B； 判断a > b 是否成立，如果成立将a的值赋值给max；如果不成立将b的值赋值给max。二者选其一 */
    		int max = a > b ? a : b; // 最大值的变量
    		
    		System.out.println("最大值：" + max); // 20
    		
    		// int result = 3 > 4 ? 2.5 : 10; // 错误写法! 印证注意事项1
    		
    		System.out.println(a > b ? a : b); // 正确写法!
    		
    		// a > b ? a : b; // 错误写法! 印证注意事项2
    	}
    }

## 方法入门 ##

/* 定义一个方法的格式： public static void 方法名称(){ 方法体 } 方法名称的命名规则和变量一样，使用小驼峰。 方法体：也就是大括号当中可以包含任意条语句。 注意事项： 1.方法定义的先后顺序无所谓。 2.方法的定义不能产生嵌套包含关系。 3.方法定义好了之后，不会执行的。如果要执行，一定要进行方法的【调用】。 如何调用方法，格式：方法名称(); */
    
    public class HelloWorld { 	
    	public static void main(String[] args) { 
    		// 方法调用
    		me();
    	}
    	
    	public static void me(){ 
    		System.out.println("学习编程java"); 
        }
    }

## 编译器的两点优化 ##

/* 对于byte/short/char三种类型来说，如果右侧赋值的数值没有超过范围。 那么javac编译器将会自动隐含地为我们补上一个(byte)(short)(char)。 1.如果没有超过左侧的范围，编译器补上强转。 2.如果右侧超过了左侧范围，那么直接编译器报错。 */
    
    public class HelloWorld { 	
    	public static void main(String[] args) { 
    		
    		/* 右侧确实是一个int数字，但是没有超过左侧的范围，就是正确的。 int --> byte，不是自动类型转换。 */
    		byte num = 30;  // 右侧没有超过左侧的范围
    		System.out.println(num); // 30
    		
    		// byte num1 = 128; // 右侧超过了左侧的范围
    		
    		/* int --> char，没有超过范围 编译器将会自动补上一个隐含的(char) */
    		char zifu = /*(char)*/ 65;
    		System.out.println(zifu); // A
    	}
    }

/* 在给变量进行赋值的时候，如果右侧的表达式当中全都是常量，没有任何变量， 那么编译器javac将会直接将若干个常量表达式计算得到结果。 short result = 5 + 8; 等号右边全都是常量，没有任何变量参与运算 编译之后，得到的.class字节码文件当中相当于【直接就是】：short result = 13; 右侧的常量结果数值，没有超过左侧范围，所以正确。 这称为"编译器的常量优化"。 但是注意：一旦表达式当中有变量参与，那么就不能进行这种优化了。 */
    
    public class HelloWorld { 	
    	public static void main(String[] args) { 
    		short num = 10; // 正确写法，右侧没有超过左侧的范围
    		
    		short a = 5;
    		short b = 8;
    		// short + short --> int + int --> int
    		// short result = a + b; // 错误写法!左侧需要是int类型
    		
    		// 右侧不用变量，而是采用常量，而且只有两个常量，没有别人
    		short result = 5 + 8;
    		System.out.println(result); // 13
    		
    		// short result1 = 5 + a + 8; // 编译报错!
    	}
    }

## 流程控制 ##

### 单if语句 ###

public class HelloWorld { 	
    	public static void main(String[] args) { 
    		System.out.println("判断是否成年"); // 判断是否成年
    		int age = 16;
    		if(age >= 18){ 
    			System.out.println("成年人");
    		}
    		System.out.println("未成年人");  // 未成年人
    	}
    }

### 标准if…else语句 ###

public class HelloWorld { 	
    	public static void main(String[] args) { 
    		System.out.println("判断奇偶数"); // 判断奇偶数
    		int num = 16;
    		if(num % 2 == 0){   // 如果除以2能够余数为0，说明是偶数
    			System.out.println("偶数"); // 偶数
    		} else { 
    			System.out.println("奇数");
    		}
    		System.out.println("判断结束");  // 判断结束
    	}
    }

### 判断语句 if…else if …else ###

/* x和y的关系满足如下： 如果 x >= 3，那么y = 2x + 1; 如果 -1 < x < 3，那么y = 2x; 如果 x <= -1，那么y = 2x - 1; */
    public class HelloWorld { 	
    	public static void main(String[] args) { 
    		int x = -10;
    		int y;
    		if(x >= 3){ 
    			y = 2 * x + 1;
    		} else if(-1 < x && x < 3) { 
    			y = 2 * x;
    		} else { 
    			y = 2 * x - 1;
    		}
    		System.out.println("结果是：" + y); // -21
    	}
    }

### 选择语句 switch ###

/* switch 语句使用的注意事项： 1.多个case后面的数值不可以重复。 2.switch后面小括号当中只能是下列数据类型： 基本数据类型：byte/short/char/int 引用数据类型：String字符串、enum枚举 3.switch语句格式可以很灵活：前后顺序可以颠倒，而且break语句可以省略。 "匹配哪一个case就从哪一个位置向下执行，直到遇到了break或者整体结束为止。" */
    public class HelloWorld { 	
    	public static void main(String[] args) { 
    		int num = 10;
    		
    		switch(num){ 
    			case 1:
    				System.out.println("星期一");
    				break;
    			case 2:
    				System.out.println("星期二");
    				break;
    			case 3:
    				System.out.println("星期三");
    				break;
    			case 4:
    				System.out.println("星期四");
    				break;
    			case 5:
    				System.out.println("星期五");
    				break;
    			case 6:
    				System.out.println("星期六");
    				break;
    			case 7:
    				System.out.println("星期日");
    				break;
    			default:
    				System.out.println("数据不合理"); // 数据不合理
    				break;
    		}		
    	}
    }

## 循环语句 ##

### for循环 ###

/* 循环结构的基本组成部分，一般可以分成四部分： 1.初始化语句：在循环可以最初执行，而且只做唯一一次。 2.条件判断：如果成立，则循环继续；如果不成立，则循环退出 3.循环体：重复要做的事情内容，若干行语句。 4.步进语句：每次循环之后都要进行的扫尾工作，每次循环结束之后都要执行一次。 */
    public class HelloWorld { 	
    	public static void main(String[] args) { 
    		for(int i = 1; i <= 10; i++){ 
    			System.out.println("学习java" + i);
    		}
    		System.out.println("程序停止");
    	}
    }

### while循环 ###

/* while循环有一个标准格式，还有一个扩展格式。 标准格式： while (条件判断){ 循环体 } 拓展格式： 初始化语句； while (条件判断){ 循环体; 步进语句； } */
    public class HelloWorld { 	
    	public static void main(String[] args) { 
    	
    		// for循环
    		for(int i = 1; i <= 10; i++){ 
    			System.out.println("学习java" + i);
    		}
    		System.out.println("程序停止");
    		System.out.println("=====================");
    		
    		// 将for循环改写为while循环
    		int i = 1;  // 1.初始化语句
    		while (i <= 10){   // 2.条件判断
    			System.out.println("学习java" + i);  // 3.循环体
    			i++;  // 4.步进语句
    		}
    		System.out.println("程序停止");
    	}
    }

### do-while循环 ###

/* do-while循环有一个标准格式，还有一个扩展格式。 标准格式： do { 循环体 } while (条件判断); 拓展格式： 初始化语句; do { 循环体; 步进语句 } while (条件判断); */
    public class HelloWorld { 	
    	public static void main(String[] args) { 
    	
    		// for循环
    		for(int i = 1; i <= 10; i++){ 
    			System.out.println("学习java" + i);
    		}
    		System.out.println("程序停止");
    		System.out.println("=====================");
    		
    		// 将for循环改写为do-while循环
    		int i = 1;  // 1.初始化语句
    		do { 
    			System.out.println("学习java" + i);  // 3.循环体
    			i++;  // 4.步进语句
    		}
    		while (i <= 10); // 2.条件判断
    		System.out.println("程序停止");
    	}
    }

### 三种循环的区别： ###

/* 三种循环的区别： 1.如果条件判断从来没有满足过，那么for循环和while循环将会执行0次，但是do-while循环会执行至少一次。 2.for循环的变量在小括号当中定义，只有循环内部才可以使用。 while循环和do-while循环初始化语句本来就在外面，所以出来循环之后还可以继续使用。 */
    public class HelloWorld { 	
    	public static void main(String[] args) { 
    	
    		// for循环
    		for(int i = 1; i < 0; i++){ 
    			System.out.println("学习java");
    		}
    		System.out.println("程序停止");
    		//System.out.println(i); //错误写法!因为变量i定义在for循环小括号内，只有for循环自己才能用。
    		System.out.println("=====================");
    		
    		// 将for循环改写为do-while循环
    		int i = 1;  // 1.初始化语句
    		do { 
    			System.out.println("学习java");  // 3.循环体
    			i++;  // 4.步进语句
    		} while (i < 0); // 2.条件判断
    		// 现在已经超出了do-while循环的范围，我们仍然可以使用变量i;
    		System.out.println(i);
    		System.out.println("程序停止");
    	}
    }

### 循环控制\_break语句 ###

/* break关键字的用法有常见的两种： 1.可以用在switch语句当中，一旦执行，整个switch语句立刻结束。 2.还可以用在循环语句当中，一旦执行，整个循环语句立刻结束，打断循环。 关于循环的选择，有一个小建议： 凡是次数确定的场景多用for循环；否则多用while循环。 */
    public class HelloWorld { 	
    	public static void main(String[] args) { 
    	
    		// for循环
    		for(int i = 1; i <= 10; i++){ 
    			// 如果希望从第4次开始，后续全都不要了，就要打断循环。
    			if(i == 4){ 
    				break;  // 那么就打断整个循环。
    			}
    			System.out.println("Hello" + i);
    		}
    	}
    }

### 循环控制\_continue语句 ###

/* continue关键字：一旦执行，立刻跳过当前次，循环剩余内容，马上开始下一次循环。 */
    public class HelloWorld { 	
    	public static void main(String[] args) { 
    	
    		// for循环
    		for(int i = 1; i <= 10; i++){ 
    			
    			if(i == 4){   // 如果当前是第4层
    				continue;  // 那么跳过当前次循环，马上开始下一次（第5层）
    			}
    			System.out.println(i + "层到了");
    			/* 打印结果： 1层到了 2层到了 3层到了 5层到了 6层到了 7层到了 8层到了 9层到了 10层到了 */ 
    		}
    	}
    }

# IDEA常用快捷键 #

<table> 
 <thead> 
  <tr> 
   <th>快捷键</th> 
   <th>功能</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Alt+Enter</td> 
   <td>自动修正代码</td> 
  </tr> 
  <tr> 
   <td>Ctrl+Y</td> 
   <td>删除光标所在行</td> 
  </tr> 
  <tr> 
   <td>Ctrl+D</td> 
   <td>复制光标所在行的内容，插入光标位置下面</td> 
  </tr> 
  <tr> 
   <td>Ctrl+Alt +L</td> 
   <td>格式化代码</td> 
  </tr> 
  <tr> 
   <td>Ctrl+/</td> 
   <td>单行注释，再按取消注释</td> 
  </tr> 
  <tr> 
   <td>Ctrl+Shift+/</td> 
   <td>选中代码注释，多行注释，再按取消注释。</td> 
  </tr> 
  <tr> 
   <td>Alt+Ins</td> 
   <td>自动生成代码，toString，get，set等方法</td> 
  </tr> 
  <tr> 
   <td>Alt+Shift+上下箭头</td> 
   <td>移动当前代码行</td> 
  </tr> 
 </tbody> 
</table>