JAVA基础篇(一)

一、Java基本介绍

1.Java 简介

• Sun公司（Stanford University NetWork）美国的斯坦福大学 在1995年推出的高级编程语言。
• Java之父： 詹姆斯 • 高斯林（James Gosling）
• Sun公司在2009年被甲骨文（Oracle）公司给收购了。

1.1 Java的优势

• 使用最广泛，且简单易学
• Java 是一门强类型语言
• Java 有非常完善的异常处理机制
• Java提供了对于大多数大数据的基础性支持

2. Java开源的跨平台语言

• 开源
  • 指的是Java的源代码是开放的
• 跨平台
  • 指的是：用Java代码编写的程序，可以在不同的操作系统上运行
• JVM
  • Java虚拟机
• 原理：
  • 有JVM保证Java程序的跨平台性，但是JVM本身并不能跨平台。
    

3.JDK 和JRE的区别以及下载和JDK安装

• JDK (Java Development Kit) ==> Java开发工具包
• JRE (Java Runtime Environment) ==>Java运行时环境
• JVM (Java Virtual Machine) ==> Java虚拟机
• JDK和JRE的图解:
  
• JDK的安装(无论mac还是windows)
  • 傻瓜式安装(下一步下一步就可以了)
• 安装路径(以后但凡是安装开发软件, 都要满足以下两点: )
  • 不要直接安装到盘符目录下.
  • 安装路径最好不要出现中文, 空格等特殊符号.

4. 配置PATH变量

• Windows 配置Path环境变量
  • 新建一个系统变量: JAVA_HOME, 它的值就是你安装的JDK的路径(注意: 不要带bin这一级)
    
  • 在path中配置你刚才设置好的JAVA_HOME环境变量.

  %JAVA_HOME%\bin
  

  • 打开cmd终端然后输入

  java -version
  

  • %JAVA_HOME%\bin 这个是干啥的?
    • %JAVA_HOME%\bin 等价于 C:\software\officeSoftware\jdk1.8.0_122\bin
    • %JAVA_HOME%读取jdk安装路径，再拼接\bin
    • bin里面存储java，javac等命令，可以在你的cmd中直接使用
• Mac 配置环境变量

# 1.打开终端
# 2.查看jdk安装目录：
	/usr/libexec/java_home -V
# 3.编辑.bash_profile文件
	vim ~/.bash_profile
# 4.在.bash_profile	文件中添加java的路径（需要修改成自身电脑的java路径）
export JAVA_HOME=/Library/Java/JavaVirtualMachines/jdk1.8.0_211.jdk/Contents/Home
export PATH=$JAVA_HOME/bin:$PATH
# 5.输入使配置生效，
	source ~/.bash_profile
# 6.然后输入
	java -version

5. 开发Java程序的IDE

• IDE解释
  • 全称叫 集成开发环境（Integrated Development Environment） 即：集代码的编写，编写，运行，调试等 工程一体的软件
• IDE解释
  • IDE全程IntelliJ IDEA，是Java编程语言开发的集成环境。IntelliJ在业界被公认为最好的java开发工具
  • IDEA是JetBrains公司的产品，这家公司总部位于捷克共和国的首都布拉格。
  • 它的旗舰版本还支持HTML，CSS，PHP，MySQL，Python等。免费版只支持Python等少数语言

6. IDEA创建项目和模块

• IDEA创建项目流程
  • 1.新建一个工作空间(workspace)
  • 2.新建一个项目（例如：JavaSE）
  • 3.在项目下新建模块（例如：Day01，Day02…）
  • 4.在模块下新建包
    • 包名需要遵循全部小写方式，一般是公司域名反写 （例如：com.baidu.demo01）
  • 5.在包中创建类（例如：HelloWorld.java）
• IDEA创建项目的两种方式：
  • 方式1：一天一个项目
  • 方式2：整个JavaSE一个项目，每天一个模块 【推荐】
    

8. IDEA如何导入导出和删除模块

• 导出
  • 直接复制模块名称：day01到指定目录即可
• 导入：最简单的方式
  • 方式1：
    • 先把模块复制到指定目录
    • 新建一个和本地模块名称一模一样的模块，那么该模块就会被自动导入
  • 方式2：直接将复制代码到src下
