Java上（2024尚硅谷）

day01.[环境变量,HelloWorld]

1.会常用的dos命令
2.会安装java所需要的环境(jdk)
3.会配置java的环境变量
4.知道java开发三步骤
5.会java的入门程序(HelloWorld)
6.会三种注释方式
7.知道Java入门程序所需要注意的地方
8.知道println和print的区别

第一章 Java概述

1.1 JavaSE课程体系介绍

• 第一部分：计算机编程语言核心结构：数据类型、运算符、流程控制、数组、…

• 第二部分：Java面向对象核心逻辑：类和对象、封装、继承、多态、抽象、接口、…

• 第三部分：JavaSE核心高级应用：集合、I/O、多线程、网络编程、反射机制、…

• 第四部分：Java新特性：Lambda表达式、函数式编程、新Date/Time API、接口的默认、静态和私有方法、…

• 第五部分：MySQL/JDBC核心技术：SQL语句、数据库连接池、DBUtils、事务管理、批处理、…

1.2 计算机语言介绍（了解）

计算机编程语言是什么

所谓计算机编程语言，就是人们使用编程语言对计算机下达的命令，让计算机完成人们需要的功能。

翻译:所谓的计算机编程语言,就是计算机能看懂的语言,我们需要学习这些计算机编程语言,给计算机下达指令,让计算机给我们完成一些功能

计算机语言发展

• 第一代：机器语言(计算机很庞大,都是0和1组成的指令,而且需要同时按下多个键才能完成一个指令,而且用0和1组成的一个一个指令,所以工程师们就要记住0和1的各种组合以及对应的指令)

• 第二代：汇编语言(面向机器的语言,因为直接面对机器需要记一些 0 和1 的指令,很痛苦,所以就出现了很多助记词,比如:add.汇编语言现在还在使用,接近于机器语言,越接近机器语言,速度越快,而且最终还是转成0和1存储)

• 第三代：高级语言(更接近我们人类语言,常见的有很多,比如C语言,java等)

  不管是第几代语言,最终都会向0和1靠近,因为CPU只认识0和1
  电脑上所有的内容,都是通过CPU将0和1转换而来的    
  

1.3 Java语言概述（了解）

Java生态圈

**Java是目前应用最为广泛的软件开发平台之一。**随着Java以及Java社区的不断壮大，Java 也早已不再是简简单单的一门计算机语言了，它更是一个平台、一种文化、一个社区。

**作为一个平台，**Java虚拟机扮演着举足轻重的作用。除了 Java语言，任何一种能够被编译成字节码的计算机语言都属于Java这个平台。Groovy、Scala、 JRuby、Kotlin等都是Java平台的一部分，它们依赖于Java虚拟机，同时，Java平台也因为它们变得更加丰富多彩。而且Java还可以跨平台

**作为一种文化，**Java几乎成为了 “开源”的代名词。在Java程序中，有着数不清的开源软件和框架。如Tomcat、Struts, Hibernate, Spring,MyBatis等。就连JDK和JVM自身也有不少开源的实现，如OpenJDK、Apache Harmony。可以说，“共享”的精神在Java世界里体现得淋漓尽致。

**作为一个社区，**Java拥有全世界最多的技术拥护者和开源社区支持，有数不清的论坛和资料。从桌面应用软件、嵌入式开发到企业级应用、后台服务器、中间件，都可以看到Java的身影。其应用形式之复杂、参与人数之众多也令人咋舌。可以说，Java社区已经俨然成为了一个良好而庞大的生态系统。其实这才是Java最大的优势和财富。

Java 是最好的语言吗？

不是，因为在每个领域都有更合适的编程语言。

• C 语言无疑是现代计算机软件编程语言的王者，几乎所有的操作系统都是 C 语言写成的。C里面有一个编译器,会将系统软件变成机器语言,让硬件识别,和硬件做交互.C++ 是面向对象的 C 语言，一直在不断的改进。

• JavaScript 是能运行在浏览器中的语言，丰富的前端界面离不开 Javascript 的功劳。近年来的 Node.js 又在后端占有一席之地。

• Python 用于系统管理，并通过高性能预编译的库，提供 API 来进行科学计算，文本处理等，是 Linux 必选的解释性语言。现在Python也被用于web开发、科学计算和统计、人工智能、网络爬虫等

• Ruby 强于 DSL（领域特定语言），程序员可以定义丰富的语义来充分表达自己的思想。

• Erlang 就是为分布式计算设计的，能保证在大规模并发访问的情况下，保持强壮和稳定性。

• Go 语言内置了并发能力，可以编译成本地代码。当前新的网络相关项目，很大比例是由 Go 语言编写的，如 Docker、Kubernetes 等。

• 编写网页用 PHP，函数式编程有 Lisp，编写 iOS 程序有 Swift/Objective-C。

• R的思想是：它可以提供一些集成的统计工具，但更大量的是它提供各种数学计算、统计计算的函数，从而使使用者能灵活机动的进行数据分析，甚至创造出符合需要的新的统计计算方法

• SQL 是用于访问和处理数据库的标准的计算机语言， 这类数据库包括：MySQL，Oracle, Sybase, SQL Server, DB2, Access 等等

一句话概括，能留在排行榜之上的语言，都是好的语言，在其所在的领域能做到最好。

Java语言发展历史

Java诞生于SUN（Stanford University Network），09年SUN被Oracle（甲骨文）收购。

Java之父是詹姆斯.高斯林(James Gosling)。

詹姆斯·高斯林等人于1990年代初开发Java语言的雏形，最初被命名为Oak，目标设置在家用电器等小型系统的程序语言，应用在电视机、电话、闹钟、烤面包机等家用电器的控制和通信。由于这些智能化家电的市场需求没有预期的高，Sun公司放弃了该项计划。随着1990年代互联网的发展，Sun公司看见Oak在互联网上应用的前景，于是改造了Oak，于1995年5月以Java的名称正式发布。Java伴随着互联网的迅猛发展而发展，逐渐成为重要的网络编程语言。

1996年发布JDK1.0版。

目前最新的版本是Java17。我们学习的Java8以及jdk17。

发行版本	发行时间	备注
Java	1995.05.23	Sun公司在Sun world会议上正式发布Java和HotJava浏览器
Java 1.0	1996.01.23	Sun公司发布了Java的第一个开发工具包
Java 1.1	1997.02.19
Java 1.2	1998.12.08	拆分成：J2SE（标准版）、J2EE（企业版）、J2ME（小型版）
Java 1.3	2000.05.08
Java1.4	2004.02.06
Java 5.0	2004.09.30	①版本号从1.4直接更新至5.0；②平台更名为JavaSE、JavaEE、JavaME
Java 6.0	2006.12.11	2009.04.20 Oracle宣布收购SUN公司
Java 7.0	2011.07.02
Java 8.0	2014.03.18
Java 9.0	2017.09.22	①每半年更新一次；②Java 9.0开始不再支持windows 32位系统
Java 10.0	2018.03.21
Java 11.0	2018.09.25	JDK安装包取消独立JRE安装包，长期支持版本
Java 12.0	2019.03.19
Java 13.0	2019.9.18
Java 14.0	2020.3.17

Google和Oracle的侵权事件:

Google 和 Oracle 纠缠多年的“Java 侵权案”又有了新的判决结果。Google 在此次对决中败诉，并可能需要支付高达88亿美元的赔偿金。这个案件还引发关于 API（应用程序编程接口）是否应该受版权保护的争议。

其实早在2010年8月，Oracle 就已经向法院起诉 Google 侵权，声称 Google 在开发 Android 平台时未经授权就使用了 Oracle 的 Java 应用编程接口数据包。

另外，虽然 Google 当年为避免版权问题而重写了 Java API，却意外地使用了和 Oracle JDK 相同的一小段代码，这使得 Google 陷入不利的局面。

正是由于 Google 在 Android 平台上使用 Java 时并未和 Sun 公司达成授权协议，造成了巨大的隐患，尤其是在 Oracle 收购 Sun 公司之后。

Java技术体系平台

