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

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

java基础篇

命令提示符–常用命令

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

常量的概念与分类

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

常量的分类：









































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

数据类型分类

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

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

基本数据类型

四类八种基本数据类型：



















































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

注意事项：

  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 { 

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

    }

  • 强制类型转换（显式）

    / 强制类型转换： 1.特点：代码需要进行特殊的格式处理，不能自动完成。 2.格式：范围小的类型 范围小的变量名 = （范围小的类型） 原本范围大的数据 注意事项： 1.强制类型转换一般不推荐使用，因为有可能发生精度损失、数据溢出。 2.byte/short/char这三种类型都可以发生数学运算，例如：加法“+” 3.byte/short/char这三种类型在运算的时候，都会被首先提升成为int类型，然后再计算。 4.boolean类型不能发生数据类型转换。 /

    public class HelloWorld { 

    1. public static void main(String[] args) { 
    3.     /* 左边是int类型，右边是long类型，不一样 long --> int，不是从小到大，不能发生自动类型转换！ 但是可以通过强制类型转换： 格式：范围小的类型 范围小的变量名 = （范围小的类型） 原本范围大的数据 */
    4.     int num = (int) 100L;
    5.     System.out.println(num); // 100
    7.     // long强制转换为int类型
    8.     int num2 = (int) 6000000000L;
    9.     System.out.println(num2); // 1705032704
    11.     // double --> int，强制类型转换
    12.     int num3 = (int) 3.99;
    13.     System.out.println(num3); // 3 注意：这并不是四舍五入，所有的小数位都会被舍弃。
    15.     /* 运算 计算机的底层会用一个数字（二进制）来代表字符A，就是65 一旦char类型进行了数学运算，那么字符就会按照一定的规则翻译成为一个数字 */
    16.     char zifu1 = 'A';
    17.     System.out.println(zifu1 + 1); // 66 也就是大写字母A被当做65进行处理
    19.     byte num4 = 40; // 注意：右侧的数值大小不能超过左侧的类型范围
    20.     byte num5 = 50;
    21.     // btye + byte --> int + int --> int
    22.     int result1 = num4 + num5;
    23.     System.out.println(result1); // 90
    25.     short num6 = 60;
    26.     // btye + short --> int + int --> int
    27.     // int 强制转换为short
    28.     // 注意：必须保证逻辑上真实大小本来就没有超过short范围，否则会发生数据溢出
    29.     short result2 = (short) (num4 + num6);
    30.     System.out.println(result2); // 100
    31. }

    }

ASCII编码表

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






















ASCII 值 控制字符
48 ‘0’
65 ‘A’
97 ‘a’

算术运算符

四则与取模运算

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

加号的多种用法

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

自增自减运算符

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

复合赋值运算符

  1. /* 复合赋值运算符： += 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.复合赋值运算符其中隐含了一个强制类型转换。 */
  3. public class HelloWorld {     
  4.     public static void main(String[] args) { 
  5.         int a = 10;
  6.         /* 按照公式进行翻译：a = a + 5 a = 10 + 5; a = 15; a本来是10，现在重新赋值得到15 */
  7.         a += 5;
  8.         System.out.println(a); // 15
  10.         int x = 10;
  11.         /* x = x % 3; x = 10 % 3; x = 1; x本来是10，现在重新赋值得到1 */
  12.         x %= 3;
  13.         System.out.println(x); // 1
  15.         // 50 = 30; // 常量不能进行赋值，不能写在赋值运算符的左边。错误写法！
  17.         byte num = 30;
  18.         /* num = num + 5; num = byte + int num = int + int num = int num = (byte) int */
  19.         num += 5;
  20.         System.out.println(num); // 35
  21.     }
  22. }

比较运算符

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

逻辑运算符

  1. /* 逻辑运算符： 与（并且） && 全都是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 */
  3. public class HelloWorld {     
  4.     public static void main(String[] args) { 
  6.         System.out.println(true && false); // false
  8.         // true && true --> true
  9.         System.out.println(3 < 4 && 10 > 5); // true
  10.         System.out.println("=============");
  12.         System.out.println(true || false); // true
  13.         System.out.println(true || true); // true
  14.         System.out.println(false || false); // false
  15.         System.out.println("============="); 
  17.         System.out.println(true); // true
  18.         System.out.println(!true); // false
  19.         System.out.println("============="); 
  21.         int a = 10;
  22.         // false && ...
  23.         System.out.println(3 > 4 && ++a < 100); // false
  24.         System.out.println(a); // 10
  25.         System.out.println("============="); 
  27.         int b = 20;
  28.         // true || ...
  29.         System.out.println(3 < 4 || ++b < 100); // true
  30.         System.out.println(b); // 20
  31.     }
  32. }

三元运算符

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

方法入门

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

编译器的两点优化

  1. /* 对于byte/short/char三种类型来说，如果右侧赋值的数值没有超过范围。 那么javac编译器将会自动隐含地为我们补上一个(byte)(short)(char)。 1.如果没有超过左侧的范围，编译器补上强转。 2.如果右侧超过了左侧范围，那么直接编译器报错。 */
  3. public class HelloWorld {     
  4.     public static void main(String[] args) { 
  6.         /* 右侧确实是一个int数字，但是没有超过左侧的范围，就是正确的。 int --> byte，不是自动类型转换。 */
  7.         byte num = 30;  // 右侧没有超过左侧的范围
  8.         System.out.println(num); // 30
  10.         // byte num1 = 128; // 右侧超过了左侧的范围
  12.         /* int --> char，没有超过范围 编译器将会自动补上一个隐含的(char) */
  13.         char zifu = /*(char)*/ 65;
  14.         System.out.println(zifu); // A
  15.     }
  16. }
  18. /* 在给变量进行赋值的时候，如果右侧的表达式当中全都是常量，没有任何变量， 那么编译器javac将会直接将若干个常量表达式计算得到结果。 short result = 5 + 8; 等号右边全都是常量，没有任何变量参与运算 编译之后，得到的.class字节码文件当中相当于【直接就是】：short result = 13; 右侧的常量结果数值，没有超过左侧范围，所以正确。 这称为"编译器的常量优化"。 但是注意：一旦表达式当中有变量参与，那么就不能进行这种优化了。 */
  20. public class HelloWorld {     
  21.     public static void main(String[] args) { 
  22.         short num = 10; // 正确写法，右侧没有超过左侧的范围
  24.         short a = 5;
  25.         short b = 8;
  26.         // short + short --> int + int --> int
  27.         // short result = a + b; // 错误写法!左侧需要是int类型
  29.         // 右侧不用变量，而是采用常量，而且只有两个常量，没有别人
  30.         short result = 5 + 8;
  31.         System.out.println(result); // 13
  33.         // short result1 = 5 + a + 8; // 编译报错!
  34.     }
  35. }

流程控制

单if语句

  1. public class HelloWorld {     
  2.     public static void main(String[] args) { 
  3.         System.out.println("判断是否成年"); // 判断是否成年
  4.         int age = 16;
  5.         if(age >= 18){ 
  6.             System.out.println("成年人");
  7.         }
  8.         System.out.println("未成年人");  // 未成年人
  9.     }
  10. }

标准if…else语句

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

判断语句 if…else if …else

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

选择语句 switch

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

循环语句

for循环

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

while循环

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

do-while循环

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

三种循环的区别：

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

循环控制_break语句

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

循环控制_continue语句

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

IDEA常用快捷键










































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

发表评论

表情：
评论列表 （有 0 条评论，311人围观）

还没有评论，来说两句吧...

相关阅读