• 删除项目:
  • 右击项目，选择：Remove Module选项即可

二、Java的基础语法

1.Java注释和关键字的基本使用

• 注释概述: 就是用来对程序进行解释和说明的文字,提高代码可读性, 并不会执行注释中的内容.

分类:
			//单行注释

			/*
				多行注释
				....
			*/

			/**
				文档注释, 主要用来修饰类, 接口, 方法.
			*/

• 代码演示 注释使用

package demo01;

/**
 * 自定义HelloWorld类（演示文档注释）
 * @author cq
 * @version 1.0
 */
public class HelloWorld {
    /*
        演示多行注释  快捷键：ctrl + shift + /
        main方法，主函数，程序的入口
        java中方法和函数就是同一个概念
        快捷键：psvm 或者 main
        main 不是关键字，函数名称
     */
    public static void main(String[] args) {
        // 逻辑代码 print() 打印
        //快捷键： sout
        System.out.println("Hello world");
        System.out.println("----------------[华丽分割线]----------------");
        //函数调用
        // 输入要计算的数字时直接输入数字就好 a：b: 会自动弹出
        int sum = getSum(1, 2);
        System.out.println(sum);
    }

    /**
     * 定义函数计算两个数之和
     * @param a 计算的第一个值 整型
     * @param b 计算的第二个值 整型
     * @return  返回两个数之和 整型
     * static 表示是一个静态方法
     */
    public static int getSum(int a ,int b){
        //代码块 一行代码结束
        return a + b;
    }
}

• Java关键字

关键字概述: 
	被JAVA语言赋予了特殊含义的单词
特点：
	1.'关键字全部是小写的。'
	2.'编辑器针对于关键字都会高亮显示'
举例：
	public protected private class static void  int ......
扩展：什么是保留字？
	'可以理解为： 备胎'
在目前版本中还不是关键字的单词，但是有关键字的作用，将来在新的JDK版本中可能升级成关键字
例如：goto ， const

2.Java的常量的基本使用

• 常量概述： 指的是在程序的执行过程中，其值不能发生改变的量。

例如：
	'光的传播速度，人的性别，圆周率'
分类：
	字面值常量：
		字符 'a' , 字符串 "james" , 整数 520 ， 小数 13.14 ，布尔 true false ， 空 null
	自定义常量：
		通过final 修饰的。 面向对象

• 代码演示

package demo01.demo02_basic;
/*
    案例: 演示Java中所有的字面值常量.
    具体的有:
        字符,
        字符串,
        整数,
        小数,
        布尔,
        空

    细节：空类型的常量是不能直接打印
*/
public class Demo01_Const {
    // 快捷键 psvm 或者main
    // 主函数 程序的入口
    public static void main(String[] args) {
        //1.演示 字符 常量 注意：字符是单引号' ' 字符有且仅有一个
        // 打印快捷键 ： sout
        System.out.println('暖');
        System.out.println('男');
        System.out.println('7');
        System.out.println(' ');
//        System.out.println('');  错误的
        System.out.println("----------------[华丽分割线]----------------");

        //2.演示 字符串 常量 字符串是双引号 " "
        System.out.println("Hello world");
        System.out.println("----------------[华丽分割线]----------------");

        //3.演示 整数 常量
        System.out.println(10);
        System.out.println(20);
        System.out.println(30);
        System.out.println("----------------[华丽分割线]----------------");

        //4.演示 小数 常量
        System.out.println(13.14);
        System.out.println(5.21);
        System.out.println("----------------[华丽分割线]----------------");

        //5.演示 布尔 常量
        System.out.println(true);
        System.out.println(false);
        System.out.println("----------------[华丽分割线]----------------");

        //6.演示 空 常量
        // System.out.println(null); // 报错
        String s = null;
        System.out.println(s);
    }
}

3.Java的变量的基本使用

• 变量概述： 指的是在程序的执行过程中, 其值能在一定范围内发生改变的量.

三要素：
	1.如何限定变量值的变化范围
		数据类型
	2.如何使用这个变量的值
		变量名
	3.如果使用某个变量，不给初始值行不行
		不行