• JavaSE（Java Platform, Standard Edition标准版）：允许您在桌面和服务器上开发和部署Java应用程序。Java提供了丰富的用户界面、性能、多功能性、可移植性和当今应用程序所需的安全性。
• JavaEE（Java Platform, Enterprise Edition企业版）：是为开发企业环境下的应用程序提供的一套解决方案，主要针对于Web应用程序开发。
• JavaME（Java Platform, Micro Edition 小型版）：为互联网上的嵌入式和移动设备上运行的应用提供了一个健壮、灵活的环境：微控制器、传感器、网关、移动电话、个人数字助理（PDA）、电视机顶盒、打印机等等。JavaME包括灵活的用户界面、健壮的安全性、内置的网络协议，以及支持动态下载的网络和离线应用程序。基于JavaME的应用程序在许多设备上都是可移植的，但是利用了每个设备的本机功能。
  • Java Embedded(Im’bedId): 用于解锁物联网的智能设备的价值：
    通过远程市场更新和刷新功能延长产品生命周期和价值；
    利用Java的可伸缩性、健壮性、可移植性和全套功能，提高生产效率，降低成本，缩短上市时间；
    在边缘启用快速数据功能；
  • Java Card：使安全元件（如智能卡和其他防篡改安全芯片）能够承载采用Java技术的应用程序。Java card提供了一个安全的、可互操作的执行平台，它可以在一个资源受限的设备上存储和更新多个应用程序，同时保持最高的认证级别和与标准的兼容性。
  • Java TV：是一种基于JavaME的技术，它为开发在tv和机顶盒设备上运行的java应用程序提供了一个性能良好、安全且易于实现的解决方案。使用Java TV运行时，开发人员可以轻松创建应用程序，例如电子节目指南（EPG）、视频点播（VOD）客户端、游戏和教育应用程序、用于访问Internet数据的应用程序（例如天气、新闻播报器、社交网络）以及大多数蓝光光盘标题上的用户界面和奖金内容。

1.4 什么是软件开发

1.概述:
  软件开发是根据用户要求建造出软件系统或者系统中的软件部分的过程
  软件开发是一项包括需求捕捉、需求分析、设计、实现和测试的系统工程
  软件一般是用某种程序设计语言来实现的。通常采用软件开发工具可以进行开发
  
2.我们将来主要从事软件开发中各个环节的哪个环节呢?实现
  
3.我们将来主要用什么程序设计语言来开发呢? java语言 sql语言  js

第二章.Java语言前言

1.字节

1.字节:计算机中存储数据的最小存储单元(计量单位),用byte或者B表示
  二进制位:用bit(比特)表示
  8个二进制位代表一个字节 
           
2.存储单元之间的转换:
  8bit = 1B
  1024B = 1KB
  1024KB = 1MB
  1024MB = 1GB
  1024GB = 1TB
      
  PB   EB  ZB ...    

2.常用的dos命令

1.打开dos命令窗口:
  win+r -> 输入cmd -> 回车

作用	命令
切换盘符	盘符名: -> 回车 盘符名不区分大小写,但是计算机上必须有指定的盘符
查看当前路径下的文件或者文件夹	dir
进入到指定文件夹下	cd 文件夹名字
进入到多级文件夹下	cd 文件夹名字文件夹名字
退到上一级目录	cd…或者 cd …
直接退到磁盘位置(退到根目录)	cd或者cd
清屏	cls
退出黑窗口	exit
创建文件夹	mkdir 文件夹名
创建多级文件夹	mkdir 文件夹名文件夹名
删除文件夹	rd 文件夹名 注意:删除的文件夹必须是空的 不走回收站
删除文件	del 文件名.后缀名 不走回收站
批量删除文件	del *.后缀名

1.如何区分正斜杠和反斜杠:

/:正斜杠

:反斜杠

2.快速打开该目录对应的dos命令窗口:

a.选中路径

b.输入cmd -> 回车

3.按上下箭头,切换之前输入过的命令

4.在dos命令窗口中,可以输入文件夹名或者文件名的一部分,按 -> tab键 -> 自动补全文件夹名或者文件名

第三章.Java所需要的环境

1.jvm和跨平台

1.jvm(java虚拟机):java运行程序的假想计算机,主要用来运行java程序的

2.跨平台:java代码可以在不同的操作系统上运行(一次编写,到处运行)
  跨:跨越
  平台:操作系统 -> windows linux mac os  
      
3.关系:java程序想要在不同的操作系统上运行,实现跨平台,就需要安装不同版本的jvm      

2.JDK和JRE

1.jdk:(Java Development Kit):java开发工具包,包含了jre
  javac 编译工具
  java 运行工具
  jdb  调试工具
  jhat 内存分析工具
  ...  
  
2.jre:(Java Runtime Environment):java运行环境,包含了jvm以及后面开发用到的核心类库
    
3.jdk和jre以及jvm的关系:
  jdk包含了jre,jre包含了jvm,所以我们只需要安装jdk即可

但是从jdk9开始jdk目录中就没有单独的jre目录了,因为jre作为一个运行时,里面不需要包含太多的东西浪费空间,降低运行效率,在jdk9的时候引用模块化的技术,让开发者能按照自己的应用创建一个最小的运行时(比如一个微服务的部署应用仅仅需要一个非常小的runtime,而不是像以前一样不管应用复杂还是简单,都需要一个近百兆的jre运行)这样提高了运行效率

2.1.jdk安装

1.下载:www.oracle.com

 1.安装:双击 -> 选择安装路径(安装路径上不要有中文,不要有空格)
 2.一定要记住:以后所有开发相关的安装路径上都不要有中文和空格    

测试:进入到jdk的bin路径下,打开对应dos命令窗口

输入javac(编译命令)和java(运行命令)

2.2.环境变量的配置

1.问题:将来我们需要创建一个java文件写代码,然后编译和运行的时候需要打开此java文件所在的目录,java文件的目录如果和javac以及java命令所在的bin目录不一致,那么javac和java命令就用不了了,毕竟javac和java命令在bin目录下,所以难道我们将来必须将所有的java文件都放到bin目录下吗?
  那么我们能不能在任意目录下都能使用javac和java命令呢?能,需要配置环境变量
    
2.配置环境变量的目的:在任意路径下都可以随意使用javac和java命令进行对java代码的编译和运行    

方式1:直接将jdk的bin路径粘贴到path中 -> 不推荐

方式2:极力推荐
     配置JAVA_HOME

jdk安装之后,自带环境变量配置->javapath(可以删除)->推荐使用JAVA_HOME

可能出现的问题:电脑重启之后,环境变量失效了

1.解决问题1:点到环境变量中,啥都不要做,直接点一下确定

2.解决问题2:直接将bin路径粘进去

当然,后面学了idea之后,不会出现这种问题了

第四章.Java第一个程序的开发

1.开发三步骤

1.编写:
  a.创建一个文本文档,将后缀名改成.java,变成一个java文件
  b.注意:我们需要将文件的后缀名显示出来  
      
2.编译:
  a.命令:javac java文件名.java
  b.注意:javac会将java文件编译,生成一个.class文件(字节码文件),jvm运行只认class文件
      
3.运行:
  a.命令:java class文件名(不需要带后缀名了)

2.编写HelloWorld

public class Demo01HelloWorld{
	public static void main(String[] args){
		System.out.println("HelloWorld");
	}
}

编译:
  javac java文件名.java

运行:
  java class文件名(不要带后缀名了)

3.注释

1.概述:对代码的解释说明
2.分类:
  a.单行注释:
    //注释内容

  b.多行注释:
    /*
      注释内容
    */

  c.文档注释:
    /**
      注释内容
    */

//单行注释 class后面的名字要和java文件名一致
public class Demo01HelloWorld{
    /*
	  多行注释:
	    main是一个方法,是程序的入口,jvm运行程序要找main当入口
		执行程序
	*/
	public static void main(String[] args){
	    /**
		  文档注释:
		    下面的语句是输出语句
		*/
		System.out.println("HelloWorld");
	}
}

1.文档注释作用:将来我们给别人一个开发好的类,如何让别人快速对我们写的代码了解呢?
  我们的文档注释中的内容可以根据javadoc命令生成一个文档(API文档)
  别人拿到这个文档,就能快速对此类以及类中实现的功能,进行快速了解
    
2.命令:javadoc -d 要生成的文件夹名字 -author -version 文件名.java    

/**
  此类是一个java的入门程序
  @author 涛哥
  @version v1.0
*/
public class Demo02HelloWorld{
	/**
	  main是一个方法,是程序的入口
	  jvm执行java代码,都是从main方法开始执行
	*/
	public static void main(String[] args){
		System.out.println("helloworld");
	}
}

1.右键中没有创建文件或者文件夹的选项 -> 所在的磁盘有权限问题

