数据类型，变量，分支和循环详解

数据类型，变量，分支和循环

1. 基本数据类型和变量

1.1 数据类型概述

整型数据类型，用于存储 整数

数据类型	占用内存空间字节数	数据范围
byte	1	-128 ~ 127
short	2	-32768 ~ 32767
int	4	-2^31 ~ 2^31 -1
long	8	-2^63 ~ 2^63 -1

【注意】使用浮点类型数据存储目标数据内容，注意精度问题和数据后期的变化问题。

数据类型	占用内存空间字节数	数据范围
double	8(64bit)	10^308
float	4	10^38

/*
计算机存储浮点数默认数据类型选择是 double 类型，计算机仅考虑数据的完整性和精度问题，其他的空间占用无所谓。
10.02 ==> double 
	float num1 = 10.02;
按照目前的写法会导致报错，double 类型的数据赋值给 float 类型，存在精度丢失。
*/
float num1 = 10.02F;
float num2 = 10.01F;

float ret = num1 - num2; ==> 0.01F;

float num1 = 10.02F;
float num2 = 10.01F;

// 0.010000229
System.out.println(num1 - num2);

double num3 = 10.02;
double num4 = 10.01;

// 0.009999999999999787
System.out.println(num3 - num4);

字符类型
字符常量是英文单引号包含的单个元素
'A' '中'
'\n' 换行
'\40' 空格

数据类型	占用内存空间字节数	数据范围
char	2	可以存储中文

布尔类型 boolean

数据类型	占用内存空间字节数	数据范围
boolean	1. 占用一个字节 2. 占用四个字节 3. boolean类型数组 每一个布尔类型占用一个 bit 位	true false

1.2 定义变量

变量定义是符合 AJCG 阿里巴巴 Java 代码开发规约

1. 字符使用范围:
	a. 数字 0 ~ 9 
	b. 英文字母 a ~ z A ~ Z
	c. 唯一可以使用的标点符号 _ 下划线
2. 变量定义对应的标识符要求英文字母开头
3. 标识符要求严格区分大小写
4. 标识符没有严格的长度限制，但是会根据实际的开发情况决定标识符的长度。
5. 标识符要求见名知意，动宾结构
	【语义性要求】
	int a,b,c; 不建议，禁止使用
 	payBeizhu 不可以使用
	
	studentAge studentName studentJavaScore studentMathScore
	findAllStudent findStudentById searchStudentUseName updateStudentById
	deleteStudentById sortStudentUsingComparator

6. 标识符命名要求
	a. 驼峰命名法
		小驼峰
			首字母小写，之后的每一个单词首字母大写
			适用于:
				变量，方法名
		大驼峰
			每一个单词首字母大写，
			适用于:
				类名，接口名
	b. 下划线命名法
		所有单词全部大写，使用 _ 下划线分割。
			适用于:
				带有名称的常量

7. 已经被 Java 占用的关键字和保留字不得用于自定义标识符使用
8. 标识符在一定范围内唯一。
9. 包名全小写。

代码案例定义变量

package com.qfedu.a_test;

public class Demo2 {
	public static void main(String[] args) {
		/*
		num 变量 int 数据类型，但是没有赋值任何的数据
		后期操作过程中，除赋值操作之外，无法参与其他任何
		的代码执行。
		Java 中严格的语法要求，避免【野值】
		int num; 后期使用注意操作
		*/		
		int num = 10;
		System.out.println(num);

		/*
		变量在一定范围以内不可以重复定义。
		 */
		// int num = 10;
		System.out.println(num);

		/*
		10L 告知编译器当前的 常量 10 采用的数据存储方式为 long 类型
		为了更好的满足【数据类型一致化要求】
		 */
		long num2 = 10L;
	}
}

2. 分支结构

2.1 if 结构

if (/* boolean 类型结果表达式 */) {
    // 执行代码内容
}

if (/* boolean 类型结果表达式 */) {
    // if 小括号内容为 true 执行代码内容
} else {
    // if 小括号内容为 false 执行代码内容
}