语法格式：
	数据类型 变量名称 = 初始化值
	  int     a    =  10；
注意点： '最后必须要写分号(;) , 一个分号表示一行 '

• 代码演示

package demo01.demo02_basic;
/*
    案例：演示变量的基本使用
*/
public class Demo02_Var {
    //快捷键 psvm
    //程序入口
    public static void main(String[] args) {
        //需求：定义一个球员的信息，打印其信息
        String name = "kobe";
        //先定义 再赋值 最后使用
        int number;
        number = 24;
        String team = "lakers";
        //打印 sout
        System.out.println(name + " - " + number + " - " + team);
    }
}

4.Java数据类型的基本使用

• 数据类型简介： 就是用来限定变量值的变化过程的.

    分类:
        基本类型:
            整型
            	byte(-128~127) 1个字节,
                short 2个字节,
                int   4个字节,
                long  8个字节
            浮点型
                float 4, double 8
            字符型
                char 2
            布尔型
                boolean 1
            引用类型:
                    除了上述之外, 所有, 例如: 类, 接口, 数组.

    数据类型的小细节:
        1. 默认的整形是int, 默认的浮点型是double.
        2. long类型的变量值要加L, float要加F.
        3. boolean类型的变量值只有true和false.

• 代码演示

package demo01.demo02_basic;

/**
 * 案例： 演示Java中的数据类型基本数据类型
 */
public class Demo03_Type {
    public static void main(String[] args) {
        // 快速复制下一行快捷键： ctrl + d
        // 1.演示 整型 变量
        //1.1 byte类型 1个字节
        byte b1 = 10;
        // java中一个字符串 + 其他数据类型 ==> 新的字符串
        System.out.println("b1 " + b1);
        //1.2 short类型 2个字节
        short b2 = 20;
        System.out.println("b2 " + b2);

        // 1.3 int类型 4个字节
        int in = 4598;
        System.out.println("in " + in);
        // 1.4 long类型 8个字节
        long lo = 1024L;
        System.out.println("lo " + lo);
        System.out.println("----------------[华丽分割线]----------------");

        // 2.演示 浮点 变量
        // 2.1 float类型 4个字节
        float f1 = 13.14F;
        System.out.println("f1 " + f1);
        // 2.2 double类型 8个字节
        double d1 = 3.1415926;
        System.out.println("d1 " + d1);
        System.out.println("----------------[华丽分割线]----------------");
        // 3.演示 字符 变量
        char str = '爱';
        System.out.println("str " + str);
        // 4.演示 布尔型 变量
        boolean flag1 = true;
        boolean flag2 = false;
        System.out.println("flag1 " + flag1);
        System.out.println("flag2 " + flag2);
    }
}

5.Java的变量的注意事项

• 注意事项：

1.变量未赋值，不能使用的
2.变量只能在所属范围内有效
3.一行可以定义多个变量，但不建议这样写

• 代码演示

package demo01.demo02_basic;

/**
 * 演示： 使用变量的注意事项
 */
public class Demo04_Variable {
    public static void main(String[] args) {
        //1.变量为赋值 不能使用
        int age;
//        System.out.println(age);   会报错

        // 2.变量只能在所属范围内有效
        // 大括号是代码块，出了这个代码块，局部变量将会失效
        {
            String name = "curry";
            System.out.println(name);
        }
        //name变量已经失效
        //System.out.println(name);

        //3.一行可以定义多个变量，但不建议这个写
        int a = 10 ,b = 20 ,c = 30 ,d;
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);

        //未赋值变量不能使用
        //System.out.println(d);
    }
}

6 Java的数据类型转换

• 数据类型转换

分类:
    隐式类型转换: 也叫自动类型转换
        特点:
            把小范围的值给大的数据类型 
            大装小  理解：把一杯水倒入大水缸，大水缸能容纳
        写法:
            正常赋值即可.

    强制类型转换: 也叫显式类型转换
        特点:
            把大范围的值给小的数据类型, 可能会丢失精度.
            小装大  理解：把一缸水倒入一杯水，杯水不能容纳，需要拓容，也就是需要强制类型转换
        写法:
            目标数据类型 变量名2 = (目标数据类型)变量值1;
            int  a = (int)13.14

