课程是b站动力节点发布的，这篇文章范围是：开始到方法之前
day01课堂笔记（第一章 Java的开发环境的搭建）
1.常用的DOS命令
win+r （组合键）：可以打开“运行”窗口
1.1、怎么打开DOS命令窗口
在运行窗口文本框中输入：cmd
然后回车
1.2 什么是DOS命令呢？
在DOS命令窗口中才可以输入并执行DOS命令。
在最初的windows计算机中没有图形界面的，只有DOS命令窗口。
也就是说通过执行DOS命令串口可以完全完成文件的新建、编辑、保存、删除等一系列操作。
1.3、mkdir abc（这个命令不是必须掌握的） （make directory)
创建一个目录，起名abc
1.4、默认情况下DOS命令打开后
C：\users\Administrator 这是默认的当前路径
1.5在DOS窗口中怎么复制内容？
win10 ：
左键直接选中，然后单击一下就到剪切板里面了。
1.6、切换盘符？
直接输入盘符就行：（不需要加cd）
c:回车
d:回车
e:回车
f:回车
就ok了。
当切换到D盘根下是，那么当前路径就是：D:\
当前路径是当前所在的位置
1.7 切换目录（非常重要，必须掌握）
使用cd命令来完成目标目录的切换：cd是什么含义？ change directory（改变目录）
cd命令怎么用，语法格式是什么？
cd路径
路径在windows系统上包括：相对路径和绝对路径 。
什么是相对路径呢？
一定要注意，从路径格式上来看，相对路径是一定不会以盘符开始的。
相对路径：相对路径一定是相对于当前所在的“位置”而言的。
相对路径是相对于当前而言，从当前所在的位置作为起点。（如：“辽宁省铁岭市凡河新区浅水湾”是绝对路径；而“走 去浅水湾”是相对路径 （相对于自己的位置而言））
死记：相对路径一定是从当前位置作为起点开始找。
什么是绝对路径呢？
在Windows操作系统中凡是路径起点是盘符的都是绝对路径，例如：
C:\Users\Adminstrator
C:\Users
D:\BaiduNetDiskDownload
注意：cd.. 是回到上级路径
cd \ 直接回到根路径
。 一个点，代表当前路径（cd命令用不着。以后配置环境时有用）
1.8、cls清屏
1.9、dir 查看当前目录下有啥东西
1.10、exit 退出DOS命令窗口。
day02常用的课堂笔记
1、常用的DOS命令（续）
1.1、del命令 ，删除一个或者多个文件
删除T1.class 文件
C:\Users\Administrator>del T1.class
删除所有.class结尾的文件中，支持模糊匹配
C:\Users\Administrator>del *.class
T1.class
T1.glass
del *ass 这个命令就会将T1.class和T1.glass都删除。 删除的一定是能匹配上的。
1.2、怎么查看本机的IP地址？
什么是IP地址？ 有什么用呢？
A计算机在网络中想要定位到（连接到）B计算机，那么必须要先知道B计算机的IP地址，IP地址也可以看作计算机在同一个网络中的身份证号（唯一标识）。
IP地址就相当于电话号码
ipconfig(IP地址的配置信息）
ipconfig /all 该命令后面添加一个/ all参数可以查看更详细的网络信息。这个详细信息中包括网卡的物理地址，例如70-8B-CD-A7-BA-25 这个物理地址具有全球唯一性。物理地址通常叫做MAC地址。
1.3、怎么查看两台计算机是否可以正常通信？
ping命令
语法格式： ping IP地址/ping 域名
ping www.baidu.com
ping 61.135.169.121(是百度的IP地址）
ping 61.135.169.121 -t （-t参数表示一直ping）一直ping的目的可以查看网络是否稳定
在一个DOS命令窗口中如果有一个命令一直在执行，想要强行终止怎么办？
ctrl+c 组合键
61.135.169.121也可以打开百度
域名底层最终还是会被解析成IP地址的形式。
2、文本编辑快捷键：
2.1、掌握常用的通用的文本编辑快捷键很重要，可以大大提升开发效率。所以，必须熟练掌握，从此刻开始强迫自己少用鼠标，用组合键快捷键的方式。
2.2常用的组合键都有哪些？
复制 ctrl + c
黏贴 ctrl + v
剪切 ctrl + x
保存 ctrl + s
撤销 ctrl + z
重做 ctrl + y
回到行首：home键
回到行尾：end键
当光标在行尾，怎么选中一行？
shift + home键
当光标在行首，怎么选中一行？
shift + end 键
回到文件头 ： ctrl + home
回到文件尾 ： ctrl + end
全选 ： ctrl + a
查找 : ctrl + f
选中一个单词：鼠标双击
选中一行 ： 鼠标连续击三次
不用鼠标选中一个单词 ： ctrl + shift + 右箭头/左箭头
——————————————————————
java 是一门面向对象的编程语言
JDK： java开发工具箱，做java必须安装的，这是最基本的一个环境；不是集成开发环境；JDK这个开发工具箱中java是最核心的库。
98年的时候：java升级到JDK1.2，java被分为三大块：
J2SE： 标准版（基础，要学java,必须先学习SE 基础语法+基础库）
J2EE：企业版（专门为企业开发软件，为企业提供解决方案。例如：OA办公系统，银行，酒店）
J2ME：微型版（专门为微型设备做嵌入式开发的）
day 03 课堂笔记
1、java语言的特性
1.1、简单性
在java语言当中真正操作内存的是：JVM（java虚拟机）所有的java程序都是运行在java虚拟机当中的。而java虚拟机执行过程中再去操作内存。对于C或者C++来说程序员都是可以直接通过指针操作内存的。C或者C++更灵活，可以直接程序员操作内存，但是要求程序员技术精湛。C语言或者C++更有驾驭感。
Java语言屏蔽了指针概念，程序员不能直接操作指针，或者说程序员不能直接操作内存。这种方式有有点也有缺点
优点：不容易导致内存泄漏
缺点：效率问题，包括驾驭感比较差
飞机航行：如果是C语言表示程序员是飞机驾驶员。 ；如果是java语言表示程序员是飞机上的乘客。
Java底层是C++，所以JVM是用C++语言写好的一个虚拟电脑。JVM在哪里？告诉大家，安装了JDK之后，JVM就代表安装好了。
内存是什么？
对于计算机来说：最受主要的几个部件是什么？
CPU:
中央处理器，相当于人类的大脑，负责发送并执行指令，是整个计算机的指挥官。
CPU是负责运算的
ex: 10 + 20 = 30
CPU负责将30这个结果计算出来，但是在计算过程中有三个数据需要临时找个空间存储一下： 这三个数据分别是 10 20 30。这时候就需要内存了
内存：
程序运行过程当中的临时数据存储空间。断电之后或者关机之后内存中的数据就消失了。
硬盘：
持久化设备，硬盘上的数据不会因断电而丢失
主板：
相当于人类的躯干，是一个载体：CPU、内存条、硬盘等主要设备的部件都是放在主板上的，主板上有很多线，将以上的部件连接起来
1.2、java是堪称完全面向对象的。
面向对象更容易让人理解，人类通常是以对象的方式认识世界的。采用面向对象的方式可以让复杂问题简单化
1.3、健壮性
主要是java中有一种机制：自动垃圾回收机制(gc)机制
java语言是健壮的（相对于c语言来说）java不易导致内存泄露。
c++或者c语言使用不当时很容易导致内存泄漏
JVM负责调度机制。程序员不需要干涉。
以上讲解中涉及的术语：
JVM（c++语言写的一个虚拟机）、GC（垃圾回收机制）
1.4、java完全/完美支持多线程并发。（比如说京东，10万人同时抢一件东西，这就是多线程并发）
1.5、可移植性/跨平台
java语言只要编写一次，可以做到到处运行。
例如：java程序编写完之后，可以运行在Windows操作系统上，不需要做任何改动可以直接运行在Linux操作系统上，同样也可以运行到Mac OS上面（平台改变了，程序不需要改）
一句非常经典的话：JVM屏蔽了操作系统之间的差异
JVM是怎么来的？在安装JDK的时候会自带JVM
所以JDK也有不同版本：windows和linux版
JVM这种机制实现了跨平台，那么优点和缺点是什么？
优点：一次编写到处运行，可以跨平台
缺点：麻烦。对于运行java程序来说必须现有一个JVM。就像你要想在网页上看视频，你必须先安装一个flash
java语言可以编写病毒吗？
可以，没问题。但是很难让用户中毒。中毒的一般都是java程序员。所以很少有人编写java的病毒脚本。
2、JDK、JRE、JVM三者之间的关系？
JDK：Java开发工具箱
JRE：Java运行环境
JVM：java虚拟机
JDK包括JRE，JRE包括JVM。
JVM不能独立安装；JRE和JDK都是可以单独安装的。没有单独的JVM安装包
问题：假设你在软件公司工作，现在要去客户那边给客户把项目部署一下，把项目跑起来，你需要安装JDK吗？
不用，只需要安装JRE就行了
3、到目前为止，总结一下接触过的术语
Java体系里的技术被划分为三大块：
JavaSE：标准版
JavaEE：企业版
JavaME：微型版
安装JDK之后：
JDK:java开发工具箱
JRE：java运行环境
JVM：java虚拟机
4、对java的加载与执行的理解（理论比较重要）
java程序从编写到最终运行经历了哪些过程？？？？？？
jav程序非常重要的两个阶段
编译阶段
运行阶段
注意：java程序员直接编写的Java代码（普通文本）是无法被JVM识别的。java程序员编写的java代码这种普通文本必须经过编译，将这个“不同文本代码”变成“字节码”，JVM能够识别“字节码”。java代码这种普通文本变成字节码的过程，被称为：“编译”。
java代码这种普通文本被称为：java源代码。（你编写的代码是源代码）
源代码不能直接执行，先进行编译，生成源代码对应的“字节码”，JVM识别的是“字节码”
问题:编译阶段和运行阶段可以在不同的操作系统上完成吗？
ex：在Windows上编译，编译生成了字节码 把字节码放到linux上运行
完全可以，因为java是跨平台的，可以做到一次编写到处运行
问题2：java源代码一旦编译之后，源代码可以删除吗？只留下字节码可以执行吗？
完全可以执行，因为源代码不参与程序的执行过程。参与程序执行过程的是字节码。但是最好不要删除源代码。因为有可能执行结果不是你需要的，当执行结果不是你想要的时候，你可以重新打开源代码进行修改，然后重新编译生成新的字节码，再重新执行。这样会有新的执行效果。
放源代码的文件扩展名必须是:xxx.java
而且需要注意的是：编译生成的字节码文件扩展名是：xxx.class
没有为什么 死记硬背！！！！！！！
.java文件就是源文件，这个文件中编写源代码。
.class文件就是字节码文件，这个文件是编译源代码而得到的。
另外需要注意的是：
1个java源文件是可以编译生成多个.class文件的。最终运行的是class文件。
问题：字节码文件是二进制文件吗？
字节码文件不是二进制文件。
如果是二进制的话，就不需要JVM了
java程序从开发最终经历了什么？
编译期
第一步：在硬盘的某个位置（随意），新建一个xxx.java文件
第二步：使用记事本或者其他文本编辑器 例如Editplus打开xxx.java文件
第三部：在xxx.java文件中编写“符合java语法规则”的源代码
第四步：保存（一定要将xxx.java文件保存一下）
第五步：使用编译器（javac【JDK安装后自带】）对xxx.java进行编译。
第六步：如果xxx.java文件中编写的源代码违背了语法规则，那么便一起会报错，编译器报错之后class文件是不会生成的，只有编译通过了才会生成class字节码文件。
并且一个java源文件是可以生成多个class文件的（编译实质上是检查语法）
运行期：（可以在windows上，也可以在其他的os上）
第七步：如果是在linux上运行，需要将Windows上生成的class文件拷贝过去，不需要拷贝源代码，真正运行的是字节码（但是源代码也不要删除，方便之后调整）
第八步：使用JDK自带的命令/工具：java（负责运行的命令/工具）执行字节码
第九步：往下的步骤就全部交给java虚拟机了（JVM），就不需要程序员干涉了。JVM会将字节码文件装载进去，然后JVM对字节码进行解释（解释器负责将字节码解释为10101010...等的二进制）
第十步：JVM会将生成的二进制码交给OS操作系统，操作系统会执行二进制码和硬件进行交互。
注意：在以上的过程中，需要使用两个非常重要的命令！
javac命令，负责编译
java命令，负责运行
小插曲：
xxx.java源文件经过编译之后生成了A.class、B.class、C.class等文件，那么我们称A是一个类、B是一个类、C是一个类。期中A B C是类的名字
（没有为什么，死记硬背，sun公司的java语法就是这么规定的。）
A/B/C是类的名称：A类、B类、C类。
源文件中编写的代码叫做：源代码
以上是一个复杂的过程，那么缩减一下，程序员到底要干啥？
新建java文件
打开java文件
写java源代码
保存
javac命令编译
编写、编译、运行
5、编写java中的第一个java程序：HelloWorld（你好世界：问世）这个程序不需要理解，照抄就行。
第一步：安装文本编译器（EditPlus）
第二步：安装JDK
第三部：写代码
第四步：编译
第五步：运行
day 04课堂笔记
1、来发第一个java程序：HelloWorld
1.1、程序写完之后，一定要ctrl +s进行保存；而且，把java源代码修改之后，必须重新编译。重新编译生成新的class字节码文件。
1.2、编译阶段
怎么编译？使用什么命令？这个命令怎么用？
需要使用的命令是：D:\java\bin\javac.exe
这个命令需要先测试一下，打开DOS窗口窗口，看看java命令是否可用。
C:\Users\Frank>javac
如果“javac不是内部或外部操作命令，也不是可运行的和程序或批处理文件”这说明：Windows操作系统没有发现“javac.exe”文件在哪。
1.3、运行阶段
运行的前提是.class（字节码）文件生成了。没有字节码文件程序是无法运行的！。重点！！！！！！！！！！！！！！！！！！！
假设该文件的名字叫做：HelloWorld.class
那么HelloWorld就是一个类名。
如果文件是Test.class，那么Test就是一个类名。
怎么运行，使用哪个命令？
使用JDK的bin目录下的：java.exe命令来运行。
现在DOS命令窗口中测试java.exe这个命令是否可用！！！！
java -version
"java.exe"这个命令怎么用，语法格式是什么？
java 加 类名
java HelloWorld.class对不对？？？？？？？？
不对！！！！
正确的写法是：
java HelloWorld
！！！！！！！！千万千万要注意：java这个命令，后面跟的是“类名”，而绝对不能跟“文件路径”，因为java命令后面跟的不是文件，是一个“类名”。
对于这个字节码：Test.class，应该 java Test
对于这个字节码：A.class，应该 java A
对于这个字节码：Hello.class，应该java Hello
......
运行java程序需要哪些步骤呢？
第一步（必须这样做，这是必须的，要记住）：
先试用CD命令切换到xxx.class文件所在的路径
第二步：执行java Test
切记：java命令后面只要是跟路径，就一定不行。
java命令后面只能是类名
2、到目前为止，我们只配置了一个环境变量path，并且这个环境变量path和java实际上没关系，是人家windows操作系统的机制。
对于java的JDK所属的环境变量，有一个叫做：JAVA_HOME， 后期学习javaWeb的时候需要安装Tomcat服务器，那个时候JAVA_HOME要配置
那么除了JAVA_HOME环境变量之外，JDK相关的环境变量还有其他的吗？
有的！！！！
3、研究一下：“Java HelloWorld”的执行过程以及原理。
第一步：会先启动JVM（java虚拟机）
第二步：JVM启动之后，JVM回去启动“类加载器classloader”，类加载器的作用：加载“类”的。本质上类加载器负责去硬盘上找“类”对应的“字节码”文件。假设是“java HelloWorld”，那么类加载器会去硬盘上搜索：HelloWorld.class文件。假设是“Java Test”，那么类加载器会去硬盘上搜索：Test.class文件
........
第三步：类加载器如果在硬盘上找不到对应的字节码文件，会报错，报什么错？
“错误：找不到或无法加载主类”
类加载器如果在硬盘上找到了对应的字节码文件，类加载器会将该字节码文件装载到JVM当中，JVM启动“解释器”将字节码解释为“10101000.。。。”这种二进制码，操作系统执行二进制码和硬件交互。
问题：默认情况下，类加载器去硬盘上找字节码文件的时候，默认从哪找？
默认情况下，类加载器（classloader）会从当前路径下找。
能不能给类加载器指定一个路径，让类加载器去指定的路径下加载字节码文件？
可以，但是我们需要设置一个环境变量，叫做：classpath
classpath是一个环境变量，是给谁指路的？
答案：是给“类加载器”指路的。
classpath环境变量不属于Windows操作系统
classpath环境变量隶属于java，是java特有的。classpath=A路径；B路径；C路径；其中，"classpath”是一个变量名，“A路径，B路径，C路径”......是变量值
配置classpath:这个环境变量在windows中没有，需要新建！！！
计算机--->右键--->属性----->高级系统设置----->环境变量------>新建.....
注意：变量名不能随意写：大小写无所谓，但必须叫做：classpath
classpath=D:\course
非常重要的一个特点，必须记住：配置了classpath=D:\course之后，类加载器只会去D:\course目录下找“xxx.class”文件，不再从当前路径下找了。看（相当于锁死了java程序的执行路径）
结论：到目前为止，classpath环境变量不需要配置，但必须要理解classpath环境变量是干什么的！！！！！
（是给类加载器指路的！！！！！！）
在没有配置环境变量classpath的时候，默认从当前路径下加载。
如果配置了环境变量classpath的话，就只能从指定的路径下加载了。
4、（了解即可，不需要掌握，现阶段也不需要这样写）
在高版本的JDK当中，有这样的一个特性，可以直接这样一步到位：
java x/y/z xxx.java（x/y/z是路径）
java后面直接加java源文件的路径。这个特性是为了简化开发而提出，但实际上底层的实现原理还是和从前一样。
以上命令在执行过程中，还是会先进行编译，然后再运行，并且编译生成的class文件在硬盘上看不到，不存在。
5、关于第一个java程序代码的解释说明！
1.什么是注释？ 有什么用？
注释是对java源代码的解释说明
注释可以帮程序员更好地理解程序
2、注释信息只保存在java源文件当中，java源文件编译生成的字节码class文件中是没有注释的
3、在实际的开发过程中，一般会要求积极地写注释，这也是一个java软件工程师应该有的素质
4、注释写的不是越多越好，精简，主线清晰，每个注释都应该是点睛之笔（慢慢锻炼）
//这种注释属于单行注释，只注释两个斜杠后面的
/*
在这里可以编写多行注释
这是第一行注释
这是第二行注释
这是第三行注释
*/
所以：// 单行注释
/*
多行注释
*/
/**
*Javadoc注释：这里的注释信息可以自动被*javadocc.exe命令解析提取并生成到帮助文档当中（会在程序中显示）
*/
对HelloWorld程序的解释说明
1.在java中任何有效的代码必须写到“类体”当中，最外层必须是一个类的定义。
2.public表示公开的，class表示一个类，HelloWorld是一个类名。类名后面必须是一对大括号，这一对大括号被称为“类体”
public class HelloWorld（声明/定义一个公开的类，起个名字叫HelloWorld）
3、大括号必须是成对的，并且建议都要成对编写，这样才不会丢掉。：{} 【】（）
4、什么时候代码缩进？
我包着你，你就比我低一级。你就需要缩进。
没有合理的缩进，代码可读性很差。或者也可以这样说：大括号里的都需要缩进。
缩进就是可读性问题，不缩进也不影响程序的编译和执行。
public static void main（String[] args）{
}
整个这一块的代码被称为：main方法（程序的入口，sun公司java语言规定的）
也就是说，java虚拟机在执行程序的时候，会主动去找这样一个方法，没有这个规格的方法，程序无法执行。
main方法也可以叫做主方法
注意：方法必须放到“类体”中，不能放到“类体”外面。
public class Test3{
static void main(String[] args)
}
这种没有语法错误，能够编译通过，但是不能运行，因为没有main方法“public static void main (String[] args)”
任何一个程序都要有一个入口，没有入口进不来，无法执行。
public static void main(String[] args)这是一个入口方法
能再来一个一模一样的入口吗？
不行，有语法错误，不允许
方法体
注意：方法体由一行一行的“java语句”构成，并且非常重要的是：任何一条java语句必须以“;”结尾，并且这个分号还得是英文的，中文的分号不行
“;”代表一条语句的结束。
非常非常重要的是：方法体中的代码遵循自上而下的顺序依次逐行执行
System.out.println("Hello World");
这行代码的作用是向控制台输出一句话，就是这个作用。
注意：如果println后面小括号里的内容是一个“字符串”的话，必须使用英文双引号括起来，双引号也要成对写
public static void main(String[] args)
注意：args可以改名字，随意，对于主方法（为什么叫主方法，因为"main"是“主要的”意思）来说只有这个位置可以改，其他位置不能动
类体当中应该是方法，而不是直接的Java语句
Q:main方法中什么也不写行吗？
以下程序编译和运行可以吗？
public class HelloWorld{
public static void main(String[] args){
}
}
可以，只不过没有结果
System.out.println(100);
这个100不加引号可以吗
可以，因为100是数字（只有字符串才需要加引号，数字不用）
System.out.println(“100”);
他们两个性质一样吗？
不一样，一个是字符串，一个是数字，但最终输出到控制台上的是一个样子，没啥区别
扩展：对于数字来说，能进行“+ - * /”吗？
System.out.println(100 + 100);
// 200，可以的
记住：
1.一个java源文件中可以定义多个class
2.public的类不是必须的，可以没有
3.在源文件中只要有一个class的定义，那么必然会对应生成一个class文件
4.public的类可以没有，但如果有的话，public修饰的类名必须和源文件保持一致。
5.public的类有也只能有一个
day05课堂笔记
1、标识符
1.1、在java程序当中，使用editplus工具进行代码编写的时候，有一些单词是蓝色，有的是红色，有的绿色，有的是黑色，有的是紫色，有的是粉色....
1.2、注意：在java源代码中，在editplus工具中显示的高亮颜色为黑色，这个单词属于标识符。
1.3、标识符可以标识什么？
可以标识：
类名
方法名
常量名
变量名
接口名
。。。
1.4、到底什么是标识符呢?
一句话搞定：凡是程序员自己有权力命名的单词都是标识符。
public static void DoSome(String[] args){}
其中，DoSome是一个方法名，可以改成其他的名字
int k=100;
int nianling = 20;
其中，k、nianling是变量名
1.5、标识符可以随意编写吗？有命名规则吗？什么是命名规则？
命名规则属于语法规则，必须遵守，不遵守命名规则的标识不合语法，编译器会报错。
规则1：标识符由数字，字母（包括中文）、下划线_、美元符号$组成，不能含有其它符号。
规则2：标识符不能以数字开头
规则3：关键字不能做标识符。例如:public class static void 这些蓝色的字体都是关键字，关键字是不能做标识符的。
class public {
}：这样是不行的
规则4：标识符是严格区分大小写的。大写A和小写a不一样
虽然java中的标识符严格区分大小写，但是对于类名来说，如果一个java源文件中同时出现了：A类和a类，那么谁在前就生成谁。大家以后最好不要让类名“相同”。
规则5：标识符理论上是没有长度限制的。
1.6、标识符的命名规范
1.见名知意（这个标识符在起名的时候，最好一看这个单词就知道什么意思。）
2.遵循驼峰命名方式（一高一低，一高一低，一高一低。。。。。）有利于单词与单词之间很好地进行分割：BiaoShiFu、一眼就能看出来是几个单词
3.类名、接口名有特殊要求
类名和接口名首字母大写，后面每个单词首字母大写。
StudentTest、UserTest，这是类名、接口名
4.变量名，方法名有特殊要求
变量名和方法首字母小写，后面每个单词首字母大写。
int nianLing = 20;
String mingZi = "zhangsan";
5.所有常量名：全部大写，并且单词和单词之间采用下划线连接
USER_AGE：用户年龄
MATH_PI：固定不变的常量 3.1415.....
2、每一天你都会编写很多程序，会遇到很多编译错误，也会遇到很多运行错误，你是否需要准备一个单独的文件来记录这些信息，以及记录这些信息是怎么导致的，原因是什么？怎么去解决的，解决办法是啥？？？
非常有必要的，要想成为一个调错高手，这个有必要进行一下。
D盘下错误录，编译错误、运行错误、图片，原因，解决方法。
class 123ABC{}：这种情况会报错
编译报错，错误信息是 “错误：需要<标识符>”
错误原因：编译器检测到class这个单词，那么编译器会从class这个单词后面找类名，而类名是标识符，编译器找了半天都没有找到标识符，因为123ABC不是标识符，所以编译器提示错误
解决办法：将123ABC修改成合法的标识符。
class Hello World{
}
错误
编译器的错误信息是：
错误：需要'{'
编译器检测到class，然后找class后面的标识符，编译器找到了一个合法的标识符叫做“Hello”，然后编译器继续往后找“{”，结果没有找到“{”，所以报错了。
解决方法：
办法1：是把World删除
办法2：把空格删除
类名是标识符，标识符“中”不能含有空格
题目：创建一个java文件，起名123.java可以吗？
完全可以，在windows操作系统中，文件叫做：123.java没毛病
但是在123.java文件中定义Public的类可以吗？
不可以，因为之前有条规则：public的类可以没用，但如果有public的类也只能有一个，而且public的类的名字必须和源文件保持一致，但是123不能做标识符，是错误的标识符。
3、关键字
3.1、什么是关键字？
在SUN公司开发java语言的时候，提前定义好了具有特殊含义的单词，这些单词全部小写，具有特殊含义，不能用做标识符。
3.2、凡是在EditPlus中以蓝色形式存在的都是关键字，具有特殊含义。
3.3切记：java语言中的所有关键字都是全部小写！！！
注意：java语言中是严格区分大小写的
public和Public不一样，Class和class不一样，Static和static也不一样
3.4、那么关键字有哪些？需要记忆吗？
long short int float double if false true.....
不需要特殊背，以后都会接触到
4、变量
1、关于程序当中的数据？
开发软件是为了解决现实世界中的问题，而现实世界当中的许多问题都是使用数据进行描述的。所以软件执行过程中最主要就是对数据的处理。
软件在处理数据之前需要能够表示数据，在java代码中，怎么表示数据呢？在java中有这样一个概念：字面量。
注意：在java语言中“数据”被称为“字面量”
10
1.23
true
false
‘a’
“abc”
以上这些都是数据，在程序中都被叫做“字面量”
字面量可以分为很多种类:
整数型字面量：1 2 3 100 -100 -20......（整数型数据）
浮点型字面量：1.2 1.3 3.14
布尔型字面量：true false （没有其他的） ture表示真，false表示假
字符型字面量：‘a’ ‘b’ ‘中’
字符串型字面量：“abc” “a” “b” “中国”
其中字符型和字符串型都描述了现实世界中的文字
需要注意的是：
所有的字符型只能使用单引号括起来
所有的字符串型只能使用双引号
字符型一定是单个字符才能称为字符型
在语法级别上怎么区分字符串型和字符型？
主要看是双引号还是单引号，单引号一定是字符型，双引号一定是字符串型。
2、什么是变量？
分析：如果只有字面量，没有变量机制的话，有什么问题？
10是一个整数型数据，在内存中占有一定空间（CPU 内存 硬盘）
10+20=30
在内存中找一块空间存储10，在找一块空间存储20，CPU负责“+”运算，算完之后的结果是30，那么这个30也会在内存中找一块临时的空间存储起来。
思考：以下的三个10在内存中是一块空间，还是三块空间？
System.out.println(10);
System.out.println(10);
System.out.println(10);
虽然都是10，但是这三个10在内存中占用三块不同的内存空间。
只有“字面量”机制的话，是远远不够的，因为只有“字面量”的话，内存是远远不够用的
定义/声明一个变量，起名叫i
int i = 10;
以下这5次访问都是访问的同一块内存空间（这样使用变量之后内存就得到了复用）
System.out.println(i)；
System.out.println(i)；
System.out.println(i)；
System.out.println(i)；
System.out.println(i)；
以下程序表示访问的是字符i以及字符串i，以下的这两个i和以上的变量i没有任何关系
System.out.println('i');
System.out.println("i");
到底什么是变量呢？
变量其实就是内存中存储数据的最基本的单元。
变量其实就是一个存储数据的盒子。
在java语言当中任何数据都是有数据类型的，其中整数型是：int（没有为什么，java当中规定的）整数型就是：int
当然，在java中除了数据类型int之外，还有其他的类型，例如带小数的：double 等…….
数据类型有什么用呢？
记住：不同的数据类型，在内存中分配的空间大小不同。
也就是说。java虚拟机到底给这个数据分配多大的空间，主要还是看这个变量的数据类型。根据不同的类型，分配不同大小的空间
对于int这种整数类型，JVM会自动给int分配4个字节大小的空间。
1个字节=8个比特位
1个比特位就是一个1或0，注意：比特位是二进制位。
int是占用多少个二进制位?1个int占有32个二进制位（bit位）
int i = 1；实际上在内存中是这样表示的：00000000 00000000 00000000 00000001
int i = 2；00000000 00000000 00000000 00000010
二进制位就是满2进一位（0 1 10 11 100 101）
十进制就是满10进一位（1 2 3 4 5）
对于一个变量来说，包括三要素：
变量的数据类型
变量的名字
变量中保存的值
类型+名字+值
类型决定空间大小
起个名字是为了以后方便访问（以后在程序中访问 这个数据是通过名称来访问的。）
值是变量保存的数据
变量名属于标识符吗？
变量名命名规范中是怎么说的？
首字母小写，后面每个单词大写，遵循驼峰命名方式，见名知意
变量怎么声明，怎么定义？语法格式是什么？
数据类型 + 变量名
例如：int nianLing；
在java语言中有一个规定，变量必须先声明，再赋值才能访问（没有值相当于这个空间没有开辟）
在java语言中怎么给一个变量赋值呢？语法格式是什么？
记住：使用一个运算符，叫做“=”，这个运算符被称为赋值运算符。
赋值运算符“=”的特点是：等号右边先执行，执行完之后赋值给左边的变量。
int nianLing;
//定义一个int类型的量，起名nianLing，该变量用来存储人的年龄。
nianLing = 45;
//给变量赋值
System.out.println(nianLing);
//输出的是45
System.out.println("nianLing");
//输出的是 nianLing
nianLing = 80;
//重新赋值（相当于覆盖住原来的45）
System.out.println(nianLing);
//输出80
变量可以声明的时候赋值吗？可以的。
int weight = 80; //声明整数型变量：weight
//体重80kg
System.out.println(weight);
//输出80
重要结论：在同一个域当中（域后面讲），变量名不能重名，不能重复声明。
一行上可以同时声明多个变量吗？
Int a,b,c =100;
System.out.println(a);
System.out.println(b);
System.out.println(c);
不行 因为上面那行只给c赋了值
1、关于变量的一个分类（需要死记硬背。）
变量根据出现的位置进行划分：
在方法体之外声明的变量：局部变量。
在方法体之外，类体内声明的变量：成员变量
重点依据是：声明的位置
2、注意：局部变量只在方法体当中有效，方法体执行结束该变量的内存就该释放了。
public class VerTest07{
//这里可以声明变量（成员变量）
int i = 100;
public static void main(String[] args){
//主方法
int k = 100;
//成员变量
//main方法结束k内存空间释放
}
}
变量的作用域
1、什么是作用域？
变量的有效范围
2、关于变量的作用域，大家可以记住一句话：出了大括号就不认识了
3、java中一个很重要的原则：就近原则（哪个离我近就访问哪个）不仅java是这样，其它编程语言也是
一个大括号代表就一个域
{A域
{B域
{C域
}
}
}
day06课堂笔记
1、数据类型
1.1、数据类型有什么用？
数据类型用来声明变量，程序在运行过程中根据不同的数据类型分配不同大小的空间。
int i = 10;
double d = 1.23;
i变量和d变量类型不同，空间大小不同。
1.2、数据类型在java语言中包括两种：
第一种：基本数据类型
基本数据类型又可以划分为4大类8小种：
第一类：整数型
byte short int long （没有小数的）
第二类：浮点型
float double（带有小数的）
第三类：布尔型
boolean:只有两个值 true（表示真）false（表示假）
第四类：字符型
char：java中规定字符型字面量必须使用单引号括起来，属于文字。
8小种：
byte,short,int,long,float,double,boolean,char
第二种：引用数据类型
字符串型String属于引用数据类型。String字符串不属于基本数据类型范畴
java中除了基本数据类型之外，剩下的都是引用数据类型。引用数据类型后期面向对象的时候才会接触。
1.3、8种基本数据类型中
整数型：byte short int long 有什么区别？
浮点型：float和double有什么区别？
区别：占用空间大小不同
关于计算机存储单位：
计算机智能识别二进制（1010110100...）
1字节（byte）=8bit（比特）
1 bit就是一个1或0
1kb是1024个byte
1mb=1024kb
1gb=1024mb
1tb=1024g
类型 占用字节数量（byte）
Byte 1
Short 2
int 4
long 8
Float 4
double 8
boolean 1（1byte的1或0）
Char 2
关于二进制
1.4、byte类型的取值范围？
byte是【-128~127】共可以表示256个不同的数字。
byte类型的最大值是怎么计算出来的？
byte是一个字节，是8个比特位，所以byte可以存储的最大值是：01111111
那么是不是2的7次方-1呢？
是不是：10000000（前边是一个二进制）-1
byte类型最大值是：2的七次方-1
有几个取值范围需要记住：
byte：【-128~127】
short：【-32768~32767】 可以表示65536个不同的数字
int：【-2147483648~2147483647】
char：【0~65535】 可以表示65536个不同的数字
short和char实际上容量相同，不过char可以标识更大的数字
1.5、对于8种基本数据类型来说：
其中
byte,short,int,long,float,double,boolean,这7种类型计算机表示起来比较容易，因为他们都是数字。其中布尔类型只有两个值true和false，实际上true和fals分别在C++中对应的是1和0,1为true，0为false
对于char类型来说，计算机表示起来比较麻烦，因为char对应的是文字，每一个国家的的文字不一样，文字不能直接通过“自然算法”转换成二进制。
这可怎么办？字符编码诞生了。
什么是字符编码？
字符编码是人为的定义的一套转换表。
在字符编码中规定了一系列的文字对应的二进制。
字符编码其实本质上就是一本字典，该字典中描述了文字与二进制之间的对照关系。
字符编码是人为规定的（某个计算机协会）
字符编码涉及到编码和解码两个过程，解码和编码的时候必须采用同一套编码方式，不然就会出现乱码。
在java中，java语言为了支持全球所有的文字，采用了一种字符编码方式叫做unicode编码。Unicode编码统一了全球所有文字，支持所有文字。
八种基本数据类型详解
字符型：char
整数型：byte short int long
浮点型：float double
布尔型：boolean
字符型：
char
1、char占用2个字节
2、char的取值范围：【0-65535】
3、char采用Unicode编码方式
4、char类型的字面量使用单引号括起来。
5、char可以存储一个汉字。（汉字占用两个字节，java中的char类型也占用两个字节，正好）
0如果加上单引号的话，就不是数字0了，就是文字0，它是一个字符
关于java中的转义字符
java语言中
char c1 = 't';
System.out.println(c1);
//普通的't'字符
char c2 = '\t';
根据之前所学，以上代码应该报错，但经过测试后没有。因为\t实际上是一个字符，不属于字符串。两个字复合在一起表示一个字符，其中\t代表“制表符tab”（相当于键盘上的Tab键）
char c2 = '\t'; ：相当于键盘上的tab键
System.out.println(“abc\tdef”);
\的出现会将紧挨着的后面的字符进行转义。\碰到t表示tab键，输出的结果是：abc def
System.out.print(HelloWorld);
和
System.out.println(HelloWorld);
的区别：
带ln的，会在下一行输出结果
不带ln的，会在同一行输出结果
现在想要在控制台输出一个 ’ 字符怎么办？
System.out.println（'\''）;
\'表示一个普通的不能再普通的单引号字符。（\'联合起来表示一个普通的 ' ）
现在想要在控制台输出一个 \ 字符怎么办？
System.out.println(' \\ ')；
在java中两个反斜杠代表一个“普通的反斜杠”字符
现在想要输出"test"怎么办?
System.out.println("\"test\"");
因为 \ 加上 " 是普通的 " ，所以....
char x = '\u4e2d'; 是什么意思？
反斜杠u表示偶后面的是一个字符的unicode编码，Unicode编码是16进制的
整数型在java语言中共4种类型：
Byte 1
short 2
Int 4
long 8
对于以上的4个类型来说，最常用的是int
开发的时候不用斤斤计较，直接选择使用int就行了。
在java语言中整数型字面量有4种表示形式：
十进制：最常用的。
十进制： int a = 10; （正常写即可）
八进制：int b = 010;（以0开头，之后加数字）
十六进制：int c = 0x10;（以0x开头，之后加数字）
二进制：int d = 0b10;（以0b开头，之后加数字）
在java中有一条非常重要的结论，必须记住：
在任何情况下，整数型的“字面量或数据”默认被当做int处理（记住就行）
如果希望该“整数型字面量”被当做long类型处理，需要在“字面量”后面添加L/l
建议使用大写L，因为小写l和1傻傻分不清
分析这个代码存在类型转换吗，以下代码什么意思？
public class IntTest02{
public static void main(String[] args){
int a = 100;
System.out.println(a);
}
}
不存在类型转换，100这个字面量被当做int类型处理。a变量是int类型，所以不存在类型的转换。int类型的字面量赋值给int类型的变量。
分析这个程序是否存在类型转换？
long b = 200;
System.out.println(b);
分析：200这个字面量默认被当做int类型处理
b变量是long类型，int类型占4个字节，long类型占8个字节。
小容量可以自动转换成大容量，这种操作被称为：自动类型转换。（相当于把小圈套到了大圈里，很自然就能套进去）
分析这个是否存在类型转换？
long c = 300L;
这个不存在类型转换，在整数型字面量300后面添加一个L之后，300L联合起来就是一个long类型的字面量。c变量是long类型，long类型赋值给long类型不存在类型转换
题目1：
long d = 2147483647;
可以吗？存在类型转换吗?
2147483647默认被当做int来处理
d变量是long类型，小容量可以自动赋值给大容量，自动类型转换（2147483647是int最大值）
题目2：
long e = 2147483648;
编译器会报错吗？为什么？
在java中，整数型字面量一上来编译器就会将它看作int类型。而2147483648已经超出了int的范围，所以在没有赋值之前就出错了。
记住，不是e放不下2147483648，e是long类型，完全可以容纳2147483648，只不过2147483648本身已经超出了int范围，编译报错的原因是：整数太大
怎么解决这个问题呢？
long e =2147483648L;
这样就可以了
1、小容量可以直接赋值给大容量，称为自动类型转换。
2、大容量不能直接赋值给小容量，需要使用强制类型转换符进行强转。但需要注意的是：加强制类型转换符之后，虽然编译通过了，但是运行的时候可能会损失精度
int a = 100;
System.out.println(a);
//定义变量a int类型，赋值100
int b = a；
//将变量a中保存的值100复制一份给b变量
System.out.println(b);
以上可以正常赋值并且输出
long x = 100L;
int y = x;
以上是错误的，不行
x是long类型，占用8个字节，而y变量是int类型，占用4个字节。在java语言中，大容量可以直接赋值给小容量吗？
不允许，因为没有这种语法。（编译错误信息：错误：不兼容的类型：从long转换到int可能会有损失）
大容量要想转换成小容量，要想编译通过，必须加强制类型转换符，进行强制类型转换。
所以，应该这么写：
long x = 100L;
int y = (int)x;
//这个（int）就是强制类型转换符，加上去就能编译通过。但是要记住：编译虽然过了，但是运行时可能损失精度。
那么，底层是怎么进行强制类型转换的呢？
（以100L为例）：long类型100L：00000000 00000000 00000000 000000000 000000000 00000000 00000000 01100100
以上的long类型100L强转为int类型，会自动将“前面”的4个字节砍掉：00000000 00000000 00000000 01100100
分析：以下代码编译可以通过吗？
public class IntTest02{
public static void main(String[] args){
byte b = 300;
}
}
不行，因为这是大变小，要想转的话得加强制类型转换符
错误提示：错误：不兼容的类型
应该是： byte b = (byte)300;
下面再分析一下精度
300这个int类型对应的二进制：00000000 00000000 00000001 00101100
byte占用一个字节，砍掉前三个字节，结果是：
00101100（对应十进制44）
以下代码编译能通过吗？
byte x = 1;
byte y = 127;
可以捏！
因为在java中有这样一条规则：当这个整数型字面量没有超出byte的取值范围，那么这个整数型字面量可以直接赋值给byte类型的变量（这种语法机制是为了方便写代码而存在的）
short s = 1;
short s1 = 32767;
这样也可以，因为整数型字面量没有超出short的取值范围，该字面量可以直接赋值给short类型的变量
day07课堂笔记
1、关于数据类型详解
整数型：byte short int long
浮点型：float double
布尔型：boolean
字符型：char
1、整数能否直接赋值给char？
咱们来测试一下
public class CharTest03{
public static void main(String[] args){
char c1 = 'a';
System.out.println(c1);
char c2 = 97;
System.out.println(c2);
char c3 = 65535;
System.out.println(c3);
char c4 = 65536;
System.out.println(c4);
}
}
结果是：
a
a
？（某种字符，受cmd的限制显示不出来）
错误：不兼容的类型：从int转换到char可能会有损失
2、经过测试，得出两个结论
①当一个整数赋值给char类型变量的时候，会自动转换成char字符型，最终的结果是一个字符。
②当一个整数没有超出byte short char的取值范围的时候，这个整数可以直接赋值给byte short char类型的变量，不用加强制类型转换符
3、原码 补码 反码（只是了解内容）
3.1、计算机在任何情况下都只能识别二进制
3.2、计算机在底层存储数据的时候，一律存储的是“二进制的补码形式”，因为补码形式效率最高。
3.3、什么是补码呢？
实际上是这样的：二进制有：原码 反码 补码
3.4.记住：
①对于一个正数来说：二进制原码、反码、补码是同一个，完全相同。
②对于一个负数来说：二进制原码、反码、补码是啥关系呢？
byte i = -1;
对应的二进制原码：10000001
对应的二进制反码（符号位不变，其它位取反）：11111110
对应的二进制补码(反码+1)：11111111
4、
public class IntTest06{
public static void main(String[] args){
char c1 = 'a';
byte b = 1;
System.out.println(c1 + b);
//这里的“+”是负责求和的
}
}
该程序输出的结果是：98
结论：byte char short做混合运算的时候，各自先转换成int再做运算
short s = c1 + b;//这样可以吗？
//错误：不兼容的类型：从int转换到short可能会有损失（因为编译器不知道这个加法最后的结果是多少，只知道是int类型）
//怎么修改呢？
short s = (short)(c1 + b);这样就可以了（强转）
public class intTest07{
public static void main(String[] args){
long a = 10L;
char c = 'a';
short s = 100;
int i = 30;
System.out.println(a + c + s + i);
}
}
这样能输出吗？如果能输出的话最终结果是什么？
不能. //错误：不兼容的类型：从long转换到int可能会有损失（因为计算结果是long类型）
结论：多种数据类型做混合运算的时候，最终的结果类型是“最大容量”对应的类型（先转成最大容量再计算）
（char+byte+short）除外，因为这三个进行混合运算的时候，会各自先转换成int再做运算。）
int temp = 10 / 3；(/是除号)
System.out.println(temp);
这个程序最终结果是什么？ 是3
java中规定，int类型和int类型最终的结果还是int类型 。
int temp2 = 1 / 2;
System.out.println(temp2);
//这个结果是0
//在java中计算结果不一定是精确的。
浮点型数据
关于java语言中的浮点型数据
浮点型包括：
float 4个字节
double 8个字节
float是单精度
double是双精度 相比之下，double更精确
比如：
10.0 / 3如果采用float来存储的话结果可能是：3.3333
10.0 / 3如果采用double来存储的话结果可能是：3.3333333333333333
但是需要注意的是，如果用在银行方面或财务方面的话，double也是远远不够的，在java中提供了一种精度更高的类型，这种类型专门使用在财务软件方面：java.math.BigDemical(不是基本数据类型，属于引用数据类型。)
float和double存储数据的时候都是存储的近似值。
为什么？
2因为现实世界中有这种无限循环的数据，例如：3.333333333333......数据实际上是无限循环，但是计算机的内存有限，用一个有限的资源表示无限的数据，只能存储近似值（真是无限小数的话计算机就不用干别的了，内存里被占满了都）
long类型占用8个字节。
float类型占用4个字节。
哪个容量大？
注意：任意一个浮点型都比整数型空间大。(涉及到底层原理，有幂和阶数之类的，很复杂，不能简单进行比较)
float容量>long容量（不要只看4个字节和8个字节，底层原理很复杂）
java中规定，任何一个浮点型数据默认被当做double来处理。如果想让这个浮点型字面量被当做float类型来处理，那么请在字面量后面添加F/f
1.0 那么1.0默认被当做double类型处理。
1.0F 这才是float类型。（或 1.0f）
double pi = 3.1415926;
System.out.println(pi);
//这个兼容，因为默认就是double类型
float f = 3.14;//这个可以吗？
//错误：不兼容的类型：从double转换到float可能会有损失
那怎么修改呢？
方法一：在字面量后面添加F/f
float f = 3.14F;
方法二：强制类型转换(但可能损失精度，谨慎使用)
float f = (float)3.14;
System.out.println(f);
int i = 10.0 / 5;
分析这个程序，可以编译通过吗？
错误：不兼容的类型：从double转换到int可能会损失
原理：先将5转换成double类型，然后再做运算，结果是double
大容量无法直接赋值给小容量，需要强转。
怎么修改呢？
Int i = (int)10.0 / 5;
System.out.println(i); //输出的结果是2
可以这样修改吗？
int x = (int)(10.0 / 5 );
System.out.println(x); //输出的结果也会2
布尔型数据
1、在java语言中boolean类型只有两个值，没有其它值：true 和 false
不像C++，C语言中1和0也可以表示布尔类型。
2、boolean类型在实际开发中使用在哪里呢？
使用在逻辑判断当中，通常放到条件的位置上（充当条件）
boolean xingBie = 1;
//错误：不兼容的类型：int无法转换为boolean
综合的看一下，在类型转换的时候需要遵循哪些规则？
①八种基本数据类型中，除boolean类型不能转换，剩下七种类型之间都可以进行转换
②如果整数型字面量没有超出byte,short,char的取值范围,可以直接将其赋值给byte,short,char类型的变量
③小容量向大容量转换称为自动类型转换，容量从小到大的排序为：
byte<short(char)<int<long<float<double，其中short和char都占用两个字节，但是char可以表示更大的
正整数
④大容量转换成小容量，称为强制类型转换，编写时必须添加“强制类型转换符”，但运行时可能出现精度损失，谨慎使用
⑤byte,short,char类型混合运算时，先各自转换成int类型再做运算
⑥多种数据类型混合运算，各自先转换成容量最大的那一种再做运算（byte short char混合除外）
所有的笔试题都超不出以上的六条规则，死记嗯背！
第五章：运算符
算术运算符：
+ 求和
-相减
*乘积
/商
%求余数（求模）
++自加1
--自减1
重点：掌握++和--（重点讲解++，--照葫芦画瓢）
首先分析一下：
int i = 10;
i++;
System.out.println(i);
int k = 10;
++k;
System.out.println(k);
这两个输出都是11，相同点是只要执行完，就会自加1。 但是++在前在后有什么区别呢?
研究：++出现在变量前和变量后有什么区别？
先看++出现在变量后
int m = 10;
int n = m++; //只要这一行代码结束，m立刻是11
System.out.println(m); //11，没得跑
System.out.println(n); //????，n得分析一下
语法：当++出现在变量后，会先做赋值运算，再自加1。
也就是说，先把m赋值给n，之后m再自加1，所以在这个程序中n的结果是10（//10）
那++出现在变量前呢？
int x = 100;
int y = ++x;
System.out.println(x); //101
System.out.println(y); //101
语法：当++出现在变量前的时候，会先进行自加1的运算，然后再赋值
也就是说，x先自加1，再赋值给y
题目
int c = 90;
System.out.println(c++);
// 把上面这行代码拆解开
// int temp = c++;
// System.out.println(temp);
// “传”，这个“传”在这里有一个隐形的赋值运算，相当于隐形地把c++先“传”给temp，再输出
// 所以先“传”，再输出。
System.out.println(c);
int d = 80;
System.out.println(++d);
// 拆解
// int temp2 = ++d;
// System.out.println(temp2);
System.out.println(d);
解释一下：
int e = 1;
int f = e; // e赋值给了f，表示将e“传”给了f
关系运算符：
>
>=
<
<=
==
!=
一定要记住一个原则：
所有的关系运算符的运算结果都是布尔类型，
不是true就是false，不可能是其他值
在java语言中：
= ：赋值运算符
==：关系运算符，判断是否相等。
int a = 10;
int b = 10;
System.out.println(a > b);
System.out.println(a >= b);
System.out.println(a < b);
System.out.println(a <=b);
System.out.println(a == b);
System.out.println(a != b);
结果是：
false
true
false
true
true
false
逻辑运算符：
& 逻辑与（可以翻译成并且）
| 逻辑或（可以翻译成或者）
！逻辑非（取反）
&& 短路与
|| 短路或
用语言描述的话：100 大于 99 并且 100 大于 98
用代码描述的话：100 > 99 & 100 > 98---->true
true & true -----> true
非常重要：
逻辑运算符两边要求都是布尔类型，并且最终的运算结果也是布尔类型。
这是逻辑运算符的特点
100 & true 不行，语法错误
100 & 200 不行，没有这种语法
True & false 这样可以
对于逻辑与&运算符来说，只要有一边是false，结果就是false。
两边同时为true，结果才为true
Public class operatorTest03{
public static void main(String[] args){
System.out.println(true & true); // true
System.out.println(true & false); // false
System.out.println(false & false); // false
}
}
注意：这里面所说的“真”或“假”指的是“真命题”或“假命题”
对于逻辑或呢？
只要有一边是true，结果就是true
int a = 100;
int b = 101;
int c = 90;
System.out.println(a < b | c > b); //true
System.out.println(true | false); //true
System.out.println(true | true); //true
System.out.println(false | false); //false
System.out.println(!false); //true
(!false代表“不是假的”)
!!! 在不确定优先级的情况下，要加括号
例：System.out.println(!(a > b)); //true
关于短路与&&，短路或||
重点学习短路与，短路或照葫芦画瓢
短路与&& 和 逻辑与& 有什么区别？
首先这两个运算符的运算结果没有任何区别，完全相同。只不过“短路与&&”会发生短路现象
什么是短路现象呢？
什么时候使用&&，什么时候使用& ？
System.out.println(true & true); //true
System.out.println(true & false); //false
System.out.println(false & false); //false
System.out.println(true && true); //true
System.out.println(true && false); //true
System.out.println(false && false); //true
接下来理解一下什么是短路现象，什么时候会发生“短路”。
先看看逻辑与
int x = 10;
int y = 11;
System.out.println(x > y & x > y++);
System.out.println(y);
执行，输出的结果是：
false
12
经过这个测试得出：x > y++ 这个表达式执行了。
按理说，左边的x > y表达式结果已经是false了，整个表达式的结果都已经确定了是false，但是右边还是执行了。
再看看短路与
int m = 10;
int n = 11;
System.out.println(m > n && m > n++);
System.out.println(n);
执行，得出的结果是：
false
11
和逻辑与不同的是，在左面表达式是false以后，右边的表达式便不会执行，这种现象被称为短路。
从效率方面来说，短路与&&的效率更高
以后的开发中，&和&&还是需要同时存在的
但是大部分情况下，用&&。
问题：什么时候发生短路或现象？
|| 短路或
“或”的时候只要有一边是true，结果就是true。
所以，当左边的表达式结果是true的时候，右边的表达式不需要执行，此时会短路。
赋值运算符
1、赋值运算符包括“基本赋值运算符”和“扩展赋值运算符”：基本的、扩展的。
2、基本赋值运算符？
=
3、扩展赋值运算符？
+=
-=
*=
/=
%=
注意：扩展赋值运算符在编写的时候，两个符号之间不能写空格。
+=：正确的
+ =：错误的
4、很重要的语法机制：
使用扩展赋值运算符的时候，永远都不会改变运算结果类型。
byte x = 100;
x += 1;
x自诞生以来是byte类型，那么x变量的类型永远都是byte
以+=运算符作为代表，学习扩展赋值运算符。
其它的运算符，例如：-= 、*=、 /=、%=原理相似
int k = 10;
k += 20;
System.out.println(k);
输出结果是30
// k变量追加20
int m = 10;
m = m + 20;
System.out.println(m); //30
所以，+=类似于以上的表达式
研究：
i += 10 和 i = i + 10 真的完全一样吗？
答案：不一样，只能说相似，其实本质上并不是完全相同
byte x = 100; // 由之前的知识，100没有超出byte类型取值范围，可以直接赋值
System.out.println(x); // 100
x = x + 1;
System.out.println(x);
//错误：不兼容的类型：从int转换到byte可能会有损失
所以必须要写成：x = (byte)(x + 1);才行
但是用扩展赋值运算符就不会有这种问题
x += 1;
System.out.println(x); //101
结论： x += 1 和 x = x + 1不一样
但是，扩展赋值运算符在使用的时候可能会损失精度
byte x = 101
x += 199;
System.out.println(x);
这就相当于int类型的300强转成了byte类型，最后输出的结果是44（损失精度）
int x = 100;
x += 100 ;
System.out.println(x); // 200
x -= 100;
System.out.println(x); //100
x *= 10;
System.out.println(x); //1000
x /= 30;
System.out.println(x); //33
x %= 10;
System.out.println(x); //3
条件运算符（三目运算符）
语法格式：
布尔表达式（true/false）+？+表达式1：表达式2
执行原理是什么？
布尔表达式的结果是true时，表达式1的执行结果作为整个表达式的结果。
布尔表达式的结果为false时，表达式2的执行结果作为整个表达式的结果。
看下列代码，并判断编译器会不会报错
public class OperatorTest05{
public static void main(String[] args){
100;
}
}
会，因为“100;”不是一个完整的语句。
看下列代码，并判断编译器会不会报错
public class OperatorTest05{
public static void main(String[] args){
boolean sex = false;
sex ? '男' : '女' ;
}
}
会，因为三目运算符只是运算符，并不是完整的语句。
得这么写：
char c = sex ? '男' : '女' ;
System.out.println(c);
字符串连接运算符：“+”
1、+运算符在java语言中有两个作用。
作用1：求和
作用2：字符串拼接
2、什么时候求和？什么时候进行字符串的拼接呢？
当 + 运算符两边都是数字类型的时候，求和。
当 + 运算符两边的任意一边是字符串类型，那么这个+会进行字符串拼接操作。
3、一定要记住：字符串拼接完之后的结果还是一个字符串
int nianLing = 35;
// 定义一个年龄变量
System.out.println("年龄=" + nianLing);
// 在这里会进行字符串的拼接操作。
输出，结果是
“年龄 = 35”
int a = 100;
int b = 200;
int c = a + b;
System.out.println(c);
// 这里的“+”是加法运算，因为两边都是数字。
问题
判断下列代码最终输出的结果是什么
System.out.println(a + b + "110");
//aef
注意：当一个表达式当中有多个加号的时候，遵循“自左向右”的顺序依次执行。（除非额外添加了小括号，小括号的优先级高）
第一个+先运算，由于第一个+左右两边都是数字，所以会进行求和。
求和之后的结果是300，代码就变成了：System.out.println(300 + “100”);
那么这个时候，由于+右边的是字符串“110”，所以此时的+会进行字符串拼接，所以最后的结果是字符串“300110”
System.out.println(a +（b + "110"）);// 100200110
先执行小括号里的程序 b + "110" ,这里的+会进行字符串的拼接，拼接之后的结果是：“200110”，这个结果是一个字符串类型。代码就变成了：
System.out.println(a + "200110");
这个时候的+还是进行字符串的拼接。最终结果是：“100200110”
在控制台上输出“100 + 200 = 300”
（System.out.println(“100 + 200 = 300”);）不是这个意思
System.out.println(a + "+" + b + "=" + c);
// 以上有效的运算符加号一共有4个，这4个加号都是字符串拼接操作。
分析以下代码结果是多少？
System.out.println(a + "+" + b + "=" + a + b );
上面表达式没有小括号，所以遵循自左向右的顺序执行。
第1,2,3,4个加号都是进行字符串拼接，拼接之后的结果是：“100 + 200 = 100”
然后这个字符串再和最后一个b变量进行字符串的拼接：“100 + 200 = 100200”
System.out.println(a + "+" + b + "=" + (a + b));
// 和上面程序不一样的地方是：最后一个加号先执行，并且会先进行求和运算。
在java语言中怎么定义字符串类型的变量呢？
以整数型为例：int i = 10;
其中int是整数型 i是变量名 10是字面量
String是字符串类型，并且String类型不属于基本数据类型范畴，属于引用类型。
name是变量名，只要是合法的标识符就行
“TangShiyao”是一个字符串型字面量
String name = "TangShiyao";
// 注意，String中的S是大写！
现在想写个程序，输出“登录成功欢迎name回来”（其中name是字符型变量）
那么就要用到“+”了
String name = "TangShiyao"
System.out.println("登录成功欢迎" + name + “回来”);
口诀：加一个双引号“”，然后双引号之间加两个加号：“++”，然后两个加号中间加变量名
day08课堂笔记
第六章 控制语句
1、怎么接受用户键盘输入？
java.util.Scanner s = new java.util.Scanner(System.in);
// 接收整数
int i = s.nextInt();
// 接收字符串
String str = s.next();
2、控制语句
2.1、控制语句的出现可以让我们的程序具有逻辑性/条理性，可以使用控制语句来实现一个“业务”了
2.2、控制语句包括几类？
3类：
选择语句：if、switch
循环语句：for、while、do…while…
转向语句：break、continue、return
2.3、选择语句也可以叫做分支语句
if语句
switch语句
2.4、循环语句：主要循环反复的去执行某段特定的代码块
for循环
while循环
do... while....循环
2.5、转向语句
break
conitune
return(这个目前先不需要学习，后面讲方法的时候会使用)
3、选择语句/分支语句if
if语句的语法结构和运行原理？
if语句是分支语句，也可以叫做条件语句。
if语句的语法格式：
①第一种写法：
if(布尔表达式){
java语句;
java语句;
}
这里的一个大括号{}叫做一个分支。
if这个单词翻译为如果，所以又叫做条件语句。
该语法的执行原理是：
如果布尔表达式的结果是true，则执行大括号中的程序，否则大括号中代码不执行。
②第二种写法：
if（布尔表达式）{ // 分支1
java语句;
}else{ //分支2
java语句;
}
执行原理：如果布尔表达式的结果是true，则执行分支1，分支2不执行。如果布尔表达式的结果是false，分支1不执行，执行分支2
以上的这个语句可以保证一定会有一个分支执行。
③第三种写法
if(布尔表达式1){ //分支1
java语句1;
}else if(布尔表达式2){ //分支2
java语句2;
}else if(布尔表达式3){
java语句3;
}else if(布尔表达式4){
java语句4;
}.....
以上if语句的执行原理？
先判断“布尔表达式1”，如果“布尔表达式1”为true，则执行分支1，然后if语句结束了。
当“布尔表达式1”的结果为false，那么会继续判断布尔表达式2的结果，如果布尔表达式2的结果为true，则执行分支2，然后整个if就结束了。以此类推.......
从上往下依次判断，主要看第一个true发生在哪个分支上。第一个true对应的分支执行，只要一个分支执行，整个if结束
④第四种写法
if(布尔表达式1){ //分支1
java语句1;
}else if(布尔表达式2){ //分支2
java语句2;
}else if(布尔表达式3){
java语句3;
}else if(布尔表达式4){
java语句4;
}else{
java语句; //以上条件没一个成立的，这个else就执行了
}
这个和第三种的区别是，第四种中如果else if的所有结果全为false，则执行else后面的语句
嵌套
if(){
if(){
}else{
}
}else{
}
原理：套娃
注意：
1、对于if语句来说，在任何情况下只能有一个分支执行，不可能存在2个或者更多个分支执行。if语句中只要有一个分支执行了，整个if语句就结束了。(对于一个完整的if语句来说的。)
2、以上四种语法机制中，凡是带有else分支的（不是else if），一定可以保证会有一个分支执行。以上4种当中，第一种和第三种没有else分支，这样的语句可能会导致最后一个分支都不执行。第二种和第四种肯定会有一个分支执行
3、当分支当中“java语句;”只有一条，那么大括号{}可以省略，但为了可读性，还是加上好。（有的程序员故意省略，你要看懂）
4、控制语句和控制语句之间是可以嵌套的，但是嵌套的时候大家最好一个语句一个语句分析，不要冗杂在一起分析（就是要一个一个看，别手忙脚乱的。）窍门：分析外面if时，里面的for循环当做普通java代码来看。
————————业务————————
当sex为true时表示男，为false时表示女
①正常打
if (sex){
System.out.println("男");
}else {
System.out.println("女");
}
②进一步改良（三目运算符）
sex = true;
System.out.println(sex ? "男" : "女");
代码可以这样写吗
if (sex = true){
System.out.println("男")；
else {
System.out.println("女");
}
}
可以，小括号当中最终取的是sex变量的值（等号右面先赋值给左面），而sex是布尔类型，所以这个可以通过。
但有一个问题:即使在程序前面给sex赋值成false也没用，因为到括号里sex又被重新赋值成true了，永远都会执行第一个语句。（else后面的语句没用了属于是）
——————————业务——————————
要求:
1、从键盘上上接受一个人的年龄。
java.util.Scannner s = new java.util.Scanner(System.in)
int num = s.nextInt()
2、年龄要求为【0-150】，其他值表示非法，需要提示非法信息。
3、根据人的年龄来动态的判断这个人属于生命的哪个阶段？
【0-5】婴幼儿
【6-10】少儿
【11-18】少年
【19-35】青年
【36-55】中年
【56-150】老年
4、请使用if语句完成以上的业务逻辑。
————————业务2———————————
1、系统接收一个学生的考试成绩，根据考试成绩输出成绩的等级
2、等级：
优：【90-100】
良：【80-89】
中：【70-79】
及格：【60-69】
不及格：【0-60】
3、要求是成绩是一个合法的数字，成绩必须在【0-100】之间，成绩可能带有小数。
————————业务3————————
从键盘上接收天气的信息：
1表示雨天 0表示晴天
同时从键盘上接受性别信息
1表示男 0表示女
业务要求：
①当天气是雨天的时候：
男的打一把大黑伞
女的打一把小花伞
②当天气是晴天的时候
男的出去玩耍
女的擦点防晒霜出去玩耍
需要使用if语句以及嵌套的方式展现这个业务
可以在程序的开始，接收两个数据，一个数据是天气，一个数据是性别。然后将这两个数据保存到变量中。
————————————————————————————————————————————————————
switch语句：
1、switch语句也是选择语句，也可以叫做分支语句
2、switch语句的语法格式
switch(值){
case值1： // switch要和case对齐 这是规矩。
java语句;
java语句;
break;
case值2：
java语句;
java语句;
break;
case值3：
java语句;
java语句;
break;
default:
java语句;
}
以上是一个完整的switch语句
其中，break语句不是必须的。default分支也不是必须的。
switch语句支持的值有哪些？
支持int类型以及String类型。
但一定要注意JDK的版本，JDK8之前不支持String类型，只支持int。JDK8之后，switch语句开始支持字符串String类型。
switch语句本质上是只支持int和String，但是byte，short，char也可以使用在switch语句当中，因为byte
short char可以进行自动类型转换。
switch语句中“值”与“值1”、“值2”比较的时候会使用“==”进行比较
3、switch语句的执行原理
拿“值”与“值1”进行比较，如果相同，则执行该分支当中的java语句，然后遇到“break”语句，switch语句就结束了。
如果“值”与“值1”不相等，会继续拿“值”与“值2”进行比较，如果相同，则执行该分支当中的java语句，然后遇到break语句，switch结束
注意：如果分支执行了，但是分支最后没有“break”，此时会发生case穿透现象。（也就是在没有break的情况下，匹配之后不会立即结束，而是接这往下执行，直到程序末端或者遇到break）
—————————业务———————————
写一个完整的switch语句：接收键盘输入，根据输入的数字判断星期几 0：星期日 1：星期一.......
关于default语句，当所有的case都没有匹配上的时候，执行default语句。
关于case合并的问题：
switch(num){
case 1: case 2: case 3:
System.out.println("星期一")；
break;
case 4:
System.out.println("星期二");
break;
}
// 输入 1，2 或者3 都会显示“星期一”
day09课堂笔记
1、控制语句
for循环
while循环
do..while ...循环
什么是循环语句，为什么要使用循环语句？
因为在现实世界中，有很多事情需要重复或者反复的去做。对应到程序当中，如果有一行代码需要重复执行，此时为了减少代码量，我们使用循环语句。
循环语句的出现就是解决代码的复用问题。
1、for循环的语法机制以及运行原理？
语法机制：
for（初始化表达式；条件表达式；更新表达式）{
循环体：// 循环体由java语句构成
java语句;
java语句;
java语句;
java语句;
java语句;
......
}
注意：
第一：初始化表达式最先执行，并且在整个循环中只执行一次。
第二：条件表达式结果必须是一个布尔类型，也就是：true或者false
执行原理：
先执行初始化表达式，并且初始化表达式只执行一次。
然后判断条件表达式的结果，如果条件表达式结果为true，则执行循环体。
循环体结束之后，执行更新表达式。
更新完之后，再判断表达式的结果，如果还是true，继续执行循环体
直到更新表达式执行结束之后，在此判断条件时，条件为false，for循环终止
更新表达式的作用是：控制循环的次数，换句话说，更新表达式会更新某个变量的值，这样条件表达式的结果才有可能从true变成false，从而终止for循环的执行，如果确实更新表达式，很有可能会导致死循环。
for(int i = 0; i < 10; i++){
System.out.println("i = " + i);
}
// 0 1 2 3.. 9
强调下，对于以上的这个for循环，其中int i = 0；
最先执行，并且只执行一次，而且i变量属于for循环的局部变量，for循环结束之后i的内存就释放了。这个i变量只能在for循环当中使用，属于for循环域，在main方法中没办法直接使用
for(int i = 0; i < 10; ){
System.out.println("i = " + i);
i++;
}
这样也可以，因为顺序是相同的，都是在输出完之后再进行自加
for(int i = 0; i < 10; ){
i++；
System.out.println("i = " + i);
}
这样，输出的东西会改变 从2到11。
for的其他形式
for(int i = 0; i < 20; i += 2){
System.out.println("value1 =" + i);
}
// 10 9 8 7 6 5 4 3 2 1
for (int i = 0 ; i < 10; i += 2){
System.out.println("value2 = " + i);
}
// 0 2 4 6 8
for (int i = 100; i > 0; i %= 3){
System.out.println("value2 = " + i );
}
// 100 1 1.... 1(死循环)
题目：
使用for循环，实现1-100所有奇数求和
至少给出两种解决方案。
第一种方案：
思路：先找出1-100所有奇数，然后再考虑求和的事。
第一步：先从1取到100，一个数字一个数字取出来。
第二步：既然可以得到每一个数字，那么我们进一步判断这个数字是否为奇数（方法是：奇数除以2余1）
int sum = 0;
for(int i = 1; i <= 100; i++){
if (i % 2 == 1){
sum += i;
}
}
System.out.println("1~100所有奇数求和结果是：" + sum);
// for循环中嵌套了if语句
// 声明sum的位置要注意，不能在循环体当中声明，这样会导致“计算器归0”
第二种方案：
sum = 0;
for(int i = 1; i < 100; i += 2){
sum += i;
}
System.out.println(sum);
优点：循环次数少，效率高
循环嵌套
1所有的合法的“控制语句”都可以嵌套使用。
2、for循环嵌套一个for循环执行原理是什么？（提示一下，不要因为for循环中嵌套了一个for循环，就感觉这个程序比较特殊，实际上可以这样看待：在分析外层for循环的时候，把里面的for当做一段普通的java语句/代码）
①单层for循环
for(int k = 0; k < 2; k ++){
System.out.println("k = " + k);
}
②循环两次
for(int k = 0; k < 2; k ++){
System.out.println("k = " + k);
}
for(int i = 0; i < 2; i ++){
System.out.println(i);
}
③嵌套
for(int k = 0; k < 2; k ++){
for(int i = 0; i < 10; i ++){
System.out.println(i);
}
}
③和②是一样的
③外面的for控制里面的for
④把i变量的定义放在外面会怎么样？
int i = 0;
for(int k = 0; k < 2 ; k ++){
for(; i < 10; i ++){
System.out.println(i);
}
}
⑤这种情况又会怎么样？
int i = 0;
for(int k = 0; k < 2; k++){
for(; i < 10; i ++){
System.out.println("k=" + k);
System.out.println("i=" + i);
}
}
// 这个跟上面不一样，只会输出一次0-9
为什么呢？
一、int i = 0在括号里的时候，循环体正常走完第一个循环，之后k为1，仍然小于2，循环体再来一次。
二、int i = 0在括号外的时候，循环体正常走完第一个循环，之后k仍为1，仍然小于2，但是此时由于没有重新给 i 归零，i仍为10，布尔表达式为false，所以i就不输出了，也就只有一次0-9
窍门: 在分析外层for循环的时候，把里面的for就当做一段普通的java语句/代码
————————业务——————————
写出九九乘法表
1 * 1=1
1 * 2=2 2 * 2=4
1 * 3=3 2 * 3=6
....... ......
先找下九九乘法表的特点
①：共九行
②：第一行一个，第二行两个，第三行三个。
public class Nine {
public static void main(String[] args){
for(int i = 1; i <= 9; i ++){
for(int j = 1; j <= i; j ++){
System.out.print(i * j);// 注意：这里不换行，所以不用ln
}
System.out.println();
}
}
}
// i是行号，即纵向循环
最重要的是：不要慌，把思路捋出来再写代码。最怕的是没找到特点/思路
while循环
1.while循环的语法机制以及执行原理
语法机制：
while（布尔表达式）{
循环体;
}
执行原理：
判断布尔表达式的结果，如果为true就执行循环体，循环体结束之后，再次判断布尔表达式的结果，如果还是true，继续执行循环体，知道布尔表达式结果为false，while循环结束。
2、while循环有没有可能循环次数是0次？
可能。while循环的次数是：0~无穷次
//for while do..while.... 这些都是循环语句，可以相互嵌套。
for和while完全可以互换，只不过就是语法格式不一样。
for(int i = 0; i < 10;){
i ++;
System.out.println(i);
}
int i = 0;
while(i < 10){
i ++;
System.out.println(i);
}
以上各两个程序输出的内容完全相同，只不过就是语法格式不一样。
目前要掌握的：
①：必须要将语法结构背会
②：必须要彻底的理解他们的执行原理
去实现案例，去实现功能。
先从简单的案例开始，慢慢的经过一个过程你才能解决复杂的问题。
do...while...循环语句
do...while....循环语句的执行原理以及语法机制
语法机制：
do{
循环体;
}while(布尔表达式);
// 注意：分号一定要加！！！！，别漏了！！！！
执行原理：
先执行循环体中的代码，执行一次循环体之后，判断布尔表达式的结果，如果为true，则继续执行循环体，如果为false循环结束。（先斩后奏）
对于do..while循环来说，循环体至少执行1次。循环体的执行次数是：1~无穷次
而对于while循环来说，循环体执行次数是：0~n次。
转向语句
关于转向语句：
break
conitune
return(后面会讲)
break语句
1、break语句比较特殊，特殊在：break语句是一个单词成为一个完整的java语句。另外：continue也是这样，他俩都是一个单词成为一条语句。
2、break翻译为“折断”、“弄断”
3、break语句用在哪里呢
用在两个地方，其他位置不行
第一个位置：switch语句当中，用来终止switch语句的执行。用在switch语句当中，防止case穿透现象，用来终止switch
第二个位置：循环语句当中，用来终止循环语句的执行
用在for当中
用在while当中
用在do...while...当中
4、以下的程序让大家更好的了解break语句
5、break;语句的执行并不会让整个方法结束，break；语句主要是用来终止离它最近的那个循环语句。
for(int i = 0; i < 10; i ++){
System.out.println("i = " + i);
}
// 以上只是一个普通的循环语句
for(int i = 0; i < 10; i ++){
if(i == 5){
// break语句会让离它最近的循环停止播放
break;
// break; 终止的不是if（也不是针对if的），而是离它最近的循环
}
System.out.println("i =" + i);
// 0 1 2 3 4
}
System.out.println("Hello World")
// 这里的代码照常执行，break;的循环并不会影响这里
continue; 语句:
1、continue翻译为：继续
2、continue语句和break语句要对比着学习
3、continue语句的作用是：
终止当前“本次”循环，直接进入下一次循环继续执行。
for(){
if(){ // 当这个条件成立时，执行continue语句
continue; // 当这个continue语句执行时，continue下面的代码不执行，直接跳过
}
// 以上的continue一旦执行，一下代码不执行，直接执行更新表达式。
code1;
code2;
code3;
code4;
}
4、continue语句后面可以指定循环吗？
可以的。
这里就不再讲了，自己测试下
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
