java基础——入门篇
1、认识java
核心知识点：JVM、搭建Java开发环境、java的发展史、java特点、java程序类型、垃圾收集器、J2SE下载和安装、环境变量的配置和测试、以及简单的开发工具的使用等等；主要了解java的发展史、特点、JDK、JRE、java技术体系、以及工具的安装与简单使用；
1.1、初步了解计算机
1.1.1 硬件与软件的区别？
硬件
1.cpu是一台计算机的运算核心和控制核心。其功能主要是解释计算机指令以及处理计算机软件中的数据。CPU由运算器、控制器、寄存器、高速缓存及实现它们之间联系的数据、控制及状态的总线构成。作为整个系统的核心，CPU 也是整个系统最高的执行单元，因此CPU已成为决定电脑性能的核心部件，很多用户都以它为标准来判断电脑的档次。CPU的主频,即CPU内核工作的时钟频率（CPU Clock Speed）。该时钟速度越快，时间段内执行的指令就越多。
2.内存是数据与CPU进行沟通的桥梁。计算机中所有程序的运行都是在内存中进行的，内存(Memory)也被称为内存储器，其作用是用于暂时存放CPU中的运算数据，以及与硬盘等外部存储器交换的数据。
3.存储设备：内存不能长久保存数据（非ROM），断电时信息就丢失，程序和数据都会被保存在存储设备中（例如硬盘），当程序和数据需要使用时，再加载进内存，注意：内存读取和写入的速度要比存储设备快的多。
存储设备主要有：磁盘驱动器，光盘驱动器（cd dvd）USB闪存（U盘）。
软件
软件的概述：按照一定顺序组织的计算机数据与指令的集合。
软件 = 数据+指令+文档
1.系统软件
例如：Widows xp 、 Linux 、 Unix
2.应用软件
例如：QQ、WPS、Photoshop、微软的Office
软件开发：制作软件。
软件的本质 ：提高人与计算机交流效率，方便人与机器交互。
1.1.2人机交互的方式
1.图形化界面：简单直观，容易操作，用户的体验好。
2.dos命令交互方式：需要有一个控制台，输入特定的指令，让计算机完成一些操作。较为麻烦，需要记录住一些命令,而且只能完成一些比较单一的功能。
控制台打开的步骤：
第一种方式：win—— 运行——cmd
第一种方式：win键盘 + R
常见的dos命令
盘符： 进入指定的盘符下。
dir : 列出当前目录下的文件以及文件夹
md : 创建目录
rd : 删除目录 注意：rd不能删除非空的文件夹，而且只能用于删除文件夹。
cd : 进入指定目录
cd.. : 退回到上一级目录
cd \ : 退回到根目录
echo "hello java">a.txt 写入文本到指定文件
type a.txt 显示文件内容命令
del : 删除文件 注意：不能删除文件夹，只能删除文件。
exit : 推出dos命令行
cls : 通知计算机将当前的命令清空
*: 是通配符。
tab 命令补全。
方向键上下是找回上次你写过的命令。
或者
小知识点
/ 和 \ 区别：Unix操作设计了这种路径分割法，他是用斜杠 /,由于网络是首先应用在Ｕｎｉｘ计算机之间的，至今为止，一半以上的网络服务器一半使用的是ｕｎｉｘ操作系统，所以网址也沿用了斜杠作为分隔符
微软在开发ＤＯＳ２.0时候，从ｕｎｉｘ中借鉴了这种目录结构，但是由于ｄｏｓ中斜杠已经用来作为命令行参数的标志了（unix中的是 - ），所以只得使用反斜杠 \
到了ｗｉｎｄｏｗｓ时代，很多时候已经没有命令行参数的干扰，加上网络使用的扩展，现在斜杠和反斜杠大多数时候都可以互换，没有什么影响。
ｃｌｓ:清除屏幕
ｅｘｉｔ：退出ｃｍｄ
1.2 java简介
语言起源
Java是SUN ( Stanford University Network 斯坦福大学网络公司 ) 1995年推出的一门高级编程语言。 Java名称的来源Java最初被命名为Oak，目标在于家用电器等小型系统的编程语言，随着市场的变化，SUN着眼于网络应用的开发。Java的名字的来源：Java是印度尼西亚爪哇岛的英文名称，因盛产咖啡而闻名。 创始人James Gosling被业界称之为ｊａｖａ之父；
1995年5月23日，JAVA语言诞生 雏形
1996年，1997分别推出JDK1.0，JDK1.1版 1999年，JAVA被分成J2SE,J2EE,J2ME
2000年，JDK1.4发布 2004年9月30日18:00PM，J2SE1.5发布，成为Java语言发展史上的又一里程碑。为了表示该版本的重要性，J2SE1.5更名为Java SE 5.0 2005年，JAVA版本正式更名为JAVAEE,JAVASE, JAVAME 2006年12月，SUN公司发布JRE6.0
2009年04月20日，Oracle以74亿美元收购Sun。取得java的版权。
2010年9月，JDK7.0已经发布，增加了简单闭包功能。
2011年7月，甲骨文公司发布java7的正式版。
1.3 java语言重要特性之跨平台
什么是跨平台（计算机系统），跨平台概念是软件开发中一个重要的概念，即不依赖于操作系统，也不信赖硬件环境。一个操作系统下开发的应用，放到另一个操作系统下依然可以运行。
Java的跨平台是相对于其他编程语言而言的，通过Java语言编写的应用程序在不同的系统平台上都可以运行。一般的高级语言如果要在不同的平台上运行，至少需要编译成不同的目标代码。在windows编译的c语言程序，在linux下是不能运行的。当然在linux下编译的c语言程序在windows下也是不能运行的。而Java语言在不同平台上运行时不需要重新编译。
Java跨平台的原理：Java的跨平台是通过Java虚拟机（JVM）来实现的。
1.4Java虚拟机（JVM）
Java Virtual Machine 一个软件模拟的计算机。Java源程序想象成我们的C源程序，Java源程序编译后生成的字节码（.class）就相当于C源程序编译后的二进制可执行文件。JVM虚拟机相当于计算机系统（操作系统+硬件环境），Java解释器相当于CPU。
.exe文件直接在windows操作系统下运行，在CPU上运行的是机器码（.exe文件）
.class字节码文件是运行在JVM虚拟机下的，在Java解释器上运行的是Java字节码。
Java解释器相当于运行Java字节码的“CPU”，但该“CPU”不是通过硬件实现的，而是用软件实现的。Java解释器实际上就是特定的平台下的一 个应用程序。只要实现了特定平台下的解释器程序，Java字节码就能通过解释器程序在该平台下运行，这是Java跨平台的根本。当前，并不是在所有的平台 下都有相应Java解释器程序，这也是Java并不能在所有的平台下都能运行的原因，它只能在已实现了Java解释器程序的平台下运行。
1.5 Java是什么？？？
是一门面向网络的高级程序设计语言，程序员可以用它创建应用程序，这些应用程序通过网络下载后运行，相对于本地是安全的。如果将Java和网络融合在一起，则会组成一个网络计算机环境；
Java的三大平台
Java SE（Java Platform，Standard Edition）。Java SE 以前称为J2SE。它允许开发和部署在桌面、服务器、嵌入式环境和实时环境中使用的Java 应用程序。Java SE 包含了支持Java Web 服务开发的类，并为Java Platform，Enterprise Edition（Java EE）提供基础。
例子：类似QQ、扫雷、飞秋、凌波这样子的桌面应用。
Java EE
Java EE（Java Platform，Enterprise Edition）。这个版本以前称为J2EE。企业版本帮助开发和部署可移植、健壮、可伸缩且安全的服务器端 Java 应用程序。Java EE 是在Java SE 的基础上构建的，它提供Web 服务、组件模型、管理和通信API，可以用来实现企业级的面向服务体系结构（service-oriented architecture，SOA）和Web 2.0 应用程序。
Java ME
Java ME（Java Platform，Micro Edition）。这个版本以前称为J2ME，也叫K-JAVA。Java ME 为在移动设备和嵌入式设备（比如手机、PDA、电视机顶盒和打印机）上运行的应用程序提供一个健壮且灵活的环境。Java ME 包括灵活的用户界面、健壮的安全模型、许多内置的网络协议以及对可以动态下载的连网和离线应用程序的丰富支持。基于Java ME 规范的应用程序只需编写一次，就可以用于许多设备，而且可以利用每个设备的本机功能。
1.6 环境的搭建
JDK简介:
JDK（Java Development Kit）是Sun Microsystems针对Java开发员的产品。自从Java推出以来，JDK已经成为使用最广泛的Java SDK。JDK 是整个Java的核心，包括了Java运行环境、Java工具和Java基础类库。JDK是学好Java的第一步。从SUN的JDK5.0开始，提供了泛型等非常实用的功能，其版本也不断更新，运行效率得到了非常大的提高。
JDK的安装网址：（http://www.oracle.com）
JDK目录介绍
1. bin目录：存放Java的编译器、解释器等工具(可执行文件)。
2. db目录：JDK7附带的一个轻量级的数据库，名字叫做Derby。
3. include目录：存放的调用系统资源的接口文件。
4. jre目录：存放Java运行环境文件。
5. lib目录：存放Java的类库文件。
6. src.zip文件：JDK提供的类的源代码。
安装JDK需要注意的事项：
1. 安装路径中不要包含中文。
2. 安装路径中不要包含空格。
jdk
Jdk(java development kit) java 开发工具包，Jre只是运行java程序，那么我们要做开发，就需要相关的开发工具。
Jdk提供给java开发人员使用的，我们使用jdk开发程序，开发完成后交给jre去运行
注意：实际上，jdk也包含了jre
Jdk = 开发工具包 +jre（jvm+核心类库）
结论：所以安装完idk后我们就不用再安装jre
jre
Jre全英文名是： java runtime Environment java运行环境
Jvm全英文名是：java Virtual Machine java虚拟机，它是java的核心，但是要运行一个java程序，核心有可能不够，它还需要一些相关的辅助工具，这个辅助工具我们把他们叫做核心类库。这里存放的是程序所需要的最笨的的和核心的内容。
所以jvm和核心类库就组成了jre
Jre = jvm +核心类库
现在有了jre，我们就可以在计算机上运行java程序了，但是我们学习java不是要运行，我们是要做开发；
总结：jre只是负责运行java程序
1.7配置path环境变量
问题：目前在控制台窗口下只能在jdk安装目录的bin目录下才能使用jdk的开发工具在控，如果想制台窗口下想要在任意目录下都可以使用javac与java或者jdk其他的开发工具那应该怎么做呢？
1.在dos窗口敲上javac
我们在随意的一个目录敲javac或者java命令时候，发现dos窗口显示这个不是内部命令，然后我们在上面敲上notepad命令时，打开了一个记事本的程序，但是在当前目录下页没有存在notepad.exe的可执行文件，那么为什么能启动呢？
错误原因：原来在dos窗口上写上一个命令时候，如果在当前目录下找不到指定的可执行文件，那么它会根据path环境变量保存的路径去搜索是否存在这个可执行文件，如果存在则启动该程序，否则就没有这个命令。
2.解决方法：
1、进入jdk的安装目录的bin目录。
2、在dos命令上敲javac。(如果出现了以上的图信息则配置成功)
3.为什么要配置path环境变量
因为在jdk下bin文件夹中有很多我们在开发中要使用的工具，如java.exe,javac.exe,jar.ex等,那么我们在使用时，想要在电脑的任意位置下使用这些java开发工具，那么我们就需有把这些工具所在的路径配置到系统的环境变量中，当我们使用时，系统可以帮且我们找到这些命令。
4.如何配置path环境变量
打开环境变量
配置java_home
配置PATH
配置classpath
测试是否安装成功：-version
1.8程序入门：hello Word
Hello Word程序入门
1.打开一个记事本在记事本里面写上class 类名{}
2.一个类缺少主函数不能独立运行。
3.可以独立运行了，但是没有效果。输出语句。
HelloWord 例子剖析：
class java关键字，用于什么一个类、
{} : 花括号表示范围。
main ： 是主函数的如果（固定写法）。
1.9 了解块（感兴趣的自己可查阅相关知识点）
Java 9 的新特征：模块化、支持HTTP2.0、改进的javadoc、接口的私有方法、集合工厂方法、代码分段缓存、货币API、简化进程API；
Java程序类型：Java应用程序、Applet小程序、Servlet程序
Java技术体系：Java编程语言、Java类文件、Java API、JVM
Java JVM的生命周期：简单可以理解为2个线程，一个守护：负责垃圾处理；一个普通（一普通为核心），对程序继续开始和结束；
垃圾收集器：避免内存泄露，相对于监视Java程序的运行
2、Java语言基础
2.1、开发工具
前期主要以简单的Eclipse为主，Eclipse 是一个开放源代码的、基于Java的可扩展开发平台。就其本身而言，它只是一个框架和一组服务，用于通过插件组件构建开发环境。幸运的是，Eclipse 附带了一个标准的插件集，包括Java开发工具（Java Development Kit，JDK）。
2.1.1插件安装方法
Eclipse插件的安装方法介绍以下2种
第一种：直接复制法
假设Eclipse的安装目录在C:\eclipse，解压下载的eclipse 插件或者安装eclipse 插件到指定目录AA(如：c:\AA)文件夹，打开AA 文件夹，在AA文件夹里分别包含两个文件夹features和plugins ，然后把两个文件夹里的文件分别复制到C:\eclipse下所对应的文件夹下的features 和plugins 下，一般的把插件文件直接复制到eclipse目录里是最直接也是最愚蠢的一种方法！因为日后想要删除这些插件会非常的困难，不推荐使用。
注意：直接将插件包解压到plugins文件夹下之后，重启eclipse，可能不会加载新的插件。
解决方法是：
1、打开命令行，到当前eclipse的目录下，输入eclipse -clean，重新启动eclipse，这样eclipse就会加上新的插件了。
2、如果插件不能生效，则请将eclipse\configuration\org.eclipse.update目录删除后再启动eclipse；
你可以在eclipse的菜单"Help"-->"About Eclipse SDK"-->"Feature Details" 和"Plug-in Details"中看到新安装的插件。
第二种：使用link文件法
a.假设Eclipse的安装目录在C:\eclipse，在该文件夹下，新建这样的目录结构C:\eclipse\PluginsEclipse\jode\eclipse；
b.解压下载的eclipse 插件或者安装eclipse 插件到指定目录BB（如：C:\BB）文件夹，打开BB文件夹，然后把 BB文件夹里的两个文件夹features和plugins复制到刚刚新建好C:\eclipse\PluginsEclipse\jode\eclipse，这样eclipse中就有了两个插件目录features and plugins下。
c.在C:\eclipse目录中新建links（C:\eclipse\links）目录，在links目录中建立一个以link为扩展名的文本文件如jode.link，内容如下path=C:/eclipse/PluginsEclipse/jode 或者path=C:\\eclipse\\PluginsEclipse\\jode（插件的目录），保存后重启eclipse插件就会安装完成。
2.1.2 具体使用
第一步：首先，电脑要安装配置好eclipse的环境，这个步骤就不在这赘述了。打开eclipse软件。
第二步：点击file--new--java project，即新建java项目
第三步：为这个项目命名，点击finish，在左边的面板上就出现了test的项目
第四步：展开test项目，对着里面的src点击右键--new--class，即新建一个类
第五步：为类命名，注意，首字母必须是大写，点击finish，这时候，就可以在主窗体编写代码了;
2.1.3 快捷键
1)单词联想 Alt + /
2)删除一行 Ctr + d
3)向上复制一行 Ctrl + Alt + 向上键
3)向下复制一行 Ctrl + Alt + 向下键
4)向下移动一行 Alt + 向下键
5)向下移动一行 Alt + 向上键
6)换行 shift + Enter 的的的的
7)美观代码 Ctrl + shift + F (该输入法跟所有的中文输入工具冲突)
8)解决小红叉错误 Ctrl + 1
9)将字母转换成小写 Ctrl + shift + y
10)将字母转换成大写 Ctrl + shift + x
11)想要打印某个变量连续按Alt + / 两次
12)添加单行注释： Ctrl + / 想要取消，再一次Ctrl + /
13)添加多行注释 Ctrl + shift + / 取消多行注释 Ctrl + shift + \
2、Java语言基础
Java基础主要的核心就是从学会Java规则到简单的运用；
2.1标识符
就是程序员在定义java程序时，自定义的一些名字，例如helloworld 程序里关键字class 后跟的Demo，就是我们定义的类名。类名就属于标识符的一种。
标识符除了应用在类名上，还可以用在变量、函数名、包名上。
2.1.1标识符必须遵循以下规则
1.标识符由26个英文字符大小写（a~zA~Z）、数字(0~9)、下划线(_)和美元符号($)组成。
2.不能以数字开头，不能是关键字
3.严格区分大小写
4.标识符的可以为任意长度
标识符的例子，合法的标识符
ComputeArea，radius，area $itcast _itcast gz_itcast
注意：由于Java严格区分大小写，ITCAST 和itcast是完全不同的标识符
非法标识符
1.class (关键字)
2.100java(不能以数字开头)
3.Hello java (空格不是组成标识符的元素)
2.1.2Java中的标识符命名规范
1.包名
多个单词组成时所有字母小写（例:package com.itcast）
2.类名和接口
多个单词组成时所有单词的首字母大写(例：HelloWorld)
3.变量名和函数名
多个单词组成时第一个单词首字母小写，其他单词首字母大写（例：lastAccessTime、getTime）。
4.常量名
多个单词组成时，字母全部大写，多个单词之间使用_分隔（例：INTEGER_CACHE）
注意：只是为了增加规范性、可读性而做的一种约定，标识符在定义的时候最好见名知意，提高代码阅读性。
我们在随意的一个目录敲javac或者java命令时候，发现dos窗口显示这个不是内部命令，然后我们在上面敲上notepad命令时，打开了一个记事本的程序，但是在当前目录下页没有存在notepad.exe的可执行文件，那么为什么能启动呢？
错误原因：原来在dos窗口上写上一个命令时候，如果在当前目录下找不到指定的可执行文件，那么它会根据path环境变量保存的路径去搜索是否存在这个可执行文件，如果存在则启动该程序，否则就没有这个命令。
2.解决方法：
1、 进入jdk的安装目录的bin目录。
2、 在dos命令上敲javac。(如果出现了以上的图信息则配置成功。
2.2Java中的关键字
(看看就好，用户碰见多了，自然就记住了)
其中：
byte short int long float double char boolean String …
用于定义数据类型
true false
判断真假
If else switch case default while do for break continue return
用于定义流程控制的关键字
2.3 注释
单行注释
单行注释的表现很简单，只需要在开头添加两个斜线就可以了.
用法： // 后面写书的内容就是注释
注意： 单行注释里可以有单行注释
多行注释
有开发和结束的注释，中间的部分全部都是被注释的内容
用法： /*
注释内容
*/
注意：单行和多行注释，很多的语言都是支持的，而接下来文档注释是java特有的多行注释中，不能有多行注释
文档注释
文档注释稍微特殊，在文档注释里面可以写程序的作者，程序的版本，同时在文档注释里面可以有注释的文字信息
用法：
/**
@author 作者
@version 版本
其他的注释内容
*/
说明：前面加个@符号，这个单词是可以被解析的；
注：文档注释用/** */表示，是java特有的注释，其中注释内容可以被JDK提供的工具 javadoc 所解析，生成一套以网页文件形式体现的该程序的说明文档。
1 public static void main(String[] args) { 2 // 第一步： 获取半径？并将半径保存在程序中 3 double radius = 5; 4 // 第二步：计算面积，并将面积保存在程序中 5 /* 6 double area = radius * radius * 3.1415; 7 // 第三步：在控制台现实面积 8 System.out.println("半径为" + radius + "的圆的面积为：" + area); 9 */ 10 11 }
注释的使用细节：
三种注释可以出现在程序的任何地方，但是不推荐找任意位置。
1. 编程习惯：
1. 给那条语句进行说明，注释应该写在该语句的旁边。
2. 单行注释一般写在语句的后面多行注释和文档注释一般写在语句的上面
注意：文档注释只能出现在类、属性、方法的上面。
2.4 数据类型
2.4.1 常量的概述
常量是指在程序运行过程中其值不能改变的量。
2.4.2常量类型
Java中常量的分类：
整数常量 ： 所有整数
小数常量 ： 所有小数
布尔常量 ： 只有true和false
字符常量 ：使用’’引起来的单个字符
字符串常量 ：使用“”引起来的字符序列，“” 、“a” 、” ”
null常量 ： 只有一个值null
2.4.3 char 类型
char类型表示的是单个字符类型，任何数据使用单引号括起来的都是表示字符。字符只能有一个字符，比如：普通的老百姓穿上军装就是军人。
注意：特殊字符的转义序列：转义字符
转义字符的概述:
特殊字符使用”\”把其转化成字符的本身输出，那么使用”\”的字符称作为转移字符。
需求：使用输出语句，打印出带引号的信息例如输出。
System.out.println("teacher said"java is fun"");编译是无法正常通过的。语法有错误，编译器读到第二个引号就认为是字符串的结束，剩余的不知道怎么处理。如何解决这个问题：java中使用转义字符来表示特殊的字符。一个转义字符以反斜杠（\）开始。
问题：想要打印带引号的字符串怎么办，就可以使用反斜杠（\）后跟字符，这个反斜杠就是转义字符。
转义 字符 名称 Unicode
\b Backspace （退格键） \u0008
\t Tab （Tab键盘） \u0009
\n Linefeed （换行） \u000A
\r Carriage Return （回车） \u000D
\\ Backslash （反斜杠） \u005C
\' Single Quote （单引号） \u0027
\" Double Quote （双引号） \u0022
其中
\r 表示接受键盘输入，相当于按下回车。
\n 表示换行。
\t 制表符，相当于Table键
\b 退格键，相当于Back Space
\’ 单引号
\’’ 双引号
\\ 表示一个斜跨
上述问问题解决：System.out.println("teacher said\"java is fun\"");
注意：换行符就是另起一行，回车符就是回到一行的开头，所以我们平时编写文件的回车符应该确切来说叫做回车换行符
2.4.4. boolean 类型
boolean由数学家Geogore Boole 发明
boolean 类型用来存储布尔值，在java中布尔值只有2个，true和false。
boolean flag=true;
flag=false;
2.4.5常见的数据类型
为什么有数据类型？
Java语言是一个强类型语言，对于每一种数据都定义了明确的绝体数据类型，在内存中分配了不同大小的内存空间。
Java中数据类型分类
Java中数据共计划分为2大类型
2-1 引用数据类型 如：数组、类、接口等等’
2-2 基本数据类型:
对基本的数据进行类型划分：
整数：由于整数有非常大的数据，也有非常小的数据，于是把证书类型又区分成4中
byte short int long
4个类型的区别：
Byte开发的空间占用内存1个字节。范围 -128 ~ 127
Short开辟的空间占内存2个字节
Int开辟空间占内存4个字节
Long开辟空间占内存8个字节 long x =123456789031L;
小数：
float(单精度)
double(双精度)
float 开辟的空间是4个字节 int
double 开辟的空间是8个字节 long
字符：
Char 占两个字节
布尔：
boolean true:真 0 false:假 1
boolean占一个字节
2.5 进制的转换
进制：进制是一种记数方式 ，可以用有限的数字符号代表所有的数值。由特定的数值组成。
整型的表现形式
1. 十进制： 都是以0-9这九个数字组成，不能以0开头。
2. 二进制： 由0和1两个数字组成。
3. 八进制： 由0-7数字组成，为了区分与其他进制的数字区别，开头都是以0开始。
4. 十六进制：由0-9和A-F组成。为了区分于其他数字的区别，开头都是以ox开始。
进制的由来
几乎每个民族最早都使用都十进制计数法，这是因为人类计数时自然而然地首先使用的是十个手指。 但是这不等于说只有十进制计数法一种计数方法。例如，世界各国在计算年月日时不约而同地使用“十二进制”12个月为一年又如：我国过去16两才算为一斤，这就是“十六进计数法”,一个星期七天，这个就是”七进制计算法”。 计算机是由逻辑电路组成，逻辑电路通常只有两个状态，开关的接通与断开，这两种状态正好可以用“1”和“0”表示。
例如：十进制转二进制的转换原理：除以2，反向取余数，直到商为0终止。（其他的自行扩展）
2.6 Java数据类型的转换
Java中可以进行不同数据类型的加减乘除运算吗？是可以的。在算术运算符中已经体验过如果两个整数（int）相除会去掉小数部分。如果需要保留小数部分，可以让除数或者被除数变为double类型的（5变为5.0）。其实Java是自动的将int的那个数变为了double类型了也就是Java自动的将整数变为了浮点数。例如5/2.0 其实是5.0/2.0；
2.6.1、 自动类型转换（也叫隐式类型转换）
可以将一个数赋值给更大数值范围的变量，例如可以经byte 变量赋值给short变量可以将short变量赋值给int变量可以将int变量赋值给long变量。
Java内部其实做了工作就是自动将数值进行了类型提升，就叫做自动类型转换（也叫隐式类型转换）
1 byte b = 1; //00000001 2 short s = b; //00000000 00000001 3 int i = s; 4 long lon = i; 5 double d = lon; //1.0
要实现自动类型的转换，需要满足两个条件，第一两种类型彼此兼容，第二目标类型取
值范围必须大于源类型。所有的数字类型，包括整形和浮点型彼此都可以进行转换。
例如：
1 byte b=100; 2 int x=b; 3 System.out.println(x);//程序把b结果自动转换为int类型。
2.6.2、 强制类型转换（也叫显式类型转换）
不可以将一个数值赋给范围更小数值范围的变量，除非进行类型转换。
1 byte b = 100; 2 b = b + 2; 3 System.out.println(b);
上述例子发生了什么，发生了类型转换。
b+2 遇到了加法运算，2默认是int类型，byte类型b变量存储的值自动类型提升为了int类型。执行完加法运算后的结果就是int类型，想要将int的类型值放入到byte类型变量b中，无法放入，编译报错。
1 byte b=1; 2 b=(byte)(b+2);
当两种类型彼此不兼容，或者目标类型取值范围小于源类型（目标是byte源是int）无法自动转换，此时就需要进行强制类型转换。
强制类型转换需要注意：
损失精度！！！
1 int a=128; 2 byte b=(byte)a; 3 System.out.println(b);//-128 4 /* 5 * 此时的强转已经造成了数值的不准确 6 */
再次分析代码
1 byte b = 100; 2 b = b + 2; 3 System.out.println(b);
编译：提示如下错误。
什么时候要用强制类型转换？？？
比如小数部分只想保留整数部分.
一定要清楚要转换的数据在转换后数据的范围内否则会损失精度.
表达式的数据类型自动提升
算术表达式，逻辑表达式
所有的byte型、short型和char的值将被提升到int型。
如果一个操作数是long型，计算结果就是long型；
如果一个操作数是float型，计算结果就是float型；
如果一个操作数是double型，计算结果就是double型。
分析 System.out.println(‘a’+1)结果？
自动类型提升
1 byte b = 3; 2 int x = 4; 3 x = x + b;// b会自动提升为int 类型参与运算。 4 System.out.println(x);// 7
强制类型转换
1 byte b = 2; 2 /* 3 * 强制类型转换，强制将b+2强制转换为byte类型，再赋值给b 4 */ 5 b = (byte) (b + 2); 6 System.out.println(b);// 4 7
小结如下：
思考1
byte b=126;
问：既然数据默认的有数据类型，那么126 默认是int类型的，为什么存储到byte类型时不会报错呢。
126 是常量java在编译时期会检查该常量（每个常量）是否超出byte类型的范围。如果没有可以赋值。
思考2：byte b=128;能否正常的编译和运行。
该语句会出现编译错误，128超出了byte变量的存储范围，所以出现编译错误。
思考3
1 byte b1=3，b2=4，b; 2 3 b=b1+b2； 4 5 b=3+4；
哪一句编译失败？为什么？
b =3+4， 3和4都是常量，所以java在编译时期会检查该常量（每个常量）是否超出byte类型的范围。如果没有可以赋值。例如b=128+1 就无法编译通过。b=127+1;也是无法通过。
b =b1+b2 不可以，因为b1 和b2 是变量，表达式求值时，变量值会自动提升为int型，表达式结果也就成了int型，这是要赋值给byte型的b，必须进行强制类型转换了。
System.out.println(‘a’+1)结果
为了让计算机识别他们生活中的文字,让二进制表示生活中的文字.所以一个字母代表了一个二进制.,二进制也有十进制的表现形式.,把生活中的字母都用数字来标识,例如97 代表a ，98 代表 b。打印’a’就把a作为输出显示,没有疑问。但是 ‘a’+1 有加号涉及到了运算。根据java自动类型提升规则，同样道理 char 提升为int 。就把’a’代表的数字体现了出来。a 表示的是97 97+1就是98; 那么 想要查看98 表示的char 是什么 怎么实现呢 ?就要用到刚才介绍的强制类型转换了 System.out.println(char(‘a’+1))；就取到了98 在ASCII码表中表示的字符。大写A 和小写a 在 ASCII有不同的表现。还有一个概念字符’1’ 在ASCII中 不是数字 1,可以运行代码查看,到此就可以明白了char 类型,char类型也是可以参与运算的,为什么可以参与运算呢。因为字符在ASCII表中都有对应的数字体现。所有的计算机兼容ASCII。
1 System.out.println('a'+1); //98 2 System.out.println((char)('a'+1)); //b
即：所有数值运算符都可以用在char型数据上，如果另一个操作数是一个数字或者字符，那么char会自动提升为int型，如果另一个操作数是字符串，那么字符就会和字符串相连。
2.7 运算符
2.7.1 算术运算符
正负号
除法
取模：求余数
取模的正负取决与被除数
（++）前自增：先自增完毕，再运算整个表达式，语句分号前面的都是运算表达式；
后自增，先运算完整个表达式（分号前面的都是表达式），再进行自增；
小结：如果运算符在变量的前面，则该变量自增1或者自减1，然后返回的是变量的新值，如
果运算符在变量的后面，则变量也会自增或者自减1，但是返回的是变量原来的值。++在前就是先运算，再取值，++在后就是先取值，再运算。
2.7.2 赋值运算符
a+=b 可以想象成 a=a+b;
变量声明完了之后，可以使用赋值语句（assignment statement）给变量赋一个值，Java中使用等号（=）作为基本的赋值运算符（assignment operator）；格式如下：
variable = expression;
变量 = 表达式;
2.7.3 比较运算符
注意的细节：
使用比较运算符的时候，要求两种数据类型必须一致。
2.7.4 逻辑运算符
什么是逻辑运算符？连接比较运算符的符号称之为逻辑运算符。逻辑运算符用于对boolean型结果的表达式进行运算，运算的结果都是boolean型。我们的比较运算符只能进行一次判断，对于对此判断无能为力，那么逻辑运算符就可以经将较运算符连接起来；
逻辑运算符
逻辑运算符用于连接布尔型表达式，在Java中不可以写成3<x<6，应该写成x>3 & x<6 。
“&”和“&&”的区别：单与时，左边无论真假，右边都进行运算；双与时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。
“|”和“||”的区别同理，双或时，左边为真右边不参与运算。
“ ^ ”异或与“|”或的不同之处是：当左右都为true时，结果为false。
& 与 | 或 ^ 异或 ! 非
2.7.5 位运算符
按位操作符用来操作整数基本数据类型中的单个比特（bit），就是二进制，按位操作符会对两个参数中对应的位（bit）执行布尔运算，最终生成一个结果。按位操作符来源于C语言面向底层的操作，Java设计的初衷是嵌入式电视机机顶盒，所以面向底层的操作也保留了下来。
任何信息在计算机中都是以二进制的形式保存的，”&”、“|”、“^”除了可以作为逻辑运算符也可以作为位运算符。位运算是直接对二进制进行运算。他们对两个操作数中的每一个二进制位都进行运算。例如int是由32个二进制数组成，因此使用位运算符可以对整数值的二进制数进行运算。
位（bit）运算符：
|
位运算符
|
运算符含义
|
|
& |
与（AND） |
|
| |
或（OR） |
|
^ |
异或 |
|
~ |
取反 |
规则：
可以把1当做true 0当做false
只有参与运算的两位都为1，&运算的结果才为1，否则就为0。
只有参加运算的两位都是0，| 运算的结果才是0，否则都是1。
只有参加运算的两位不同，^ 运算的结果才为1，否则就为0。
2.7.6 移位操作符
<< 左移
>> 右移
>>> 无符号右移
|
位运算符 |
||
|
运算符 |
运算 |
范例 |
|
<< |
左移 |
3 << 2 = 12 --> 3*2*2=12 |
|
>> |
右移 |
3 >> 1 = 1 --> 3/2=1 |
|
>>> |
无符号右移 |
3 >>> 1 = 1 --> 3/2=1 |
|
& |
与运算 |
6 & 3 = 2 |
|
| |
或运算 |
6 | 3 = 7 |
|
^ |
异或运算 |
6 ^ 3 = 5 |
|
~ |
反码 |
~6 = -7 |
|
位运算符的细节 |
|
|
<< |
空位补0，被移除的高位丢弃，空缺位补0。 |
|
>> |
被移位的二进制最高位是0，右移后，空缺位补0； 最高位是1，空缺位补1。 |
|
>>> |
被移位二进制最高位无论是0或者是1，空缺位都用0补。 |
|
& |
二进制位进行&运算，只有1&1时结果是1，否则是0; |
|
| |
二进制位进行 | 运算，只有0 | 0时结果是0，否则是1; |
|
^ |
任何相同二进制位进行 ^ 运算，结果是0；1^1=0 , 0^0=0
不相同二进制位 ^ 运算结果是1。1^0=1 , 0^1=1 |
2.7.7 三元运算符
格式
(条件表达式)?表达式1：表达式2；
如果条件为true，运算后的结果是表达式1；
如果条件为false，运算后的结果是表达式2；
2.7.8 运算符的优先级与结合性
理解例子
2.7.9 案例（部分辅助理解）
案例：类型简单例子
1 public static void main(String[] args) { 2 //定义两个变量(语法：数据类型 变量名 = 常量值;) 3 int a = 3; 4 int b = 4; 5 6 System.out.println(a + b); 7 System.out.println(a - b); 8 System.out.println(a * b); 9 System.out.println(a / b); //整数和证书相除，我们只要整数部分(取商) 10 11 System.out.println(a % b); //取模实际上就是取余数 12 13 System.out.println(4223 / 1000 * 1000); //整数和整数加减乘除的结果只要整数 14 //当算术运算两侧的类型不一致的时候,结果向大的类型保持。 15 System.out.println(4223 / 1000.0 * 1000); 16 }
自增自减运算符案例
1 //一 2 int i = 10; 3 int newNum = 10 * i++; 4 System.out.println(newNum);//? 5 // 二 6 int i = 10; 7 int newNum = 10 * ++i;//? 8 System.out.println(newNum); //? 9 //一可以理解为 10 int i = 10; 11 int newNum = 10 * i; 12 i = i + 1; 13 //二可以理解为 14 int i = 10; 15 i = i + 1; 16 int newNum = 10 * i; 17
案例
1 public static void main(String[] args) { 2 // 判断一个整数一奇数还是偶数 3 int x = -100; 4 // 奇数是，1,3,5...偶数是2,4,6...显然整数除2能整除，也就%（取模）结果为0就是偶数。 int result = x % 2; 5 System.out.println(result); 6 // 使用判断语句进行判断。 7 if (result == 0) { 8 System.out.println(x + "是偶数"); 9 } else { 10 System.out.println(x + "是奇数"); 11 } 12 }
案例
1 public static void main(String[] args) { 2 // 判断一个整数一奇数还是偶数 3 int x = 1; 4 // 奇数是，1,3,5...偶数是2,4,6...显然奇数%的结果为1. 5 int result = x % 2; 6 System.out.println(result); 7 // 使用判断语句进行判断。 8 if (result == 1) { 9 System.out.println(x + "是奇数"); 10 } else { 11 System.out.println(x + "是偶数"); 12 } 13 }
改进
1 public static void main(String[] args) { 2 // 判断一个整数一奇数还是偶数 3 int x = -1; 4 // 奇数是，1,3,5...偶数是2,4,6...显然奇数%的结果为1. 5 int result = x % 2; 6 System.out.println(result); 7 // 使用判断语句进行判断。 8 if (result != 0) { 9 System.out.println(x + "是奇数"); 10 } else { 11 System.out.println(x + "是偶数"); 12 } 13 }
案例：判断星期
1 public static void main(String[] args) { 2 // 设定今天是星期1，用int 1表示星期一，0表示星期天 3 int today = 1; 4 // 十天后是星期几？，一个星期是7天，7天之后又是星期1，可以用？ 5 int future = (today+10) % 7; 6 if (future == 0) { 7 System.out.println("10天后是星期天"); 8 } else { 9 System.out.println("10天后是星期：" + future); 10 } 11 12 }
案例：运算符
1 public static void main(String[] args) { 2 int x = 1; // 声明int变量x， 赋值1给变量x 3 int y = 0; // 声明int变量y， 赋值0给变量y 4 double area; // 声明double变量area 5 double radius = 1.0; // 声明double变量radius，并赋值1.0给变量radius 6 x = 5 * (3 / 2) + 3 * 2; // 将=右半部分表达式的计算结果赋值给变量x 7 x = y + 1; // 将变量y和1的求和的值赋值给变量x 8 area = radius * radius * 3.14159; // 将计算面积的值赋值给变量area 9 }
赋值小问题：
问题1：
1 int x; 2 Syst2intln(x = 1);
如何理解?
答：等价于
1 x=1; 2 System.out.println(x); 3 //注意：不能 1=x,变量名必须在赋值运算符的左边。
案例：位运算符
& 与运算
|
00000000 |
00000000 |
00000000 |
00000110 |
6 |
|
00000000 |
00000000 |
00000000 |
00000011 |
3 |
|
00000000 |
00000000 |
00000000 |
00000010 |
& =2 |
| 或运算
|
00000000 |
00000000 |
00000000 |
00000110 |
6 |
|
00000000 |
00000000 |
00000000 |
00000011 |
3 |
|
00000000 |
00000000 |
00000000 |
00000111 |
| =7 |
|
|
|
|
|
|
^ 异或运算
|
00000000 |
00000000 |
00000000 |
00000110 |
6 |
|
00000000 |
00000000 |
00000000 |
00000011 |
3 |
|
00000000 |
00000000 |
00000000 |
00000101 |
^ =5 |
~ 反码
|
0000-0000 |
0000-0000 |
0000-0000 |
0000-0110 |
6 |
|
1111-1111 |
1111-1111 |
1111-1111 |
1111-1001 |
取反 -7 |
负数表示
|
0000-0000 |
0000-0000 |
0000-0000 |
0000-0110 |
6 |
|
1111-1111 |
1111-1111 |
1111-1111 |
1111-1001 |
取反 |
|
1111-1111 |
1111-1111 |
1111-1111 |
1111-1010 |
加1 |
异或特点
|
0000-0000 |
0000-0000 |
0000-0000 |
0000-0110 |
6 |
|
0000-0000 |
0000-0000 |
0000-0000 |
0000-0011 |
^3 |
|
0000-0000 |
0000-0000 |
0000-0000 |
0000-0101 |
|
|
0000-0000 |
0000-0000 |
0000-0000 |
0000-0011 |
^3 |
|
0000-0000 |
0000-0000 |
0000-0000 |
0000-0110 |
结果是6 |
案例：位运算
左移 （算术移位）3<< 2
|
00000000 |
00000000 |
00000000 |
00000011 |
3 的二进制 |
||
|
00000000 |
00000000 |
00000000 |
000011 |
左移2位，砍掉高位 |
||
|
0000 0000 |
0000 0000 |
0000 0000 |
0000 1100 |
低位补0 |
||
右移6>>2
|
00000000 |
00000000 |
00000000 |
00000110 |
6的二进制 |
||
|
000000 |
00000000 |
00000000 |
00000001 |
右移10被砍掉 |
||
|
00000000 |
00000000 |
00000000 |
00000001 |
高位补0 |
||
推论
3<<2=12; 3<<1=6 ; 3<<3=24;
3*4=12 ; 3*2=6; 3*8=24;
3*22=12; 3*21=6 3*23 =24;
结论往左移几位就是乘以2的几次幂。
右移规律
6>>2=1 ;6>>1=3 ;
6/4=1 ; 6/2=3 ;
右移两位就是除以 2的2次方,右移一位就是除以 2的一次方。
总结 ：>> 是除以2的移动位数次幂
<< 是乘以2的移动位数次幂
案例：三元
获取两个数中大数
1 int x = 1; 2 int y = 2; 3 int z; 4 z = x > y ? x : y; 5 System.out.println(z); //2
判断一个数是奇数还是偶数
1 int x=5; 2 System.out.println((x%2==0?"偶数":"奇数"))
3 、流程控制
3.1顺序语句
使用分号分隔的代码称作为一个语句。顺序语句就是按照从上往下的顺序执行的语句。
注意：没有写任何代码只是一个分号的时候，也是一条语句，称作空语句。
3.2 条件语句
条件语句可根据不同的条件执行不同的语句。包括if条件语句与switch多分支语句。
3.2.1 if 、if..else
if条件语句
使用if条件语句，可选择是否要执行紧跟在条件之后的那个语句。关键字if之后是作为条件的“布尔表达式”，如果该表达式返回true，则执行其后的语句；若为false，则不执行if后的语句。可分为简单的if条件语句、if···else语句和if···else if多分支语句。
if(判断条件){
如果符合条件执行的代码;
执行的代码块1；
执行的代码块2；
……………….；
执行的代码块n；
}
1 int a = 100; 2 if(a == 100) { 3 System.out.println(a); 4 }
如上方代码，｛｝之间为复合语句，if为条件语句，翻译过来就是如果a等于100，则输出a的值，否则不执行。
如果if后只有一条语句，比如上述代码只有一条输出，可以不加｛｝，但为了代码的可读性，以及防止代码过多出现不必要的错误，建议所有的if、else后都加上相应的{}.
if···else语句是条件语句中最常用的一种形式，它会针对某种条件有选择的作出处理。通常表现为“如果满足某种条件，就进行某种处理，否则就进行另一种处理”。
if后的()内的表达式必须是boolean型的。如果为true，则执行if后的复合语句；如果为false，则执行else后的复合语句。
if(判断条件){
执行的代码块1；
执行的代码块2；
……………….；
执行的代码块n；
}else{
执行的代码块1；
执行的代码块2；
……………….；
执行的代码块n；
}
简单案例理解：
1 import java.util.Scanner; 2 public class Demo { 3 public static void main(String[] args) { 4 Scanner sc=new Scanner(System.in); 5 int nextInt = sc.nextInt(); 6 if(nextInt%5==0){ 7 System.out.println("是5的倍数"); 8 } 9 if(nextInt%2==0){ 10 System.out.println("是2的倍数"); 11 } 12 } 13 }
或者另外一种方式
1 public static void main(String[] args) { 2 int x = 8; 3 if (x == 1) { 4 System.out.println("星期一"); 5 } else if (x == 2) { 6 System.out.println("星期二"); 7 } else if (x == 3) { 8 System.out.println("星期三"); 9 } else if (x == 4) { 10 System.out.println("星期四"); 11 } else if (x == 5) { 12 System.out.println("星期五"); 13 } else if (x == 6) { 14 System.out.println("星期六"); 15 } else if (x == 7) { 16 System.out.println("星期日"); 17 } else { 18 System.out.println("请输入数字1-7"); 19 } 20 }
案例：
1 public static void main(String[] args) { 2 Scanner sc = new Scanner(System.in); 3 System.out.println("请输入一个整数："); 4 int nextInt = sc.nextInt(); 5 if (nextInt % 2 == 0) { 6 System.out.println("是偶数"); 7 } else { 8 System.out.println("是奇数"); 9 } 10 System.out.println("over"); 11 }
同样道理如果花括号中只有一条语句，那么花括号可以省略不写；
1 public static void main(String[] args) { 2 Scanner sc = new Scanner(System.in); 3 System.out.println("请输入一个整数："); 4 int nextInt = sc.nextInt(); 5 if (nextInt % 2 == 0) 6 System.out.println("是偶数"); 7 else 8 System.out.println("是奇数"); 9 10 System.out.println("over"); 11 }
其中发现if else语句有点类似于三元运算符
1 Public static void main(String[] args) { 2 int x = 0, y = 1, b; 3 // if else 语句 4 if (x > y) { 5 b = x; 6 } else { 7 b = y; 8 } 9 System.out.println(b);// 1 10 // 3元运算 11 b = x > y ? x : y; 12 System.out.println(b); // 1 13 }
例子：判断闰年；可以被4整除不能被100整除，或者可以被400整除，那么这一年就是闰年
1 public static void main(String[] args) { 2 Scanner sc = new Scanner(System.in); 3 System.out.println("请输入年份："); 4 5 int year = sc.nextInt(); 6 // 判断年份能否被4整除 7 boolean isLeapYear = (year % 4 == 0); 8 // 年份能被4整除，并且不能被100整除并且使用&&（and） 9 isLeapYear = isLeapYear && (year % 100 != 0); 10 // 年份或者能够被400整除 11 isLeapYear = isLeapYear || (year % 400 == 0); 12 if (isLeapYear) { 13 System.out.println(year + "是闰年！"); 14 } 15 // 简写格式； 16 if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) { 17 System.out.println(year + "是闰年！"); 18 } 19 }
三元运算符：
好处：可以简化if else代码。
弊端：因为是一个运算符，所以运算完必须要有一个结果。
if语句特点
- 与三元运算符的区别：三元运算符运算完要有值出现。好处是：可以写在其他表达式中。
- 条件表达式无论写成什么样子，只看最终的结构是否是true 或者 false。
3.2.2 switch
switch语句中表达式的值必须是整型或字符型，常量值1~n必须也是整型或字符型。
在Java的1.7之后的JDK版本，java中的switch里面表达式的类型可以是string类型。（Jdk版本一定要1.7之后，1.5可能只能是int或者char类型；怎么执行？
首先switch语句先计算表达式的值，如果表达式的值与case后的常量值相同，则执行该case后的若干个语句，直到遇到break语句为止。
如果没有break，则继续执行下一case中的若干语句，直到遇到break为止。
若没有一个常量的值与表达式的值相同，则执行default后面的语句。default语句可选，如果不存在default语句，而且switch语句中的表达式的值与任何case的常量值都不相同，则switch不做任何处理。并且，同一个switch语句，case的常量值必须互不相同。
switch语句
格式
|
switch(表达式) { case 取值1: 执行语句； break； case 取值2: 执行语句； break； …... default: 执行语句； break； } |
switch语句特点：
1,switch语句选择的类型只有四种：byte，short，int ， char。
2,case之间与default没有顺序。先判断所有的case，没有匹配的case执行
default。
3,switch语句停止的条件是遇到了break关键字或者结束switch语句的大括号。
4,如果匹配的case或者default没有对应的break，那么程序会继续向下执行，运
行可以执行的语句，直到遇到break或者switch结尾结束。
5，switch case中的值必须要与switch表达式的值具有相同的数据类型。而且case后跟的值必须是常量，不能跟变量。
例子
1 public static void main(String[] args) { 2 int x = 3; 3 switch (x) { 4 case 1: 5 System.out.println("1"); 6 break; 7 case 2: 8 System.out.println("2"); 9 break; 10 case 3: 11 System.out.println("3"); 12 break; 13 default: 14 System.out.println("ok"); 15 break; 16 } 17 }
case 就像选择题的答案之一。 break 就是如果该答案正确那么就可以跳出switch 了,意思就是说 已经找出了正确的答案了。那么这道题也就做完了。如果 case 没有匹配接着进行下一个case 匹配,直到匹配为止。 最后如果都没有匹配上,那么 switch 给提供了一个默认的答案,就是 default。
注意: case后跟的是冒号:
每个case中的执行语句一定要加break；
例子：根据用于指定的月份,打印该月份所属的季节；
1 public static void main(String[] args) { 2 int x = 3; 3 switch (x) { 4 case 3: 5 case 4: 6 case 5: 7 System.out.println("spring"); 8 break; 9 case 6: 10 case 7: 11 case 8: 12 System.out.println("sunmer"); 13 break; 14 case 9: 15 case 10: 16 case 11: 17 System.out.println("autumn"); 18 break; 19 case 12: 20 case 0: 21 case 1: 22 System.out.println("winter"); 23 default: 24 System.out.println("ok"); 25 break; 26 } 27 }
案例：char 类型在switch 中的使用
1 public static void main(String[] args) { 2 int x = 1, y = 2; 3 char ch = '*'; 4 switch (ch) { 5 case '+': 6 System.out.println("x*y=" + (x + y)); 7 break; 8 case '-': 9 System.out.println("x-y="+(x-y)); 10 break; 11 case '*': 12 System.out.println("x*y="+(x*y)); 13 break; 14 case '/': 15 System.out.println("x/y="+(x/y)); 16 break; 17 default: 18 System.out.println("没有"); 19 } 20 }
if 和switch 语句很像，具体什么场景下,应用哪个语句呢?
如果判断的具体数值不多,而是符号byte,short int char 四种类型.
虽然2个语句都可以使用,建议使用switch语句.因为效率稍高.
其他情况:
对区间判断,对结果为boolean 类型判断,使用if if的使用范围更广。
if 除了能判断具体数值还能判断区间。switch 判断区间会很费劲的。要写好多case 对于运算结果是boolean型的 if 能判断 switch 是不能实现的。例如：根据学生考试成绩划分ABCD；
3.3 循环语句
Java提供了三种类型的循环语句：while循环，do-while循环和for循环。
3.3.1while循环
while语句格式：
while(条件表达式)
{
执行语句；
}
while是用来解决重复操作执行，提供的方式叫做循环；下面一例子为辅助去理解；
例子：想要打印出1-100之间的奇数
1 public static void main(String[] args) { 2 int x = 1; 3 while (x < 100) { 4 System.out.println(x); 5 x = x + 2; 6 } 7 }
1 public static void main(String[] args){ 2 int x=1; 3 while(x<100){ 4 5 if(x%2!=0){ 6 System.out.print(x); 7 } 8 x++; 9 } 10 System.out.println();
例子：计算1+2+3+4+5+6+7+8+9 的值
1 int sum = 0; 2 int i = 1; 3 while (i < 10) { 4 sum = sum + i; 5 i++; 6 } 7 System.out.println(sum)
注意：要精确控制循环的次数。常犯错误是是循环多执行一次或者少执行一次。
例如会执行101次，想要执行100次，要么是count初始值为1，然后count<=100
要么是count初始值为0，coung<100
1 int count = 0; 2 while (count <=100) { 3 System.out.println("hello "); 4 count++; 5 } 6 System.out.println("over");
3.3.2 do-while循环
do while语句格式：
|
do { 执行语句； }while(条件表达式); do while特点是条件无论是否满足， 循环体至少被执行一次。 |
简单例子
1 public static void main(String[] args) { 2 int x = 0, y = 0; 3 do { 4 System.out.println(x); 5 x++; 6 } while (x < 0); 7 // do while do会先执行一次,不管是否满足循环条件。 8 while (y < 0) { 9 System.out.println(y); 10 y++; 11 } 12 }
while:先判断条件，只有条件满足才执行循环体。
do while: 先执行循环体，再判断条件，条件满足，再继续执行循环体。
简单一句话：do while：无论条件是否满足，循环体至少执行一次。
注意一个细节do while 后面的分号;
例子：猜数字游戏
1 public static void main(String[] args) { 2 // 记录用户输入的数字 3 int guess = -1; 4 // 记录用户输入次数 5 int count = 0; 6 // 生成1-100之间随机数 7 int num = (int) (int)(Math.random()*100)+1; 8 Scanner sc = new Scanner(System.in); 9 10 // 循环猜数字 11 do { 12 System.out.println("请输入1-100之间的数字"); 13 guess = sc.nextInt(); 14 if (guess > num) { 15 16 System.out.println("太大了"); 17 } else if (guess < num) { 18 19 System.out.println("太小了"); 20 } else { 21 22 System.out.println("中啦"); 23 } 24 count++; 25 26 } while (num != guess); 27 System.out.println("你猜测的数字是:" + num + "猜测了" + count + "次"); 28 }
例子：计算器
系统自动生成2个随机数用于参与运算。
系统生成0-4之间的随机数，表示加减乘除取模运算。
使用switch 进行匹配
1 class TestCouter { 2 public static void main(String[] args) throws InterruptedException { 3 // 生成随机数Math.random()生成0-1值，不包含0和1， 4 //乘以10得到0和10之间的数（double类型），不包含0和10 5 //强转为int，并加1得到1和10之间的数，包含1和10 6 int x = (int)(Math.random()*10)+1; 7 int y = (int)(Math.random()*10)+1; 8 System.out.println(x); 9 System.out.println(y); 10 // 创建0-4随机数 0 1 2 3 4 各表示加减乘除取模 11 int z = (int) (int)(Math.random()*5); 12 System.out.println(z); 13 14 switch (z) { 15 case 0: 16 System.out.println(x + "+" + y + "=?"); 17 System.out.println("哥们快猜。。。。"); 18 Thread.sleep(2000); 19 System.out.println(x + "+" + y + "=" + (x + y)); 20 break; 21 case 1: 22 System.out.println(x + "-" + y + "=?"); 23 System.out.println("哥们快猜。。。。"); 24 Thread.sleep(2000); 25 System.out.println(x + "-" + y + "=" + (x - y)); 26 break; 27 case 2: 28 System.out.println(x + "*" + y + "=?"); 29 System.out.println("哥们快猜。。。。"); 30 Thread.sleep(2000); 31 System.out.println(x + "*" + y + "=" + (x * y)); 32 break; 33 case 3: 34 System.out.println(x + "/" + y + "=?"); 35 System.out.println("哥们快猜。。。。"); 36 Thread.sleep(2000); 37 System.out.println(x + "/" + y + "=" + (x / y)); 38 break; 39 case 4: 40 System.out.println(x + "%" + y + "=?"); 41 System.out.println("哥们快猜。。。。"); 42 Thread.sleep(2000); 43 System.out.println(x + "%" + y + "=" + (x % y)); 44 break; 45 } 46 47 } 48 }
3.3.3 for循环
格式：for(初始化表达式；循环条件表达式；循环后的操作表达式)
{
执行语句；
}
举个例子说明：打印5次helloworld
1 public static void main(String[] args) { 2 for (int x = 0; x < 5; x++) { 3 System.out.println("hello java"); 4 } 5 }
for的执行流程
for 知道要进行循环，读到x=0 的时候，在内存中开辟了空间,定义变量x 赋值为0。接着进行条件判断 x<5，为真，这个时候对满足条件后执行了循环体的内容System.out.println("hello java");当循环体执行完毕之后,执行x < 5;后的表达式即 x++ 。x自增后变为了1 ，再次进行判断 x<5 (int x=0 只执行一次)，如果为真就再次运行System.out.println("hello java");如果为假，for循环结束。
for 和while的区别
1 public static void main(String[] args) { 2 for (int x = 0; x < 5; x++) { 3 System.out.println("hello java"); 4 } 5 System.out.println(x); 6 //x cannot be resolved to a variable 7 8 int y = 0; 9 while (y < 5) { 10 System.out.println("hello world"); 11 y++; 12 } 13 System.out.println(y); 14 }
错误原因？
x 为什么会找不到,注意了变量的作用域,也就是变量的作用范围。x 只在 for 循环的大括号内有效,出了这个区域，就无效了.在内存中就消失了。x消失后,仍要访问它,肯定会报错的。
y 就不一样了，y 是定义在while 外的。while循环完毕仍有效 while的初始化 动作在外边，循环结束后y 仍然存在。
当定义的y 只作为循环增量存在的话的，循环完毕后y就没有用了，但是y还是占着一块内存。所以，如果定义的变量只作为循环增量存在的话，就用for 循环可以节约内存。
其实for 和while 是可以互换的。
最后总结
1、for里面的两个表达式运行的顺序，初始化表达式只读一次，判断循环条件，为真就执行循环体，然后再执行循环后的操作表达式，接着继续判断循环条件，重复找个过程，直到条件不满足为止。
2、while与for可以互换，区别在于for为了循环而定义的变量在for循环结束时就在内存中释放。而while循环使用的变量在循环结束后还可以继续使用。
3、最简单无限循环格式：while(true) , for(;;),无限循环存在的原因是并不知道循环多少次，而是根据某些条件，来控制循环。推荐使用while(true)
例子：获取1-10的和，并打印（for）
1 public static void main(String[] args) { 2 // 获取1到10的和1+2+3+4+5+6+7+8+9+10 3 int sum = 0; 4 for (int x = 1; x <= 10; x++) { 5 System.out.println((sum + x) + "=" + sum + "+" + x); 6 sum = sum + x; 7 } 8 System.out.println(sum);// 55 9 }
累加思想：通过变量记录住循环操作后的结果；通过循环的形式.进行累加的动作。
计数器思想：通过一个变量记录住数据的状态变化，也是通过循环完成。
语句的嵌套应用，什么是嵌套形式，其实就是语句中还有语句。
例子：打印*号
1 public static void main(String[] args) { 2 for (int x = 0; x < 5; x++) { 3 System.out.println("*"); 4 } 5 }
或者
1 public static void main(String[] args) { 2 for (int x = 0; x < 5; x++) { 3 for(int y=0;y<6;y++){ 4 System.out.print("*"); 5 } 6 System.out.println(); 7 } 8 }
再或者
1 public static void main(String[] args) { 2 for (int x = 5; x > 0; x--) { 3 for(int y=x;y>0;y--){ 4 System.out.print("*"); 5 } 6 System.out.println(""); 7 } 8 }
和
1 public static void main(String[] args) { 2 for (int x = 0; x < 5; x++) { 3 for (int y = 0; y <= x; y++) { 4 System.out.print("*"); 5 } 6 System.out.println(""); 7 } 8 9 }
例子：9*9 乘法表
1 public static void main(String[] args) { 2 for (int x = 1; x <= 9; x++) { 3 for (int y = 1; y <= x; y++) { 4 System.out.print(y + "*" + x + "=" + x * y + '\t'); 5 } 6 System.out.println(" "); 7 } 8 }
3.4 转向语句
break、continue关键字；
break关键字：break 语句用于终止最近的封闭循环或它所在的 switch 语句。控制传递给终止语句后面的语句（如果有的话）。
适用：for循环 、 switch两种循环语句。
break的用法：
- 单独使用。
- 与标签一起使用。(标签：即一个名字，满足标识符的条件即可)。
使用细节： 不要再break语句之后，编写其他语句，永远都执行不到，编译报错。
continue关键字：语句将控制权传递给它所在的封闭迭代语句的下一次迭代。(跳出本循环，执行下一次循环)。
适用于：while 、 do while 、 for循环语句
使用细节：
1. 如果continue出现在循环的末尾(最后一条语句),那么可以省略。
2. 如果continue出现在循环的第一条语句，那么后面的语句都无法执行，所以编译报错。
3. 可以结合标记使用。
3.5 返回语句
1、语法格式
return 符合返回值类型的表达式
2、含义：将表达式的值作为该函数运行的结果反馈给调用函数的地方；结束该函数的运行，返回到调用该函数的地方，继续执行后面的语句。如果返回值类型不是空类型，必须保证函数一定会返回一个值。
3、返回值和运行结果区别：
返回值：它是函数反馈给调用函数处的信息。
运行结果：是程序通过屏幕反馈给用户的信息。
return语句终止当前正在执行的函数并将控制权返回到调用该函数的地方。
return语句有两种形式：
return;
return expression;
无返回值函数
没有返回值的return语句只能用在返回类型是void的函数中。返回void的函数不要求非得有return语句，因为在这类函数的最后一句后面会隐含地执行return。
通常情况下，void函数如果想在它的中间位置提前退出，可以使用return语句。return的这种用法有点类似于我们用break语句退出循环。
一个返回类型是void的函数也能使用return语句的第二种形式，不过此时return语句的expression必须是另一个返回void的函数。强行令void函数返回其他类型的表达式将产生编译错误。
有返回值的函数
return语句的第二种形式提供了函数的结果。只要函数的返回类型不是void，则该函数内的每天return语句必须返回一个值。return语句返回值的类型必须与函数的返回类型相同，或者能隐式地转换成函数的返回类型。
尽管C++无法确保结果的正确性，但是可以保证每个return语句的结果类型正确。也许无法顾及所有情况，但是编译器仍然尽量确保具有返回值的函数只能通过一条有效的return语句退出。
在含有return语句的循环后面应该也有一条return语句，如果没有的话该程序就是错误的。
end...