核心: 基本类型的范围如下:
    byte < short, char < int < long < float < double 
    注意：boolean不参与.

• 代码演示

package demo01.demo02_basic;

public class Demo05_TransFrom {
    public static void main(String[] args) {
        // 1.隐式转换（小转大）
        int age = 10;
        double d1 = age;
        System.out.println(d1);
        System.out.println("----------------[华丽分割线]----------------");

        //2.强制类型转换（大转小）
        //语法：目标数据类型 变量名2 = （目标数据类型）变量名1
        double price = 99.99;
        int target = (int)price;
        System.out.println(target);
    }
}

7.ASCII码表介绍

• 代码演示

package demo01.demo02_basic;
/*
ASCII码表
美国信息通用码表，就是描述字符在计算机里面是怎么存储的，字符和int之间的对应关系
字符在计算机存储：'男' => 数字（十进制） => 数字（二进制） => 存储
字符在计算机读取： 读取二进制数据  => 十进制  => 字符内容
记忆： 'a' => 97  'A' => 65  '0' => 48
GBK: 国内中文编码（汉字内码拓展规范）
UTF-8: 万国码，统一编码
 */
public class Demo06_ASCII {
    public static void main(String[] args) {
        // 字符 + 0  获取二级制对应的十进制值
        System.out.println('a' + 0);
        System.out.println('A' + 0);
        System.out.println('0' + 0);
    }
}

8.Java的运算符详解

• 运算符解释
  • 就是用来操作变量和常量得到操作符
  • 表达式介绍
    • 用运算符连接起来的式子就叫做表达式，例如：a+b， 叫做 算术表达式 a > b就叫做关系表达式

运算符分类
	算术运算符:
  		+, -, *, /, %,  ++, --
    赋值运算符:
  		=, +=, -=, *=, /=, %=
    关系运算符: >, < , >= , <=
    逻辑运算符: &&, ||, !
    三元运算符: 条件表达式 ? 表达式条件成立的值 : 表达式条件不成立的值;
细节:
      1. Java中整数相除, 结果肯定是整数.
      2. ++(自增运算符), --(自减运算符), 用法如下(此处以++举例):
	单独使用:
  		前加后加没有区别.
	参与运算:
  		前加: 先自身+1, 然后以新值运算.
    	后加: 先以原值运算, 然后自身+1.

• 代码

package demo01.demo02_basic;

/**
 * 演示java的各种运算符
 */
public class Demo07_Operator {
    public static void main(String[] args) {
        //1.算术运算符
        // java中整数相除结果一定是整数 这个和python不太一样
        System.out.println(10 / 3);  //结果是3

        System.out.println("----------------[华丽分割线]----------------");

        int a = 10;
        // 演示 ++ --
        // 前加 ++a 先自身+1 然后再参与运算
        // 后加 a++ 先以原值参与运算 在+1
        int Sum = a++ + --a + ++a;
        System.out.println(a);  // 11
        System.out.println(Sum);   //  31

        System.out.println("----------------[华丽分割线]----------------");

        //2.赋值 运算符  20 + 10
        int b = 10;
        b += 20;
        System.out.println("b " + b);
        System.out.println("----------------[华丽分割线]----------------");

        // 3.关系运算符
        boolean f1 = 10 > 20;   //false
        boolean f2 = 10 < 20;   // true
        System.out.println(f1);
        System.out.println(f2);
        System.out.println("----------------[华丽分割线]----------------");

        // 4.逻辑运算符
        // 与 &&
        System.out.println(true && true);   //true
        System.out.println(true && false);  //false
        System.out.println(false && true);  //false
        System.out.println("----------------[华丽分割线]----------------");
        // 或 ||
        System.out.println(true || true);   //true
        System.out.println(true || false);  //true
        System.out.println(false || true); //true
        System.out.println("----------------[华丽分割线]----------------");
        // 非 ！
        System.out.println(!true);  //false
        System.out.println(!!!!true); //true
        System.out.println("----------------[华丽分割线]----------------");

        //5.三元运算符
        //语法： 表达式？ 表达式成立返回值 : 表达式不成立返回值
        String name = 23 > 24 ? "kobe" : "jordan";
        System.out.println(name);  //jordan

    }
}