2.右键盘符 -> 属性 -> 安全 -> 编辑 -> 修改权限(完全控制)

4.第一个Java程序中每一句话的解释以及注意事项

/*
  1.public class Demo03HelloWorld:定义一个类
  2.class:代表的就是类,类是java程序最基本的组成单元,所有代码都需要在类中写
  3.class后面跟的名字叫做类名,类名要和java文件名保持一致
*/
public class Demo03HelloWorld{
	/*
	  public static void main(String[] args)
	  叫做main方法,是程序的入口
	  jvm执行代码,会从main方法开始执行
	*/
	public static void main(String[] args){
		//打印语句(输出语句),会将我们想要输出的内容打印到控制台上
		System.out.println("helloworld");
	}
}

注意事项:
  1.类名要和java文件名保持一致
  2.程序中的标点符号必须是英文的  
  3.不要将main写成mian
  4.System和String的首字母s要大写
  5.每个单词写完来个空格增强代码的可读性
  6.括号要一对一对的写
  7.代码写完语句用;代表结束了,一句话来个分号,证明这是一个单独的语句    

6.关键字

1.关键字:java提前定义好的,具有特殊含义的小写单词
2.怎么记:不用提前都背下来,关键字在高级记事本中颜色特殊,学到哪里记到哪里    

Java关键字大全

7.编写HelloWorld时要注意的问题

7.1字符编码问题

1.编码:保存数据的过程就是编码的过程
2.解码:读数据的过程就是解码的过程
3.注意:
  a.编码和解码遵守的编码规范必须是一样的
  b.常见的两个编码规范:
    GBK:专门为我们中文所设计的编码
        ANSI代表的是GBK
        
        一个中文汉字在GBK中占2个字节
        
    UTF-8:一个中文汉字在UTF-8中占3个字节
        
  c.dos命令窗口默认编码:GBK       

7.2源文件名(java文件名)与类名一致问题？

1.类名必须要和java文件名一致嘛?
  不是必须的
    
  如果类名和java文件名不一致,需要将class前面的public干掉
    
2.如果class前面带public,此时类名必须要和java文件名一致
    
3.一个java文件中可以写多个class类,但是只能有一个类带public
    
  但是建议不要随意在一个java文件中写多个class -> 一个java文件中就写一个class,而且带public的
    
4.main方法必须写在带public的类中    

小结:

1.一个java文件只写一个class,而且带public

2.类名和java文件名保持一致

3.main方法写在带public的类中

9.println和print区别

相同点:都是输出语句
不同点:
  a.println:输出之后自带换行效果
  b.print:输出之后不带换行效果    

public class Demo05HelloWorld{
	public static void main(String[] args){
		//System.out.println("床前明月光");
		//System.out.println("疑是地上霜");
		//System.out.println("举头望明月");
		//System.out.println("低头思故乡");
		System.out.print("床前明月光");
		System.out.print("疑是地上霜");
		System.out.print("举头望明月");
		System.out.print("低头思故乡");
		
	}
}

小技巧:

1.复制当前行:ctrl+d

2.一次操作多行:

​ a.预留出足够的空间

​ b.按住alt不放,鼠标往下拉,此时发现光标变长了

模块二.变量 数据类型转换 运算符

第一章.常量

1.概述:在代码的运行过程中,值不会发生改变的数据
2.分类:
  整数常量:所有整数
  小数常量:所有带小数点的
          2.5  1.5  2.0
  字符常量:带单引号的 ''  单引号中必须有且只能有一个内容
          '1'(算)   '11'(不算)   ''(不算)  'a1'(不算)
          ' '(算)   '  '(两个空格不算)
          '写一个tab键'(算)
      
  字符串常量:带双引号的 ""  双引号中内容随意
            ""   "helloworld"

  布尔常量:true(真) false(假) -> 这两个单词不要加双引号
          "true"(这样写属于字符串,不属于布尔常量)
      
  空常量:null  代表的是数据不存在    

public class Demo01Constant{
	public static void main(String[] args){
		//整数常量
		System.out.println(1);
		System.out.println(-1);
		
		//小数常量
		System.out.println(1.5);
		System.out.println(1.0);
		
		//字符常量   单引号中必须有且只能有一个内容
		System.out.println('1');
		//System.out.println('11');错误
		System.out.println(' ');//一个空格算一个内容
		//System.out.println('    ');//四个空格算四个内容,所以不属于字符常量
		System.out.println('	');//tab键算一个内容
		
		//字符串常量
		System.out.println("本人是尚硅谷第一帅的男人");
		System.out.println("");
		
		//布尔常量
		System.out.println(true);
		System.out.println(false);
		
		//空常量 不能直接使用
		//System.out.println(null);
	}
}

public class Demo02Constant{
	public static void main(String[] args){
		System.out.println(10+3);//13
		System.out.println(10-3);//7
		System.out.println(10*3);//30
		/*
		  /前后如果都是整数,结果只取整数部分
		  
		  /前后只要有一个数带小数点,结果就是正常小数了
		*/
		System.out.println(10/3);//3
		System.out.println(10.0/3);//3.3333333333333335
		System.out.println(10/3.0);//3.3333333333333335
	}
}

第二章.变量

数据类型	关键字	内存占用	取值范围
字节型	byte	1个字节	-128 至 127 定义byte变量时超出范围,废了
短整型	short	2个字节	-32768 至 32767
整型	int（默认）	4个字节	-231 至 231-1 正负21个亿 -2147483648——2147483647
长整型	long	8个字节	-263 至 263-1 19位数字 -9223372036854775808到9223372036854775807
单精度浮点数	float	4个字节	1.4013E-45 至 3.4028E+38
双精度浮点数	double（默认）	8个字节	4.9E-324 至 1.7977E+308
字符型	char	2个字节	0 至 216-1
布尔类型	boolean	1个字节	true，false(可以做判断条件使用)

1.变量的介绍以及使用

1.变量的数据类型:
  基本数据类型:4类8种
      整型:byte short int long
      浮点型:float double
      字符型:char
      布尔型:boolean
          
  引用数据类型: 类 数组 接口 枚举 注解
      
2.概述:在代码的运行过程中,值会随着不同的情况而随时发生改变的数据
    
3.作用:一次接收一个数据
       将来定义一个变量,接收一个值,后续可能会根据不同的情况对此值进行修改,此时可以用变量
    
4.定义:
  a.数据类型 变量名 = 值;

  b.数据类型 变量名;
    变量名 = 值;

  c.连续定义三个相同类型的变量
    数据类型 变量名1,变量名2,变量名3;
    变量名1 = 值;
    变量名2 = 值;
    变量名3 = 值;

    比如:int i,j,k;
         i = 10;
         j = 20; 
         k = 30;


    数据类型 变量名1 = 值,变量名2 = 值,变量名3 = 值;
    比如: int i = 10,j = 20,k = 30;

    正确读法:先看等号右边的,再看等号左边的 -> 将等号右边的数据赋值给等号左边的变量
            哪怕等号右边有运算,我们都得先将等号右边的运算算出一个值来,最后赋值给等号左边的变量
        
5.注意:
  a.字符串不属于基本数据类型,属于引用数据类型,用String表示
    String（引用数据类型）是一个类,只不过字符串在定义的时候可以和基本数据类型格式一样
      
6.float和double的区别:
  a.float的小数位只有23位二进制,能表示的最大十进制为2的23次方(8388608),是7位数,所以float型代表的小数,小数位能表示7位
      
  b.double的小数位只有52位二进制,能表示的最大十进制为(4 503 599 627 370 496),是16位数,所以double型代表的小数,小数位能表示出16位
      
      
7.切记:将来开发不要用float或者double直接参与运算,因为直接参与运算会有精度损失问题    

public class Demo03Var{
	public static void main(String[] args){
		//byte
		byte num1 = 100;
		System.out.println(num1);
		
		//short
		short num2 = 1000;
		num2 = 1001;
		System.out.println(num2);
		
		//int  整数的默认类型
		int num3 = 10000;
		num3 = 1;
		System.out.println(num3);
		
		//long -> 定义long型的变量后面加个L
		long num4 = 10L;
		System.out.println(num4);
		
		//float -> 定义float型变量的时候后面加个F
		float num5 = 2.5F;
		System.out.println(num5);
		
		//double -> 小数的默认类型
		double num6 = 2.5;
		System.out.println(num6);
		
		//char
		char num7 = 'A';
		System.out.println(num7);
		
		//boolean
		boolean num8 = true;
		boolean num9 = false;
		
		/*
		   num9 = false
		   num8 = num9 -> 将num9的值赋值给num8 -> 相当于num8 = false
		*/
		num8 = num9;
		System.out.println(num8);
		
		//String -> 是一个引用数据类型,属于类的一种,但是定义和基本类型一致
		String name = "金莲";
		System.out.println(name);
	}
}

