零基础学习java------day1------计算机基础以及java的一些简单了解（《零基础学java》）

25-02-14 18

想了解零基础学习java------day1------计算机基础以及java的一些简单了解的新动态吗？本文将为您提供详细的信息，我们还将为您解答关于《零基础学java》的相关问题，此外，我们还将为您

想了解零基础学习java------day1------计算机基础以及java的一些简单了解的新动态吗？本文将为您提供详细的信息，我们还将为您解答关于《零基础学java》的相关问题，此外，我们还将为您介绍关于Day1 java的基础、java 基础学习 day 04、Java 基础学习 day02、Java 基础学习 day03的新知识。

本文目录一览：

零基础学习java------day1------计算机基础以及java的一些简单了解（《零基础学java》）
Day1 java的基础
java 基础学习 day 04
Java 基础学习 day02
Java 基础学习 day03

零基础学习java------day1------计算机基础以及java的一些简单了解（《零基础学java》）

一. java的简单了解

Java是一门面向对象编程语言，不仅吸收了C++的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程。

1. 跨平台特性：

（1）什么是平台？即：操作系统和cpu (cpu运行时需要指令（cpu在不同的操作系统上运行时，指令集不同）)

比如qq就不是跨平台的，其在安卓和ios上需要不同的版本

（2）java通过什么实现跨平台

java通过jvm（Java Virtual Machine ）实现跨平台, 但JVM本身不是跨平台的

2. JRE(Java Runtimr Enviroment ,Java运行环境)

其包含java虚拟机（JVM）和java程序运行所需要的核心类型库等，如果只是想要运行java，不进行开发，计算机安装JRE即可

3. JDK(Java Development Kit ，java开发工具包)

JDK是提供给java开发人员使用的，其中包含了java的开发工具，也包括了JRE，所以安装了JDK就不用在单独安装JRE了，其中的开发工具有编译工具（javac.exe）、运行工具(java.exe)等。简单来说，使用JDK开发完成java程序，然后交给JRE去运行。

注：javac+文件名进行编译（编译后得到字节码文件，即后缀为 .class的文件，编译后得到的文件才能被java.exe运行）

二. HelloWorld 书写流程

1. 未配置环境变量的情况（java文件只能在jdk安装目录下的bin目录）

（1）安装JDK，保证文件的扩展名是显示的（查看中勾选文件扩展名）

（2）进入jdk安装目录下的bin目录，右键-->新建文本文档--->改名HelloWorld.java

（3）双击该文件，编辑，写java代码

class HelloWorld{
    public static void main(String[] args){
        System.out.println("我是你爹");

    }                                        
}

（4）打开命令控制台，使用cd命令进入bin目录下

（5）编译： javac 文件名.java 如 javac HelloWorld.java

（6）运行 java 类名如java HelloWorld

2. 环境变量的配置

配置目的：可以在计算机的任一位置执行java命令

方式: 只需要把jdk安装路径下的bin文件夹配置到环境变量当中----->把bin目录配到path中

class PrintDemo{
    public static void main(String[] args){
        System.out.print("哈哈")：      //print打印不换行
        System.out.print("呵呵")：
        System.out.println("嘿嘿")：    //println打印换行
        System.out.println("嘎嘎")：
    }

}

三. 注释

1.注释概述：用于解释说明程序的文字

2. java中注释分类格式

（1）单行注释

格式： //注释文字

（2）多行注释

格式： /* 注释文字 */

（3）文档注释

　　格式：/** 注释文字 */

说明：对于单行和多行注释，被注释的文字，不会被JVM(虚拟机)解释执行；对于文档注释，是java特有的注释，其中注释内容可以被JDK提供的工具javadoc所解析，生成一套以网页文件形式体现的该程序的说明文档

四. 计算机基础

1. 计算机是由软件和硬件组成

2. 冯诺依曼体系结构：

运算器，控制器，存储器，输入设备，输出设备

3. 软件

　系统软件（OS）

应用软件（APP）

4.快捷键的使用

　win + d: 回到桌面

win + e 打开文件资源管理器

win + r 打开运行提示框

cmd：进入dos

　　　　　mspaint: 画图

calc 计算器

ctrl + c ：复制

　ctrl + v：粘贴

ctrl + x：剪切

ctrl + s ：保存

ctrl + z：撤销

ctrl + y：撤销的撤销

alt + tab：切换工作窗口

5. dos命令：

d: 盘符切换

cd 路径进入目录

md 创建文件夹

dir 显示当前目录下的所有文件和文件夹

五. 练习

1.计算机由哪两部分组成

计算机硬件，计算机软件

2. JRE, JDK, JVM全名是什么以及他们之间的关系

JRE: Java Runtime enviroment java运行环境

JDK： Java development kit java开发工具包

JVM: Java virtual machine java虚拟机

关系：

JDK包含JRE, JRE包含JVM

3. 编译和运行的命令是什么？

编译：javac 文件名

运行：java 类名

4. JVM是跨平台的嘛

是

5.main方法的写法

public static void main(String[] args){}

6. print和println的区别

println：换行打印

print：不换行

7. java中的注释

文档注释：/** 注释内容 */

多行注释：/* 注释内容 */

单行注释： //

Day1 java的基础

Day1 重新学习java的笔记

重新学java

初入大四，开始了秋招，才惶惶察觉自己大学期间什么也没学到，大一大二一直在研究算法，只在杂七杂八的算法比赛得过奖，却没机会去参加ACM算是一个遗憾，~~不过倒是洛谷签到硬生生签了365天~~，编译一直用的C++，然而大学从大三开始的课程却是要用到java，于是大三几乎没再碰过C++，靠着C++基础，转用java，倒是能勉强能用，但是对java只有一个大概的印象。

学校的课程是先从java开始，然后接触javaweb,数据库，再进阶SSM三层架构写一个项目，然后接着教Android开发，到大三下的课设已经是要完成一个既有Android 端又有前端SSM架构的项目，靠着从第一个项目的代码（不知道从哪复制粘贴的），自己倒是照葫芦画瓢，也就是复制粘贴以前的代码，重新修改一下数据库，改一下每一个类及参数，毫无长进的完成每一个课设，全都是临时抱佛脚，迷迷糊糊的看一遍教学视频，至于为什么这样用，倒是没有一个清晰的概念。

到了大四没有任何大型java项目的经验，以这个水平，自觉在秋招没什么底气，于是下定决心在学校期间重新系统的学习一遍java全栈的知识，来弥补自己的不足。

从JavaSE开始

java基础

我的java语言基础一直是依赖C++的语法，对java的细节一直没怎么了解，由于以前写的项目都是用eclipse写的，但是由于这个ide太过老旧且写着不方便，于是决定更换IDEA使用，为了更彻底，更卸载了当初初学java时下载的jdk为15的版本，重新下载java8，也是因为java8用的更多。不过更换了idea后，以前的Maven,springboot等框架也决定重新更改，不过因为不了解idea的操作，决定按部就班的学习，从javase学习开始，慢慢的向后学习，用到的时候再去部署。

注释

java的注释和C++的一样

单行注释： //

多行注释：/* */