四、Scanner

1.Scanner 基本用法

• Scanner简介： 类似于python中的input（），就是用来做键盘输入的。

使用步骤：
	1. 导包
		import java.util.Scanner;
	2. 创建对象
		Scanner sc = new Scanner(System.in);
	3.调用方法
		
	int类型
		int num = sc.nextInt();
	整行 字符串类型
	String str = sc.nextLine();	

• 代码演示

package demo01.Scanner;

import java.util.Scanner;

/**
 * 从键盘输入一个球员的信息（名字、年龄、号码、球队）
 */
public class Demo01_Scanner {
    public static void main(String[] args) {
        System.out.println("请输入一个球员的信息(姓名、年龄、号码、球队): ");
        //1.导包  输入《new Scanner()》后，会自动去导包
        // 快捷方法 new Scanner().var
        Scanner sc = new Scanner(System.in);
        // 调用方法获取输入内容
        String player = sc.nextLine();
        System.out.println(player); //科比 38 35 湖人
    }
}

• 案例 获取三个人的最高身高

键盘录入三个人的身高

思路：
	1.创建Scanner对象
	2.提示录入三个人的身高
	3.比较  获去最大值
	4.打印结果。

package demo01.Scanner;

import java.util.Scanner;

/**
 * 需求：键盘录入三个人的身高 获取最大值 并打印结果
 */
public class Demo02_Example {
    public static void main(String[] args) {
        //1.导包 创建Scanner对象
        Scanner sc = new Scanner(System.in);
        //获取第一个人的身高
        System.out.println("请输入第一个人的身高: "); //  1.72
        double h1 = sc.nextDouble();
        //获取第二个人的身高
        System.out.println("请输入第二个人的身高: ");//   1.80
        double h2 = sc.nextDouble();
        //获取第三个人的身高
        System.out.println("请输入第三个人的身高: ");//   1.56
        double h3 = sc.nextDouble();

        // 比较三个人的身高
        double tall = h1 > h2 ? h1 : h2;
        double tall2 = h1 > h3 ? h1 : h3;
        double best = tall > tall2 ? tall : tall2;
        
        // 方案2： 三元运算符的嵌套使用
        //double max1 = h1 > h2? (h1比较高) : (h2比较高);
        double max1 = h1 > h2? (h1 > h3 ? h1 : h3) : (h2 > h3 ? h2 : h3);
        System.out.println("最高的身高为: " + best);  //最高的身高为: 1.8
        System.out.println("最高的身高为: " + max1);
    }
}

五、流程控制语句

• 概念

流程控制语句分类：
	顺序结构：
		代码从上往下，从左往右，一次执行。
	分支结构：
		if结构：	主要用于范围校验。
		switch结构： 主要用于固定值校验

		枚举：	已关注 取消关注 拉黑 删除
	
	循环结构：
		for： 主要用于循环次数 已知。
		while： 主要用于循环次数不固定。
			

1. 流程控制语句_顺序结构

• 代码演示

package demo04__if_for;
/*
    演示流程控制语句之顺序结构
    顺序结构 代码从上到下 从左到右 一次逐行执行。
*/
public class Demo01 {
    public static void main(String[] args) {
        // 开始
        System.out.println("start");

        //字符串拼接
        // java中字符串和数字拼接 返回一个新的字符串
        // 某开没有开挂5555
        System.out.println("55" + "开没有开挂" + 55 + 55);

        // 结束
        System.out.println("end");

        /*
            结果打印：
              start
              55开没有开挂5555
              end
        */
    }
}

2. 流程控制语句_if分支结构

• 定义

分支结构：
	if结构：主要用于范围校验。
		if单分支：
			if(关系表达式){
				语句体1；
				.....	
			}
		if双分支：
			if(关系表达式){
				语句体1；
			} else{
				语句体2；
			}

		if多分支：
			if(关系表达式1) {
                    语句体1;
                } else if(关系表达式2) {
                    语句体2;
                } else if(关系表达式3) {
                    语句体3;
                } else {
                    语句体n;
                }
     switch:  主要用于固定值校验.     