public class Demo04Var{
	public static void main(String[] args){
		int num1 = 10;
		int num2 = 3;
		
		int sum = num1+num2;
		System.out.println(sum);//13
		
		int sub = num1-num2;
		System.out.println(sub);//7
		
		//System.out.println(num1*num2);//30
		int mul = num1*num2;
		System.out.println(mul);//30
		
		/*
		  由于/前后都是整数,结果取整数部分,结果还赋值给一个整数变量
		*/
		int div = num1/num2;
		System.out.println(div);//3
		
		double div1 = num1/num2;//3.0
		System.out.println(div1);
	}
}

public class Demo05Var{
	public static void main(String[] args){
		/*
		  转义字符:  
		  
		  可以这样简单理解:
		    a.将普通字符转成具有特殊含义的字符
			b.将具有特殊含义的字符转成普通字符
		
		*/
		
		
		/*
		   n:普通字符
		   n:换行符
		*/
		
		System.out.print("春眠不觉晓n");
		System.out.print("处处闻啼鸟n");
		System.out.print("夜来风雨声n");
		System.out.print("花落知多少n");
		
		/*
		   t:普通字符
		   t:制表符 -> 就是tab键
		*/
		System.out.println("本人t是尚硅谷第一帅");
		
		
		/*
		  用String表示一个路径
		  在java中两个\代表一个
		*/
		
		String path = "E:\01_javase_video\code";
		System.out.println(path);
	}
}

public class Demo06Var{
	public static void main(String[] args){
		float a = 10;
		float b = 3;
		
		float result = a/b;
		System.out.println(result);//3.3333333
		
		
		double c = 10;
		double d = 3;
		double result02 = c/d;
		System.out.println(result02);//3.3333333333333335
		
		
		float x = 3.55F;
		float y = 2.12F;
		
		float result03 = x-y;
		System.out.println(result03);//1.4300001
		
	}
}

2.变量使用时的注意事项

1.变量不初始化(第一次赋值)不能直接使用
2.在同一个作用域(一对大括号就是一个作用域)中不能定义重名的变量 
3.不同作用域中的数据尽量不要随意互相访问
  在小作用域中能直接访问大作用域中的变量
  在大作用域中不能直接访问小作用域中的变量

public class Demo07Var{
	public static void main(String[] args){
		int i = 10;
		System.out.println(i);
		
		int j;
		
		j = 10;
		System.out.println(j);
		
		int k = 10;
		//int k = 20;//只要是变量名前带具体的数据类型就是重新定义
		System.out.println(k);
		
		{
		   int x = 1000;
           System.out.println(k);		   
		}
		
		//System.out.println(x);	
		
	}
}

3.练习

定义一个人类,用变量表示 姓名 性别 年龄 身高 体重

public class Demo08VarPerson{
	public static void main(String[] args){
		//姓名
		String name = "张三";
		//性别
		char sex = '男';
		//年龄
		int age = 20;
		//身高
		double height = 175.5;
		//体重
		double weight = 145.5;
		
		System.out.println(name);
		System.out.println(sex);
		System.out.println(age);
		System.out.println(height);
		System.out.println(weight);
	}
}

第三章.标识符

1.概述:咱们给类,方法,变量取的名字
2.注意:
  a.硬性规定(必须遵守)
    标识符可以包含"英文字母","数字","$和_"
    标识符不能以数字开头  int i1 = 100(正确)  int 1i = 100(错误)
    标识符不能是关键字  int static = 100(错误)   int public = 100(错误)
      
  b.软性建议(可遵守可不遵守,但是建议遵守)
    给类取名字:遵循大驼峰式 -> 每个单词首字母大写
    给方法和变量取名字:遵循小驼峰式 -> 从第二个单词开始往后首字母大写
   
    见名知意

第四章.数据类型转换

1.什么时候发生类型转换:
  a.等号左右两边类型不一致
  b.不同类型的数据做运算
      
2.分类:
  a.自动类型转换
    将取值范围小的数据类型赋值给取值范围大的数据类型 -> 小自动转大
    取值范围小的数据类型和取值范围大的数据类型数据做运算 -> 小自动转大
      
  b.强制类型转换
    当将取值范围大的数据类型赋值给取值范围小的数据类型 -> 需要强转
      
3.基本类型中按照取值范围从小到大排序:
  byte,short,char -> int -> long -> float -> double     

1.自动类型转换

1.将取值范围小的数据类型赋值给取值范围大的数据类型 -> 小自动转大
2.取值范围小的数据类型和取值范围大的数据类型做运算 -> 小自动转大    

public class Demo09DataType{
	public static void main(String[] args){
		/*
		  等号右边是整数,整数默认类型为int
		  等号左边是long型的变量
		  
		  将取值范围小的数据类型赋值给取值范围大的数据类型,发生了自动类型转换
		*/
		long num1 = 100;
		System.out.println(num1);
		
		
		int i = 10;
		double b = 2.5;
		
		/*
		   double = int+double
		   double  = double+double
		   int自动提升为了double,发生了自动类型转换
		*/
		double sum = i+b;
		System.out.println(sum);
	}
}

2.强制类型转换

1.将取值范围大的数据类型赋值给取值范围小的数据类型
  取值范围小的数据类型 变量名 = 取值范围大的数据类型 -> 需要强转
    
2.怎么强转:
  取值范围小的数据类型 变量名 = (取值范围小的数据类型)取值范围大的数据类型

public class Demo10DataType{
	public static void main(String[] args){
		/*
		  等号右边的数据是小数,小数默认类型为double
		  等号左边的变量是float型
		  
		  将取值范围大的赋值给取值范围小 -> 报错,需要强转
		*/
		//float num1 = 2.5;
		//float num1 = (float)2.5;
		float num1 = 2.5F;
		System.out.println(num1);
		
	}
}

3.强转的注意事项

1.不要随意写成强转的格式,因为会有精度损失问题以及数据溢出现象,除非没有办法
2.byte,short定义的时候如果等号右边是整数常量,如果不超出byte和short的范围,不需要我们自己强转,jvm自动转型  
    
  byte,short如果等号右边有变量参与,byte和short自动提升为int,然后结果再次赋值给byte或者short的变量,需要我们自己手动强转
    
    
3.char类型数据如果参与运算,会自动提升为int型,如果char类型的字符提升为int型会去ASCII码表(美国标准交换代码)范围内去查询字符对应的int值,如果在ASCII码表范围内没有对应的int值,回去unicode码表(万国码)中找  

public class Demo11DataType{
	public static void main(String[] args){
		//精度损失
		int i = (int)2.9;
		System.out.println(i);
		
		/*
		  数据溢出
		  int型占内存4个字节,4个字节变成二进制是32位
		  
		  100个亿: 10 0101 0100 0000 1011 1110 0100 0000 0000 -> 34位二进制
		  
		  100个亿的二进制位比int型的二进制位多出来2位,此时干掉最前面的2位
		  
		  101 0100 0000 1011 1110 0100 0000 0000
		  
		  101 0100 0000 1011 1110 0100 0000 0000->1410065408
		*/
		int j = (int)10000000000L;
		System.out.println(j);//1410065408
		
	    System.out.println("=========================");
		
		byte b = 10;
		System.out.println(b);
		
		b = (byte)(b+1);
		System.out.println(b);
		
		System.out.println("=========================");
		
		char c = '中';
		System.out.println(c+0);//20013
	}
}

第五章.进制的转换(了解)

十进制	二进制	八进制	十六进制
0	0	0	0
1	1	1	1
2	10	2	2
3	11	3	3
4	100	4	4
5	101	5	5
6	110	6	6
7	111	7	7
8	1000	10	8
9	1001	11	9
10	1010	12	a或A
11	1011	13	b或B
12	1100	14	c或C
13	1101	15	d或D
14	1110	16	e或E
15	1111	17	f或F
16	10000	20	10

3.1 十进制转成二进制

辗转相除法 -> 循环除以2,取余数

3.2 二进制转成十进制

8421规则

3.3 二进制转成八进制

将二进制数分开  (3位为一组)