文档注释/** */（这个我倒是没在C++用到过）

从后面的学习了解到，文档注释一般用在类、方法和变量上面，用来描述其作用

标识符、关键字

static是新遇到的，倒是没有搞太懂，现在用着是来定义全局变量的？只有加了static后在main里才能直接调用，不加就要在main里New一个这个类后才能方法调用，学习的课程以后会重新讲到，先这样理解。

更多的和C++的标识符一样，int 、float 、double 、long这些用来定义变量类型的标识符

数据类型及扩展

和C++类似，比较基础的知识

进制问题，做算法题也常遇到二进制 0b 八进制 0 十进制十六进制0x

倒是java的浮点数，double和float在很大的数上精度不高，是有限的离散的形式,会舍入误差，所以在用大数浮点数推荐用BigDecimal这个类。

java上的类型转换挺方便，大部分类都有方法来转换，而如int，char等类型可以用在前面加括号的形式来转换。

char a='a';
int b=(int)a;
systerm.out.println(b);
//b=97

变量，常量

命名规则和C++一样，很好理解，尤其是命名的规范也需要注意

1.包名：全小写，如 java.awt.event, test

2.类名：首字母大写，如果由多个单词组成，要求每个单词的首字母都大写，如 HelloWorldApp

3.接口名：命名规则与类名相同。

4.方法名：往往由多个单词合成，第一个为动词，因此动词要全小写，后面的单词首字母大写，如

balanceAccount、isButtonpressed

5.变量名：一般为名词，全小写，如 area，lenth

6.常量名：全大写，如 MAX_INT, YEAR

常量

常量是用final来表示与C++的const不同

运算符

java的运算符与C++几乎一样，很基础。

包基础

包是java要了解的，类似于文件夹一样，是为了更好的组织类。

Javadoc 生成文档

这个也是首次了解到，它从程序源代码中抽取类、方法、成员等注释形成一个和源代码配套的API帮助文档。也就是说，只要在编写程序时以一套特定的标签作注释，在程序编写完成后，通过Javadoc就可以同时形成程序的开发文档了

就是前面了解的文档注释,用来了解方法，类，成员等。

思考

有了C++的基础，Java基础理解上不难，不过此前缺的就是细节上的知识，对我还是很有用的，了解到了新知识。明天继续学习！

java 基础学习 day 04

1. 基本数据类型变量的定义和使用

变量的定义格式：数据类型变量名 = 初始化值

数据类型：byte，short，char，int，long，float，double，boolean.

注意：

定义 long 类型变量的时候，最好直接加 L.

定义 float 类型变量的时候，最好直接加 F.

2. 变量定义的注意事项：

A：变量未赋值，不能直接被使用

B：变量旨在他所属的范围内有效（变量属于他所在的那对大括号）

C：一行上可以定义多个变量，但是不建议

3. 类型转换之隐式转换

我们在做运算的时候，一般要求参与运算的数据类型必须一致.

类型转换：

