Java-基础篇【Java安装运行基础、类型转换、常用运算符、流程控制】
1：Java背景知识
Java是美国 sun 公司（Stanford University Network）在1995年推出的一门计算机高级编程语言。
Java 早期称为Oak(橡树)，后期改名为Java。
Java 之父：詹姆斯·高斯林(James Gosling)。
2009年 sun公司被Oracle公司收购
2：Java技术体系
3：Java安装
验证JDK安装成功的方式：查询JDK的版本号
在命令行 窗口中分别输入javac –version 及 java –version看版本提示，如果版本提示与自己安装的版本号一致，则代表JDK环境搭建成功
4：Javac 和 java介绍
5：Java 程序开发的三个步骤
6：入门程序Hello world
package com.ywt.hello.hello; import java.sql.SQLOutput; public class HelloWorld { public static void main(String[] args) { // main补全 System.out.println("hello World"); // sout 补全 } } /* IDEA的结构都是什么样的： project - module - package – class
注意：文件名称必须与代码中的类名称一致。
保存文件：ctrl + s
*/
7：编译代码，运行代码
8：JDK的组成
9：配置Java_home 环境变量
10：IDEA项目结构
11：IDEA 工具快捷操作 ctrl +
12：注释
什么是注释 注释是写在程序中对代码进行解释说明的文字，方便自己和其他人查看，以便理解程序的。 注释有哪些 单行注释：// 注释内容，只能写一行 多行注释：/* */ 文档注释：/** */ 文档注释的内容是可以提取到一个程序说明文档中去的
快捷键进行注释： 单行注释（对当前行进行注释）： Ctrl + / 对选中的代码进行多行注释： Ctrl + Shift + /
13：字面量
字面量：
计算机是用来处理数据的，字面量就是告诉程序员：数据在程序中的书写格式。
常用数据
字符、字符串在程序中的书写格式有什么要求？ 字符 必须单引号围起来，有且仅能一个字符。 字符串 必须用双引号围起来。 几个常见的特殊值的书写格式是？ true、false、null、\n、\t
package com.ywt.hello.literal; public class LiteralDemo { public static void main(String[] args) { // 目标：学会常见字面量数据在程序中的书写格式。 // 1、整数、小数 System.out.println(666); System.out.println(3.14); // 2、字符：加单引号，有且仅能有一个字符 System.out.println('a'); System.out.println('A'); System.out.println('0'); System.out.println('中'); //System.out.println('中国'); // 报错的 //System.out.println(''); // 报错的 System.out.println(' '); // 注意：几个特殊字符 System.out.println('a'); System.out.println('\n'); // \n代表换行 System.out.println('a'); System.out.println('\t'); // \t代表一个tab // 3、字符串：加双引号，里面的内容可以随便写 System.out.println(""); System.out.println(" "); System.out.println("程序员"); System.out.println("我爱您中国 abc 1234324 "); // 4、布尔值：true , false System.out.println(true); System.out.println(false); } }
14：变量
什么是变量：
变量就是内存中的一块区域，用来存储一个数据的，且存储的数据可以被替换
定义变量需要注意的几个问题：
变量要先声明再使用
变量声明后，不能存储其他类型的数据。
变量的有效范围是从定义开始到“}”截止,且在同一个范围内部不能定义2个同名的变量
变量定义的时候可以没有初始值，但是使用的时候必须给初始值
package com.ywt.hello.variable; /** 目标：学会定义并使用变量。 */ public class VariableDemo1 { public static void main(String[] args) { // 数据类型 变量名称 = 初始值; // 注意：从右往左边看的（赋值） int age = 21; System.out.println(age); age = 25; System.out.println(age); System.out.println("-------------实际操作------------"); double money = 6.0; System.out.println(money); // 收红包4元 money = money + 4.0; System.out.println(money); } } // 变量就是内存中的一块区域，用来存储一个数据的，且存储的数据可以被替换。
package com.ywt.hello.variable; /** * 目标：理解变量定义的注意事项，并注意 * */ public class VariableDemo2 { public static void main(String[] args) { // 1、变量要先声明再使用 int age = 21; age = 25; System.out.println(age); // 2、变量声明后，不能存储其他类型的数据。 // age = 35.9; // 3、变量的有效范围是从定义开始到“}”截止,且在同一个范围内部不能定义2个同名的变量。 { double money = 23.5; System.out.println(money); // double money = 10.4; // 报错 // int age = 28; // 报错 } // System.out.println(money); // 报错 System.out.println(age); double money = 99.5; System.out.println(money); // 4、变量定义的时候可以没有初始值，但是使用的时候必须给初始值。 int number ; number = 100; System.out.println(number); System.out.println("----------------数据在底层存储的原理：二进制形式------------------"); char ch = 'a'; // ch = 97 System.out.println(ch + 1); System.out.println(ch); // a int i1 = 0b01100001; // 二进制 System.out.println(i1); // 输出 97 int i2 = 0141; // 八进制 System.out.println(i2); // 输出 97 int i3 = 0x61; // 十六进制 System.out.println(i3); // 输出 97 } }
package com.ywt.hello.variable; /** 引用数据类型：string 基本数据类型：4 种 8大类 整数 浮点数 字符 布尔 关键字： public .... */ public class VariableDemo3 { public static void main(String[] args) { // 目标：掌握常用8种基本数据类型定义变量。 // 1、byte 字节型 1个字节 byte age = 120; byte age2 = 127; // byte age3 = 128; // 报错 // 2、short 短整型 2个字节 short s1 = 32542; // short s2 = 42542; // 报错 // 3、int 整型 (默认类型，如果不确定数据的范围会多大，就用int) 4个字节 int i = 1; int it = 243244244; // 4、long 长整型 8个字节 long l = 32332323; // 注意：随便写一个字面量34243243243245默认是当成int类型的，34243243243245虽然没有超过long的范围 // 但是34243243243245它超过了int本身的范围，如果希望34243243243245这个数据是long类型的，需要在后面加L l long l2 = 34243243243245L; // 5、浮点型（小数） 4个字节 // float称为单精度小数：注意：随便写一个小数字面量默认是double类型的，如果希望随便写一个小数默认是float类型的需要加上F/f float f = 3.14F; // 6、double 双精度 8个字节 double score = 99.5; // 7、字符型 2个字节 0-65535字符 只能放一个值 char ch = '徐'; char ch1 = '黑'; // 8、布尔类型 1个字节 boolean flag = true; boolean flag2 = false; System.out.println("--引用数据类型：String--"); // String表示的是字符串类型，定义的变量可以存储一个字符串 String name = "西门吹雪"; System.out.println(name); int class1 = 21; int itheima = 23; } }
15：Java中 二进制，八进制，十六进制简介
二进制： 除 2 取 余，从下往上取 计算机 8 位 一组一个字节存储数据 1位 1bit 1byte【字节】 = 8 bit 简写 1B=8b char ch = "a"; ASCII 编码 a = 97 97转成二进制 图片： 像素点，颜色数据 像素点对应的二进制形式 声音： 声波，二进制表示波形 2 进制转 10 进制 n*2*0 + n*2*1 + n*2*2 ....... 8进制 2 进制3位当成一组来看 16级制 2 进制4位当成一组来看 java中 0B/0b：二进制 0：八进制 0X/0x :十六进制
计算机中的数据的最小单位： 计算机中数据最小的组成单元：使用8个二进制位为一组，称之为一个字节（byte,简称B） 字节中的每个二进制位就称为 位（bit，简称b）, 1B = 8b
16：关键字
17：标识符
18：基本数据类型之——整型
随便写的整数、小数字面值默认什么类型？ 23 默认是int类型 , 加上L/l就是long类型的数据了。 23.8 默认是double类型，加上F/f就是float类型了。
19：自动类型转换
package com.itheima.type; /** * 目标：理解自动类型转换 * */ public class TypeDemo1 { public static void main(String[] args) { byte a = 20; int b = a; // 发生了自动类型转换 System.out.println(a); // 20 System.out.println(b); // 20 int age = 23; double db = age; // 自动类型转换 System.out.println(db); // 23.0 char ch = 'a'; // 00000000 01100001 int code = ch; // 00000000 00000000 00000000 01100001 字符可以转 int System.out.println(code); // 97 } } /* 字段类型转换： 类型范围 小的变量 赋值给类型范围大的变量 字段类型转换： byte ——> short ——> int ——> long ——> float ——> double byte 、short、char ——> int ——> long ——> float ——> double byte 、short、char 程序里直接转换成int 运算的 */
20：表达式的自动类型转换
package com.itheima.type; /** * 目标：掌握表达式的自动类型转换的规则。 * */ public class TypeDemo2 { public static void main(String[] args) { byte a = 10; int b = 20; double c = 1.0; double rs = a + b + c; // 31.0 double接收才不报错，double是最高的 System.out.println(rs); double rs2 = a + b - 2.3; // 27.7 2.3是 double System.out.println(rs2); // 面试题 byte i = 100; byte j = 120; int k = i + j; System.out.println(k); } }
21：强制类型转换：强行将范围大的变量，数据赋值给范围小的变量
package com.itheima.type; /** * 目标：理解强制类型转换，并使用。 * */ public class TypeDemo3 { public static void main(String[] args) { int a = 20; byte b = (byte)a; System.out.println(a); //20 System.out.println(b); // 20 int i = 1500; byte j = (byte) i; System.out.println(j); // -36 double score = 99.5; int it = (int) score; System.out.println(it); // 99 } } /* 自动类型转换只能小到大： byte ——> short ——> int ——> long ——> float ——> double 强制类型转换 使用函数强制 把大范围变量可以转换成小范围变量的 int a = 20; byte b = (byte)a; int：4字节 byte：1字节 int转byte，直接只拿后1个字节，前面3字节丢弃 强制类型转换可能造成数据(丢失)溢出； 浮点型强转成整型，直接丢掉小数部分，保留整数部分返回 */
22：基本算术运算符 + - * / %
Tips：如果两个整数做除法，其结果一定是整数，因为最高类型是整数
package com.itheima.operator; /** * 目标：掌握基本的算术算术运算符的使用：+ - * / % * */ public class OperatorDemo1 { public static void main(String[] args) { int a = 10; int b = 3; System.out.println(a + b); System.out.println(a - b); System.out.println(a * b); System.out.println(a / b); // 3.3333 ==> 3 运算 a整数，b整数，最大的数值范围就是整数 System.out.println(a * 1.0 / b); // 3.3333 一定要得到一个小数 a * 1.0 【 *1.0一点放前面，放后面不行，完了，已经算出3了 】 System.out.println(3 / 2); System.out.println(3 * 1.0 / 2); // 1.5 System.out.println(3 / 2 * 1.0); // 1.0 System.out.println(a % b); // 1 } }
package com.itheima.operator; /** * 目标：拆分三位数【百位，十位，个位】 * */ public class OperatorTest2 { public static void main(String[] args) { // 需求：拆分3位数，把个位、十位、百位分别输出 int data = 589; // 1、个位 int ge = data % 10; System.out.println(ge); // 2、十位 int shi = data / 10 % 10; // data / 10 得到 58再求余数 System.out.println(shi); // 3、百位 int bai = data / 100; // 保留整数值 System.out.println(bai); } }
23： + 当作连接符
package com.itheima.operator; /** * 目标：+符号做连接符的识别：能算则算，不能算连接在一起 * */ public class OperatorDemo3 { public static void main(String[] args) { int a = 5 ; System.out.println("abc" + 'a'); // abca System.out.println("abc" + a); // abc5 System.out.println(5 + a); // 10 System.out.println("abc" + 5 + 'a'); // abc5a System.out.println(15 + "abc" + 15); // 15abc15 System.out.println(a + 'a'); // 102 变量 a 和字符 "a"能运算的 System.out.println(a + "" +'a'); // 5a System.out.println(a + 'a'+" itheima "); // 102 itheima System.out.println("itheima"+ a + 'a'); // itheima5a System.out.println("itheima"+ ( a + 'a' ));// itheima102 System.out.println("a" + "a"); } }
24：自增自减运算符 ++ --
package com.itheima.operator; /** * 目标：学会使用自增自减运算符： ++ -- * */ public class OperatorDemo4 { public static void main(String[] args) { int a = 10; // a++; // a = a + 1 ++a; // a = a + 1 System.out.println(a); // 11 int b = 10; //b--; // b = b -1 --b; System.out.println(b); // 9 System.out.println("------------------------------"); // 在表达式中或者不是单独操作的情况，++ -- 在变量前后存在区别 // ++ -- 在变量前面。先+1 -1 再使用。 int i = 10; int j = ++i; System.out.println(i); // 11 System.out.println(j); // 11 // ++ -- 在变量的后面 先使用再+1 -1 int m = 10; int n = m++; System.out.println(m); // 11 System.out.println(n); // 10 System.out.println("-----------拓展案例（可以了解和参考）--------------"); int k = 3; int p = 5; // k 3 4 5 4 // p 5 4 3 4 // rs 3 + 5 - 4 + 4 - 5 + 4 + 2 int rs = k++ + ++k - --p + p-- - k-- + ++p + 2; System.out.println(k); // 4 System.out.println(p); // 4 System.out.println(rs); // 9 } } /* ++ 和 -- 单独使用放前面和后面没有差别
++ 和 -- 用在表达式中有区别： 在变量前 ，先进行变量自增/自减，再使用变量 在变量后 ，先使用变量，再进行变量自增/自减 k++：先用 K=3 用完之后K马上变成4【先用所以rs第一位为 3 】 ++k：先加 k从4变成了K=5，先加所以【后用所以rs第二位为 5】 --p：先减 p从5变成p=4【后用所以rs第三位为4】 p--：先用 p从4变成了p=3【先用所以rs第四位为4】 k--：先用 K从5变成了K=4【先用所以rs第五位为5】 ++p：先加 p从3变成了P=4【后用所以rs第六位为4】 rs： 3【现用】+ 5【先加】 - 4 + 4 - 5 + 4 + 2 K=4 P=4 rs=9 */
25：赋值运算符 = += -=
package com.itheima.operator; /** * 目标：学会使用赋值运算符：= += -= *= /= %= * */ public class OperatorDemo5 { public static void main(String[] args) { int a = 10; int b = 200; // a = a + b; a += b; // a = (int)(a + b) System.out.println(a); byte i = 10; byte j = 20; // i = (byte) (i + j); i += j; // i = (byte) (i + j); System.out.println(i); int m = 10; int n = 5; //m += n; //m -= n; // 等价于： m = (int)(m - n) //m *= n; // 等价于： m = (int)(m * n) // m /= n; // 等价于： m = (int)(m / n) m %= n; // 等价于： m = (int)(m % n) System.out.println(m); } }
26：关系运算符 ：== ！= > <
package com.itheima.operator; /** * 目标：学会使用关系运算符。 * */ public class OperatorDemo6 { public static void main(String[] args) { int a = 10; int b = 10; boolean rs = a == b; // 判断是否相等 System.out.println(rs); System.out.println(a == b); System.out.println(a != b); // false 不等于 System.out.println(a > b); // false System.out.println(a >= b); // true System.out.println(a < b); // false System.out.println(a <= b); // true int i = 10; int j = 5; System.out.println(i == j); // false System.out.println(i != j); // true System.out.println(i > j); // true System.out.println(i >= j); // true System.out.println(i < j); // false System.out.println(i <= j); // false System.out.println(i = j); // 5 相等判断必须是== 如果使用=是在进行赋值操作！ } }
27：逻辑运算符 && || ! ^
package com.itheima.operator; /** * 目标：学会使用逻辑运算符，并能够选择合适的逻辑运算符解决问题。 * */ public class OperatorDemo7 { public static void main(String[] args) { double size = 9.8; double storage = 6; // 需求：尺寸大于等于6.95 内存要大于等于8GB System.out.println(size >= 6.95 & storage >=8); // 注意：必须前后都是true结果才是true // 需求：要么内存大于等于8 要么尺寸大于等于6.95 System.out.println(size >= 6.95 | storage >=8); // 注意：只要有一个是true 结果就一定是true | System.out.println(!true); System.out.println(!false); // 逻辑异或：必须两个不同结果才是true System.out.println(false ^ true); // true System.out.println(true ^ false); // true System.out.println(true ^ true); // false System.out.println(false ^ false); // false System.out.println("-----------&& & || |的区别-------------------"); int a = 10; int b = 20; System.out.println(a > 100 && ++b > 10); // ++b 不会执行 b还是20 // System.out.println(a > 100 & ++b > 10); // ++b 会执行 b还是21 System.out.println(b); int i = 10; int j = 20; //System.out.println(i > 2 || ++j > 10); System.out.println(i > 2 | ++j > 10); System.out.println(j); } } /* & 逻辑与 必须都是true，结果才是true; 只要有一个是false，结果一定是false | 逻辑或 只要有一个为true、结果就是true ！ 逻辑非 你真我假、你假我真。 !true=false 、 !false= true ^ 逻辑异或 如果两个条件都是false或者都是true则结果是false。两个条件不同结果是true && 短路与 判断结果与“&”一样。过程是左边为 false，右边则不执行,左边false就能确定结果，性能好 || 短路或 判断结果与“|”一样。过程是左边为 true， 右边则不执行，左边true就能确定结果，性能好 | 和 & 前后不管怎么都会执行 */
28：三元运算符
package com.itheima.operator; /** * 目标：学会使用三元运算符，理解其流程 * */ public class OperatorDemo8 { public static void main(String[] args) { double score = 18; String rs = score >= 60 ? "考试通过" : "挂科"; System.out.println(rs); // 需求：需要从2个整数中找出较大值 int a = 10000; int b = 2000; int max = a > b ? a : b; System.out.println(max); System.out.println("-------求三个整数的最大值-----------"); int i = 10; int j = 30; int k = 50; // 1、找出2个整数的较大值 int temp = i > j ? i : j; // 2、拿临时变量与第三个变量的值继续比较 int rsMax = temp > k ? temp : k; System.out.println(rsMax); System.out.println("-------------求三个整数的最大值：拓展知识-------------"); int rsMax1 = i > j ? (i > k ? i : k) : (j > k ? j : k); // 不加括号也行 // 问 i 有没有 大于 j // i > j i比较大，拿i和k比，走 (i > k ? i : k) // 反之 System.out.println(rsMax1); } } /* 格式：条件表达式 ? 值1 : 值2; 首先计算关系表达式的值，如果值为true，返回值1，如果为false，返回值2 */
29：运算符优先级
package com.itheima.operator; /** * 目标：看看Java是否存在优先级，大家以后需要注意优先级问题 * */ public class OperatorDemo9 { public static void main(String[] args) { // 目标：看看Java是否存在优先级，大家以后需要注意优先级问题 System.out.println(10 > 3 || 10 > 3 && 10 < 3); //true System.out.println( (10 > 3 || 10 > 3 ) && 10 < 3); // false } } /* () ! -：取反 ++：自增 --：自减 .... */
30：导包操作
package com.itheima.scanner; import java.util.Scanner; /** * 1、导包操作 (并不需要自己写的，以后通过工具进行导入更方便) * */ public class ScannerDemo { public static void main(String[] args) { // 目标：接收用户的键盘输入的数据。 Scanner sc = new Scanner(System.in); // 2、得到一个键盘扫描器对象 System.out.println("请您输入您的年龄："); int age = sc.nextInt(); // 3、等待接收用户输入一个整数，按了回车键才会把数据交给age变量 System.out.println("您的年龄是：" + age); System.out.println("请您输入您的名称："); String name = sc.next(); // 4、等待接收用户输入一个字符串，按了回车键才会把数据交给name变量 System.out.println(name + "欢迎进入系统！"); } } /* System.out.println 不需要导包，默认的lang 包主动导入 */
31：if分支结构
if 第一种格式： 首先判断条件表达式的结果，如果为true执行语句体，为 false 就不执行语句体 注意事项： if 语句中，如果大括号控制的只有一行代码，则大括号可以省略不写 if 第二种格式： 首先判断条件表达式的结果，如果为true执行语句体1，为 false 就执行语句体2。 if 第三种格式： 先判断条件1的值，如果为true则执行语句体1，分支结束；如果为false 则判断条件2的值 如果值为true就执行语句体2，分支结束；如果为false则判断条件3的值 ... 如果没有任何条件为true，就执行else分支的语句体n+1。
package com.itheima.branch; /** 目标：学会使用if分支结构解决问题，理解其流程。 */ public class IfDemo1 { public static void main(String[] args) { // 需求：心跳（60 - 100）之间是正常的，否则系统提示进一步检查 // 格式1： if(条件表达式){ 代码... } int heartBeat = 30; if(heartBeat < 60 || heartBeat > 100) { System.out.println("您的心跳数据是：" + heartBeat +"，您可能需要进一步检查！"); } System.out.println("检查结束"); // 格式2： if(条件表达式){ 代码... } else { 代码... } // 需求：发红包。 double money = 1; // 发送一个1314. if(money >= 1314){ System.out.println("您当前发送红包成功~~~"); }else { System.out.println("您自己都没钱，就别发了~~"); } // 格式3： if(条件表达式){ 代码...}else if(条件表达式){ 代码... } ... else{ 代码...} // 绩效系统： 0-60 C 60-80 B 80-90 A 90-100 A+ int score = 199; if(score >= 0 && score < 60){ System.out.println("您本月的绩效是：C"); }else if(score >= 60 && score < 80){ System.out.println("您本月的绩效是：B"); }else if(score >= 80 && score < 90){ System.out.println("您本月的绩效是：A"); }else if(score >= 90 && score <= 100){ System.out.println("您本月的绩效是：A+"); }else { System.out.println("您录入的分数有毛病！"); } } }
32：switch分支
switch分支的格式、执行流程是怎么样的？ if、switch分支各自适合做什么业务场景？ if其实在功能上远远强大于switch。 if适合做区间匹配。 switch适合做：值匹配的分支选择、代码优雅
switch分支注意事项： 表达式类型只能是 byte、short、int、char， JDK5开始支持枚举，JDK7开始支持String、不支持double、float、long。 case给出的值不允许重复，且只能是字面量，不能是变量。 不要忘记写break，否则会出现穿透现象
package com.itheima.branch; /** * 目标：学会使用switch分支结构，理解流程 * */ public class SwitchDemo2 { public static void main(String[] args) { // 周一：埋头苦干，解决bug 周五：今晚吃鸡 // 周二：请求大牛程序员帮忙 周六：与王婆介绍的小芳相亲 // 周三：今晚啤酒、龙虾、小烧烤 周日：郁郁寡欢、准备上班。 // 周四： 主动帮助新来的女程序解决bug String weekday = "周二"; switch (weekday){ case "周一": System.out.println("埋头苦干，解决bug "); break; case "周二": System.out.println("请求大牛程序员帮忙"); break; case "周三": System.out.println("今晚啤酒、龙虾、小烧烤"); break; case "周四": System.out.println("主动帮助新来的女程序解决bug"); break; case "周五": System.out.println("今晚吃鸡"); break; case "周六": System.out.println("与王婆介绍的小芳相亲"); break; case "周日": System.out.println("郁郁寡欢、准备上班"); break; default: System.out.println("数据有误！"); } } }
package com.itheima.branch; /** * 目标：清楚switch的注意点。并在开发的时候注意。 * */ public class SwitchDemo3 { public static void main(String[] args) { // 表达式类型只能是byte、short、int、char，JDK5开始支持枚举，JDK7开始支持String、不支持double、float、long。 //double a = 0.1 + 0.2; //System.out.println(a); long lg = 20; // switch (lg){ // } // case给出的值不允许重复，且只能是字面量，不能是变量。 switch (3){ case 31: break; case 3: break; } // 不要忘记写break，否则会出现穿透现象。 String weekday = "周二"; switch (weekday){ case "周一": System.out.println("埋头苦干，解决bug "); break; case "周二": System.out.println("请求大牛程序员帮忙"); //break; case "周三": System.out.println("今晚啤酒、龙虾、小烧烤"); //break; case "周四": System.out.println("主动帮助新来的女程序解决bug"); break; case "周五": System.out.println("今晚吃鸡"); break; case "周六": System.out.println("与王婆介绍的小芳相亲"); break; case "周日": System.out.println("郁郁寡欢、准备上班"); break; default: System.out.println("数据有误！"); } } }
package com.itheima.branch; /** * 需求：用户输入月份可以展示该月份的天数。 * */ public class SwicthDemo4 { public static void main(String[] args) { // 1、3 、5、 7 、 8、 10、 12月份是 31天 // 2月份是闰年为29天、非闰年为28天。 // 4 、6 、9、 11月份 是30天 int month = 7; switch (month){ case 1: case 3: case 5: case 7: case 8: case 10: case 12: System.out.println(month +"是31天！"); break; case 2: System.out.println(month +"月闰年为29天、非闰年为28天！"); break; case 4: case 6: case 9: case 11: System.out.println(month +"是30天！"); break; default: System.out.println("数据有误！"); } } }
33：for循环
package com.itheima.loop; /** * 目标：学会使用for循环，并理解它的执行流程。 * */ public class ForDemo1 { public static void main(String[] args) { // 需求：输出3次HelloWorld for (int i = 0; i < 3; i++) { System.out.println("HelloWorld"); } System.out.println("---------------------"); for (int i = 0; i < 5; i++) { System.out.println("HelloWorld"); } System.out.println("---------------------"); for (int i = 1; i < 5; i++) { System.out.println("HelloWorld"); } System.out.println("---------------------"); for (int i = 1; i <= 5; i++) { } System.out.println("---------------------"); for (int i = 1; i <= 5; i+=2) { System.out.println("HelloWorld"); } } }
package com.itheima.loop; /** * 需求：计算1-5的和 * */ public class ForTest2 { public static void main(String[] args) { // 2、定义一个整数变量用于累加数据求和 int sum = 0; // 1、定义一个for循环找到 1 2 3 4 5 for (int i = 1; i <= 5 ; i++) { // i = 1 2 3 4 5 // 3、把循环的数据累加给sum变量 /** 等价于： sum = sum + i i == 1 sum = 0 + 1 i == 2 sum = 1 + 2 i == 3 sum = 3 + 3 i == 4 sum = 6 + 4 i == 5 sum = 10 + 5 */ sum += i; } System.out.println("1-5的和是：" + sum); } }
package com.itheima.loop; /** * 需求：求1-0的奇数和 * */ public class ForTest3 { public static void main(String[] args) { // 3、定义一个求和的变量 累加奇数和 int sum = 0; // 1、定义一个循环找到 1 2 3...10 for (int i = 1; i <= 10; i++) { // i 1 2 3 4 5 6 7 8 9 10 // 2、筛选出奇数 if(i % 2 == 1){ // i = 1 3 5 7 9 sum += i; } } // 4、输出求和变量即可 System.out.println("1-10的奇数和是：" + sum); System.out.println("-------------------"); // 2、定义一个求和的变量 累加奇数和 int sum1 = 0; // 1、定义循环找到 1 3 5 7 9 for (int i = 1; i <= 10; i+=2) { // i = 1 3 5 7 9 sum1 += i; } // 3、输出求和变量即可 System.out.println("1-10的奇数和是：" + sum1); } }
package com.itheima.loop; /** * 需求：找出水仙花数并输出 * */ public class ForTest4 { public static void main(String[] args) { // 在循环外定义一个变量用于记录水仙花的个数 int count = 0; // 1、定义一个for循环找出全部三位数 for (int i = 100; i <= 999; i++) { // 2、判断这个三位数是否满足要求 // i = 157 // 个位 int ge = i % 10; // 十位 int shi = i / 10 % 10; // 百位 int bai = i / 100; if( (ge*ge*ge + shi * shi * shi + bai * bai * bai) == i){ System.out.print(i+"\t"); count++; } } System.out.println(); // 换行！ System.out.println("水仙花个数是：" + count); } }
34：while循环
什么时候用for循环，什么时候用while循环： 功能上是完全一样的，for能解决的while也能解决，反之亦然。 使用规范是：知道循环几次：使用for；不知道循环几次建议使用：while
package com.itheima.loop; /** * 目标：学会使用while循环，并理解它的流程 * */ public class WhileDemo5 { public static void main(String[] args) { int i = 0; while (i < 3){ System.out.println("Hello World"); i++; } System.out.println("----------------------"); int j = 0; while (j < 3){ System.out.println("Hello World"); } } }
package com.itheima.loop; /** * 需求：珠穆朗峰高度是8848860 纸张厚度 0.1 折叠纸张直到不低于珠穆朗峰位置，求折叠几次 * */ public class WhileTest6 { public static void main(String[] args) { // 1、定义变量记录山峰的高度 纸张的厚度 double peakHeight = 8848860; double paperThickness = 0.1; // 3、定义一个变量用于记录纸张折叠的次数 int count = 0; // 2、定义一个while循环控制纸张进行折叠 while (paperThickness < peakHeight){ // 让纸张的厚度多一倍 paperThickness *= 2; count++; } System.out.println("折叠的次数：" + count); System.out.println("纸张的最终厚度：" + paperThickness); } }
35：do-while循环
三种循环的区别小结：for/whike/do-while for循环 和 while循环（先判断后执行） do...while （第一次先执行后判断）
for循环和while循环的执行流程是一模一样的。 如果已知循环次数建议使用for循环，如果不清楚要循环多少次建议使用while循环。 for循环中，控制循环的变量只在循环中可以使用。While循环中，控制循环的变量在循环后还可以继续使用。
package com.itheima.loop; /** * 目标：学会使用dowhile循环，并理解其执行流程 * */ public class DoWhileDemo7 { public static void main(String[] args) { int i = 0; do { System.out.println("Hello World"); i++; }while (i < 3); System.out.println("--------------------"); for (int j = 0; j < 3; j++) { System.out.println("Hello World"); } for (int j = 0; j < 3; j++) { System.out.println("Hello World"); } int n = 0; while (n < 3){ System.out.println("Hello World"); n++; } System.out.println(n); } }
36：死循环的经典写法
死循环 一直循环的执行下去，如果没有干预不会停止下来： for(;;) {
System.out.println("Hello World");} // 经典做法 while(true) {
System.out.println("Hello World");} do {
System.out.println("Hello World");} while (true);
package com.itheima.loop; import java.util.Scanner; /** * 目标：学会定义死循环。 * */ public class DeadForDemo8 { public static void main(String[] args) { // for ( ; ; ) { // System.out.println("Hello World~~~~"); // } // 经典写法 // while (true) { // System.out.println("我是快乐的死循环~~~~"); // } // do{ // System.out.println("我是快乐的死循环~~~~"); // }while (true); System.out.println("-----------------------------"); // 1、定义正确的密码 int okPassword = 520; // 2、定义一个死循环让用户不断的输入密码认证 Scanner sc = new Scanner(System.in); while (true) { System.out.println("请您输入正确的密码："); int password = sc.nextInt(); // 3、使用if判断密码是否正确 if(password == okPassword){ System.out.println("登录成功了~~~"); break; // 可以理解结束当前所在循环的执行的 }else { System.out.println("密码错误！"); } } } }
package com.itheima.loop; /** * 目标：理解嵌套循环的执行流程 * */ public class ForForDemo9 { public static void main(String[] args) { // 场景：假如你有老婆，然后你犯错了，你老婆罚你说5天，每天3句我爱你。 for (int i = 0; i < 5; i++) { for (int j = 0; j < 3; j++) { System.out.println("我爱你"); } System.out.println("--------------"); } /** ***** ***** ***** ***** */ for (int i = 0; i < 4; i++) { for (int j = 0; j < 5; j++) { System.out.print("*"); } System.out.println(); // 换行 } } }
37：break 和 continue 关键字的使用
跳转控制语句介绍 break : 跳出并结束当前所在循环的执行 continue: 用于跳出当前循环的当次执行，进入下一次循环 break : 只能用于结束所在循环, 或者结束所在switch分支的执行。 continue : 只能在循环中进行使用
package com.itheima.loop; /** * 目标：理解break 和 continue的作用。 * */ public class BreakAndContinueDemo10 { public static void main(String[] args) { // 场景：假如你又有老婆了，然后你犯错了，你老婆罚你做5天家务，每天都是洗碗。 // 但是洗碗到第三天后心软了 原谅你了不用洗了 for (int i = 0; i < 5; i++) { System.out.println("快乐的洗碗~~~~"); if(i == 2) { break; // 跳出并结束当前循环的执行~~ } } // continue 跳出当前循环的当次执行，进入循环的下一次 // 场景：假如你又有老婆了，然后你犯错了，你老婆罚你做5天家务， // 每天都是洗碗。但是洗碗到第三天后心软了 原谅你了不用洗了 但是依然不解恨 继续洗第4天 5天 for (int i = 1; i <= 5 ; i++) { if(i == 3){ continue; // 立即跳出当次执行，进入循环的下一次！ } System.out.println("洗碗：" + i); } } }
package com.itheima.loop; /** * 目标:理解break和continue操作外部循环：直接结束两层循环 * */ public class BreakAndContinueDemo11 { public static void main(String[] args) { // 目标:理解break和continue操作外部循环。 // 场景：假如你有老婆，你老婆罚你说3天，每天5句我爱你，但是说到第二天的第3句就心软了，以后都不用说了！ OUT: for (int i = 1; i <= 3; i++) { for (int j = 1; j <= 5; j++) { System.out.println("我爱你~~"); if(i == 2 && j == 3){ break OUT; // 指定跳出外部循环，并结束外部循环了！ } } System.out.println("-----------------"); } System.out.println("===================================================="); // continue可以指定结束外部循环的当次执行，进入外部循环的下一次执行 // 场景：假如你有老婆，你老婆罚你说3天，每天5句我爱你，但是说到第二天的第3句就心软了，当天 // 不用说了，但是依然不解恨，第3天还是要说的。 OUT: for (int i = 1; i <= 3; i++) { for (int j = 1; j <= 5; j++) { System.out.println("我爱你~~"); if(i == 2 && j == 3){ continue OUT; } } System.out.println("-----------------"); } } }
38：Random随机技术
Random随机数类生成需要几步，具体是什么样的？ 导包：import java.util.Random; Random r = new Random(); int number = r.nextInt(10); Random随机数如何生成 65 – 91之间的随机数？ 65 – 91 => （0 - 26）+ 65 int number = r.nextInt(27) + 65;
package com.itheima.random; import java.util.Random; /** * 目标：学会使用Java提供的随机数类Random * */ public class RandomDemo1 { public static void main(String[] args) { // 1、导包 // 2、创建随机数对象 Random r = new Random(); // 3、调用nextInt功能（方法）可以返回一个整型的随机数给你 for (int i = 0; i < 20; i++) { int data = r.nextInt(10); // 0 - 9 不包含10的（包前不包后） System.out.println(data); } System.out.println("-----------------------"); // 1 - 10 ==> -1 ==> (0 - 9) + 1 int data = r.nextInt(10) + 1; System.out.println(data); // 3 - 17 ==> -3 ==> (0 - 14) + 3 int data1 = r.nextInt(15) + 3; System.out.println(data1); } }
package com.itheima.random; import java.util.Random; import java.util.Scanner; public class RamdomTest2 { public static void main(String[] args) { // 1、随机一个幸运号码 1- 100之间 (0 - 99) + 1 Random r = new Random(); int luckNumber = r.nextInt(100) + 1; // 2、使用一个死循环让用户不断的去猜测，并给出提示 Scanner sc = new Scanner(System.in); while (true) { // 让用户输入数据猜测 System.out.println("请您输入猜测的数据（1-100）："); int guessNumber = sc.nextInt(); // 3、判断这个猜测的号码与幸运号码的大小情况 if(guessNumber > luckNumber){ System.out.println("您猜测的数据过大~"); }else if(guessNumber < luckNumber){ System.out.println("您猜测的数据过小"); }else { System.out.println("恭喜您，猜中了，可以去买单了~~~"); break; // 直接跳出并结束当前死循环！！ } } } }
