目录
3.2.1）. if..if..else...else // 使用if语句 判断是否为奇偶数
3.2.2）.switch //使用switch语句 成绩等级判断 A B C D
3.3.1)while 循环 · 使用比较运算符 //程序：单位数猜数游戏 (自定义值 不调用随机值)
3.3.2) for 循环 · 使用逻辑运算符 && //程序：打印 0-100 可以被5整除的偶数
3.3.3) do..while() 循环 · 结合上述知识点 //程序：17题
一.前言
有个较为基础的顺序结构，就是自上而下，声明一些变量 做些单一的运算处理
二.知识点回顾
2.1.框架 就是就是说在进入程序如何开始进行
package one; //one项目的整体
public class two { //这里与Java文件名对应
//公开调用 class类 程序名称
public static void main(String[] args) //写死 程序开始 从main进入
{
}
}
2.2.打印 输出
第二点知识点回顾的代码 要复制到框架里运行
//系统.out 调用println类 ("在""中是字符串 可以输入任意内容")
System.out.println("知识点回顾 2.打印 输出 println的类表示输入并换行");
// 同理 print的类表示输入 在字符串的末尾+\n 表示换行
System.out.print("知识点回顾 "+ 2 + ".打印 输出 print的类表示输入\n");
// 同理 print**指 printf println print
System.out.println("知识点回顾 2.在print**的运算");
System.out.println("知识点回顾 2.在print**的运算 在字符串可以进行运算， 在字符串之后 之后的运算 默认为成字符串");
// 第一个加号 可以看成与不同变量类型的一个衔接
System.out.println("知识点回顾 2.在print** 例子1:" + 1+1); //这里的1+1 按照想法应该是2， 因为在字符串之后就不是了
System.out.println(1+1 + "知识点回顾 2.在print**的运算" + 1+1); //在字符串可以进行运算2.3. 常见的变量类型
//3. 常见的变量类型
System.out.println(); //换行
System.out.println("3. 常见的变量类型 ");
int i; //声明变量 int 表示整型数 之后的 i 是变量名称
i = 999; //对i经行赋值 把右边的值 赋值到 左边 的i
double d = 99.9; //在声明变量是 也可以直接对其赋值 double 为双精度 浮点数（小数）
//引用 println 打印字符串的内容 加号衔接 变量 (本身已经被声明的变量 所以说不是字符串 可以正常输出)
System.out.println("3.1 常见的变量类型 int整形 i = " + i);
System.out.println("3.2 常见的变量类型 double双精度浮点型 d = " + d);
System.out.println("3.3 常见的变量类型 还有float单精度浮点型 它与double不同的是 小数点的长度短 小数点之后的6 7位 ，double 16位");
// 基本上都会讲到大小占字节数之类的 背了也会忘 这里是双斜杠 因为要输出一个斜杠(只有一个会报错)
System.out.println("3.4 常见的变量类型 3.3讲的就是 变量的大小范围 严谨的说 占系统内存空间也不一样 可以百度 \"八大基本数据类型\" <- 输入单引号在之前加入\\");
//声明变量 String 表示字符串 str 变量名称 = "内容"
String str = "My ID_name is To My @ Tao";
System.out.println("3.5 常见的变量类型 String 字符串类型:" + str);2.4. Scanner类 输入 -> 与程序交互
先导入java.util.Scanner包
在程序顶部
package one; //one项目的整体 import java.util.*; //调用 Scanner类 字符串 用于程序交互
//4. Scanner类 输入 -> 与程序交互
System.out.println(); //换行
//这里提示一个输出 第47行 程序接收值 注意!!\n y有一个换行
System.out.print("4. Scanner类 输入 -> 与程序交互\nplease input a number:");
//创建Scanner类的对象
//扫描类 名称 系统写入
Scanner in = new Scanner(System.in);
//创建一个变量用于接收输入的数据
int arr = in.nextInt(); //这里的Int() 表示整型 in.next(); 也可以
//打印
System.out.println("4. Scanner类 输入 -> The number is " + arr);2.5. Java中运算符
结合第三点 流程控制来依次举例 在这里表示一下有哪些类型
2.5.1.比较运算符
比较运算符就是两个数据之间进行比较的运算
//5.Java中运算符
//1.比较运算符 字面意思就是用来比比较的
//大于： > 小于： < 大于等于： >= 小于等于： <=
//相等： == 不等： !=
System.out.println(); //换行
System.out.println("5.Java中运算符->1.比较运算符 < ");2.5.2.逻辑运算符
//2.逻辑运算符
/*
* && （and符）表示逻辑与运算符，相当于“并且”，同真为真，一假为假
|| 表示逻辑或运算符，相当与“或者”，一真为真，同假为假
！表示逻辑非运算符，相当于“取反”，真为假，假为真
* */
//
System.out.println("5.Java中运算符->2.逻辑运算符 && || !/!=");2.5.3.算术运算符
//3.算术运算符
// 字面意思就是做运算用到的加减乘除 和 "%"取模 也叫取余数
// 自增++ 自减--
System.out.println("5.Java中运算符->3.算术运算符 + - * / ++ -- %");三.正文 程序 流程控制
常规一点就是 流程控制 有三大结构
1. 像前言所说 自上而下的 顺序结构
2. 利用到的 if 、 switch的 分支结构
3. while、do while、for 循环结构
3.1 结合算术运算符 顺序结构 举例
//3.正题 程序的流程控制
System.out.println(); //换行
//1. 结合算术运算符 顺序结构 举例
//声明变量
int x = 100;
int y = 999;
//在声明之后 修改变量的值
x = 10;
y = 99;
// 右边先运算 然后在给左边赋值
x = x + y;
System.out.println("3.1.程序的流程控制->1.顺序结构 +运算 x = "+ x);
x = x * y;
System.out.println("3.1.程序的流程控制->1.顺序结构 *运算 x = "+ x);
// 解释一下取模运算 x % y = ? 假设x = 111 ,y = 10;
// 就是说 111 除以 10 余数位1 那么1 就是取模结果
x = 111;
y = 10;
System.out.println("3.1.程序的流程控制->1.顺序结构 *运算 剩下的同理 %运算 x = "+ x);3.2 结合比较运算符 分支（选择）结构 举例
3.2.1）. if..if..else...else // 使用if语句 判断是否为奇偶数
//框架
if(控制条件)
{
语句；
}
else if(控制条件)
{
语句2；
}
else
语句3;//思路：程序说明 -> 声明变量 -> 向程序赋值 -> 判断 -> 返回结果
//2. 结合比较运算符 分支（选择）结构 举例
System.out.println(); //换行
//举例是否为奇偶数 //思路：程序说明 -> 声明变量 -> 向程序赋值 -> 判断 -> 返回结果
//程序说明
System.out.println("3.2 程序的流程控制->1.分支结构 输入数字判断是否为奇偶数");
System.out.print("3.2 程序的流程控制->1.分支结构input:");
//声明变量
int num;
//使用 Scanner 向程序交互赋值
Scanner text = new Scanner(System.in);
num = text.nextInt();
//判断
if (num % 2 == 0)
{
System.out.println("3.2 程序的流程控制->1.分支结构数字:" + num + "是偶数");
}
else if(num % 2 != 0)
{
System.out.println("3.2 程序的流程控制->1.分支结构数字:" + num + "是奇数");
}
else
System.out.println("出错！");
//ps: 就是代码风格是这样 一个数字 非偶己奇
// if(表达式/条件控制) 中的 == 就是比较 num%2的余数 == 0
// 没有余数 就为 0 0 == 0 为真 执行语句
// else 就是否则， 否则 怎么样
// 如果用多种判断条件 在if 语句之后 使用if..else3.2.2）.switch //使用switch语句 成绩等级判断 A B C D
//框架
switch(表达式)
{
case 常量表达式1: 语句1
case 常量表达式2: 语句2
//……
//……
case 常量表达式 n-1: 语句 n-1
default： 语句n
}
/*
意思是先计算表达式的值再逐个和case 后的常量表达式比较
若不等则继续往下比较，若一直不等，则执行default后的语句；
若等于某一个常量表达式 则从这个表达式后的语句开始执行
并执行后面所有case后的语句。
*///思路：程序说明 -> 声明变量 -> 向程序赋值 -> 判断 -> 返回结果
//2. 结合比较运算符 分支（选择）结构 举例
System.out.println(); //换行
//举例 成绩等级判断 A B C D D- //思路：程序说明 -> 声明变量 -> 向程序赋值 -> 判断 -> 返回结果
//程序要求 90以上A; 80->B; 70->C; 60->D 60以下D-
//程序说明
System.out.println("3.2.2 程序的流程控制->1.分支结构 switch 成绩等级判断 A B C D D-");
System.out.print("3.2.2 程序的流程控制->1.分支结构 switch input:");
//声明变量
int result;
//使用 Scanner 向程序交互赋值
Scanner two = new Scanner(System.in);
num = two.nextInt();
//判断
switch (num / 10)
{
case 10:
case 9:
System.out.print("3.2.2 程序的流程控制->1.分支结构switch 成绩:" + num + "等级：A");
break;
case 8:
System.out.print("3.2.2 程序的流程控制->1.分支结构switch 成绩:" + num + "等级：B");
break;
case 7:
System.out.print("3.2.2 程序的流程控制->1.分支结构switch 成绩:" + num + "等级：C");
break;
case 6:
System.out.print("3.2.2 程序的流程控制->1.分支结构switch 成绩:" + num + "等级：D");
break;
default:
System.out.print("3.2.2 程序的流程控制->1.分支结构switch 成绩:" + num + "等级：D-");
}
//switch 分支语句是一种多分支选择结构，不是条件性语句，也不是循环语句
//break 当break出现在switch语句体内时 执行了 该段的case 之后的语句 应当使用break跳出，否侧会执行下面的语句3.3 结合逻辑运算符 循环结构 举例
3.3.1)while 循环 · 使用比较运算符 //程序：单位数猜数游戏 (自定义值 不调用随机值)
这个例子并非用到了 逻辑运算符，结合while 巩固一下之前的知识点
//while 循环 · 使用比较运算符 //程序：单位数猜数游戏 （自定义值 不调用随机值）
//流程：声明程序 -> 声明两个变量 -> 键入值 -> 判断 -正确退出 -否侧-> 再判断
//程序声明
System.out.print("\n3.3.1 程序的流程控制->1.while 循环 单位数猜数游戏\n");
System.out.print("input");
//声明变量
int n = 4; //答案
int m; //输入值
// //使用 Scanner 向程序交互赋值
// Scanner three = new Scanner(System.in);
// m = three.nextInt();
while (true) //非0即真 一直循环
{
Scanner three = new Scanner(System.in);
m = three.nextInt();
if(m < n)
{
System.out.print("3.3.1 程序的流程控制->1.while 循环-The number is little\n");
}
else if(m > n)
{
System.out.print("3.3.1 程序的流程控制->1.while 循环-The number's so big\n");
}
else
{
System.out.print("3.3.1 程序的流程控制->1.while 循环-It's right\n");
break;
}
}3.3.2) for 循环 · 使用逻辑运算符 && //程序：打印 0-100 可以被5整除的偶数
//框架
int i_3;
// 变量初值 条件控制 算术运算符的自增(+1)
// 每次循环i_3+1; 当i_3 不小于 100 时 跳出循环
for(i_3 = 0; i_3 < 100; i_3++)
{
//语句;
}
//由此可见的wile循环更灵活一点
//重新解释
for（循环变量类型 循环变量名称：要被遍历的对象）{
循环体；
}//流程：声明程序 -> 声明两个变量 -> 循环 - 判断 - 打印
//声明程序
System.out.print("\n3.3.2 程序的流程控制->1.for循环:打印 0-100 可以被5整除的偶数\n");
//声明变量-循环
//int i_3; 也可以在for直接声明 不过跳出循环体 就不能使用i_3变量了
System.out.print("3.3.2 程序的流程控制->1.for循环 result:\n"); //提示输出
for(int i_3 = 0; i_3 <= 100; i_3++)
{
//这里的&& and 就是相当于“并且”，同真为真，//一假为假 假就不执行
if(i_3 % 5 == 0 && i_3 % 2 == 0) // = 是赋值 ==是比较
//当if循环只有一条语句是 可以不用 { } //自行换行隔开 方便阅读程序
System.out.print(i_3 + " "); //每次输入有一个空格
}3.3.3) do..while() 循环 · 结合上述知识点 //程序：17题
//框架
do
{
//语句/循环体
}
while(条件控制/表达式); //注意分号结尾
//为假跳出循环 和 while类似
//不同的是 do..while至少先循环一次 在做判断 是否再循环
//分析：100W, 存入了 年利率8%的账户，每年的最后一天-10W 什么时候取完所有的钱
//思路 程序说明->声明变量->循环-有利息 改值（1*1+0.08）-取钱 - 从第一年开始计数
//3.3.3) do..while() 循环 · 结合上述知识点 //程序：17题
System.out.println(); //换行
System.out.print("\n3.3.3 程序的流程控制->1.do..while循环:17题\n");
//100W, 存入了 年利率8%的账户，每年的最后一天-10W 什么时候取完所有的钱
//思路 程序说明->声明变量->循环-有利息 改值（1*1+0.08）-取钱 - 从第一年开始计数-输出
//程序说明
System.out.println("100W,存入了 年利率8%的账户，每年的最后一天-10W 什么时候取完所有的钱");
//定义变量
double d_3 = 100.0; //本金
int i_4 = 0; //计数
do
{
d_3 = d_3 + (d_3 * 0.08); //算术运算符 计算每年的利息
//每年取走10W
d_3 -= 10; //d_3 = d_3 - 10; 的简写
if(d_3 <= 10) //在最后一年剩余的钱
{
++i_4; //最后一年在计一次数
break; //取完结束
}
//循环体 自增自减的变量 一般放在最下端,执行后就重新循环了
++i_4; //因为不影响任何变量， 取走了10W 就是一年结束 然后计数的i_4变量自增+1
}while(true);
System.out.print("3.3.3 程序的流程控制->1.do..while循环:17题 结果为：" + i_4 + "年");3.3.4) 循环结构总结
很明显就是 循环次数是未知的 在框架不变的情况下 不能使用for循环
在while中 用在不确定的次数中
for循环 显而易见在特定的情况下 如知道了循环次数，可以用for循环
do..while至少先循环一次 在做判断 是否再循环 //记得结尾的分号
四.数组
4.1、数组讲解
4.1.1数组
数组就是存储数据长度固定的容器，保证多个数据的数据类型要一致
根据变量类型声明，数组也是变量,数组是相同类型数据的有序集合。数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。其中每一个数据称为一个数组元素，每个数组元素可以通过一个下标来访问他们
4.1.2数组的类型
int float / double char //三种基本类型
4.1.3数组的初始化
1.动态初始化
数组存储的数据类型 数组名字[ ] = new 数组存储的数据类型[数组长度];
- 动态初始化（指定长度）
int[] arr = new int[3];
int arr[] = new int[3];
// 可以拆分
int[] arr;
arr = new int[3];- 静态初始化（指定内容）
数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3…};int[] arr = new int[]{1,2,3,4,5};
// 可以拆分
int[] arr;
arr = new int[]{1,2,3,4,5};
4.2、举例·引用数组：数组的遍历
4.2.1例子1 数组实现遍历 int
要求：int 使用for循环初始化 为值1 - 10 并输出
//4.2、举例·引用数组：数组的遍历
System.out.println(); //换行
//要求：int 使用for循环初始化 为值1 - 10 并输出
System.out.println("4.2.1例子1 数组实现遍历 int");
int [] arr_4 = new int[10];
//int 使用for循环初始化 为值1 - 10
for(int x_4 = 0; x_4 < 10; x_4++)
arr_4[x_4] = x_4+1; //正如if一样 只有一条语句不用 {}
for(int x_4 = 0; x_4 < 10; x_4++)
System.out.print(arr_4[x_4] + " "); //打印之后 空格
System.out.println();跟我想象中 熟悉Java数组不太一样，， 没有弄通，进度并不是很高 ， 也行后面会在补充
我想 解释个char类型的数组 ，也或许可以说有点急 ，还有其他的事情 so i have to stop it
五、结尾
重点就是流程第三段的流程控制
看代码块中的注释 和思路 //复制后可以直接运行
还有基本类型的大小 和 占字节数 浅百度一下就行了 用多就记住了 ，背了也会忘
总结了一下 2周Java线上课的进度
有问题可以直接私信 ，You should elevate yourself. Of course, and me.
298
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