3.4 二进制转成十六进制

 将二进制数分组-> 4位为一组

第六章.位运算符(了解)

1.符号的介绍:
  a. &(与) -> 有假则假
  b. |(或) -> 有真则真
  c. ~(非) -> 取反
  d. ^(异或) -> 符号前后结果一样为false,不一样为true
     true ^ true -> false
     false ^ false -> false
     true ^ false -> true
     false ^ true -> true
      
2.   1代表true   0代表false  
      
3.我们要知道计算机在存储数据的时候都是存储的数据的补码,计算也是用的数据的补码 
  但是我们最终看到的结果是原码换算出来的
      
  原码   反码   补码
      
4.正数二进制最高位为0;  负数二进制最高位为1
    
5.如果是正数  原码 反码 补码 一致
  比如:5的原码  反码  补码一致:
      0000 0000 0000 0000 0000 0000 0000 0101 -> 因为是正数,二进制最高位为0
          
  如果是负数,原码 反码 补码不一样了
       反码是原码的基础上最高位不变,剩下的0和1互换
       补码是在反码的基础上+1
          
  比如:-9
       原码: 1000 0000 0000 0000 0000 0000 0000 1001
       反码: 1111 1111 1111 1111 1111 1111 1111 0110
       补码: 1111 1111 1111 1111 1111 1111 1111 0111

（1）左移：<<

​ 运算规则：左移几位就相当于乘以2的几次方

​ **注意：**当左移的位数n超过该数据类型的总位数时，相当于左移（n-总位数）位

2<<2   结果等于8
快速算法:  2*(2的2次方)

-2<<2  等于-8
快速算法: -2*(2的2次方)

（2）右移：>>

快速运算：类似于除以2的n次，如果不能整除，向下取整

9>>2  等于2
    
快速算法: 9除以(2的2次方)

-9>>2   等于-3
    
快速算法: -9除以(2的2次方)

（3）无符号右移：>>>

运算规则：往右移动后，左边空出来的位直接补0，不管最高位是0还是1空出来的都拿0补

正数：和右移一样

9>>>2 等于2

负数：右边移出去几位，左边补几个0，结果变为正数

-9>>>2
结果为:1073741821    

笔试题: 8>>>32位 -> 相当于没有移动还是8

​ 8>>>34位 -> 相当于往右移动2位

（4）按位与：&

小技巧:将0看成为false 将1看成true

运算规则：对应位都是1才为1,相当于符号左右两边都为true,结果才为true

1&1 结果为1

1&0 结果为0

0&1 结果为0

0&0 结果为0

5&3 结果1

（5）按位或：|

运算规则：对应位只要有1即为1,相当于符号前后只要有一个为true,结果就是true

1|1 结果1

1|0 结果1

0|1 结果1

0|0 结果0

5|3    结果为7

（6）按位异或：^

​ 运算规则：对应位一样的为0,不一样的为1

1^1 结果为0 false

1^0 结果为1 true

0^1 结果为1 true

0^0 结果0 false

5^3   结果为6

（7）按位取反

运算规则：~0就是1

​ ~1就是0

~10   结果为-11

第七章.运算符的优先级(了解)

提示说明：
（1）表达式不要太复杂
（2）先算的使用(),记住,如果想让那个表达式先运行,就加小括号就可以了
i<(n*m)

模块三 idea_运算符

第一章.IDEA的使用

1.idea的介绍

1.概述:开发工具
2.特点:
  a.idea是java写的,所以本地上必须有正确的jdk环境(JAVA_HOME)
  b.idea自动保存
  c.不用我们打开dos命令窗口执行javac和java命令
  d.idea有强大的快捷键,生成代码,纠错等
  e.idea会自动管理我们写的代码
      
3.相关开发工具:eclipse myeclipse   
    
4.作用:加速我们的开发    

2.idea的目录结构

先创建project,在project下创建module,在module下创建package -> 必须记住

3.Project的操作

3.1.project的创建

3.2再次创建一个新的Project

3.3.关闭Project

file-> close project

3.4.打开project

4.module的操作

4.1.创建module

4.2.关闭module

a.对着要关闭的module右键 -> remove module -> 此时是关闭,不是真正的删除module
b.再对着关闭的module右键-> delete -> 从本地上真正删除

4.3.导入已有的module

5.package的操作

5.1创建

5.2 package的删除

右键-> delete

5.3 package取名字规范

1.公司域名倒着写:
  比如:尚硅谷  域名为:www.atguigu.com
  我们写代码创建包: com.atguigu

6.创建类以及基本语句生成快捷键

1.生成main方法:输入main -> 回车

2.生成输出语句:sout -> 回车

3.将变量名放到输出语句中:

a.变量名.sout

b.变量名.soutv -> 带字符串平拼接格式的输出方式-> 输出格式好看

7.基本设置

7.1设置字体

file-settings

7.2设置提示的快捷键

file-settings

7.3 设置注释字体

8.快捷键

快捷键	功能
Alt+Enter	导入包，自动修正代码(重中之重)
Ctrl+Y	删除光标所在行
Ctrl+D	复制光标所在行的内容，插入光标位置下面
Ctrl+Alt+L	格式化代码
Ctrl+/	单行注释
Ctrl+Shift+/	选中代码注释，多行注释，再按取消注释
Alt+Shift+上下箭头	移动当前代码行

先写等号右边的,可以自动生成等号左边的变量

或者

9.出现的问题

1.在运行代码时会出现"找不到对应的发行源"或者"不支持发行版本"或者"无效的发行源版本",证明本地jdk版本和idea中的language level不匹配
  所以要匹配版本
  file->project Structure->点击project->引入本地jdk->project level选择对应的版本
2.没有out路径的问题
  out路径是专门存放idea自动编译生成的.class文件的
  所以需要指明out路径
    
3.src是灰色的,对着src,右键,选项中没有java class或者package
    
4.刚使用,jdk没有配置

第二章.运算符

1.算数运算符

符号	说明
+	加法
–	减法
*	乘法
/	除法 如果符号前后都是整数,结果取整数部分 如果符号前后有一个为小数,结果就是正常小数
%	模,取余数部分

public class Demo01Arithmetic {
    public static void main(String[] args) {
        int i = 10;
        int j = 3;
        int add = i+j;//推荐使用
        System.out.println(add);//13
        System.out.println(i+j);//13

        int sub = i-j;
        System.out.println(sub);//7

        int mul = i*j;
        System.out.println(mul);//30

        int div = i/j;
        System.out.println(div);//3

        int mo = i%j;
        System.out.println(mo);//1
    }
}

+:
  1.运算
  2.字符串拼接:任何类型的数据遇到字符串都会变成字符串,此时+就不再是运算了,而是字符串拼接,将内容直接往后拼接    
 

public class Demo02Arithmetic {
    public static void main(String[] args) {
        int i = 10;
        int j = 3;
        System.out.println(i+j+"");//13
        System.out.println(i+j+""+1);//131
        System.out.println(i+""+j);//103

        System.out.println("i和j相加只和为:"+(i+j));
    }
}

1.2.自增自减运算符(也算算数运算符的一种)

1.格式:
  变量++ -> 后自加
  ++变量 -> 前自加
  变量-- -> 后自减
  --变量 -> 前自减
      
  自增和自减只变化1
      
2.使用:
  a.单独使用: ++ -- 单独为一句,没有和其他的语句掺和使用
    i++;

    符号前在在后都是先运算
        
  b.混合使用: ++ -- 和其他的语句掺和使用了(比如:输出语句,赋值语句)
    符号在前:先运算,在使用运算后的值
    符号在后:先使用原值,使用完毕之后,自身再运算
      

public class Demo03Arithmetic {
    public static void main(String[] args) {
        int i = 10;
        //i++;
        ++i;
        System.out.println("i = " + i);

        System.out.println("==================");

        int j = 100;
        int result01 = ++j;
        System.out.println("result01 = " + result01);//101
        System.out.println(j);//101

        System.out.println("==================");
        int k = 10;
        int result02 = k++;
        System.out.println("result02 = " + result02);
        System.out.println(k);

        System.out.println("==================");

        int z = 100;
        System.out.println(z++);
        System.out.println(z);

        System.out.println("==================");

        int x = 10;
        int y = 20;

        /*
           10+19 = 29
           29+12 = 41

           以后开发肯定不会这么写
         */

        int result03 = x++ + --y + ++x;
        System.out.println("result03 = " + result03);

        System.out.println("=======================");

        int c = 10;
        c = c++;
        System.out.println(c);//10
        System.out.println(c);//10

    }
}