• 学生成绩案例 演示代码：

package demo01.demo04__if_for;

import java.util.Scanner;

/**
 * 输入学生成绩 判断是否及格
 */
public class Demo02_IF {
    public static void main(String[] args) {
        //创建Scanner对象
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入你的成绩: ");
        // 获取输入的值
        double score = scanner.nextDouble();

        //单分支
        if (score > 60){
            System.out.println("恭喜你，及格啦");
        }

        //双分支
        if (score > 60) {
            System.out.println("恭喜你，及格啦");
        } else {
            System.out.println("宝贝，回家请你吃大饼");
        }

        //多分支
        if (score >= 90){
            System.out.println("非常优秀");
        } else if (score >= 80){
            System.out.println("考的不错再接再厉");
        } else if (score >= 60){
            System.out.println("刚及格少玩游戏 小心老娘的皮带");
        } else{
            System.out.println("宝贝，回家请你吃大饼");
        }
    }
}

2.1 流程控制语句_switch分支结构

分支结构:
        if结构:   主要用于范围校验.

        switch:  主要用于固定值校验.
            switch(值) {
                case 值1:
                    语句体1;
                    break;
                case 值2:
                    语句体2;
                    break;
                ....
                default:
                    语句体n;
                    break;
            }

    细节:
        1. switch小括号中可以放什么:
            JDK1.5以前: byte, short, char, int
            JDK1.5: 枚举   man female
            JDK1.7: String
        2. 如果不写break会发生什么?
            可能会发生case穿透(即不判断case值的情况下, 程序继续往下执行).
            如果最后一个break不写, 对结果没有影响.
        3. switch的结束标记:
            1.遇到break.
            2.遇到switch的右大括号}

• 代码演示

package demo01.demo04__if_for;

import java.util.Scanner;

/**
 *  switch 用法代码演示
 */
public class Demo03_Switch {
    public static void main(String[] args) {
        // 提示用户录入月份，输出季节
        System.out.println("请输入一个月份: ");
        // 创建Scanner对象
        Scanner scanner = new Scanner(System.in);
        int month = scanner.nextInt();

        // 进入Switch部分
        switch (month){
            case 12:
                System.out.println("寒冬观雪，醒亦念卿，梦亦念卿");
                break;
            case 1:
                System.out.println("寒冬观雪，醒亦念卿，梦亦念卿");
                break;    // 不添加break 会连同2月份一起加载   case穿透
            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;
            case 8:
                System.out.println("夏夜观星，撩亦动心，扶亦动心");
                break;
            case 9:
                System.out.println("秋深落叶，醒亦念卿，梦亦念卿");
                break;
            case 10:
                System.out.println("秋深落叶，醒亦念卿，梦亦念卿");
                break;
            case 11:
                System.out.println("秋深落叶，醒亦念卿，梦亦念卿");
                break;
            default:
                System.out.println("么得这个季节");
                break;
        }

    }

}

• switch穿透精简写法代码 对上面的代码进行些许改造

package demo01.demo04__if_for;

import java.util.Scanner;

/**
 * 案列：输入一个月份判断是哪个季节
 */
public class Demo04_Switch {
    public static void main(String[] args) {
        // 提示用户录入月份，输出季节
        System.out.println("请输入一个月份: ");
        // 快速导包快捷键：alt + 回车
        // 创建Scanner对象
        Scanner scanner = new Scanner(System.in);
        int month = scanner.nextInt();

        // 进入Switch部分 (case穿透的写法)
        switch (month){
            case 12:
            case 1:
            case 2:
                System.out.println("寒冬观雪，醒亦念卿，梦亦念卿");
                break;
            case 3:
            case 4:
            case 5:
                System.out.println("春赏百花，醒也思卿，寐也思卿");
                break;
            case 6:
            case 7:
            case 8:
                System.out.println("夏夜观星，撩亦动心，扶亦动心");
                break;
            case 9:
            case 10:
            case 11:
                System.out.println("秋深落叶，醒亦念卿，梦亦念卿");
                break;
            default:
                System.out.println("么得这个季节");
                break;
        }

    }
}

