第一章 Java概述

1.1 JavaSE课程体系介绍

JavaSE知识图解

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等)

 但是不管是什么语言,最后都要向机器语言靠近,因为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版。

目前公司主流是Java8。

发行版本	发行时间	备注
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
···	···

 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数据的应用程序（例如天气、新闻播报器、社交网络）以及大多数蓝光光盘标题上的用户界面和奖金内容。

第二章.Java语言前言

1.Java的介绍

 1.计算机编程语言:计算机能看懂的语言(指令),我们可以通过计算机编程语言让计算机帮我们去做事
 2.Java之父:詹姆斯.高斯林
 3.Java涉及的范围:应用于互联网领域
   银行  电商  物流等服务端应用程序
 4.目前使用的jdk版本:java8或者java11

2.字节

 1.概述:计算机中最小的存储单元(存储单位),用byte或者B表示
       8个二进制(bit)代表一个字节
 2.存储单位的换算:
   8bit = 1byte或者1B
   1024B = 1KB
   1024KB = 1MB
   1024MB = 1GB
   1024GB = 1TB

3.常用的dos命令

 1.调出dos命令窗口:win+r->输入cmd

说明	命令
切换盘符	盘符名:->回车
查看当前目录下内容	dir
进入到指定目录	cd 文件夹名
进入多级文件夹	cd 文件夹名\文件夹名
退到上一级目录	cd..或者cd ..
退到根目录	cd\或者cd \
清屏	cls
退出黑窗口	exit
创建文件夹	mkdir 文件夹名
创建多级文件夹	mkdir 文件夹名\文件夹名
删除文件夹	rd 文件夹名;注意:删除的文件夹必须是空的,不走回收站
删除文件	del 文件名;注意:不走回收站
批量删除文件	del *.后缀名

第三章.Java所需要的环境

1.jvm和跨平台

 1.jvm:java虚拟机,是运行所有Java程序的假想计算机，是Java程序的运行环境之一，也是Java 最具吸引力的特性之一。我们编写的Java代码，都运行在JVM之上。
     
 2.跨平台:java程序可以在不同的操作系统上运行
   跨:跨越
   平台:操作系统
       
 3.jvm和跨平台之间的关系:
   java程序想要在不同的操作系统上运行实现跨平台,必须要有不同版本的jvm的支持