if (/* 匹配条件 1 */) {
   // 处理方式 1
} else if (/* 匹配条件 2 */) {
   // 处理方式 2
} else if (/* 匹配条件 3 */) {
   // 处理方式 3
} else {
   // 无任何匹配项的处理方式
}

要求和建议
事不过三，不建议连续的三层嵌套结构，阅读性太差
任何时候不允许省略任何一个大括号，哪怕代码仅有一行
常规建议，一个方法最多 80 行，不允许代码中出现过于繁琐的 if 结构

2.2 运算符和案例

算术运算符：
	+ - * / % =
	升级版:
		+= -= *= /= %=

关系运算符:
	> < >= <= != ==
	对外结果为 boolean 类型

逻辑运算符:
	&& 同真为真，有假【即】假
	|| 有真【即】真，同假为假
	!  犟 取反

自增自减运算符:
	++ 
	--
	要求:
		1. 有且只能操作变量
		2. 在变量之前先执行自增自减，再取值操作
		3. 再变量之后先取值操作，再执行自增自减
		4. 语义性较差，再开发中避免复杂使用，推荐使用 += 1 和 -= 1 替换
		5. 自增自减运算符，单独成行！

细节补充

double num1 = 10.5;
double num2 = 2.3;

System.out.println(num1 / num2);
System.out.println(num1 % num2);
/*
4 * 2.3 = > 9.2
10.5 - 9.2 = 1.3
 */

int num = 10;

/*
按照 Java 的语法规则，当前
	num == 10
	10 == num 【墙裂建议】
	实际上结果一致，并且可以有效的防止一定的错误。
	
	num = 10 赋值语句正常操作
	10 = num 赋值语句，但是语法错误，因为常量不可以被赋值。

【注意】
	等值判断，常量在前，变量在后。适用于 == 包括 后期的【方法】 equals
*/
if (num == 10) { // 10 == num
	System.out.println("测试");
}

逻辑与和逻辑或的【短路原则】
重点是关注后期条件的排列关系和对应的操作流程，优化条件罗列。

int num = 10;

boolean ret = num > 15 && ++num > 5;

ret = ?; false
num = ?; 10
/*
逻辑与【短路原则】
	逻辑与 同真为真，有假【即】假
	逻辑与表达式，从第一个 false 条件开始，之后的所有表达式不在运行。
*/

----------------------------------------------------------------
    
int num = 10;

boolean ret = num > 5 || ++num > 5;

ret = ?; true
num = ?; 10
/*
逻辑或【短路原则】
	逻辑或 有真【即】真，同假为假
	逻辑或表达式，从第一个 true 条件开始，之后的所有表达式不在运行。
*/

自增自减运算符面试题

int a = 10;
int b = 5;
int c = 3;

int ret = a++ * ++b - (c-- + b++);

/*
拆掉所有的算术运算符，包括小括号，小括号优先级有且只在自增自减结果提供之后参与。
拆解之后:
    a++ ==> 10
    ++b ==> 6
    c-- ==> 3
    b++ ==> 6
确定每一个自增自减运算符提供的数据之后，恢复原本的运算结构
	10 * 6 - (3 + 6) ==> 60 - 9 ==> 51
*/

ret = 51;
a = 11;
b = 7;
c = 2;

int num = 10;
++(num++);【语法错误 一】
num = ?;

++num--;【语法错误 二】

/*
【语法错误 一】
	1. 自增自减运算符有且只允许操作【变量】
	2. 小括号结果对外是一个【常量】，值，value，数
	代码运行之后的结果:
		++(常量) ==> ++常量 
		语法错误

【语法错误 二】
	1. 自增自减运算符最终提供给表达式的结果是一个常量
	++num ==> 11
	11--; -- 自减运算符，操作的不是一个变量，而是常量数据
	语法错误
*/

if 分支结构演示

/*
rank 分
	1000分 以上 白银
	1200分 以上 黄金
	1400分 以上 铂金
	1600分 以上 钻石
	1800分 以上 大师
	2000分 以上 王者

结构选择:	
	if else if 结构
用户数据提供:
	Scanner 用户从程序外部提供数据的能力和形式。后期使用 前端(HTML页面，APP, 小程序)
用户输入数据合法性判断:
	判断用户提供的数据情况是否满足当前需求
用户输入友好性提示
*/
package com.qfedu.a_test;