3.流程控制语句_循环基本使用

循环结构:
        for:     主要用于循环次数已知.
            for(初始化条件1; 判断条件2; 控制条件4) {
                循环体3;
            }

            执行流程:
                第1次执行:  1, 2, 3, 4      如果判断条件成立.
                重复执行:   2, 3, 4
                最后1次执行: 2               判断条件不成立.

        while:   主要用于循环次数不固定.
             初始化条件1;
             while(判断条件2) {
                循环体3;
                控制条件4;
            }

• 代码演示

package demo01.for_while;

/**
 * 演示循环结构 跑10圈
 */
public class Demo01_For_While {
    public static void main(String[] args) {
        // 演示for循环
        for (int i = 1; i <= 10; i++) {
            System.out.println("跑了第" + i + "圈");
        }
        System.out.println("----------------[华丽分割线]----------------");
        // 演示while循环基本使用
        int j = 1;
        while (j <= 10){
            System.out.println("跑了第" + j + "圈");
            j++;
        }
    }
}

4.流程控制语句_循环进阶

• 代码演示

package demo01.for_while;
/*
    案例: 演示循环进阶.
  死循环:
      while(true){}
      for(;;){}
      for(;true;){}
  控制跳转:
      break: 终止循环, 循环不再继续执行.
      continue: 跳出本次循环, 进行下一次循环.
  循环嵌套:
      99乘法表.
*/
public class Demo02_99 {
    public static void main(String[] args) {
        // 1.死循环
        // 方案1
        // 多行注释快捷键 ctrl + shift + /
        /*while (true){
            System.out.println("111");
        }
        会一直打印 1111  */

        // 方案2 for的死循环
        /*for (;;) {
            System.out.println("2222");
        }   会一直打印222*/

        // 方案3
        /*for (;true;) {
            System.out.println(333);
        }*/

        //循环嵌套
        // 打印99乘法表
        // 外层循环控制有多少行
        // for循环快捷键 fori
        for (int i = 1; i <= 9; i++) {
            //内层循环控制有多少列
            for (int j = 1; j <= i; j++) {
                // 中间添加 \t 制表符
                // print 打印并且不换行
                System.out.print(j + " * " + i + " = " + (i * j) + "\t");
            }
            // println 打印并且自动换行
            //代表一行打印完毕 打印换行
            System.out.println();
            
            /*  结果打印
                1 * 1 = 1	
                1 * 2 = 2	2 * 2 = 4	
                1 * 3 = 3	2 * 3 = 6	3 * 3 = 9	
                1 * 4 = 4	2 * 4 = 8	3 * 4 = 12	4 * 4 = 16	
                1 * 5 = 5	2 * 5 = 10	3 * 5 = 15	4 * 5 = 20	5 * 5 = 25	
                1 * 6 = 6	2 * 6 = 12	3 * 6 = 18	4 * 6 = 24	5 * 6 = 30	6 * 6 = 36	
                1 * 7 = 7	2 * 7 = 14	3 * 7 = 21	4 * 7 = 28	5 * 7 = 35	6 * 7 = 42	7 * 7 = 49	
                1 * 8 = 8	2 * 8 = 16	3 * 8 = 24	4 * 8 = 32	5 * 8 = 40	6 * 8 = 48	7 * 8 = 56	8 * 8 = 64	
                1 * 9 = 9	2 * 9 = 18	3 * 9 = 27	4 * 9 = 36	5 * 9 = 45	6 * 9 = 54	7 * 9 = 63	8 * 9 = 72	9 * 9 = 81	  
            */
        }
    }
}

7.猜数字小游戏

• 生成随机数

可以获取0.0 ~ 1.0 之间的所有数据，左包右不包。
Math.random();

实例：
	获取1 ~ 100之间的随机整数
	int num = (int)(Math.random() * 100 + 1);

• 代码演示

package demo01.for_while;

import java.util.Scanner;