隐式转换：byte，short，char--int--long--float--double (从低到高）

强制转换：目标类型变量名 =(目标类型)（被转换的数据）；

建议：数据做运算，结果应该是什么类型，就用什么类型接受，不要随意转换类型，否则会有精度的损失。

4.Eclipse 中内容辅助键和快捷键的使用

内容辅助键：Alt+/

A：main 方法

main，然后 alt+/，回车.

B：输出语句

syso，然后 alt+/，回车.

快捷键：

A：注释

单行选中内容，ctrl+/，再来一次就是取消注释

多行选中内容，ctrl+shift+/，取消注释 ctrl+shift+\

B：格式化

ctrl+shift+f

右键 --Source--Format

Java 基础学习 day02

-----01运算符-----

运算符的作用是什么？

把常量或者是变量连接起来的符号。

运算符：对常量或者变量进行操作的符号。

表达式：通过运算符连接起来的式子。

例如：
+ 是运算符，10+20 是表达式
- 是运算符，a - b 是表达式

常用的运算符：

算术运算符、赋值运算符、自增自减运算符、关系运算符、逻辑运算符、三元运算符

算术运算符

符号	作用	说明
-	减	进行减法操作
+	加	对数字进行加法运算，对字符串进行拼接。
*	乘	进行乘法操作
/	除	==整数相除的结果只能是整数，想要得到小数，必须有浮点数参与运算。==
%	取余	==a%b，获得a和b相除的余数。==

算数运算符的基本使用

/*
    算术运算符
*/
public class OperatorDemo01 {
    public static void main(String[] args) {
        //定义两个变量
        int a = 6;
        int b = 4;
        
        System.out.println(a + b);
        System.out.println(a - b);
        System.out.println(a * b);
        System.out.println(a / b);
        System.out.println(a % b);
        //除法得到的是商，取余得到是余数
        
        //整数相除只能得到整数，要想得到小数，必须有浮点数的参与
        System.out.println(6.0 / 4);
    }
}

表达式自动提升

/*
    字符的"+"操作
*/
public class OperatorDemo02 {
    public static void main(String[] args) {
        //定义两个变量
        int i = 10;
        char c = ''A''; //''A''的值是65
        c = ''a''; //''a''的值是97
        c = ''0''; //''0''的值是48
        System.out.println(i + c);
        
        //char ch = i + c;
        //char类型会被自动提升为int类型
        int j = i + c;
        System.out.println(j);
        
        //int k = 10 + 13.14;
        double d = 10 + 13.14;
    }
}

除法运算的时候特点是什么？

byte、char、short参与运算的时候数据类型会自动提升至init类型。
两个不同类型的数据在运算的时候，结果取决于大的数据类型。

//    1. byte\ short\char数据类型在运算的时候会自动提升至int类型
        byte b1 = 1;
        byte b2 = 2;
        int b3 = b1+b2;
        System.out.println(b3);
        
        
        //2.两个不同类型的数据在运算的时候，结果取决于大的数据类型。
        int i = 10;
        double d = 3.0;
        double result4 = i+d;
        System.out.println(result4);
        
        
        
        int a = 10;
        int b =3;
        int result5 = a/b; //3.33333333333
        System.out.println(result5); //3

拓展

【笔试题】
有两个变量定义如下: 
    byte b = 10; 
    short s = 20;
指出下面一段代码中有问题的代码行号（ 1,2,4  ）

    1   short s2 = b + s;   //有问题， 结果是int类型。
    2   short s3 = s + 5;  //有问题， 结果是int类型。
    3   short s4 = 10 + 20; //没问题。，java编译器在编译的时候可以检查到常量的。 
    4   float f = b + 1.0;  //有问题 ， 结果是double类型
    5   double d = s + 1.0F; //没问题

--------------------------------------------------------------

【单选题】以下关于数据类型的转换，说法错误的是（B  ）

A：int a = 1; 
   byte b = 1; 
   System.out.println(a+b); 程序不会报错并且打印2

B：int类型的数据转为double类型，需要强制转换。 

C：int类型转成short砍掉2个字节，可能造成数据丢失。

D：short h = 1; h=h+1; 需要使用强制转换才能编译-成功。

--------字符的+运算--------

字符参与运算的规则：

==将字符换算成编码表里对应的数值进行运算。==

编码表：

计算机底层使用二进制运算，所以文字和符号必须转换成二进制数才能被计算机识别，编码表就是将文字等符号编成对应的数的表格，因为二进制记录起来比较麻烦，所以使用十进制数进行文字编码。

世界上第一张编码表ASCII（美国标准信息交换码）。常用编码表都兼容ASCII码表。

常用的编码：

ASCII编码：美国标准信息交换码，世界上第一张编码表。

GB2312编码：简体中文编码，对常用汉字进行了编码，兼容ASCII。

GBK：加强版的中文编码表，对更多汉字进行了编码，兼容ASCII

UTF-8编码：万国码表，常作为浏览器上的网页编码，可以统一显示各国文字，兼容ASCII。

常见字符对应数：

‘a'' ~ ''z'' : 97 ~ 122

''A'' ~ ''Z'' : 65 ~ 90

''0'' ~ ''9'' : 48 ~ 57

基本汉字：19968 ~ 40869

/*
    字符的"+"操作
*/
public class OperatorDemo02 {
    public static void main(String[] args) {
        //定义两个变量
        int i = 10;
        char c = ''A''; //''A''的值是65
        c = ''a''; //''a''的值是97
        c = ''0''; //''0''的值是48
        System.out.println(i + c);
        
        //char ch = i + c;
        //char类型会被自动提升为int类型
        int j = i + c;
        System.out.println(j);
        
        //int k = 10 + 13.14;
        double d = 10 + 13.14;
    }
}

字符串使用+的特点

/*
    字符串的"+"操作
*/
public class OperatorDemo03 {
    public static void main(String[] args) {
        System.out.println("it" + "heima");
        System.out.println("itheima" + 666);
        System.out.println(666 + "itheima");
        
        System.out.println("华为" + 6 + 66);
        System.out.println(1 + 99 + "年华为");
    }
}

小结

字符串使用+的特点

字符串使用+并不是做加法运算，而是做拼接。
任何数据与字符串使用+的时候结果都是字符串。

练习

以下语句的输出结果是什么？
System.out.println("hello" + 3 + 4);  //  hello34
System.out.println(3 + 4 + "hello");  // 7hello 
System.out.println(3 + 4 + "hello" + 5 + 6); //7hello56
System.out.println(3 + 4 + "hello" + (5 + 6)); 7hello11

--------赋值运算符--------

赋值运算符有哪些？赋值运算符的特点

符号	作用	说明
=	赋值	a=10，将10赋值给变量a
+=	加后赋值	a+=b，将a+b的值给a
-+	减后赋值	a-=b，将a-b的值给a
*=	乘后赋值	a*=b，将a×b的值给a
/=	除后赋值	a/=b，将a÷b的商给a
%=	取余后赋值	a%=b，将a÷b的余数给a

/*    
    赋值运算符
*/
public class OperatorDemo {
    public static void main(String[] args) {
        //把10赋值给int类型的变量i
        int i = 10;
        System.out.println("i:" + i);
        
        // += 把左边和右边的数据做加法操作，结果赋值给左边
        i += 20;
        //i = i + 20;
        System.out.println("i:" + i);
        
        //注意：扩展的赋值运算符底层隐含了强制类型转换
        short s = 10;
        s += 20;
        //s = (short)(s + 20);
        System.out.println("s:" + s);
    }
}

赋值运算符的特点？

赋值运算符在运算的时候隐式进行强制类型转换。

练习1：

//以下代码是否会报错？
short s = 10;

s = s + 10;   //报错， 需要强制类型转换

s+=10;  //不会， 因为赋值运算符隐式维护了强制类型转换。

练习2：

【练习题】以下不属于赋值运算符的是（D，E ）
A：=
B：*=
C：%=
D：++
E：==

自增自减运算符

使用说明

1、++ 、 -- 可以放在变量的前面，也可以放在变量的后面。

单独进行运算时放在前面或者后面，效果一样。

2、参与其他运算的时候：

==a++ ：先将a的值参与其他运算，运算结束后再自身加1。==

==++a ：先将a自身加1，再将自增后的值参与其他运算。==

自减与自增规则相同。

3、最常见用法：单独使用。

/*    
    自增自减运算符
*/
public class OperatorDemo {
    public static void main(String[] args) {
        //定义变量
        int i = 10;
        System.out.println("i:" + i);
        
        //单独使用
        //i++;
        //++i;
        //System.out.println("i:" + i);
        
        //参与操作使用
        //int j = i++;
        int j = ++i;
        System.out.println("i:" + i);
        System.out.println("j:" + j);
    }
}

小结

自增、自减本质上的操作是什么？
- 自增本质上就是操作数+1 比如： int a = 1 ; a++ 相当于 a = a+1
- 自减的本质上就是操作数-1. 比如： int a = 1 ; a-- 相当于 a = a-1
前自增、后自增独立运算与其他操作数运算的特点？
- 独立运算的时候前自增与后自增没有任何的区别。
- 自增与其他操作数在在运算的时候是有区别的：
  - 后自增：先给别人去使用，然后再自增。
  - 前自增：先自增，然后再给比人去使用

--------关系运算符（比较运算符）--------

符号	作用	说明
==	等于	a == b，判断如果a等于b，则为true，否则为false
!=	不等于	a!=b，判断如果a不等于b，则为true，否则为false
>	大于	a>b，如果a大于b，则为true，否则为false
>=	大于等于	a>=b，如果a大于等于b，则为true，否则为false
<	小于	a<b，如果a小于b，则为true，否则为false
<=	小于等于	a<=b，如果a小于等于b，则为true，否则为false

/*
    关系运算符案例代码
*/
public class GuanXiDemo {
    public static void main(String[] args) {
        //定义变量
        int i = 10;
        int j = 20;
        int k = 10;
        
        
        //相等 ==
        System.out.println(i == j);
        System.out.println(i == k);
        System.out.println("--------");
        
        //不等 !=
        System.out.println(i != j);
        System.out.println(i != k);
        System.out.println("--------");

        //大于 >
        System.out.println(i > j);
        System.out.println(i > k);
        System.out.println("--------");
        
        //大于等于 >=
        System.out.println(i >= j);
        System.out.println(i >= k);
        System.out.println("--------");
        
        //如果把 ==写成了=
        //把j的值赋值给了i，然后输出i的值
        System.out.println(i = j);
    }
}

=与==的区别

= 是赋值

== 判断是否等于

--------逻辑运算符--------

逻辑运算符有哪些？

符号	说明	格式	运算结果
&	逻辑与	表达式1 & 表达式2	所有表达式均为true，结果才为true
\|	逻辑或	表达式1 \| 表达式2	任意表达式为true，结果就为true
！	逻辑非	! 表达式	对表达式结果取反
^	逻辑异或	表达式1 ^ 表达式2	左右两边结果不同为true，相同为false

/*
    逻辑运算符
*/
public class OperatorDemo01 {
    public static void main(String[] args) {
        //定义变量
        int i = 10;
        int j = 20;
        int k = 30;
        
        //& 有false则false
        System.out.println((i > j) & (i > k)); //false & false
        System.out.println((i < j) & (i > k)); //true & false
        System.out.println((i > j) & (i < k)); //false & true
        System.out.println((i < j) & (i < k)); //true & true
        System.out.println("--------");
        
        //| 有true则true
        System.out.println((i > j) | (i > k)); //false | false
        System.out.println((i < j) | (i > k)); //true | false
        System.out.println((i > j) | (i < k)); //false | true
        System.out.println((i < j) | (i < k)); //true | true
        System.out.println("--------");
        
        //^ 相同为false，不同为true
        System.out.println((i > j) ^ (i > k)); //false ^ false
        System.out.println((i < j) ^ (i > k)); //true ^ false
        System.out.println((i > j) ^ (i < k)); //false ^ true
        System.out.println((i < j) ^ (i < k)); //true ^ true
        System.out.println("--------");
        
        //!
        System.out.println((i > j)); //false
        System.out.println(!(i > j)); //!false
        System.out.println(!!(i > j)); //!!false
        System.out.println(!!!(i > j)); //!!!false
    }
}

短路与和单与的区别

/*
   短路逻辑运算符
*/
public class OperatorDemo02 {
   public static void main(String[] args) {
      //定义变量
      int i = 10;
      int j = 20;
      int k = 30;
      
      //&& 有false则false
      System.out.println((i > j) && (i > k)); //false && false
      System.out.println((i < j) && (i > k)); //true && false
      System.out.println((i > j) && (i < k)); //false && true
      System.out.println((i < j) && (i < k)); //true && true
      System.out.println("--------");
      
      //|| 有true则true
      System.out.println((i > j) || (i > k)); //false || false
      System.out.println((i < j) || (i > k)); //true || false
      System.out.println((i > j) || (i < k)); //false || true
      System.out.println((i < j) || (i < k)); //true || true
      System.out.println("--------");
      
      //&&和&
      //System.out.println((i++ > 100) & (j++ > 100)); //false & false
      System.out.println((i++ > 100) && (j++ > 100)); //false && false
      System.out.println("i:" + i);
      System.out.println("j:" + j);  
   }
}

小结

什么时候需要使用逻辑运算符？

逻辑运算符是用于连接关系型表达式，两个条件。

public class Demo1{
    
    public static void main(String[] args){
        //年龄
        int age = 15;
        //工作经验经验
        int workAge = 1;
        
        System.out.println(age>=16 & workAge>=1);
    
        
    }
    
}

2.逻辑运算符的规律？

& 并且，左右两边表达式都是true结果才为true。
| 或者，左右两边表达式只有有一个true，结果则为true。
^ 异或，左右两边表达式的结果如果不一样则为true，一样为false。
! 非，取反。

3.短路与和单与的区别?

短路与只要左边的为false，那么直接返回结果false，不会再运算右边的表达式了。
短路或只要左边的表达式为true，那么结果则为true。不会再运算右边的表达式了。

--------三元运算符--------

语法格式：判断表达式 ? 表达式1 : 表达式2;

执行流程：

执行判断表达式，判断结果是boolean类型，为true时执行表达式1并返回结果，false执行表达式2并返回结果。

三元运算符的基本使用(比较两个数的最大值)

/*
    三元运算符
    
    格式：
        关系表达式 ? 表达式1 : 表达式2;

    范例：
        a > b ? a : b;
    
    执行流程：
        首先计算关系表达式的值
        如果值为true，表达式1的值就是运算结果
        如果值为false，表达式2的值就是运算结果
*/
public class OperatorDemo {
    public static void main(String[] args) {
        //定义两个变量
        int a = 10;
        int b = 20;
        
        //获取两个数据中的较大值
        int max = a > b ? a : b;
        
        //输出结果
        System.out.println("max:" + max);
    }
}

案例：两只老虎

/*
    两只老虎
    
    需求：
        动物园里有两只老虎，已知两只老虎的体重分别为180kg、200kg，
        请用程序实现判断两只老虎的体重是否相同。
*/
public class OperatorTest01 {
    public static void main(String[] args) {
        //1：定义两个变量用于保存老虎的体重，单位为kg，这里仅仅体现数值即可。
        int weight1 = 180;
        int weight2 = 200;
        
        //2：用三元运算符实现老虎体重的判断，体重相同，返回true，否则，返回false。
        boolean b = weight1 == weight2 ? true : false;
        
        //3：输出结果
        System.out.println("b:" + b);
    }
}

案例：三只和尚

/*
    三个和尚
    
    需求：
        一座寺庙里住着三个和尚，已知他们的身高分别为150cm、210cm、165cm，
        请用程序实现获取这三个和尚的最高身高。
*/
public class OperatorTest02 {
    public static void main(String[] args) {
        //1：定义三个变量用于保存和尚的身高，单位为cm，这里仅仅体现数值即可。
        int height1 = 150;
        int height2 = 210;
        int height3 = 165;
        
        //2：用三元运算符获取前两个和尚的较高身高值，并用临时身高变量保存起来。
        int tempHeight = height1 > height2 ? height1 : height2;
        
        //3：用三元运算符获取临时身高值和第三个和尚身高较高值，并用最大身高变量保存。
        int maxHeight = tempHeight > height3 ? tempHeight : height3;
        
        //4：输出结果
        System.out.println("maxHeight:" + maxHeight);
    }
}

小结

什么时候需要使用三元运算符？

二选一的时候则需要使用三元运算符。
三元运算符的格式？

关系表达式？值1：值2
三元运算符使用的时候要注意的事项
- 使用三元运算符的时候一定需要定义变量接收结果或者是直接使用结果。

　　三元运算符要注意的事项： 1. 使用三元运算符的时候一定需要定义变量接收结果或者是直接使用结果。

public static void main(String[] args){
    //从a与b两个变量中获取最大值
    int a = 10;
    int b = 20; 
    
    /*
    //方式一: 定义变量接收结果。
    int result = a>b?a:b;
    System.out.println(result);
    */
    
    //方式二： 直接使用结果 
    
    System.out.println("最大值为："+ (a>b?a:b));
}

## Scanner键盘录入

#### 目标

使用Scanner的步骤？ 使用Scanner完成升级三个和尚小案例



#### 随堂代码

**scanner基本使用**

```java
/*
    数据输入：
        导包：
            import java.util.Scanner;
        创建对象：
            Scanner sc = new Scanner(System.in);
        接收数据：
            int x = sc.nextInt();
*/
import java.util.Scanner;

public class ScannerDemo {
    public static void main(String[] args) {
        //创建对象
        Scanner sc = new Scanner(System.in);
        
        //接收数据
        int x = sc.nextInt();
        
        //输出数据
        System.out.println("x:" + x);
    }
}

案例：使用Scanner完成三个和尚

/*
    三个和尚
    
    需求：
        一座寺庙里住着三个和尚，他们的身高必须经过测量得出，请用程序实现获取这三个和尚的最高身高。
*/
import java.util.Scanner;

public class ScannerTest {
    public static void main(String[] args) {
        //身高未知，采用键盘录入实现。首先导包，然后创建对象。
        Scanner sc = new Scanner(System.in);
        
        //键盘录入三个身高分别赋值给三个变量。
        System.out.println("请输入第一个和尚的身高：");
        int height1 = sc.nextInt();
        
        System.out.println("请输入第二个和尚的身高：");
        int height2 = sc.nextInt();
        
        System.out.println("请输入第三个和尚的身高：");
        int height3 = sc.nextInt();
        
        //用三元运算符获取前两个和尚的较高身高值，并用临时身高变量保存起来。
        int tempHeight = height1 > height2 ? height1 : height2;
        
        //用三元运算符获取临时身高值和第三个和尚身高较高值，并用最大身高变量保存。
        int maxHeight = tempHeight > height3 ? tempHeight : height3;
        
        //输出结果。
        System.out.println("这三个和尚中身高最高的是：" + maxHeight +"cm");
    }
}

小结

使用Scanner的步骤？
- 使用Scanner的作用：可以接收键盘录入数字。
- 使用Scanner的步骤
  - 导包 import java.util.Scanner
  - 创建对象 Scanner 变量名 = new Scanner(System.in);
  - 接收数据变量类型变量名= 变量名.nextInt();

--------控制流程语句--------

/*
    顺序结构
*/
public class OrderDemo {
    public static void main(String[] args) {
        System.out.println("开始");
        
        System.out.println("语句A");
        System.out.println("语句B");
        System.out.println("语句C");
        
        System.out.println("结束");
    }
}

小结

什么是顺序结构语句

从上到下按照代码的顺序去执行的语句称作为顺序结构
顺序结构语句的执行特点？

从上到下按照代码的顺序去执行的语句称作为顺序结构

--------if选择分支结构--------

if语句格式1

格式：

if (boolean表达式) {
    语句体;    
}

执行流程：

①首先计算关系表达式的值。

②表达式的值为 true 时执行语句体，为 false 时不执行语句体。

③往下执行 if结构后面的语句内容。

if语句格式2

格式：

if(关系表达式){
    语句体1；
}else{
    语句体2；
}

执行流程：

①首先计算关系表达式的值。

②表达式的值为 true 时执行语句体1，为 false 时执行语句体2。

③继续执行 if-else 结构后面的语句内容。

//需求1：键盘录入一个整数，使用if-else结构该数是奇数还是偶数。
public class IfDemo2{
    public static void main(String[] args){
        
    }
}

//需求2：使用if-else结构求出两个数的较大值
public class IfDemo3{
    public static void main(String[] args){
        int a = 10;
        int b = 20;
       
    }
}

◆ if语句格式3

格式：

if(关系表达式1){
    语句体1；
}else if(关系表达式2){
    语句体2；
}
else{
    语句体n+1；  
}

【注意】：该格式中可以有多个else if结构，也可以没有else结构。

执行流程：

①首先计算关系表达式1的值。

②如果为 true 则执行语句体1，为 false 时计算关系表达式2的值。

③如果为 true 则执行语句体2，为 false 时计算关系表达式3的值，以此类推。

④所有关系表达式都为false时，执行else里的语句体n+1。

//案例：键盘录入一个1~7的整数，输出对应的星期一到星期日。
//导包
import java.util.Scanner;
public class IfTest{
    public static void main(String[] args){
        //创建Scanner对象
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个整数(1~7)：");
        
        //接收键盘录入的整数
        int week = sc.nextInt();
        
        //使用if-elseif结构判断
        if(week==1){
            System.out.println("星期一");
        }else if(week==2){
            System.out.println("星期二");
        }else if(week==3){
            System.out.println("星期三");
        }else if(week==4){
            System.out.println("星期四");
        }else if(week==5){
            System.out.println("星期五");
        }else if(week==6){
            System.out.println("星期六");
        }else if(week==7){
            System.out.println("星期日");
        }else{
            System.out.println("您输入的数字无效！");
        }
    }
}

【练习】以下代码的打印结果是什么？ AA

int a = 10;
int b = 10;
if(a==b){
    System.out.println("AA");
}else if(a==b){
    System.out.println("BB");
}else{
    System.out.println("CC");
}

/*
 * 案例2：
 * 键盘录入学生成绩，根据成绩判断学生属于哪个级别
 * 90-100  优秀
 * 80-90   好
 * 70-80   良
 * 60-70   及格
 * 60以下  不及格
 */
/*
    考试奖励
    
    需求：
        小明快要期末考试了，小明爸爸对他说，会根据他不同的考试成绩，送他不同的礼物，假如你可以控制小明的得分，
        请用程序实现小明到底该获得什么样的礼物，并在控制台输出。
        
    奖励：
        95~100        山地自行车一辆
        90~94        游乐场玩一次
        80~89        变形金刚玩具一个
        80以下        胖揍一顿
*/

import java.util.Scanner;

public class IfTest02 {
    public static void main(String[] args) {
        //小明的考试成绩未知，可以使用键盘录入的方式获取值
        Scanner sc = new Scanner(System.in);
        
        System.out.println("请输入一个分数：");
        int score = sc.nextInt();
        
        //由于奖励种类较多，属于多种判断，采用if...else...if格式实现
        //为每种判断设置对应的条件
        //为每种判断设置对应的奖励
        /*
        if(score>=95 && score<=100) {
            System.out.println("山地自行车一辆");
        } else if(score>=90 && score<=94) {
            System.out.println("游乐场玩一次");
        } else if(score>=80 && score<=89) {
            System.out.println("变形金刚玩具一个");
        } else {
            System.out.println("胖揍一顿");
        }
        */
        
        //数据测试：正确数据，边界数据，错误数据
        if(score>100 || score<0) {
            System.out.println("你输入的分数有误");
        } else if(score>=95 && score<=100) {
            System.out.println("山地自行车一辆");
        } else if(score>=90 && score<=94) {
            System.out.println("游乐场玩一次");
        } else if(score>=80 && score<=89) {
            System.out.println("变形金刚玩具一个");
        } else {
            System.out.println("胖揍一顿");
        }
    }
}

小结

if语句的三种结构的特点与格式？
- 格式一：只能适用于一种情况下去使用
```
if(关系表达式){
    
    符合条件执行的语句；
}
    
```
  ==注意：符合条件的时候如果只有一个语句需要执行，那么可以省略大括号不写==

　　　　　　格式二：符合两种条件下去执行的。

if(关系表达式){
    如果关系表达式是true，则执行语句1
    
}else{
    
      如果关系表达式是false，则执行语句2
}

==if语句的格式二与三元运算符的区别：==

使用三元运算符的时候，三元运算符要求比较之后必须又要有结果值返回，不能是其他的语句。
三元运算符的比较简洁。

//需求： 比较a与b两个变量的大小，如果a大于b,输出a大。 否则输出b大.
        int  a = 10;
        int b =4;
        /*
        
        if(a>b){
            System.out.println("a大");
        }else{
            System.out.println("b大");
        }
         */
        
        //把上述的需求转换为三元运算符
         a>b?a:b;

格式三：符合多种条件

if(条件1){
    符合条件1执行的语句
    
}else if(条件2){
    符合条件2执行的语句
    
}else if(条件3){
    符合条件3执行的语句
    
}....else{
    如果上述条件都不满足的情况执行的语句
}

三种结构的应用场景？

格式一：如果只有一种情况下去使用

格式二：有两种情况下去使用

格式三：有多种情况下去使用

Java 基础学习 day03

--------switch语句--------

switch语句的格式

switch(表达式){
        case 1：
            语句体1；
               break;
        case 值2：
            语句体2；
               break;
        ...
        default 
            语句体n+1；
               break;
}

switch语句的执行流程

1、先计算括号中表达式的值。

2、将结果依次和case后面的值比较，匹配上的就执行case对应的语句体，==遇到break就结束switch结构。==

3、当所有的case值都不匹配时，执行default后面的语句体n+1， default省略break，效果一样。

switch语句的基本使用

/*
 * 需求：根据键盘录入的1-7,输出对应的星期一到星期日
 */
// 导包
import java.util.Scanner;
public class SwitchDemo {

    public static void main(String[] args) {
        // 创建键盘录入对象
        Scanner sc = new Scanner(System.in);
        // 提示用户输入
        System.out.println("请输入一个数字：");
        // 接收用户输入
        int week = sc.nextInt();
        
        // 使用switch结构实现判断
        switch (week) {
            case 1:
                System.out.println("星期一");
                break;
            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;
            default:
                System.out.println("输入的数字有误");
                break;
        }
    }
}

switch语句的穿透性

/*
    春夏秋冬

    需求：
        一年有12个月，分属于春夏秋冬4个季节，键盘录入一个月份，
        请用程序实现判断该月份属于哪个季节，并输出。

    春：3、4、5
    夏：6、7、8
    秋：9、10、11
    冬：12、1、2
*/

import java.util.Scanner;

public class SwitchDemo {
    public static void main(String[] args) {
        //键盘录入月份数据，使用变量接收
        Scanner sc = new Scanner(System.in);
        
        System.out.println("请输入一个月份：");
        int month = sc.nextInt();
    
        //case穿透
        switch(month) {  //4
            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;
            case 12:
            case 1:
            case 2:
                System.out.println("冬季");
                break;
            default:
                System.out.println("你输入的月份有误");
        }        
    }
}

小结

注意：

swith语句的变量的类型只能使用byte、short、 char、 int、String, 枚举
default语句可以不出现。
case后面一定只能是常量

switch语句的执行流程？

- 拿着变量与case后面的每一个常量进行比较，符合条件执行对应的语句。

switch语句的穿透性?

使用switch语句的时候，switch的变量一旦匹配上一个值，然后没有break，那么就会按照代码的顺序从上往下执行，执行的过程中不会再判断，直到遇到break或者是switch语句的结束。

练习1： 键盘输入数字1~5，控制台输出工作日，输入6,7时，输出休息日。

/*
    分析：
        1、导包并创建Scanner对象。
        2、提示用户输入数字
        3、使用nextInt()方法获取键盘录入的整数
        4、使用switch结构判断数字的值，输出对应的内容。
*/
//导包
import java.util.Scanner;
public class SwitchDemo{
    public static void main(String[] args){
        
        // 1、创建Scanner对象。
        Scanner sc = new Scanner(System.in);
        // 2、提示用户输入数字
        System.out.println("请输入一个整数（1~7）：");
        // 3、使用nextInt()方法获取键盘录入的整数
        int week = sc.nextInt();
        
        // 4、使用switch结构判断数字的值，输出对应的内容。
        // 利用case穿透现象优化代码
        switch(week){
            case 1:
            case 2:
            case 3:
            case 4:
            case 5:
                System.out.println("工作日");
                break;
            case 6:
            case 7:
                System.out.println("休息日");
                break;
            default:
                System.out.println("您输入的数字有误！");
                break;
        } 
    }
}

练习2: 以下程序的打印结果是什么？

int y=3;
    switch(2){
        case 2:
            y++; //4
        case 3:
            y++; //5
        default:
            y++; // 6
    }
System.out.println(y); //  6

练习三：以下程序的打印结果是什么？

int y=3;
    switch(4){
        default:
            y++; //  4
        case 2:
            y++; //5
        case 3:
            y++; //6
    }
System.out.println(y); //4  6

if-else if...else 与switch语句的区别

switch语句的结构非常清晰，如果if语句能满足，switch语句也能够满足的情况下，推荐使用switch语句。
如果是属于区间判断，我们建议使用if语句，使用switch语句太麻烦了。
switch语句的效率比if语句的高。

--------for循环语句--------

for循环格式：

for (初始化语句; 条件判断语句; 条件控制语句) {
    循环体语句;
}

//案例：for循环打印5次HelloWorld
for(int i=1; i<=5; i++){
    System.out.println("HelloWorld");
}

执行流程：

1、执行初始化语句：int i = 1==（只会执行一次）==。

2、执行条件判断语句 i<=5，如果为true，执行循环体语句，如果为false，则结束循环。

3、执行循环体语句： System.out.println("HelloWorld");

4、执行条件控制语句：i++

5、回到第2步继续往下执行。

【案例1】打印1~5，5~1

//【案例1】打印1~5，5~1
public class ForDemo{
    public static void main(String[] args){
        //1~5
        for(int i=1; i<=5; i++){
            System.out.println(i);
        }
        
        System.out.println("-------------");
        
        //5~1
        for(int i=5; i>=1; i--){
            System.out.println(i);
        }
    }
}

案例2】求1~5的整数和

public class ForDemo2{
    public static void main(String[] args){
        int sum= 0;
        for(int i=1; i<=5; i++){
            //int sum= 0; //不能放到此处，每次对sum重置
            sum+=i;
           
        }
        //循环结束，打印求和结果
        System.out.println(sum);
    }
}

【案例3】求1~100之间的偶数和

/*
    求偶数和
    
    需求：
        求1-100之间的偶数和，并把求和结果在控制台输出
*/
public class ForTest03 {
    public static void main(String[] args) {
        //求和的最终结果必须保存起来，需要定义一个变量，用于保存求和的结果，初始值为0
        int sum = 0;
        
        //对1-100的数据求和与1-5的数据求和几乎完全一样，仅仅是结束条件不同
        for(int i=1; i<=100; i++) {
            //对1-100的偶数求和，需要对求和操作添加限制条件，判断是否是偶数
            if(i%2 == 0) {
                sum += i;
            }
        }
        
        //当循环执行完毕时，将最终数据打印出来
        System.out.println("1-100之间的偶数和是：" + sum);
    }
}

小结

for循环语句的格式？

for(初始化语句；循环条件判断语句；条件控制语句){

要循环语句

}

public class Demo {
public static void main(String[] args) {
    
    for(int i = 1 ; i<=5 ; i++){
        System.out.println("hello world");
    }
    
}
}

for循环语句的执行流程？

----------------第一轮循环-----------------------------
- ==初始化语句==
- 循环条件判断语句
- 循环语句
- 循环条件控制语句

----------------第二轮循环-----------------------------

循环条件判断语句
循环语句
循环条件控制语句

使用for循环完成水仙花数

水仙花数：

水仙花数是一个三位数
水仙花数 = 个位的三次方 + 十位三次方+ 百位的三次方

123 = 3 * 3 * 3 + 2* 2 * 2 + 1* 1 *1 = 27+8 +1 = 36 不是水仙花数

153 = 3 * 3 * 3 + 5* 5 * 5 + 1* 1 *1 = 27 + 125 +1= 153 是水仙花数

/*
    【案例4】控制台打印水仙花数
    步骤:
        1 for循环获取所有三位数
            for(int i=100; i<=999; i++)
        2 得到每个三位数的个,十,百位上的数字
            int ge = i%10;
            int shi = i/10%10;
            int bai = i/100%10;
        3 判断是否是水仙花数 : 个, 十, 百位立方和等于该三位数本身
            153 = 1*1*1 + 5*5*5 + 3*3*3 =1 + 125 +27
            if( i == (ge*ge*ge + shi*shi*shi + bai*bai*bai) )
        4 打印水仙花数
            System.out.println(i);
*/
public class ForDemo4 {
    public static void main(String[] args) {
        
        // 1. for循环获取所有三位数
    
        for(int i=100; i<1000; i++) {
            
            // 2. 得到每个三位数的个,十,百位上的数字
            int ge = i%10;
            int shi = i/10%10;
            int bai = i/100;
            
            // 3. 判断是否是水仙花数 : 个, 十, 百位立方和等于该三位数本身
            if(ge*ge*ge + shi*shi*shi + bai*bai*bai == i) {
                //4. 打印水仙花数
                System.out.println(i);
                
            }
        }
    }
}

案例：统计水仙花数的个数

/*
    【案例5】统计水仙花数的个数
*/
public class ForDemo5 {
    public static void main(String[] args) {
        //定义统计变量
        int count = 0;
        
        // 1. for循环获取所有三位数
        for(int i=100; i<1000; i++) {
            
            // 2. 得到每个三位数的个,十,百位上的数字
            int ge = i%10;
            int shi = i/10%10;
            int bai = i/100;
            
            // 3. 判断是否是水仙花数 : 个, 十, 百位立方和等于该三位数本身
            if(ge*ge*ge + shi*shi*shi + bai*bai*bai == i) {
                //System.out.println(i);
                //4. 统计个数
                count++;
            }
        }
        // 5. 循环结束打印个数
        System.out.println(count);
    }
}

for循环的死循环写法。

/*
for循环的死循环格式：
    
    for(;;){
        
    }

*/    

import java.util.Scanner;

public class Demo2 {
    public static void main(String[] args) {
        for(;;){
            System.out.println("Hello");
        }

    
    }
}

while循环语句

while循环的格式

初始化语句;
while(条件判断语句){
    循环体语句;
    条件控制语句;
}

while循环基本使用

public class WhileDemo {
    public static void main(String[] args) {
        //需求：在控制台输出5次"HelloWorld"
        //for循环实现
        for(int i=1; i<=5; i++) {
            System.out.println("HelloWorld");
        }
        System.out.println("--------");
        
        //while循环实现
        int j = 1;
        while(j<=5) {
            System.out.println("HelloWorld");
            j++;
        }
        
    }
}

案例：世界最高山峰是珠穆朗玛峰(8844.43米=8844430毫米)，假如我有一张足够大的纸，它的厚度是0.1毫米，请问，我折叠多少次，可以折成珠穆朗玛峰的高度?

/*
    珠穆朗玛峰
    
    需求：
        世界最高山峰是珠穆朗玛峰(8844.43米=8844430毫米)，假如我有一张足够大的纸，它的厚度是0.1毫米。
        请问，我折叠多少次，可以折成珠穆朗玛峰的高度?
*/
public class WhileTest {
    public static void main(String[] args) {
        //定义一个计数器，初始值为0
        int count = 0;
        
        //定义纸张厚度
        double paper = 0.1;
        
        //定义珠穆朗玛峰的高度
        int zf = 8844430;
        
        //因为要反复折叠，所以要使用循环，但是不知道折叠多少次，这种情况下更适合使用while循环
        //折叠的过程中当纸张厚度大于珠峰就停止了，因此继续执行的要求是纸张厚度小于珠峰高度
        while(paper <= zf) {
            //循环的执行过程中每次纸张折叠，纸张的厚度要加倍
            paper *= 2;
            
            //在循环中执行累加，对应折叠了多少次
            count++;
        }
        
        //打印计数器的值
        System.out.println("需要折叠：" + count + "次");
    }
}

小结

1 清楚while循环的格式

初始化语句;
while(条件判断语句){
    循环体语句;
    条件控制语句;
}


while(条件判断语句){
    循环语句
}

2 while的执行流程。

每次执行完循环体语句都会回到条件判断语句判断一把

do_while循环语句（了解即可）

do_while格式

初始化语句;
do {
    循环体语句;
    条件控制语句;
}while(条件判断语句);

/*
    do...while语句

    基本格式：
        do {
            循环体语句;
        }while(条件判断语句);
        
    完整格式：
        初始化语句;
        do {
            循环体语句;
            条件控制语句;
        }while(条件判断语句);

    执行流程：        
        1:执行初始化语句
        2:执行循环体语句
        3:执行条件控制语句
        4:执行条件判断语句，看其结果是true还是false
            如果是false，循环结束
            如果是true，继续执行
        5:回到2继续
 */
public class DoWhileDemo {
    public static void main(String[] args) {
        //需求：在控制台输出5次"HelloWorld"
        //for循环实现
        for(int i=1; i<=5; i++) {
            System.out.println("HelloWorld");
        }
        System.out.println("--------");
        
        //do...while循环实现
        int j = 1;
        do {
            System.out.println("HelloWorld");
            j++;
        }while(j<=5);
        
    }
}

小结

1 清楚do_while循环语句格式

初始化语句
do{
   循环体语句
   控制循环的次数语句
}while(循环条件语句);

2do_while循环的特点

第一次循环的时候不管条件是否满足，至少会执行一次。

三种循环的区别

for

while

do-while

特点

先判断，再执行

先执行，后判断（至少执行一次）

初始化变量

for循环外无法使用初始化变量

循环结束后，初始化变量能继续使用

适用场景

循环次数确定的情况

循环次数不确定的情况

循环至少需要执行一次

依次推荐使用：for循环、while循环、do-while循环

/*
    三种循环的区别
 */
public class LoopTest {
    public static void main(String[] args) {
        /*
        //for循环
        for(int i = 3; i<3; i++) {
            System.out.println("我爱Java");
        }
        System.out.println("--------");
        
        //while循环
        int j = 3;
        while(j<3) {
            System.out.println("我爱Java");
            j++;
        }
        System.out.println("--------");
        
        //do...while循环
        int k = 3;
        do {
            System.out.println("我爱Java");
            k++;
        }while(k<3);
        */
        
        /*
        //for循环
        for(int i = 1; i<3; i++) {
            System.out.println("我爱Java");
        }
        //System.out.println(i);
        System.out.println("--------");
        
        //while循环
        int j = 1;
        while(j<3) {
            System.out.println("我爱Java");
            j++;
        }
        System.out.println(j);
        System.out.println("--------");
        */
        
        //死循环
        /*
        for(;;) {
            System.out.println("for");
        }
        */
        
        /*
        while(true) {
            System.out.println("while");
        }
        */
        
        do {
            System.out.println("do...while");
        }while(true);
        
        
    }
}

三种循环语句的格式

for(初始化语句；循环条件判断语句；循环次数控制语句){

循环体语句

}

初始化语句

while(循环条件判断语句){

循环体语句

循环次数的控制语句

}

初始化语句

do{

循环体语句

循环次数的控制语句

}while(循环条件判断语句)

--------跳转控制语句(break关键字、continue关键字)--------

/*
    continue:用在循环中，基于条件控制，跳过某次循环体内容的执行，继续下一次的执行
    break:用在循环中，基于条件控制，终止循环体内容的执行，也就是说结束当前的整个循环
*/
public class ControlDemo {
    public static void main(String[] args) {
        for(int i = 1; i<=5; i++) {
            if(i%2 == 0) {
                //continue;
                break;
            }
            
            System.out.println(i);
        }
    }
}

小结

break语句的作用？

break结束整个循环
continue的作用？

continue跳过本次的循环，继续下一次

练习1：控制台输出1-10，打印的过程中，不要3的倍数

/*
需求：控制台输出1-10，打印的过程中，不要3的倍数


分析： 
    1. 利用for循环语句打印1-10
    2. 判断当前的数字是否为3的倍数，如果是3的倍数，跳过。
    3. 如果没有跳过的数字则输出即可。
*/    

import java.util.Scanner;

public class Demo2{
    public static void main(String[] args) {
        //1. 利用for循环语句打印1-10
        for(int i=1 ; i<=10 ; i++){
            //2. 判断当前的数字是否为3的倍数，如果是3的倍数，跳过。
            if(i%3==0){
                continue;//跳过本次循环
            }
            //3. 如果没有跳过的数字则输出即可。
            System.out.println(i);
        }
        
        
    }
}

嵌套循环

/*
    循环嵌套：
        循环语句中包含循环语句
    
    需求：
        在控制台输出一天的小时和分钟
        
        分钟和小时的范围：
            分钟：0 <= minute < 60
            小时：0 <= hour < 24
*/
public class ForForDemo {
    public static void main(String[] args) {
        /*
        System.out.println("0时0分");
        System.out.println("0时1分");
        System.out.println("0时2分");
        System.out.println("0时3分");
        System.out.println("--------");
        System.out.println("1时0分");
        System.out.println("1时1分");
        System.out.println("1时2分");
        System.out.println("1时3分");
        System.out.println("--------");
        System.out.println("2时0分");
        System.out.println("2时1分");
        System.out.println("2时2分");
        System.out.println("2时3分");
        */
        
        //循环改进
        /*
        for(int minute=0; minute<4; minute++) {
            System.out.println("0时" + minute + "分");
        }
        System.out.println("--------");
        
        for(int minute=0; minute<4; minute++) {
            System.out.println("1时" + minute + "分");
        }
        System.out.println("--------");
        
        for(int minute=0; minute<4; minute++) {
            System.out.println("2时" + minute + "分");
        }
        System.out.println("--------");
        */
        
        //外循环控制小时的范围，内循环控制分钟的范围
        /*
        for(int hour=0; hour<3; hour++) {
            for(int minute=0; minute<4; minute++) {
                System.out.println(hour + "时" + minute + "分");
            }
            System.out.println("--------");
        }
        */
        
        for(int hour=0; hour<24; hour++) {
            for(int minute=0; minute<60; minute++) {
                System.out.println(hour + "时" + minute + "分");
            }
            System.out.println("--------");
        }
    }
}

小结

什么是嵌套循环

循环中的循环体语句是另外一个循环。
嵌套循环的执行流程是如何？

外层循环执行一次，内层循环要执行完毕。
嵌套循环的执行次数?

次数 = 外层循环的次数* 内层循环的次数

--------Random随机数--------

Random类的作用？

Random是java提供的工具类，位于【 java.util 】包下，==用于产生随机数。==

Random类的使用步骤？

1、导包 import java.util.Random;

2、创建对象 Random r = new Random();

3、产生随机数 int num = r.nextInt(100);

/*
    Random
    
    作用：
        用于产生一个随机数

    使用步骤：
        1:导包
            import java.util.Random;
        2:创建对象
            Random r = new Random();
        3:获取随机数
            int number = r.nextInt(10);
            获取数据的范围：[0,10) 包括0,不包括10
*/

import java.util.Random;

public class RandomDemo {
    public static void main(String[] args) {
        //创建对象
        Random r = new Random();
        
        //用循环获取10个随机数
        for(int i=0; i<10; i++) {
            //获取随机数
            int number = r.nextInt(10);
            System.out.println("number:" + number);
        }
        
        //需求：获取一个1-100之间的随机数
        int x = r.nextInt(100) + 1;
        System.out.println(x);
    }
}

小结

使用Random获取随机数的步骤

导包 import java.util.Random
创建对象 Random 变量名 = new Random（）；
调用对象的方法产生随机数变量名.nextInt(范围值) 产生随机数的范围：0~范围值-1

猜数字游戏

目标

使用Random完成猜数字游戏

/*
    猜数字

    需求：
        程序自动生成一个1-100之间的数字，使用程序实现猜出这个数字是多少？
        当猜错的时候根据不同情况给出相应的提示
        
        如果猜的数字比真实数字大，提示你猜的数据大了
        如果猜的数字比真实数字小，提示你猜的数据小了
        如果猜的数字与真实数字相等，提示恭喜你猜中了
*/

import java.util.Random;
import java.util.Scanner;

public class RandomTest {
    public static void main(String[] args) {
        //要完成猜数字的游戏，首先需要有一个要猜的数字，使用随机数生成该数字，范围1到100
        Random r = new Random();
        int number = r.nextInt(100) + 1;
        
        
        //使用程序实现猜数字，每次均要输入猜测的数字值，需要使用键盘录入实现
        Scanner sc = new Scanner(System.in);
        
        while(true) {
            System.out.println("请输入你要猜的数字：");
            int guessNumber = sc.nextInt();
            
            //比较输入的数字和系统产生的数据，需要使用分支语句。这里使用if..else..if..格式，根据不同情况进行猜测结果显示
            if(guessNumber > number) {
                System.out.println("你猜的数字" + guessNumber + "大了");
            } else if(guessNumber < number) {
                System.out.println("你猜的数字" + guessNumber + "小了");
            } else {
                System.out.println("恭喜你猜中了");
                break;
            }
        }
        
    }
}

小结

猜数字游戏的步骤
- 先产生一个随机。
- 提示用户录入猜测的数字。
- 判断随机数与猜测的数字对比，给用户相应的提示。

我们今天的关于零基础学习java------day1------计算机基础以及java的一些简单了解和《零基础学java》的分享就到这里，谢谢您的阅读，如果想了解更多关于Day1 java的基础、java 基础学习 day 04、Java 基础学习 day02、Java 基础学习 day03的相关信息，可以在本站进行搜索。

本文标签：