2.JDK和JRE

 1.JRE(Java Runtime Environment):java程序运行时所需要的环境,包含`JVM` 和运行时所需要的`核心类库
 2.JDK(Java Development's Kit):是Java程序开发工具包，包含`JRE` 和开发人员使用的工具(javadoc)   
 3.jvm和jre以及jdk的关系:
   jdk包含jre,jre包含jvm

1.如果要是直接运行一个已有的java程序,只安装jre即可

2.如果要是开发,到运行 安装jdk

3.jdk包含jre,jre包含jvm-> 只安装jdk即可

2.1.JDK安装

 1.双击jdk安装包->点下一步
 2.修改jdk安装路径->路径上不要有中文,不要有空格
 3.将"独立jre"叉掉
 4.点击"安装"

测试jdk是否安装好了:

1.进入到bin路径下,执行两个命令:javac java

2.javac->编译命令

java->运行命令

2.2.环境变量的配置

1.配置环境变量的目的:为了在任意位置都可以使用javac和java命令

打开配置环境变量的位置:
  1.右键"此电脑"->属性->高级系统设置->高级->环境变量

常见的配置环境变量的2种方式
  1.直接配置jdk的bin路径
      
  2.JAVA_HOME:
    a.在环境变量的系统变量中设置
    b.新建:
      变量名:JAVA_HOME
      变量值:jdk安装路径中bin路径的上一级路径
    c.找到path:
      编辑->新建->%JAVA_HOME%\bin

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

1.开发三步骤

1.编写
  a.创建文本文档,将后缀名改成.java
  b.注意:将文件后缀名显示出来
2.编译:
  javac命令编译java文件->生成一个对应的.class文件(字节码文件)
  
  javac 文件名.java
      
3.运行:
  java命令运行java程序->jvm运行的就是这个编译生成的class文件
  
  java class文件的文件名

2.编写HelloWorld

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

3.注释

1.概述:对代码进行的一个解释说明,不参与编译和运行
2.分类:
  单行注释:  // 注释内容
  多行注释:  /*注释内容*/

  文档注释:  /**注释内容*/
        文档注释中注释的内容可以被jdk提供的工具javadoc所解析,生成一套以网页文件形式体现的程序的说明
        命令:javadoc -d 要生成的文件夹名字 -author -version 文件名.java
        注意:这里的-author和-version是参数生成的时候需要加，加什么就会输出什么

/**
 * 文档演示
 * 这是一个入门程序
 * @author tian
 * @version v1.0
 */
public class HelloWorld{
	/**
	 * 下面是一个main入口
	 */
	public static void main(String[] args) {
		System.out.println("HelloWorld");
	}
}

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

/*
   定义一个类:类(class)是java代码的最基本的单元,所以的代码都要在类中写
              class 代表的就是类
			  class后面的单词是类名,此名要求和java文件名保持一致
			    
*/
public class Demo01HelloWorld{
	/*
	  下面一句话叫方法:main方法或者叫主方法,是程序的入口
	  java代码的运行都是从main方法开始运行
	*/
	public static void main(String[] args){
		
		//输出语句(打印语句),可以将结果打印到控制台上,输出来
		System.out.println("HelloWorld");
	}
}

注意事项:
  1.class后面的类型要和java文件名保持一致
  2.java中的所有的标点符号都是英文的
  3.不要将main写成mian
  4.String和System的首字母S要大写
  5.写完一个单词,可以用空格来增加代码的可读性
  6.写代码时,写括号要成对出现
  7.一句话结束,用;结束

6.关键字

1.概述:java提前定义好的具有特殊含义的小写单词
2.怎么记:不用单独去记,关键字在高级记事本中颜色特殊,所以我们学到哪里记到哪里

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

7.1字符编码问题

当cmd命令行窗口的字符编码与.java源文件的字符编码不一致，会出现乱码,如何解决？

解决方式1:在notepad++中将字符编码选择成ANSI的

解决方式2:利用javac -encoding utf-8 文件名.java  -> 不建议使用

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

（1）源文件名是否必须与类名一致？

如果这个类不是public，那么源文件名可以和类名不一致。

如果这个类是public，那么要求源文件名必须与类名一致。

我们建议大家，不管是否是public，都与源文件名保持一致，而且一个源文件尽量只写一个类，目的是为了好维护。


（2）一个源文件中是否可以有多个类？

一个源文件中可以有多个类，编译后会生成多个.class字节码文件。

但是一个源文件只能有一个public的类。


（3）main必须在public的类中吗？

    不是。

但是后面写代码时，基本上main习惯上都在public类中。

小结:

1.一个java文件中尽量只写一个类,而且是带public的

2.不管类带不带public,类名尽量和文件名保持一致

9.println和print区别

1.相同点:
  都是输出语句(打印语句)
2.不同点:
  println:输出之后自动换行
  print:输出之后不换行

第五章.常量

1.概述:在代码的运行过程中,值不会发生改变的数据
2.分类:
  整数常量:所有整数
  小数常量:带小数点的  2.5  2.0
  字符常量:带单引号的 '' ->   单引号中必须有,且只能有一个内容
          'a'是
          'a1'不是
          '11'不是
          '中'是
          ' ' 是->一个空格也是内容
          '  '不是->两个空格不是字符常量
          ''不是->单引号中没内容
          'tab键'->是
  字符串常量:带双引号的 ""  内容随意
  布尔常量:true false
  空常量:null  代表数据不存在,不能直接使用   null ""

public class Demo04ChangLiang{
	public static void main(String[] args){
		//整数常量
		System.out.println(1);
		//小数常量
		System.out.println(2.5);
		//字符常量
		//System.out.println('');//错误,单引号中必须有且只能有一个内容
		System.out.println(' ');
		//System.out.println('11');//错误,单引号中必须有且只能有一个内容
		System.out.println('a');
		System.out.println('中');
		
		//字符串常量
		System.out.println("helloworld");
		System.out.println("加油");
		
		//布尔常量
		System.out.println(true);
		System.out.println(false);
		
		/*
		空常量
		null代表数据不存在,不能直接使用
		*/
		System.out.println(null);
	}                                      
}       

public class Demo05ChangLiang{
	public static void main(String[] args){
		System.out.println(10+3);
		System.out.println(10-3);
		System.out.println(10*3);
		System.out.println(10/3);//在java中两个整数相除,取整数部分
		System.out.println(10/3.0);//在java中除号前后一旦有一个为小数,结果就是带小数点的
	}                                      
}

第六章.变量

数据类型	关键字	内存占用	取值范围
字节型	byte	1个字节	-128 至 127 定义byte变量时超出范围,废了
短整型	short	2个字节	-32768 至 32767
整型	int（默认）	4个字节	-2^31 至 2^31-1 正负21个亿
长整型	long	8个字节	-2^63 至 2^63-1 19位数字
单精度浮点数	float	4个字节	1.4013E-45 至 3.4028E+38
双精度浮点数	double（默认）	8个字节	4.9E-324 至 1.7977E+308
字符型	char	2个字节	0 至 2^16-1
布尔类型	boolean	1个字节	true，false

1.变量的介绍以及使用

1.概述:在代码的运行过程中,值可以发生改变的数据
2.作用:一次存储一个数据
      数据可以在不同的情况下,随时改变
3.定义格式:
  数据类型 变量名 = 值;  //先看等号右边-> 将等号右边的值赋值给等号左边的变量
  
  数据类型 变量名;
  变量名 = 值;

4.数据类型分类:
  基本数据类型:4类8种
      整型:byte short int long
      浮点型:float double
      字符型:char
      布尔型:boolean
          
  引用数据类型:
      类 接口 枚举 注解 数组
  
5.注意:
  a.float和double有什么区别:
    float 的小数位只有 23 位，即二进制的 23 位，能表示的最大的十进制数为 2 的 23 次方，即 8388608，即十进制的 7 位，严格点，精度能百分百保证十进制的 6 位运算。
    double 的小数位有 52 位，对应十进制最大值为 4 503 599 627 370 496，这个数有 16 位，所以计算精度能百分百保证十进制的 15 位运算。
        
  b.变量中整数默认类型为:int
         小数默认类型为:double
  c.首先浮点类型分单精度float和双精度double

	而他们的底层存储结构不同：他们是由符号位，指数位，尾数位组成。
	种类-------符号位-------------指数位----------------尾数位---- 
	float---第31位(占1bit)---第30-23位(占8bit)----第22-0位(占23bit) 
	double--第63位(占1bit)---第62-52位(占11bit)---第51-0位(占52bit) 

	c.1.符号位：表示浮点数的正负，0为正，1为负；
	c.2.指数位：占的位数代表着该类型的范围，例如：
	float指数位范围：第30-23位(占8bit)，则范围为2^8-1等同于-128~128
	double的指数范围：第62-52位(占11bit)，范围：2^11-1等同于-1024~1024
	c.3.尾数位：占的位数代表着精度，也就是小数点后面的尾数。
	float的尾数：23位，其范围为：0~2^23，而2^23=8388608，所以float的精度为6~7位，能保证6位为绝对精确，7位一般也是正确的，8位就不一定了（但不是说8位就绝对不对了）
	double的尾数：52位，2^52=2.220446049250313E-16，最小是16位，但最小不是1.0E-16，所以精度是15~16，能保证15，一般16位。
             
6.按照取值范围为基本类型进行一个排序:从小到大
  byte->short->char->int->long->float->double
    
7.字符串型的变量:  String  -> String不属于基本数据类型,属于引用数据类型
  String 变量名 = "";

public class Demo01Var{
	public static void main(String[] args){
	   //byte
	   byte num1 = 10;
	   System.out.println(num1);
	   
	   //short
	   short num2 = 100;
	   System.out.println(num2);
	   
	   //int
	   int num3 = 100;
	   num3 = 200;
	   System.out.println(num3);
	   
	   /*
	   long
	     定义long的变量时,值后面需要加上L或者l
	   */
	   long num4 = 20000L;
	   num4 = 1L;
	   System.out.println(num4);
	   
	   /*
	   float
	     定义float的变量时,值后面需要加上F或者f
	   */
	   float num5 = 2.5F;
	   System.out.println(num5);
	   
	   //double
	   double num6 = 3.5;
	   System.out.println(num6);
	   
	   //char
	   char num7 = '中';
	   System.out.println(num7);
	   
	   
	   //boolean
	   boolean num8 = true;
	   boolean num9 = false;
	   System.out.println(num8);//true
	   System.out.println(num9);//false
	   
	   /*
	     num8 = num9-> 相当于将num9这个变量的值赋值给num8这个变量
		 num8 = false;
	   */
	   num8 = num9;
	   System.out.println(num8);//false
	}
}

public class Demo02Var{
	public static void main(String[] args){
	   /*
	    常量和常量之间的运算
	   */
	   
	   System.out.println(10+3);
	   System.out.println(10-3);
	   System.out.println(10*3);
	   System.out.println(10/3);//取整数部分
	   
	   System.out.println("============================");
	   
	   /*
	      变量和常量之间的运算
       */
	   int num1 = 10;
	   /*
	     先看等号右边:num1+3->10+3 = 13
		 再将13赋值给等号左边的变量result
		 此时result就是13
	   */
	   int result = num1+3;
	   System.out.println(result);//13
	   
	   
	   int result02 = num1-3;
	   System.out.println(result02);//7
	   
	   int result03 = num1*3;
	   System.out.println(result03);//30
	   
	   
	   /*
	     /前后都是整数,结果取整数部分
		 /前后有一个是小数,结果就是带小数点的
	   */
	   double result04 = num1/3.0;
	   System.out.println(result04);
	   
	   System.out.println("============================");
		
	   /*
	     变量和变量之间运算
	   */
	   int a = 10;
	   int b = 3;
	   int sum1 = a+b;
	   System.out.println(sum1);
	}
}

public class Demo03Var{
	public static void main(String[] args){
	  /*
	    定义3个int型的变量,分别赋值为10  20  30
	  */
	  int a = 10;
	  int b = 20;
	  int c = 30;
	  System.out.println(a);
	  System.out.println(b);
	  System.out.println(c);
	  
	  System.out.println("========================");
	  
	  int i,j,k;
	  i = 10;
	  j = 20;
	  k = 30;
	  System.out.println(i);
	  System.out.println(j);
	  System.out.println(k);
	  
	  System.out.println("========================");
	  
	  int x = 10,y = 20,z = 30;
	  System.out.println(x);
	  System.out.println(y);
	  System.out.println(z);
	}
}

//变量中的转移字符

public class Demo04Var{
	public static void main(String[] args){
	   /*
	     转义字符:  \
	   */
	   
	   /*
	     \n  换行符
	   */
	   System.out.print("床前明月光");
	   System.out.print("\n");
	   System.out.print("疑是地上霜");
	   System.out.print("\n");
	   System.out.print("举头望明月");
	   System.out.print("\n");
	   System.out.print("低头思故乡");
	   System.out.print("\n");
	   
	   /*
	    t
		\t  制表符 相当于tab
	   */
	   System.out.println("柳岩和涛哥"+"\t"+"的故事");
	   
	   /*
	     使用java代码表示'
	   */
	   char data1 = ''';
	   System.out.println(data1);
	   
	   /*
	     使用java代码表示路径
		 在java中两个\代表一个\
	   */
	   String path = "E:\java\bin";
	   System.out.println(path);
	}
}

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

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

public class Demo05VarNotice{
	public static void main(String[] args){
	   int i = 10;
	   i = 20;
	   
	   int j;
	   j = 1000;
	   System.out.println(j);
	   
	   int k = 200000;
	   {
		 int x = 100000;
          System.out.println(k);		 
	   }
	   //访问不到小作用域中的数据
	   System.out.println(x);
	}
}

第七章.标识符

1.概述:我们自己给类,方法,变量取得名字
2.硬性规定(必须遵守)
  - 标识符可以包含`英文字母26个`、`0-9数字` 、`$（美元符号）`和`_（下划线）`。
  - 标识符不能以数字开头。  int i1 = 10   int 1i = 10(错误)
  - 标识符不能是关键字。  public class static{}(错误)
                      public class staticpublic{}
  
3.软性建议(建议遵守规则):
  给类取名:每一个单词首字母都大写(大驼峰式)  -> 从第一个单词开始往后每一个单词首字母大写
          public class StaticPublic{}
  给方法取名字:  从第二个单词开始往后(包括第二个单词)首字母大写(小驼峰式)  
  给变量取名字:  从第二个单词开始往后(包括第二个单词)首字母大写(小驼峰式)
               int test = 10
               int testDemo = 10
               String personNameAge = 10   

第八章.数据类型转换

1.整数默认类型:int
  小数默认类型:double
2.基本类型按照取值范围从小到大排列:
  byte->short->char->int->long->float->double
3.什么时候发生类型转换:
  当等号左右两边类型不一致时
  自动类型转换
  强制类型转换

1.自动类型转换

1.什么时候发生自动类型转换
  取值范围大的数据类型 变量名 = 取值范围小的数据类型    -> 小类型自动提升为大类型
2.注意:
  当取值范围小的类型和取值范围大的类型做运算,也会发生自动类型转换,小的转大的

public class Demo01DataType{
  public static void main(String[] args){
	  /*
	    等号右边:100->默认类型int
		等号左边:long型的变量
		
		将取值范围小的int型数据赋值给取值范围大的long型,发生了自动类型转换
	  */
	  long num1 = 100L;
	  System.out.println(num1);
	  
	  
	  /*
	    等号右边:10->默认类型int
		等号左边:double型的num2
		
		将取值范围小的类型赋值给了取值范围大的类型->发生了自动类型转换
		
	  */
	  double num2 = 10;
	  System.out.println(num2);
	  
	  /*
	    当取值范围小的类型和取值范围大的类型做运算,也会发生自动类型转换,小的转大的
	  */
	  double a = 2.5;
	  /*
	    double = double+int
		double = double+double
	  */
	  double result = a+10;
	  System.out.println(result);
  }
}

2.强制类型转换

1.什么时候需要强制类型转换
  取值范围小的数据类型 变量名 = 取值范围大的数据类型    -> 报错
2.怎么强转
  取值范围小的数据类型 变量名 = (取值范围小的数据类型)取值范围大的数据类型

public class Demo02DataType{
  public static void main(String[] args){
	  /*
	    等号右边:2.5 默认类型为double
		等号左边:int型的num1
		
		将取值范围大的类型赋值给了取值范围小的类型->需要强转
	  */
	  //int num1 = 2.5;
	  int num1 = (int)2.9;
	  System.out.println(num1);
	  
	  int num2 = (int)100L;
	  System.out.println(num2);
	  
	  float num3 = 2.5F;
	  System.out.println(num3);
  }
}

3.强转的注意事项

1.不要随意强转,强转容易导致,数据精度损失,或者数据溢出
2.byte,short如果等号右边是常量,只要是不超出范围,不用强转,因为jvm自动给转了
  byte,short如果等号右边有变量参与,结果再赋值给byte,short的变量,会自动提升为int型,需要手动强转
3.char类型的数据一旦参与运算,会自动提升为int型;
  char类型一旦被变成int型,字符会自动去编码表中查询字符对应的int值->ASCII码表
      
  如果字符在ASCII码表中找不到对应的int值,会去unicode码表(万国码)中查询

public class Demo03DataType{
  public static void main(String[] args){
	  /*
	    等号右边:2.5 默认类型为double
		等号左边:int型的num1
		
		将取值范围大的类型赋值给了取值范围小的类型->需要强转
	  */
	  //int num1 = 2.5;
	  int num1 = (int)2.9;
	  System.out.println(num1);
	  
	  /*
	  数据溢出现象
	  
	  int占4个字节  1个字节是8个二进制位
	  
	  int型数据最多能用32位二进制表示
	  
	  100亿换成二进制:36位
	  
	  多出来4位二进制,会把最前面的4位二进制干掉,剩下的就是最终结果
	  */
	  int num2 = (int)10000000000L;
	  System.out.println(num2);//1410065408
	 
  }
}

public class Demo04DataType{
  public static void main(String[] args){
	 byte num1 = 10+10;
	 System.out.println(num1);
	 
	 byte num2 = 10;
	 /*
	   byte = byte+int->int+int
	 */
	 //byte sum1 = num2+1;
	 byte sum1 = (byte)(num2+1);
	 System.out.println(sum1);
	 
	 System.out.println("=====================");
	 
	 char num3 = '中';
	 System.out.println(num3+0);
  }
}

第九章.运算符

1.算数运算符

符号	说明
+(加)	加法
-(减)	减法
*(乘)	乘法
/(除)	除法 如果符号前后都是整数,结果取整数部分;一旦前后有一个是带小数点的,结果就是小数
%(模)	取余数

public class Demo01YunSuanFu{
	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
		
		int mul = num1*num2;
		System.out.println(mul);//30
		
		int div = num1/num2;
		System.out.println(div);//3
		
		int mo = num1%num2;
		System.out.println(mo);//1
	}
}

+:
 加法
 字符串拼接:任何类型遇到字符串都会变成字符串,直接拼接

public class Demo02YunSuanFu{
	public static void main(String[] args){
		int a = 10;
		int b = 20;
		
		String result = a+b+"";
		
		System.out.println(result);
		
		System.out.println(a+""+b);//1020
		System.out.println(""+a+b);//1020
		System.out.println(""+(a+b));//30
		
		int x = 10;
		int y = 20;
		int sum = x+y;
		System.out.println("两个变量的和为:"+sum);
	}
}

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

1.格式:
  变量++ : 后自加
  ++变量:  前自加
  变量--:  后自减
  --变量:  前自减

2.使用:
  a.单独使用:++ --单独是一句,没有和其他代码混合使用
    符号在前或者在后没区别,都是先运算
  b.混合使用:++ --和其他语句混合使用(赋值语句,打印语句等)
    符号在前:先计算,然后再使用计算后的值
    符号在后:先使用原值,使用完毕之后,自身再运算

public class Demo03ZiJiaZiJian{
	public static void main(String[] args){
		int i = 10;
		//i++;
		
		++i;
		System.out.println(i);//11
		
		System.out.println("=================");
		
		int j = 10;
		int result = j++;
		System.out.println(result);
		System.out.println(j);
		
		System.out.println("=================");
		
		/*
		  特殊:
		    c的原值是100
			将100又赋值给了c
			此时c依然是100
		*/
	    int c = 100;
		c = c++;
		System.out.println(c);
		System.out.println(c);
		
		System.out.println("=================");
		
		int x = 10;
		int y = 20;
		
		/*
		  10+21 = 31
		  
		  10+21-11 = 20
		  
		  注意:不要担心,以后开发绝对不用
		*/
		int result02 = x++ + ++y - x--;
		System.out.println(result02);
		System.out.println(x);
		
	}
}

3.赋值运算符

基本赋值运算符
=    -> 先看等号右边的
    
复合赋值运算符    
+=
    int i = 10;
    i+=1;//  展开  i = i+1
-=
*=
/=: 取整数部分
%=: 取余数部分
    
注意:
  byte,short使用复合赋值运算符时,jvm会自动强转

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

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

1.作用:比较判断,作为比较条件使用
2.结果:结果为boolean型

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

public class Demo05Compare{
	public static void main(String[] args){
		int i = 10;
		int j = 20;
		int k = 10;
		
		boolean result01 = i==k;
		System.out.println(result01);
		
		System.out.println(i>j);
		System.out.println(i<j);
		System.out.println(i>=k);
		System.out.println(i<=j);
		System.out.println(i!=j);
		System.out.println(i!=k);
	}
}

5.逻辑运算符

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

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

public class Demo06LuoJi{
	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);//false
		
		boolean result02 = (i>j)||(i<=k);
		System.out.println(result02);//true
		
		boolean result03 = (i>j)^(i<k);
		System.out.println(result03);//false
		
		boolean result04 = !(i>j);
		System.out.println(result04);//true
	}
}

1.&&和&区别

&:如果符号前后为boolean表达式,就是逻辑运算符,有假则假

如果符号前后为数字,&就是位运算符

&&(短路与):有假则假,如果符号前为false,后面不看了

2.||和|区别:

|:如果符号前后为boolean表达式,就是逻辑运算符,有真则真

如果符号前后为数字,|就是位运算符

||(短路或):有真则真,如果符号前为true,后面不看了

问题:定义一个变量,判断此变量的值是否是1-100之间的

数学写法: 1<=x<=100

java写法: x>=1 && x<=100

6.三元运算符

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

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

十进制	二进制	八进制	十六进制
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代表true   0代表false

我们要知道计算机在存储数据的时候都是存储的数据的补码,而计算的也是数据的补码

1.正数二进制最高位为0;负数二进制最高位是1
2.正数的原码,反码,补码一致
  如:5的源码,反码,补码为:
     0000 0000 0000 0000 0000 0000 0000 0101->二进制最高位是0,因为是正数
3.负数的话原码,反码,补码就不一样了
  反码是原码的基础上最高位不变,其他的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

相当于: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的使用

1.idea的介绍

1.概述:开发工具   由java编写, 使用idea必须由jdk环境   自动保存
2.作用:加速我们的开发

2.idea的目录结构

3.如何去创建一个Project

3.1再次创建一个新的Project

或者:

4.关闭Project

file->close project

5.打开project

file->close project->open

6.创建module

6.1创建新的module

或者

或者

6.2打开和关闭module

关闭:

打开:

7.创建以及删除package

7.1创建

7.2 package的删除

对着包->右键->delete

7.3 package取名字规范

1.不要有中文
2.不要以数字开头
3.给包取名时一般都是公司域名倒着写,而且都是小写
  www.atguigu.com
  
  那么我们去package包名应该写成:com.atguigu.名字
      
 com.atguigu.a_for->在本地上是文件夹嵌套   一个.就是一级文件夹

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

psvm-->生成main方法

sout->生成输出语句

9.基本设置

9.1设置字体

file->settings

9.2设置提示的快捷键

file->settings

9.3 设置注释字体

10.快捷键

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

先写等号右边,按"alt+enter"自动生成等号左边的变量

11.出现的问题

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

第十四章.键盘录入_Scanner

1.概述:Java定义好的一个类
2.作用:可以通过键盘录入的形式将数据放到代码中参与运行
3.怎么使用:
  a.导包:import 包名.包名.类名  -> import java.util.Scanner
    目的:找到我们要使用的类
  b.创建对象:
    Scanner 名字 = new Scanner(System.in);
  c.调用方法,实现键盘录入
    名字.方法名()
      
4.常用方法:
  nextInt():输入int型的整数
  nextDouble():输入double型的小数
  next():输入一个字符串

快捷操作:

一.自动生成等号左边部分

1.alt+回车->自动生成等号左边的部分

2. var->->自动生成等号左边的部分

   二.快速将变量放到输出语句中

变量名.sout

public class Demo01Scanner {
    public static void main(String[] args) {
        //创建对象
        Scanner sc = new Scanner(System.in);
        //调用方法,实现键盘录入
        int data1 = sc.nextInt();
        System.out.println(data1+1);

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

public class Demo02Scanner {
    public static void main(String[] args) {
        //创建Scanner
        Scanner scanner = new Scanner(System.in);
        System.out.println("请你输入第一个整数:");
        int data1 = scanner.nextInt();
        System.out.println("请你输入第二个整数:");
        int data2 = scanner.nextInt();

        int result = data1 + data2;

        System.out.println(result);
    }
}

Exception in thread "main" java.util.InputMismatchException
	at java.util.Scanner.throwFor(Scanner.java:864)
	at java.util.Scanner.next(Scanner.java:1485)
	at java.util.Scanner.nextInt(Scanner.java:2117)
	at java.util.Scanner.nextInt(Scanner.java:2076)
	at com.atguigu.b_scanner.Demo02Scanner.main(Demo02Scanner.java:10)

以上问题原因:输入的类型不一致

录入字符串:next()  nextLine()

next()->在录入的过程中,遇到空格和回车就结束录入了
nextLine()->在录入的过程中,遇到回车就结束录入

public class Demo03Scanner {
public static void main(String[] args) {
  Scanner scanner = new Scanner(System.in);
  String data = scanner.next();
  String data1 = scanner.nextLine();
  System.out.println(data);//abc
  System.out.println(data1);// haha
}
}

第十五章.switch(选择语句)

1.switch基本使用

1.格式:
  switch(变量){
      case 常量值1:
          执行语句1;
          break;
      case 常量值2:
          执行语句2;
          break;
      case 常量值3:
          执行语句3;
          break;
      ...
      
      default:
          执行语句n;
          break
  }
2.执行流程:
  用变量的值挨个和下面每一个case后面的常量值进行匹配,匹配上哪个case就执行哪个case对应的执行语句,然后走对应的break,结束switch
  如果以上所有的case都没有匹配上,就走default对应的执行语句
      
3.break关键字:
  代表的是结束switch语句
      
4.switch中能写什么类型的数据:
  byte short int char 枚举类型(jdk5是新增),String类型(jdk7新增)

public class Test01Switch {
    public static void main(String[] args) {
        //创建Scanner对象
        Scanner scanner = new Scanner(System.in);
        int num = scanner.nextInt();

        switch (num) {
            case 1:
                System.out.println("111");
                break;
            case 2:
                System.out.println("222");
                break;
            case 3:
                System.out.println("333");
                break;
            case 4:
                System.out.println("444");
                break;
            default:
                System.out.println("ddddd");
                break;
        }
    }
}

public class Test02Switch {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请你输入一个月份:");
        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("输入有误!");
                break;
        }
    }
}

2.case的穿透性

如果,没有break,会出现case的穿透性,一直往下穿透,直到第一次遇到break或者switch代码执行完毕为止

public class Test03Case {
    public static void main(String[] args) {
        int num = 2;
        switch (num) {
            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("涛哥");
        }
    }
}

public class Test02Switch {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请你输入一个月份:");
        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("你有病呀,输入有误!");
                break;
        }
    }
}

第十六章.分支语句

1.if的第一种格式

1.格式:
  if(boolean表达式){
    执行语句
  }
2.执行流程:
  先走if后面的boolean表达式,如果是true,就走if后面大括号中的执行语句,否则就不执行

public class Demo01If {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请您输入第一个整数:");
        int data1 = sc.nextInt();
        System.out.println("请您输入第二个整数:");
        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,否则走else后面的执行语句2

public class Demo02IfElse {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请您输入第一个整数:");
        int data1 = sc.nextInt();
        System.out.println("请您输入第二个整数:");
        int data2 = sc.nextInt();

        if (data1 == data2) {
            System.out.println("相等");
        }else{
            System.out.println("不相等");
        }

        System.out.println("哈哈哈");
    }
}

2.1 练习

任意给出一个整数，请用程序实现判断该整数是奇数还是偶数，并在控制台输出该整数是奇数还是偶数
步骤:
  1.创建Scanner
  2.调用nextInt方法录入一个整数 data
  3.利用if判断奇偶性  data%2==0

public class Demo03IfElse {
    public static void main(String[] args) {
        //1.创建Scanner
        Scanner sc = new Scanner(System.in);
        //2.调用nextInt方法录入一个整数 data
        int data = sc.nextInt();
        //3.利用if判断奇偶性  data%2==0
        if (data%2==0){
            System.out.println("偶数");
        }else{
            System.out.println("奇数");
        }
    }
}

2.2练习

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

public class Demo04IfElse {
    public static void main(String[] args) {
        //1.创建Scanner
        Scanner sc = new Scanner(System.in);
        //2.调用nextInt方法录入一个整数 data1
        int data = sc.nextInt();
        int data1 = sc.nextInt();

        if (data>data1){
            System.out.println(data);
        }else{
            System.out.println(data1);
        }
    }
}

public class Demo05IfElse {
    public static void main(String[] args) {
        //1.创建Scanner
        Scanner sc = new Scanner(System.in);
        //2.调用nextInt方法录入一个整数 data1
        int data1 = sc.nextInt();
        int data2 = sc.nextInt();
        int data3 = sc.nextInt();

        int temp;
        if (data1>data2){
            temp = data1;
        }else{
            temp = data2;
        }


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

    }
}

2.3练习

案例：从键盘输入年份，请输出该年的2月份的总天数。闰年2月份29天，平年28天。

闰年：
（1）能被4整除，不能被100整除
（2）能被400整除
    
 步骤:
  1.创建Scanner对象
  2.调用nextInt,录入一个年份: year
  3.判断是否为闰年:
    (year%4==0 && year%100!=0)||(year%400==0)

public class Demo06IfElse {
    public static void main(String[] args) {
        //1.创建Scanner对象
        Scanner sc = new Scanner(System.in);
        //2.调用nextInt,录入一个年份: year
        int year = sc.nextInt();
        /*3.判断是否为闰年:
        (year%4==0 && year%100!=0)||(year%400==0)  */
        if ((year%4==0 && year%100!=0)||(year%400==0)){
            System.out.println("闰年2月29天");
        }else{
            System.out.println("平年2月28天");
        }
    }
}

2.4练习

public class Test06 {
    public static void main(String[] args) {
        boolean num1 = false;
        boolean num2 = true;
        int i = 1;
        if (num1 = num2){//相当直接写了一个true
            i++;
            System.out.println(i);
        }
        
        if (false){//相当于直接写了一个false
            --i;
            System.out.println(i);
        }
    }
}

3.if的第三种格式

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

2.执行流程:
  a.走if后面的boolean表达式,如果是true,就走if对应的执行语句1
  b.如果是false,走下面的else if,继续判断,如果是true,就走else if对应的执行语句2
  c.如果还是false,继续往下判断
  d.如果以上所有情况都不满足,就 走else对应的执行语句n
3.使用场景:2种情况以上的判断

public class Demo07ElseIf {
    public static void main(String[] args) {
        //1.创建Scanner
        Scanner sc = new Scanner(System.in);
        //2.调用nextInt方法录入一个整数 data1
        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");
        }
    }
}

3.1.练习

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

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

public class Test01 {
    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>7 || week<=0){
            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练习

- 需求: 小明快要期末考试了，小明爸爸对他说，会根据他不同的考试成绩，送他不同的礼物，假如你可以控制小明的得分，请用程序实现小明到底该获得什么样的礼物，并在控制台输出。
- 奖励规则:
95~100		山地自行车一辆
90~94		游乐场玩一次
80~89		变形金刚玩具一个
80以下	   胖揍一顿

public class Test02 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int score = sc.nextInt();

        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 if (score>=0 && score<80){
            System.out.println("胖揍一顿");
        }else{
            System.out.println("没这个分数,往死里打");
        }
    }
}

第十七章.循环语句

1.for循环

1.格式:
  for(初始化变量;比较;步进表达式){
     循环语句
  }
2.执行流程:
  a.初始化变量
  b.比较判断,如果是true,进入循环体,执行循环语句,走步进表达式(初始化的变量的值改变)
  c.再比较,如果还是true,继续进入循环体,执行循环语句,再走步进表达式
  d.再比较,直到比较为false,循环结束

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

1.1练习

for循环练习1：求1-3之间的数据和，并把求和结果在控制台输出

    1+2+3
步骤:
  1.定义一个变量,接收两个数的和 sum
  2.利用循环,将1 2 3表示出来
  3.在循环体中,两两相加,将结果赋值给sum
  4.输出sum

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

1.2练习

需求:求出1-100的偶数和
步骤:
  1.定义一个变量,接收两个偶数的和  sum
  2.利用循环将1-100循环出来
  3.判断,i%2==0,如果是true,证明是偶数,相加
  4.输出sum

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

1.3练习

需求:统计一下1-100之间的偶数个数
    
1.定义变量,用来计数,count
2.利用循环将1-100循环出来
3.判断,i%2==0,如果是true,证明是偶数,count++
4.输出count

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

快速生成for循环的快捷键:

次数.fori

第十八章.循环语句_while

1.while循环

1.1while循环的简单使用

1.格式:
  初始化变量
  while(比较){
     循环语句
     步进表达式
  }
2.执行流程:
  a.初始化变量
  b.比较,如果是true,执行循环语句,走步进表达式
  c.再比较,如果还是true,继续循环,继续走步进表达式
  d.再比较,知道比较为false,循环结束     

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

public class Test02 {
    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);
    }
}

1.2while练习

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

步骤:
  1.定义一个变量,统计次数-> count
  2.利用while循环,循环比较
  3.如果纸的厚度<=山峰高度
  4.循环对折,count++
  5.输出count

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

2.do...while循环(了解)

1.格式:
  初始化变量
  do{
    循环语句
    步进表达式
  }while(比较);
2.执行流程:
  a.初始化变量
  b.执行循环语句,步进表达式
  c.比较,如果是true,继续循环,如果是false,循环结束
          
3.特点:至少执行一次循环

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

温馨小提示:快速生成for循环-> 次数.fori

xmind快捷键:

生成子主题	tab
生成兄弟主题	回车
编辑主题	F2
添加备注	F4
删除主题	delete

3.循环的区别

1.for:在for循环中初始化的变量,出了for循环使不了了
2.while:在while循环初始化的变量,出了while循环还能使用
3.do...while:至少执行一次
4.确定次数用for,不确定次数用while

4.循环控制关键字

1.break:
  a.在switch中代表结束switch语句
  b.在循环中表示结束循环
2.continue:
  a.结束本次循环,自动进入下一次循环

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

5.死循环

1.概述:一直循环
2.什么时候发生:比较一直为true

public class Test01 {
    public static void main(String[] args) {
        int count = 0;
        for (;;){
            count++;
            System.out.println("我爱钱"+count);
        }

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

6.嵌套循环

1.概述:循环中又套着一个循环
2.执行流程:
  先走外层for循环,进入内层for循环,内层for循环就一直循环,直到内层for循环结束,外层for循环进入下一次循环
  直到外层for循环都结束了,所有的循环全部结束

public class Test01 {
    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 + "秒");
            }
        }
    }
}