/*
   可以获取0.0 ~ 1.0之间所有的数据, 包左不包右.
   Math.random();
*/
public class Demo03_GuessNumber {
    public static void main(String[] args) {
        // 1.获取0.0 ~ 1.0之间的随机浮点数
        double r1 = Math.random();
        System.out.println(r1);

        // 获取1-100之间的随机整数
        // 包左不包右. 最大值是99 需要+1
        // 由于生产的随机浮点类型数据，强制类型转换成整型
        int num = (int)(Math.random() * 100 + 1);
        System.out.println(num);

        // 生成一个随机数1-100之间让用户来猜.
        // 1.生成1-100之间的随机整数
        // 2.由于不知道用户多少次能猜对，所以我们使用while死循环

        while (true){
            //提示用户输入整数
            System.out.println("请输入一个(1 ~ 100)整数: ");
            // 导包
            Scanner scanner = new Scanner(System.in);
            int input_num = scanner.nextInt();

            //4 比较用户输入数字 与 随机数是否一致
            if (input_num > num) {
                System.out.println("您输入的大了！ 请再次输入");
            } else if (input_num < num) {
                System.out.println("您输入的小了！请再次输入");
            } else {
                System.out.println("恭喜您猜对了");
                break;
            }
        }
    }
}

8. 案例练习

• 获取到所有的水仙花数, 并将结果打印到控制台上.

水仙花数解释
    1.	水仙花数是一个3位数的整数.
    2.	该数字的各个位数立方和相加等于它本身. 
    3.	例如: 153就是水仙花数, 153 = 1 * 1 * 1 + 5 * 5 * 5 + 3 * 3 * 3 = 153

• 答案代码

package demo01.for_while;
/*
水仙花数解释
  1.	水仙花数是一个3位数的整数.
  2.	该数字的各个位数立方和相加等于它本身.
  3.	例如: 153就是水仙花数, 153 = 1 * 1 * 1 + 5 * 5 * 5 + 3 * 3 * 3 = 153
*/
public class SXH {
    public static void main(String[] args) {
        // 水仙花数是一个3位数的整数. 所以这是一个3位数的整数
        // for循环的i 还从100开始的
        for (int i = 100; i <= 1000; i++) {
            //需要拿到它的个位数  十位数  百位数
            //i 是保存循环遍历的结果 如100  101 102  103 ......1000
            // % 是取余数 101 % 10 余数 1  是个位数
            int ge = (i / 1) % 10;
            // 和上面一样 在JAVA中 整型 /  整型 得到的 还是整型  余数是0
            int shi = (i / 10) % 10;
            // 这个和上面一样
            int bai = (i / 100) % 10;

            //该数字的各个位数立方和相加等于它本身.
            //开始判断
            if (ge * ge * ge + shi * shi * shi + bai * bai * bai == i) {
                System.out.println(i + "是水仙花数");
                
                /*  打印结果
                    153是水仙花数
                    370是水仙花数
                    371是水仙花数
                    407是水仙花数
                 */
            }
        }
    }
}

• 案例二 打印1-100之间的所有质数，按照五个一行的格式输出，格式如下

2   3   5		7   11
13  17	19	23	29
31 ....
  
提示：质数只能被1和自身整除的数字，最小的质数是2

• 实现代码

package demo01.for_while;

/*
    2   3   5		7   11
    13  17	19	23	29
    31 ....

    提示：质数只能被1和自身整除的数字，最小的质数是2
 */
public class ZhiShu {
    public static void main(String[] args) {
        // 定义统计变量count 记录质数的数量  控制每一行打印的数量
        int count = 0;
        // 循环遍历 1 ~ 100  有范围 使用for
        A:for (int i = 2; i <= 100; i++) {
            // 举例： 10的质数 2,3,5 剩下的一般肯定是无法整除的
            for (int j = 2; j <= i/2; j++) {
                if (i % j == 0){
                    // 不是质数，需要重新执行外层循环
                    // 只要能整除就不是质数 判断下一个数字即可（细节）
                    // 不满足条件 跳过本次循环 执行下一次循环 continue
                    continue A;
                }
            }
            // 统计质数的数量
            count++;
            //走到这里一定是质数了，5个一行打印
            if (count % 5 == 0) {
                //5个一行 需要换行   细节 不能使用 println打印 自带换行
                System.out.print(i + "\r\n");
            } else {
                // 不需要换行
                System.out.print(i + "\t");
            }
        }
    }
}