import java.util.Scanner;

/**
 *
 * @author Anonymous 2023/2/21 11:28
 */
public class Demo4 {
    /*
    rank 分
        1000分 以上 白银
        1200分 以上 黄金
        1400分 以上 铂金
        1600分 以上 钻石
        1800分 以上 大师
        2000分 以上 王者

    结构选择:
        if else if 结构
    用户数据提供:
        Scanner 用户从程序外部提供数据的能力和形式。后期使用 前端(HTML页面，APP, 小程序)
    用户输入数据合法性判断:
        判断用户提供的数据情况是否满足当前需求
    用户输入友好性提示
         */
    public static void main(String[] args) {
        int rank = 0;
        Scanner scanner = new Scanner(System.in);

        // 用户输入提示
        System.out.println("请输入您的 Rank 分:");
        rank = scanner.nextInt();

        /*
         用户输入数据合法性判断
         根据实际情况判断用户提供的数据是否合法，是否满足生活逻辑
         rank 分没有负数
         */
        if (rank < 0) {
            System.out.println("兄弟，你这个 rank 分有问题！！！");
            /*
            不可以进入正常的代码逻辑：
                1. 终止方法运行【合理】
                    return;
                2. 终止程序运行【过分】
             */
            return;
        }

        // 不推荐的形式
        if (rank >= 1000 && rank < 1200) {
            System.out.println("白银");
        } else if (rank >= 1200 && rank < 1400) {
            System.out.println("黄金");
        } else if (rank >= 1400 && rank < 1600) {
            System.out.println("铂金");
        } else if (rank >= 1600 && rank < 1800) {
            System.out.println("钻石");
        } else {
            System.out.println("其他");
        }

        // 推荐形式
        if (rank >= 2000) {
            System.out.println("王者");
        } else if (rank >= 1800) {
            System.out.println("大师");
        } else if (rank >= 1600) {
            System.out.println("钻石");
        } else if (rank >= 1400) {
            System.out.println("铂金");
        } else if (rank >= 1200) {
            System.out.println("黄金");
        } else if (rank >= 1000) {
            System.out.println("白银");
        } else {
            System.out.println("黄铜");
        }
    }
}

2.3 switch - case

switch case 结构支持数据类型一共四个
整数，字符，字符串和枚举
【墙裂推荐】整数和枚举
格式要求:
按照标准的 switch case 结构完成代码，不允许缺少任何的 break ，case
阿里巴巴 Java 开发规约中要求 default 结构不允许省略

switch (变量存储目标数据类型) {
	case 常量1:
		处理方式1;
		break;
	case 常量2:
		处理方式2;
		break;
	default:
		break;
}

3. 循环结构

循环结构对于代码运行性能是比较浪费的，使用循环要考虑以下问题
循环结构选择
循环次数控制
循环终止条件控制

3.1 循环结构有哪些

while (/* 循环判断，循环条件，要求为 boolean 类型 */) {
    // 循环体
}

do {
  // 循环体  
} while (/* 循环判断，循环条件，要求为 boolean 类型 */);

for (/* 循环条件初始化 */; /* 循环条件判断 */; /* 循环条件变更 */) {
	// 循环体
}

while 循环适合无限循环，但是有终止条件限制，或者数据解析，文本读取，无法预知数据的长度，但是明确存在终止标记。例如 文本读取 EOF(End Of File -1)
for 循环适合明确数据开始，数据结束已经步进关系的循环情况。

3.2 循环控制的关键字

break 可以用于在满足条件的情况下，终止当前循环。

continue 终止本次循环，直接进入下一次循环，continue 有且只推荐在 for 循环中使用

3.3 课堂练习

1. 1 ~ 150 的和
	解决方案:
		a. for 循环可以解决问题
		b. 高斯求和公式 【数学思维】