c++原理 -> 反编译

3.赋值运算符

1.基本赋值运算符:
  =  -> 先看等号右边的,再将右边的数据赋值给等号左边的变量
      
2.复合赋值运算符:
  +=:
    int i = 10;
    i+=2 -> i = i+2
       
        
  -=
  *=
  /=  : 取整数部分
  %=  : 取余数部分  
      
3.注意:byte short 遇到复合赋值运算符,jvm会自动转型      

public class Demo01Assignment {
    public static void main(String[] args) {
        int i = 10;
        i+=2;//i = i+2
        System.out.println(i);
    }
}

public class Demo02Assignment {
    public static void main(String[] args) {
        byte b = 10;
        //b = (byte)(b + 1);
        b+=1;//b = b+1
        System.out.println(b);
    }
}

4.关系运算符(比较运算符)

1.结果:boolean型 -> 要么是true,要么是false
2.作用:做条件判断使用    

符号	说明
==	如果符号前后相等为true;否则为false
>	如果符号前的数据大于符号后的数据为true,否则为false
<	如果符号前的数据小于符号后的数据为true,否则为false
>=	如果符号前的数据大于或者等于符号后的数据为true,否则为false
<=	如果符号前的数据小于或者等于符号后的数据为true,否则为false
!=	如果符号前后不相等为true;否则为false

public class Demo01Compare {
    public static void main(String[] args) {
        int i = 10;
        int j = 20;

        boolean result01 = i == j;
        System.out.println("result01 = " + result01);//false
        System.out.println(i>j);//false
        System.out.println(i<j);//true
        System.out.println(i>=j);//false
        System.out.println(i<=j);//true
        System.out.println(i!=j);//true

    }
}

5.逻辑运算符

 1.作用:连接多个boolean结果的
 2.结果:boolean型结果    

符号	说明
&&(与,并且)	有假则假,符号前后有一个结果为false,整体就是false
||(或者)	有真则真,符号前后有一个结果为true,整体就是true
!(非,取反)	不是true,就是false;不是false,就是true
^(异或)	符号前后结果一样为false;不一样为true true^true -> false true^false -> true false^true -> true false^false -> false

public class Demo01Logic {
    public static void main(String[] args) {
        int i = 10;
        int j = 20;
        int k = 10;

        boolean result01 = (i>j) && (i==k);
        System.out.println("result01 = " + result01);//false

        boolean result02 = (i>j) || (i==k);
        System.out.println("result02 = " + result02);//true

        boolean result03 = (i>j) ^ (i==k);//false ^ true
        System.out.println("result03 = " + result03);//true

        boolean result04 = !(i>j) ;
        System.out.println("result04 = " + result04);//true
    }
}

符号	说明
&	1.单与,如果前后都是布尔型,有假则假,但是如果符号前为false,符号后的判断会继续执行 2.如果该符号前后都是数字,看做是位运算符
&&	1.双与,有假则假,但是有短路效果,如果符号前为false,符号后的判断就不会执行了
|	1.单或,如果前后都是布尔型,有真则真,但是如果符号前为true,符号后的判断会继续执行 2.如果该符号前后都是数字,看做是位运算符
||	1.双或,有真则真,但是有短路效果,如果符号前为true,符号后的判断就不会执行了

public class Demo02Logic {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        //boolean result01 = (++a>100)&(++b>10);
        //boolean result01 = (++a > 100) && (++b > 10);

        //boolean result01 = (++a<100)|(++b>10);
        boolean result01 = (++a<100)||(++b>10);
        System.out.println("result01 = " + result01);
        System.out.println("a = " + a);
        System.out.println("b = " + b);
    }
}

问题:定义一个变量(a),随意给一个值,判断这个变量接收的值是否在1-100之间

1<=a<=100 -> 错误,这是数学写法

i>=1 && i<=100 -> java写法,用逻辑运算符拼接多个判断

6.三元运算符

1.格式:
  boolean表达式?表达式1:表达式2
      
2.执行流程:
  先判断,如果是true,就走?后面的表达式1,否则就走:后面的表达式2

模块四_流程控制

第一章.键盘录入_Scanner

1.概述:是java定义好的一个类
2.作用:将数据通过键盘录入的形式放到代码中参与运行 
3.位置:java.util
4.使用:
  a.导包:通过导包找到要使用的类 -> 导包位置:类上
    import java.util.Scanner -> 导入的是哪个包下的哪个类
      
  b.创建对象
    Scanner 变量名 = new Scanner(System.in);

  c.调用方法,实现键盘录入
    变量名.nextInt() 输入整数int型的
    变量名.next() 输入字符串  String型的  

public class Demo01Scanner {
    public static void main(String[] args) {
        //创建对象
        Scanner sc = new Scanner(System.in);
        //录入int型整数
        int data1 = sc.nextInt();
        System.out.println("data1 = " + data1);

        //录入String型字符串
        String data2 = sc.next();
        System.out.println("data2 = " + data2);
    }
}

====================================================
public class Demo02Scanner {
    public static void main(String[] args) {
        //创建对象
        Scanner sc = new Scanner(System.in);
        //录入int型整数
        int old1 = sc.nextInt();
        int old2 = sc.nextInt();
        int old3 = sc.nextInt();

        int temp = old1>old2?old1:old2;
        int max = temp>old3?temp:old3;
        System.out.println(max);
    }
}
    

变量名.next():录入字符串 -> 遇到空格和回车就结束录入了
变量名.nextLine():录入字符串 -> 遇到回车就结束录入了

public class Demo03Scanner {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String data1 = sc.next();
        String data2 = sc.nextLine();
        System.out.println(data1);
        System.out.println(data2);
    }
}

Exception in thread "main" java.util.InputMismatchException -> 输入类型不匹配异常
	at java.base/java.util.Scanner.throwFor(Scanner.java:939)
	at java.base/java.util.Scanner.next(Scanner.java:1594)
	at java.base/java.util.Scanner.nextInt(Scanner.java:2258)
	at java.base/java.util.Scanner.nextInt(Scanner.java:2212)
	at com.atguigu.a_scanner.Demo04Scanner.main(Demo04Scanner.java:8)
    
原因:录入的数据和要求的数据类型不一致    

第二章.Random随机数

学习Random和学习Scanner方式方法一样

1.概述:java自带的一个类
2.作用:可以在指定的范围内随机一个整数
3.位置:java.util
4.使用:
  a.导包:import java.util.Random
  b.创建对象:
    Random 变量名 = new Random()
  c.调用方法,生成随机数:
    变量名.nextInt() -> 在int的取值范围内随机一个整数

public class Demo01Random {
    public static void main(String[] args) {
        //创建对象
        Random rd = new Random();
        int data = rd.nextInt();
        System.out.println("data = " + data);
    }
}

在指定范围内随机一个数:
nextInt(int bound) -> 在0-(bound-1)
    
a.nextInt(10) -> 0-9
b.在1-10之间随机一个数: nextInt(10)+1 -> (0-9)+1 -> 1-10
c.在1-100之间随机一个数:nextInt(100)+1 -> (0-99)+1 -> 1-100
d.在100-999之间随机一个数: nextInt(900)+100 -> (0-899)+100 -> 100-999

public class Demo02Random {
    public static void main(String[] args) {
        //创建对象
        Random rd = new Random();
        //在1-100之间随机
        int data1 = rd.nextInt(100)+1;
        System.out.println("data1 = " + data1);

        System.out.println("=====================");

        //在100-999之间随机一个数
        int data2 = rd.nextInt(900)+100;
        System.out.println("data2 = " + data2);
    }
}

第三章.switch(选择语句)

学switch  if  循环必须要先掌握定义格式,然后掌握执行流程(带一个数进去,根据执行流程观察值的变化)

1.switch基本使用

1.格式:
  switch(变量){
      case 常量值1:
          执行语句1;
          break;
          
      case 常量值2:
          执行语句2;
          break;
          
      case 常量值3:
          执行语句3;
          break;
          
      case 常量值4:
          执行语句4;
          break;
          ...
      default:
          执行语句n;
          break;
  }

2.执行流程:
  用变量接收的值和下面case后面的常量值匹配,匹配上哪个case就执行哪个case对应的执行语句
  如果以上所有case都没有匹配上,就走default对应的执行语句n
      
3.break关键字:代表的是结束switch语句 
    
4.注意:switch能匹配什么类型的数据:
  byte short int char 枚举类型 String类型
  
   

public class Demo01Switch {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请您输入一个整数:");
        int data = sc.nextInt();
        switch (data){
            case 1:
                System.out.println("鹅鹅鹅");
                break;
            case 2:
                System.out.println("曲项向天歌");
                break;
            case 3:
                System.out.println("白毛浮绿水");
                break;
            case 4:
                System.out.println("红掌拨清波");
                break;
            default:
                System.out.println("下面没有了");
                break;

        }

    }
}

2.case的穿透性

1.如果没有break,就会出现case的穿透性,程序就一直往下穿透执行,直到遇到了break或者switch代码执行完毕了,就停止了

public class Demo02Switch {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int data = sc.nextInt();
        switch (data){
            case 1:
                System.out.println("鹅鹅鹅");

            case 2:
                System.out.println("曲项向天歌");

            case 3:
                System.out.println("白毛浮绿水");

            case 4:
                System.out.println("红掌拨清波");
                break;
            default:
                System.out.println("下面没有了");
                break;

        }
    }
}

public class Demo03Switch {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int month = sc.nextInt();
        switch(month){
            case 12:
                System.out.println("冬季");
                break;
            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;
            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("什么情况,你家有这个月份?");
        }
    }
}

public class Demo03Switch {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int month = sc.nextInt();
        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("什么情况,你家有这个月份?");
        }
    }
}

第四章.分支语句

1.if的第一种格式

1.格式:
  if(boolean表达式){
      执行语句;
  }

2.执行流程:
  先走if后面的boolean表达式,如果是true,就走if后面大括号中的执行语句,否则就不走
      
3.注意:
  if后面跟的是boolean表达式,只要是结果为boolean型的,都可以放在小括号中,哪怕直接写一个true或者false

public class Demo01If {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int data1 = sc.nextInt();
        int data2 = sc.nextInt();
        if (data1==data2){
            System.out.println("两个整数相等");
        }
    }
}

2.if的第二种格式

1.格式:
  if(boolean表达式){
      执行语句1;
  }else{
      执行语句2;
  }
2.执行流程:
  a.先走if后面的boolean表达式,如果是true,就走if后面的执行语句1
  b.否则就走else后面的执行语句2    

public class Demo02IfElse {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int data1 = sc.nextInt();
        int data2 = sc.nextInt();
        if (data1==data2){
            System.out.println("两个整数相等");
        }else{
            System.out.println("两个整数不相等");
        }
    }
}

2.1 练习

任意给出一个整数，请用程序实现判断该整数是奇数还是偶数，并在控制台输出该整数是奇数还是偶数

public class Demo03IfElse {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int data = sc.nextInt();
        if (data%2==0){
            System.out.println("偶数");
        }else{
            System.out.println("奇数");
        }
    }
}

2.2练习

需求.利用if  else 求出两个数的较大值

public class Demo04IfElse {
    public static void main(String[] args) {
        int i = 10;
        int j = 20;
        if (i>j){
            System.out.println(i);
        }else{
            System.out.println(j);
        }
    }
}

public class Demo05IfElse {
    public static void main(String[] args) {
        int i = 10;
        int j = 20;
        int k = 30;

        //定义临时变量,接收前两个数的较大值
        int temp = 0;

        if (i>j){
            temp = i;
        }else{
            temp = j;
        }

        if (temp>k){
            System.out.println(temp);
        }else{
            System.out.println(k);
        }
    }
}

2.3练习

案例：从键盘输入年份，请输出该年的2月份的总天数。闰年2月份29天，平年28天。
闰年:
 a.能被4整除,但是不能被100整除  year%4==0 && year%100!=0
 b.或者能直接被400整除  year%400==0

步骤:
  1.创建Scanner对象,调用nextInt键盘录入一个年份 year
  2.判断(year%4==0 && year%100!=0) || (year%400==0)
  3.如果条件成立,就输出闰年2月29天,否则输出平年2月28天    

public class Demo06IfElse {
    public static void main(String[] args) {
        //1.创建Scanner对象,调用nextInt键盘录入一个年份 year
        Scanner scanner = new Scanner(System.in);
        int year = scanner.nextInt();
        //2.判断(year%4==0 && year%100!=0) || (year%400==0)
        if ((year%4==0 && year%100!=0) || (year%400==0)){
        //3.如果条件成立,就输出闰年2月29天,否则输出平年2月28天
            System.out.println("闰年2月29天");
        }else{
            System.out.println("平年2月28天");
        }
    }
}

2.4练习

public class Demo07IfElse {
    public static void main(String[] args) {
        boolean num1 = false;
        boolean num2 = true;

        int i = 1;

        /*
           num1 = false
           num2 = true
           num1 = num2 -> 相当于将num2的true赋值给了num1
         */
        if (num1=num2){
            i++;
            System.out.println(i);//2
        }

        if (false){
            --i;
            System.out.println(i);
        }
    }
}

3.if的第三种格式

1.格式:
  if(boolean表达式){
      执行语句1
  }else if(boolean表达式){
      执行语句2
  }else if(boolean表达式){
      执行语句3
  }...else{
      执行语句n
  }

2.执行流程:
  从if开始往下挨个判断,哪个if判断结果为true,就走哪个if对应的执行语句,如果以上所有的判断都是false,就走else对应的执行语句n
      
3.使用场景:2种情况以上的判断      

public class Demo08ElseIf {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int data1 = sc.nextInt();
        int data2 = sc.nextInt();
       /* if (data1>data2){
            System.out.println("data1大于data2");
        }else if(data1<data2){
            System.out.println("data1小于data2");
        }else{
            System.out.println("data1等于data2");
        }*/

        if (data1>data2){
            System.out.println("data1大于data2");
        }else if(data1<data2){
            System.out.println("data1小于data2");
        }else if (data1==data2){
            System.out.println("data1等于data2");
        }
    }
}

注意:最后一种情况,不一定非得用else,但是必须要保证所有的情况都判断了

3.1.练习

需求:
 键盘录入一个星期数(1,2,...7)，输出对应的星期一，星期二，...星期日

输入  1      输出	星期一
输入  2      输出	星期二
输入  3      输出	星期三
输入  4      输出	星期四
输入  5      输出	星期五
输入  6      输出	星期六
输入  7      输出	星期日
输入  其它数字   输出      数字有误

public class Demo09ElseIf {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int week = sc.nextInt();
        /*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("是不是有点大病,没有这个星期!");
        }*/

        if (week<1 || week>7){
            System.out.println("是不是有点大病,没有这个星期!");
        }else{
            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("周日");
            }
        }
    }
}

3.2练习

根据最新的年龄段划分标准:
  0-6岁为婴幼儿
  7-12岁为少儿
  13-17岁为青少年
  18-45岁为青年
  46-69岁为中年
  69岁以上为老年
请键盘录入一个年龄,判断属于什么年龄段  

public class Demo10ElseIf {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int age = sc.nextInt();
       /* if (age>=0 && age<=6){
            System.out.println("婴幼儿");
        }else if (age>=7 && age<=12){
            System.out.println("少儿");
        }else if (age>=13 && age<=17){
            System.out.println("青少年");
        }else if(age>=18 && age<=45){
            System.out.println("青年");
        }else if(age>=46 && age<=69){
            System.out.println("中年");
        }else if (age>69 && age<=130){
            System.out.println("老年");
        }else {
            System.out.println("年龄不太符合实际");
        }*/

        if (age<0 || age>130){
            System.out.println("年龄不太符合实际");
        }else{
            if (age>=0 && age<=6){
                System.out.println("婴幼儿");
            }else if (age>=7 && age<=12){
                System.out.println("少儿");
            }else if (age>=13 && age<=17){
                System.out.println("青少年");
            }else if(age>=18 && age<=45){
                System.out.println("青年");
            }else if(age>=46 && age<=69){
                System.out.println("中年");
            }else if (age>69 && age<=130){
                System.out.println("老年");
            }
        }
    }
}

switch和if的区别:debug

1.switch:会直接跳到相匹配的case

2.if:从上到下挨个判断 -> 实际开发主要用if做判断,灵活

第五章.循环语句

什么时候使用循环语句:
  当我们发现一件事或者一段代码在反复执行,我们就可以考虑使用循环语句了

1.for循环

1.格式:
  for(初始化变量;比较;步进表达式){
      循环语句 -> 哪段代码循环执行,就将哪段代码放到此处
  }