2. 需要通过代码展示 1 ~ 100 中所有的偶数。
	解决方案:
		a. 常规的开发思维
        for (int i = 1; i <= 100; i++) {
            if (i % 2 == 0) {
                sout(i);
            }
        }

		b. 基于生活，数学习惯分析的代码内容
        for (int i = 2; i <= 100; i += 2) {
            sout(i);
        }
 
 3. 逢七过 100以内
 	 与 7 无关的数:
 	 	【当前操作条件判断次数过多，性能较差】
 	 	if (i % 7 != 0 && i % 10 != 7 && i / 10 != 7) { 
 	 		sout(i)
 	 	} else {
 	 		sout(过)
 	 	}
 	 
 	 与 7 相关的数:
 	 	【性能较好】
 	 	if (i % 7 == 0 || i / 10 == 7 || i % 10 == 7) {
 	 		sout(过)
 	 	} else {
 	 		sout(i)
 	 	}

4. 方法

4.1 方法的基本格式

权限修饰符 是否静态 返回值类型 方法名(形式参数列表) { 方法体 }
核心: 形式参数列表，返回值类型

4.2 方法分类

方法分析，关注后期的 Lambda 表达式，Stream 流，方法引用

★有参数有返回值 
	最常用的模式，在开发中非常友好，方便代码操作

无参数无返回值
	一般为测试方法，展示方法，内置方法。
	
无参数有返回值
	生产者方法
	
有参数无返回值
	消费者方法

4.3 案例代码

package com.qfedu.a_test;

/**
 * 方法注意事项：
 *      1. Java 中所有的方法平级，不允许出现一个方法内部定义一个新的方法。
 *      2. 目前演示代码采用的方法为【public 修饰 static 标注的 静态方法】
 *
 *
 * @author Anonymous 2023/2/21 15:39
 */
public class Demo6 {
    public static void main(String[] args) {
        /*
        调用方法要求:
            1. 需要明确方法名
            2. 需要提供小括号，Java 中区分变量和方法的最大的区别就是 ()
            3. 需要提供方法所需实际参数
         */
        test();

        // 提供的实际参数类型和方法所需参数类型一致，严格遵守【数据类型一致化要求】
        printIntValue(10);

        int ret = giveMeFive();
        System.out.println("方法返回值结果:" + ret);

        int sum = sumOf(10, 20);
        System.out.println("两数之和:" + sum);
    }

    // 文档注释的目的，是为了在后期开发中，可以快速看到当前方法的注释内容
    // 提示方法的功能
    /**
     * 无参数无返回值方法，当前方法没有返回值和参数，无需告知当前
     * 方法的调用者，该方法的相关返回值和参数信息，只需要告知调用者
     * 当前方法的作用。
     *
     * 测试方法
     */
    public static void test() {
        System.out.println("无参数无返回值方法演示");
    }

    /*
     @param parameter 解释当前参数的用意，特征，数据需求和解释
     方法声明中的形式参数列表对应的【参数名】就是一个可以在
     方法中使用的【局部变量】
     */
    /**
     * 在控制台展示调用者提供的 int 类型数据
     *
     * @param num 用户提供的 int 类型数据内容
     */
    public static void printIntValue(int num) {
        System.out.println("用户提供的数据：" + num);
    }

    /*
     @return 解释当前返回值内容，类型，情况，分析，结果，特征。。。
     Java 中的方法有且只有一个返回值，数据类型要求一致化
     */
    /**
     * 返回一个 int 类型数值 5
     *
     * @return 返回值是一个 int 类型常量 5
     */
    public static int giveMeFive()  {
        /*
        return 关键字:
            1. return 可以将关键字之后的数据返回到方法之外，要求
                关键字之后的数据类型和方法声明返回值类型一致
            2. 结束当前方法运行。
         */
        return 5;
    }

    // 【重要】

    /**
     * 计算返回调用者提供的两个 int 类型数据内容
     *
     * @param num1 用户提供的 int 类型数据
     * @param num2 用户提供的 int 类型数据
     * @return 计算两个 int 类型之和最终的结果内容
     */
    public static int sumOf(int num1, int num2) {
        return num1 + num2;
    }
}