2.执行流程:
  a.先走初始化变量
  b.比较,如果是true,走循环语句,走步进表达式(初始化的变量的值进行变化) 
  c.再比较,如果还是true,继续走循环语句,走步进表达式
  d.再比较,直到比较为false,循环结束了

public class Demo01For {
    public static void main(String[] args) {
        for(int i = 0;i<3;i++){
            System.out.println("我爱java");
        }
    }
}

快捷键: 次数.fori

1.1练习

for循环:求1-3之间的数据和,并把求和结果输出到控制台上
1+2+3
    
步骤:
  1.定义一个变量,用来接受两个数的和  sum
  2.利用for循环将1-3表示出来
  3.在循环的过程中,两两相加,将结果赋值给sum
  4.输出sum    

public class Demo02For {
    public static void main(String[] args) {
        //1.定义一个变量,用来接受两个数的和  sum
        int sum = 0;
        //2.利用for循环将1-3表示出来
        for (int i = 1; i <= 3; i++) {
        //3.在循环的过程中,两两相加,将结果赋值给sum
            sum+=i;//sum = sum+i;
        }
        //4.输出sum
        System.out.println("sum = " + sum);
    }
}

1.2练习

需求:求出1-100的偶数和

步骤:
  1.定义一个变量sum,接受两个偶数的和
  2.利用for循环将1-100表示出来
  3.判断,如果是偶数,相加,将加的结果赋值给sum
  4.输出sum    

public class Demo03For {
    public static void main(String[] args) {
        //1.定义一个变量sum,接受两个偶数的和
        int sum = 0;
        //2.利用for循环将1-100表示出来
        for (int i = 1; i <= 100; i++) {
            //3.判断,如果是偶数,相加,将加的结果赋值给sum
            if (i % 2 == 0) {
                sum += i;
            }
        }
        //4.输出sum
        System.out.println("sum = " + sum);
    }
}

1.3练习

统计一下1-100之间的偶数个数

步骤:
  1.定义一个变量count,用来计数
  2.利用for循环将1-100表示出来
  3.判断,如果是偶数,count++
  4.输出count    

public class Demo04For {
    public static void main(String[] args) {
        //1.定义一个变量count,用来计数
        int count = 0;
        //2.利用for循环将1-100表示出来
        for (int i = 1; i <= 100; i++) {
            //3.判断,如果是偶数,count++
            if (i % 2 == 0) {
                count++;
            }
        }
        //4.输出count
        System.out.println("count = " + count);
    }
}

2.while循环

1.格式:
  初始化变量;
  while(比较){
      循环语句;
      步进表达式
  }

2.执行流程:
  a.初始化变量
  b.比较,如果是true,就走循环语句,走步进表达式
  c.再比较,如果还是true,继续走循环语句,继续走步进表达式
  d.再比较,直到比较为false,循环结束

public class Demo01While {
    public static void main(String[] args) {
        int i = 0;
        while(i<5){
            System.out.println("我爱java,我更爱钱");
            i++;
        }
    }
}

public class Demo02While {
    public static void main(String[] args) {
        int sum = 0;
        int i = 1;
        while(i<=3){
           sum+=i;
           i++;
        }
        System.out.println("sum = " + sum);
    }
}

public class Demo03While {
    public static void main(String[] args) {
        int sum = 0;
        int i = 1;
        while (i <= 100) {
            if (i % 2 == 0) {
                sum += i;
            }
            i++;
        }
        System.out.println("sum = " + sum);
    }
}

public class Demo04While {
    public static void main(String[] args) {
        int count = 0;
        int i = 1;
        while (i <= 100) {
            if (i % 2 == 0) {
                count++;
            }
            i++;
        }
        System.out.println("count = " + count);
    }
}

1.1while练习

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

步骤:
  1.定义一个变量表示山峰的高度  mountain
  2.定义一个变量表示纸的厚度    paper
  3.定义一个变量表示折纸的次数  count
  4.利用while循环循环比较,如果paper<mountain 就循环对折
    paper = paper*2;
    count++;
  5.输出count

public class Demo05While {
    public static void main(String[] args) {
        //1.定义一个变量表示山峰的高度  mountain
        int mountain = 8844430;
        //2.定义一个变量表示纸的厚度    paper
        double paper = 0.1;
        //3.定义一个变量表示折纸的次数  count
        int count = 0;
        /*4.利用while循环循环比较,如果paper<mountain 就循环对折
          paper = paper*2;
          count++;*/
        while(paper<mountain){
            paper*=2;
            count++;
        }
        //5.输出count
        System.out.println("count = " + count);
    }
}

3.do…while循环(了解)

1.格式:
  初始化变量;
  do{
      循环语句;
      步进表达式
  }while(比较);

2.执行流程:
  a.初始化变量
  b.走循环语句
  c.走步进表达式
  d.判断,如果是true,继续循环,直到比较为false,循环结束
      
3.特点:
  至少循环一次

public class Demo01DoWhile {
    public static void main(String[] args) {
        int i = 0;
        do{
            System.out.println("我爱java");
            i++;
        }while(i<5);
    }
}

4.循环控制关键字

1.break:
  a.在switch中代表结束switch语句
  b.在循环中代表结束循环 
      
2.continue:
  结束当前本次循环,直接进入下一次循环,直到条件为false为止

public class Demo01BreakAndContinue {
    public static void main(String[] args) {
        for (int i = 1; i <= 5; i++) {
            if (i==3){
                //结束循环
                //break;
                //结束本次循环,进入下一次循环
                continue;
            }
            System.out.println("我爱java"+i);
        }
    }
}

5.死循环

1.概述:
  一直循环
2.什么条件下一直循环:
  比较条件一直是true
  

public class Demo01Endless {
    public static void main(String[] args) {
        int count = 0;
        for (int i = 0; i < 10;) {
            count++;
            System.out.println("我爱java"+count);
        }


       /* while(true){
            count++;
            System.out.println("我爱java"+count);
        }*/


    }
}

6.嵌套循环

1.概述:循环中还有循环
2.执行流程:
  先执行外层循环,再进入内层循环,内层循环就一直循环,直到内层循环结束,外层循环进入下一次循环,直到外层循环都结束了,整体结束

public class Demo02Nest {
    public static void main(String[] args) {
        for (int fen = 0; fen < 60; fen++) {
            for (int miao = 0; miao < 60; miao++) {
                System.out.println(fen+"分"+miao+"秒");
            }
        }
    }
}

练习:打印矩形

public class Demo03Nest {
    public static void main(String[] args) {
        //外层循环控制行
        for (int i = 0; i < 5; i++) {
            //内层循环控制列
            for (int j = 0; j < 5; j++) {
                System.out.print("* ");
            }
            System.out.println();
        }
    }
}

练习:打印直角三角形

* 
* * 
* * * 
* * * *   

public class Demo04Nest {
    public static void main(String[] args) {
        for (int i = 1; i < 5; i++) {
            for (int j = 0;j<i;j++){
                System.out.print("* ");
            }
            System.out.println();
        }
    }
}

7.练习.猜数字小游戏

1.创建Scanner和Random对象
2.调用Random中的nextInt(100)+1在1-100之间随机一个数  rdNumber
3.调用Scanner中的nextInt()方法 键盘录入一个要猜的数   scNumber
4.如果scNumber大于rdNumber,证明猜大了
5.如果scNumber小于rdNumber,证明猜小了
6.如果scNumber等于rdNumber,证明猜中了

public class Demo01Exam {
    public static void main(String[] args) {
        //1.创建Scanner和Random对象
        Scanner sc = new Scanner(System.in);
        Random rd = new Random();
        //2.调用Random中的nextInt(100)+1在1-100之间随机一个数  rdNumber
        int rdNumber = rd.nextInt(100) + 1;
        while(true){
            //3.调用Scanner中的nextInt()方法 键盘录入一个要猜的数   scNumber
            System.out.println("请您猜一个数:");
            int scNumber = sc.nextInt();
            //4.如果scNumber大于rdNumber,证明猜大了
            if (scNumber>rdNumber){
                System.out.println("对不起,您猜大了!");
            }else if (scNumber<rdNumber){
                //5.如果scNumber小于rdNumber,证明猜小了
                System.out.println("对不起,您猜小了!");
            }else{
                //6.如果scNumber等于rdNumber,证明猜中了
                System.out.println("恭喜您,猜中了!");
                break;
            }
        }

    }
}