1、Java简介和计算机基础
-
从今天开始大家就是Java软件工程师了! ! ! !
-
什么是软件工程师呢?
是一种职位的名称
通常是通过计算机的"某种编程语言"完成软件的开发。 -
什么是软件呢?
大家眼前的笔记本电脑就是一台 计算机，计算机就包含了很多软件。
1.1.计算机组成
- 计算机包括两部分:
- ==硬件:==鼠标、键盘、显示器、主机箱内部的CPU、内存条、硬盘等…
==注意:==计算机只有硬件是无法工作的，需要软件驱动硬件才能工作。 - 软件:
软件包括:系统软件和应用软件
系统软件:
直接和硬件交互的软件，例如: window7、winxp、 win8、 win10、 Linux操作系统
应用软件:
应用软件通常运行在系统软件中，例如:运行在windows操作系统上。
QQ就是典型的应用软件之一。
win7就是操作系统软件之一。
- ==硬件:==鼠标、键盘、显示器、主机箱内部的CPU、内存条、硬盘等…
1.2.Java工程师
- 我们通常所说的软件开发一般都是指使用计算机编程语言==完成“应用软件"==的开发。
- 开发软件需要计算机编程语言，计算机编程语言很多，例如: c语言、C++、 Java、 NET、 c#、php…**
- 我们主要学习哪个编程语言呢?
- java编程语言。java系列的技术。
- 通过学习java系列的技术完成应用软件开发。
- 我们主要学习哪个编程语言呢?
- Java软件工程师:
- 通过Java编程语言完成应用软件的开发。
- 我们不是搞硬件的，我们是搞软件开发的。
- 学习之前先安装一 个好点儿的文本编辑器:
- 我们这里安装的是EditPlus3
- 注意：安装EditPlus之 后取消文件自动备份，不然会产生很多不必要的文件。
- 设置字体—首选项
1.3. 电脑的配置
- CPU：中央处理器。建议使用intel的处理器，建议使用i7十代以上的。
- 内存：建议16G以上，至少16G，有条件的，可以是32G。
- 硬盘：当然是固态硬盘最好。（次要的）
1.4. 截图工具的安装与使用
- Snipaste-2.5.6-Beta-x64
1.5. OneNote工具的安装与使用
- OneNote 2007版
1.6. 高效的学习方法
- 指法速度快，敲代码快。左手：asdf 右手：jkl;
- 形成编程思想。
- 多敲（多写代码，不要一味的只听理论。一天当中大部分空闲时间的90%都要使用在敲代码上）
- 不要照抄代码。只有第一个Java程序是可以照抄的。照抄代码很难形成自己的编程思路，很难提高自己的解决问题的能力。可以将老师代码的核心思路总结/提取出来。然后将老师代码关闭，根据这个中心思路去一步一步实现。慢慢形成自己的编程思想。
- 在听课的过程当中，一定要记笔记。并且笔记中一定是体现课堂上的重点内容。（每天要回顾以前的内容。最好是当天能够回顾最近5天的内容，这个回顾不是把所有代码敲一遍，最好能在30分钟之内完成，大概浏览一下之前的笔记。）
- 结论验证法：课堂上老师会讲解很多结论，大家应该对这种结论怀有怀疑的态度。课下应该写代码去推翻这个结论，如果你无法推翻，那么这个结论你自然就记住了。
1.7. 显示文件扩展名以及隐藏文件
- 让文件的扩展名展示出来。如果隐藏文件的扩展名，会影响java文件的创建。
- 让隐藏的文件显示出来。作为一个专业的程序员，电脑不应该对我们有隐瞒。
1.8. 文本编辑器EditPlus的安装与配置
- EditPlus的安装
- 字体设置
- 取消备份
- 设置缩进大小
1.9. 常用的文本编辑快捷键
- ctrl + c 复制
- ctrl + v 粘贴
- ctrl + x 剪切
- ctrl + s 保存
- ctrl + z 撤销
- ctrl + y 重做
- ctrl + a 全选
- Home 光标回到行首
- End 光标回到行尾
- Shift + Home/End 光标在行首或者行尾的时候如何选中一行
- ctrl + Home/End 光标回到整个文档的开始或者回到整个文件的结尾
- 鼠标双击 选中一个单词
- ctrl + shift + 右方向/左方向 选中一个单词
- ctrl + f 查找
1.10. 什么是计算机
计算机（computer）俗称电脑，是现代一种用于高速计算的电子计算机器，可以进行数值计算，又可以进行逻辑计算，还具有存储记忆功能。是能够按照程序运行，自动、高速处理海量数据的现代化智能电子设备。
计算机发明者约翰·冯·诺依曼。计算机是20世纪最先进的科学技术发明之一，对人类的生产活动和社会活动产生了极其重要的影响，并以强大的生命力飞速发展。它的应用领域从最初的军事科研应用扩展到社会的各个领域，已形成了规模巨大的计算机产业，带动了全球范围的技术进步，由此引发了深刻的社会变革，计算机已遍及一般学校、企事业单位，进入寻常百姓家，成为信息社会中必不可少的工具。
1.11. 计算机的组成
-
硬件+软件
-
硬件
- CPU
- 内存
- 硬盘
- 主板
- 显示器
- 鼠标
- 键盘
- …
-
软件
- 系统软件
- windows
- Linux
- mac OS
- …
- 应用软件
- QQ聊天软件
- office办公软件
- 财务软件
- …
- 系统软件
1.12. 什么是计算机编程语言
- 什么是语言，有什么用？
- 语言的存在保证了人和人之间的沟通。
- 语言其实就是制定的一套标准。
- 不同的国家有不同的语言，比如：日语、韩语、汉语、德语…
- 什么是计算机编程语言，有什么用？
- 计算机编程语言保证了人和计算机之间的沟通。（人机交互）
- 计算机编程语言也是人为的制定的一套标准。
- 计算机编程语言也包括很多种：C、C++、Java、Python…
1.13. 计算机编程语言发展史
- 第一代 机器语言
- 用0和1组成的程序指令代码
- 优点：直接执行，速度快，资源占用少
- 缺点：可读性差，可移植性差，编程繁杂
- 机器语言由数字组成所有指令。当让你使用数字编程，写几百个数字，甚至几千个数字，每天面对
的是纯数字，我大胆预测：“程序员群体100%会有精神问题”。
- 第二代 低级语言
- 低级语言的代表是汇编语言，汇编语言是机器指令的符号化。
- 优点：执行速度快，占用内存少。
- 缺点：可读性仍然很差，移植性差，不好学。
- 汇编语言目前多数应用于工业电子编程领域、软件的加密解密、计算机病毒分析等方面。
- 第三代 高级语言
- 高级语言又主要是相对于汇编语言而言的，它是较接近自然语言和数学公式的编程，基本脱离了机器的硬件系统，用人们更易理解的方式编写程序。
- 包括：C、C++、Java、Python等。
- 高级语言的出现，尤其是面向对象语言的出现，相当于人类的工业社会,高级语言极其易用，编程门槛和难度大大降低，大量的人员进入软件开发行业，为软件爆发性的增长提供了充足的人力资源。
1.14. Java语言能开发什么类型的软件
- 大型高并发的互联网应用
- 京东商城
- 淘宝
- 12306
- 企业内部的管理系统，为企业提供解决方案
- 银行
- 保险
- 证券
- 医疗
- 教育
- …
- 手机应用
- 这个主要是指Java的android部分，安卓应用，安卓手机游戏等
- 微型电子设备的嵌入式程序
- 移动电话
- 机顶盒
- 电饭煲…
1.15. Java语言发展史
- Java的logo是一杯冒着热气的咖啡，据说这种咖啡香气扑鼻，产自爪哇岛。
- Java之父James gosling带领团队研发的。
- Java是1995年诞生的。
| 时间 | 描述 |
|---|---|
| 1991~1995 | Sun为了占领智能消费电子产品市场，由James gosling负责该项目，来开发Oak语言 |
| 1995 | 将Oak改名为Java |
| 1996 | 发布JDK1.0 |
| 1997 | 发布JDK1.1 |
| 1998 | 发布JDK1.2，将该版本命名为J2SDK，将Java更名为Java 2 |
| 1999 | 将Java分为三大块：J2SE(Java标准版)、J2EE（Java企业版）、J2ME(Java微型版本) |
| 2000 | 发布J2SE1.3 |
| 2002 | 发布J2SE1.4 |
| 2004 | 此时不再叫J2SE1.5，叫5.0 |
| 2005 | 2005 Java 10周年，将J2SE改为 JAVA SE、将J2EE改为 JAVA EE、将J2ME改为 JAVA ME |
| 2006 | 发布 JAVA SE 6 |
| 2009 | Sun公司被Oracle公司收购了，从此Java语言由Oracle来进行升级维护。 |
| 2011 | 发布JAVA7 |
| 2014 | 发布Java8 |
| 2017 | 发布Java9 |
| 2018年3月 | 发布Java10 |
| 2018年9月 | 发布Java11 |
| 2019年3月 | 发布Java12 |
| 2019年9月 | 发布Java13 |
| 2020年3月 | 发布Java14 |
| 2020年9月 | 发布Java15 |
| 2021年3月 | 发布Java16 |
1.16. Java语言特性
- 简单性
- java是纯面向对象语言，语法简单明了，易于掌握。
- java使用接口代替了多重继承。
- 取消了复杂的指针语法。
- java提供了垃圾自动回收机制，使得内存管理更为简单。
- 健壮性
- java会检查程序在编码和运行时的错误，并消除错误。
- 支持多线程
- java支持在同一时间并行执行多项任务。
- 安全性
- java语言删除了类C语言的指针和内存释放等语法，有效地避免了用户对内存的非法操作。
- 可移植性
- java语言是可以跨平台的。
- 一次编译，到处运行。
- 怎么做到的？java虚拟机（JVM：Java Virtual Machine）的功劳。
2、Dos基础
2.1.dos基础
- DOS命令在哪里编写?
- 在Dos命令窗口当中编写Dos命令
-
Dos命令窗口怎么打开呢?
- 开始菜单–>运行–>输入cmd–>回车[默认打开的是黑色的命令窗口，这就是Dos窗口]
- color 数字 :可以改变背景颜色，例如：
02黑绿05 红黑
-
DOs窗口中的内容怎么复制?
- 在DOS窗口的任意位置，点击鼠标右键，然后选择标记,接下来选中要复制的内容，在Dos窗口的任意位置点击鼠标右键,此时被复制的内容已经到剪贴板了。在需要粘贴的位置粘贴即可。
-
常见的DOS命令?
-
exit 退出当前Dos命令窗口
-
cls 清屏
-
dir 列出当前目录下所有的子文件/子目录
-
cd 命令
-
cd …回到上级目录。
-
cd / 直接回到根目录。
-
怎么切换盘符:
c:
回车
d:
回车
e:回车
f:回车
-
-
cd命令表示: change directory [改变目录]
- cd命令怎么用呢?
cd 目录的路径
2.2.路径
- 路径包括绝对路径和相对路径【出发点不同】
-
绝对路径:表示该路径从
某个磁盘的盘符下作为出发点的路径 -
相对路径:表示该路径从
当前所在的路径下作为出发点的路径- 假设当前所在的路径是c: \Users\Administrator,那么在此时输入
cd Desktop,那么其中Desktop就是一-个相对路径，从当前所在的
C: \Users\Administrator这个路径作为出发点，开始找Desktop目 录。
- 假设是这样写的: cd
C:\Users\Administrator\Desktop
其中cd C: \Users\Administrator\Desktop路径就是一个绝对路径。
3、计算机语言发展史
3.1.扩展名
- 关于windows操作系统的文件扩)展名的设置
- 作为java程序员，以后要新建.java结尾的文件，所以必须保证文件的扩展名是.java
- 怎么做呢?
- 打开计算机–>组织–>文件夹和搜索选项–>查看–>隐藏已知文件类型的扩展名( 前面对勾去掉)
3.2.计算机语言
-
计算机语言发展史
- 什么是计算机<编程>语言?
- 提前的人为的制定好的一套交流规则，有的时候，有的语法是需要死记硬背的，不需要问为什么。而只要遵守这套语法规则，那么人和计算机之间就可以很好的沟通、交流。这就是计算机编程语言。
- 什么是计算机<编程>语言?
-
计算机编程语言也有很多语种。例如: c语言C++ Java PHP…
-
计算机语言发展史
-
第一代语言:机器语言
主要编写二进制码，直接编写100101010101这样的二进制。以打孔机为代表。
-
第二代语言:低级语言
- 主要以汇编语言为代表
- 在低级语言当中已经引入了–些英语单词，例如变量赋值采用nv
-
第三代语言:高级语言
- 几乎和人类的语言完全相同，即使是没有学习过计算机编程，只要看到这段代码就知道该代码主要完成什么功能。例如: c语言、C++、Java
- 总之，大家看到了编程语言的发展方向是:向着人类更加容易理解的方向发展。
-
3.3.Java语言发展史
- Java语言 发展史
- Java语言诞生于1995年。其实在1995年之前SUN公司(太阳微电子公司),为了占领智能电子消费产品市场，派James Gosling领导团队开发了一个oak(橡树)语言。sun公司目前被oracle (甲骨文:做数据库的)收购了)
- 1996年: JDK1. 0诞生什么是JDK?
- Java开发工具包,做Java开发必须安装的一个工具包，该工具包需要从官网下载。
- 目前SUN被orac1e收购了，所以下载需要去oracle官网下载（请点击下一行访问）。
- [Oracle官网](http : //www . oracle . com)
- JDK最高版本是: Java8/ JDK1.8/JDK8，JDK8和JDK11功能差不多
- JDK6以前Switch不支持String类型，JDK7开始支持String类型
- Java包括三大块
- JavaSE ( Java标准版)
- JavaEE (Java企业版)
- JavaME ( Java微型版)
其中JavasE是基础,我们的主攻方向EE
4、Java语言特性
4.1.Java语言特性
Java语言特性[开源、免费、纯面向对象、跨平台]
-
简单性:
- 相对而言的，例如java中不再支持多继承，C++是支持多继承的，多继承比较复杂
- C++中有指针，Java中 屏蔽了指针的概念。所以相对来说Java是简单的。
- Java语言底层是C++实现的。但是java不是c语言。
-
面向对象
- Java是纯面向对象的。更符合的人的思维模式。更容易理解。
- 世间万物皆对象
-
可移植性
- 什么是可移植性?
java程序可以做到一次编译，到处运行。也就是说java程序可以在windows操作系统上运行，不做任何修改，同样的java程序可以直接放到Linux操作系统上运行，这个被称为Java程序的可移植性，或者叫做跨平台。
- windows操作系统内核和Linux操作系统的内核肯定不同，他们这两个操作系统执行指令的方式也是不一样的。显然java程序不能直接和操作系统打交道。因为java程序只有一份。操作系统执行原理都不同。
- JVM
- SUN的团队很聪明，他们想了-一个办法，他们
让java程序 运行在-一合虚拟的计算机当中，这个虛拟的计算机叫做Java虚拟机，简称JVM。Java虚拟机再和底层的操作系统打交道，避开了java代码直接与不同的操作系统打交道。 - java源代码---->javac—>java字节码----->运行在各个操作系统对应的JVM中---->JVM将字节码解释成二进制编码，这些二进制编码再去指挥硬件做什么
- SUN的团队很聪明，他们想了-一个办法，他们
-
多线程
-
健壮性
- 和自动垃圾回收机制有关，自动垃圾回收机制简称GC机制。Java语言运行过程中产生的垃圾是自动回收的，不需要程序员关心。
-
安全性
5、Java的加载与执行
- Java程序的运行包括两个非常重要的阶段
- 编译阶段
- 运行阶段
- 编译阶段
- 编译阶段主要的任务是检查Java源程序是否符合Java语法,符合Java语法则能够生成正常的字节码文件(xxx.class)，不符合Java语法规则则无法生成字节码文件
- 字节码文件中不是纯粹的二进制，这种文件无法在操作系统当中直接执行。
- 编译阶段的过程
程序员需要在硬盘的某个位置<位置随意>新建-一个. java扩展名的文件,该文件被称为Java源文件，源文件当中编写的是Java源代码/源程序。而这个源程序是不能随意编写，必须符合Java语法规则,Java语法规则是需要记忆的
- 编译和运行
- Java程序员需要使用JDK当中国带的Javac.exe命令进行Java程序的编译。
- java命令进行运行
6、java代码编译与运行
6.1.javac编译命令
- javac怎么用呢?在哪用呢?
- javac的使用规则:
javac java源文件的路径 - 在DoS命令窗口中使用javac是一一个 java编译器工具/命令。
- 一个java源文件可能编译生成多个.class文件，取决于要编译的源文件有多少个类。
- javac的使用规则:
- 编译后源文件的地位？
- 字节码文件/class文件是
最终要执行的文件，所以说.class文件生成
之后，java源文件删除并不会影响java程序的执行。 - 自己编写生成的 .class 与JDK类库的地位一样，只是是否大面积普及被大家调用与否
- 但是一 般java源程序不要删除，因为class文件最终执行效果可能不是我们想要的，那么这个
时候需要回头再重新修改java源程序，然后将java源程序重新编译生成新的class文件，然后再运行这个class程序，生成新的效果。另外就是后期的调试和维护也需要源文件，我们也是在源文件上操作
- 字节码文件/class文件是
- 编译结束之后，可以将class文件拷贝到其他操作系统当中运行。 [跨平台]，运行阶段 [可以在其它操作系统当中，跨平台]
6.2.java运行命令
-
JDK安装之后，除了自带-一个
javac.exe之外，还有另一个工具/命令，叫做java.exe，java. exe命令主要负责运行阶段。 -
java.exe在哪里用?
- 在DOS窗口中使用。
-
java.exe怎么用呢?
- java 类名
例如:
硬盘上有一个A.class， 那么就这样用: java A 即可运行A
千万要注意:不要写成这样:java A.class[这种方式是错误的，大家记住就行]
- java 类名
-
运行阶段的过程是:
- 打开Dos命令窗口
输入: java A - java. exe命令会启动Java虚拟机(JVM) ，JVM会 启动类加载器ClassLoader
ClassLoader会去硬盘上搜索A.class文件，找到该文件则将该字节码文件装载到JVM当中。
- 打开Dos命令窗口
-
JVM将A.class字节码文件解释成 二进制1010101010这样数据。然后操作系统执行二进制和底层硬件平台进行交互。|归根结底的，操作系统的硬件最终执行的还是二进制数
7、第一个java程序与环境变量
- 保证计算机当中已经安装了文本编辑器EditPlus
7.1.JDK、JRE、JVM的关系
- 安装JDK JDk一 般需要从oracle的官网 下载]，我们这里讲解的是JDK7、JDK、JRE、JVM的关系搞清楚
- JDK = JRE + 开发工具集（例如 Javac,java 编译工具等)
- JRE = JVM + Java SE 标准类库（java 核心类库）
- JDK目录的介绍:
- JDK/bin:该目录下存放了很多命令，例如javac. exe和java. exe
- javac .exe负责编译
- java . exe负责运行
7.2.配置环境变量
-
开发HelloWorld. java源程序[照抄，不要问为什么，注意大小写]
-
public class HelloWorld{
public static void main(String [] args){
System.out.println("HelloWorld");
}
}
-
将HelloWorld. java源程序通过javac工具进行编译:
-
首先需要解决的问题是:javac命令是否可用
-
打开Dos命令窗口，直接输入javac, 然后回车，出现以下:
'javac’不是内部或外部命令，也不是可运行的程序
或批处理文件。
出现以上问题是因为:windows操作系统无法找到javac.exe命令文件 -
-
win系统可以直接使用ipconfig命令的原因：
- 该命令在win path指定了查找路径
- 作用于当前用户
- 作用于整个操作系统
-
怎么解决以上javac不可用的问题?
-
windows操作系统是如何搜索硬盘上某个命令的呢?
- 首先会从当前目录下搜索
- 当前目录搜索不到的话，会从环境变量path指定的路径当中搜索某个命令
- 如果都搜索不到，则报以上的错误
-
配置环境变path注意:
-
path环境变量和java语言没有关系，path环境变量是属于windows操作系统的一-个知识点。
-
path环境变量是专门给windows操作系统指路的
javac要想能随意使用，需要将javac所在的目录路径配置到环境变量path当中
path= =xxxx ;C: \Program Files\Java\jdk1. 7.0_ 80\bin
👁🗨环境变量配置
-
win11专业工作站版
-
-
以win10专业版为例
-
-
在DOS窗口进行测试,输入以下三个命令：
-
java
-
javac
-
java -version
-
Microsoft Windows [版本 10.0.17763.1577] (c) 2018 Microsoft Corporation。保留所有权利。 C:\Users\Administrator>java 用法：java [options] <主类> [args...] （执行类） 或 java [options] -jar <jar 文件> [args...] （执行 jar 文件） 或 java [options] -m <模块>[/<主类>] [args...] java [options] --module <模块>[/<主类>] [args...] （执行模块中的主类） 或 java [options] <源文件> [args] （执行单个源文件程序） 将主类、源文件、-jar <jar 文件>、-m 或 --module <模块>/<主类> 后的参数作为参数 传递到主类。 其中，选项包括： -cp <目录和 zip/jar 文件的类搜索路径> -classpath <目录和 zip/jar 文件的类搜索路径> --class-path <目录和 zip/jar 文件的类搜索路径> 使用 ; 分隔的, 用于搜索类文件的目录, JAR 档案 和 ZIP 档案列表。 -p <模块路径> --module-path <模块路径>... 用 ; 分隔的目录列表, 每个目录 都是一个包含模块的目录。 --upgrade-module-path <模块路径>... 用 ; 分隔的目录列表, 每个目录 都是一个包含模块的目录, 这些模块 用于替换运行时映像中的可升级模块 --add-modules <模块名称>[,<模块名称>...] 除了初始模块之外要解析的根模块。 <模块名称> 还可以为 ALL-DEFAULT, ALL-SYSTEM, ALL-MODULE-PATH. --list-modules 列出可观察模块并退出 -d <module name> --describe-module <模块名称> 描述模块并退出 --dry-run 创建 VM 并加载主类, 但不执行 main 方法。 此 --dry-run 选项对于验证诸如 模块系统配置这样的命令行选项可能非常有用。 --validate-modules 验证所有模块并退出 --validate-modules 选项对于查找 模块路径中模块的冲突及其他错误可能非常有用。 -D<名称>=<值> 设置系统属性 -verbose:[class|module|gc|jni] 启用详细输出 -version 将产品版本输出到错误流并退出 --version 将产品版本输出到输出流并退出 -showversion 将产品版本输出到错误流并继续 --show-version 将产品版本输出到输出流并继续 --show-module-resolution 在启动过程中显示模块解析输出 -? -h -help 将此帮助消息输出到错误流 --help 将此帮助消息输出到输出流 -X 将额外选项的帮助输出到错误流 --help-extra 将额外选项的帮助输出到输出流 -ea[:<程序包名称>...|:<类名>] -enableassertions[:<程序包名称>...|:<类名>] 按指定的粒度启用断言 -da[:<程序包名称>...|:<类名>] -disableassertions[:<程序包名称>...|:<类名>] 按指定的粒度禁用断言 -esa | -enablesystemassertions 启用系统断言 -dsa | -disablesystemassertions 禁用系统断言 -agentlib:<库名>[=<选项>] 加载本机代理库 <库名>, 例如 -agentlib:jdwp 另请参阅 -agentlib:jdwp=help -agentpath:<路径名>[=<选项>] 按完整路径名加载本机代理库 -javaagent:<jar 路径>[=<选项>] 加载 Java 编程语言代理, 请参阅 java.lang.instrument -splash:<图像路径> 使用指定的图像显示启动屏幕 自动支持和使用 HiDPI 缩放图像 (如果可用)。应始终将未缩放的图像文件名 (例如, image.ext) 作为参数传递给 -splash 选项。 将自动选取提供的最合适的缩放 图像。 有关详细信息, 请参阅 SplashScreen API 文档 @argument 文件 一个或多个包含选项的参数文件 -disable-@files 阻止进一步扩展参数文件 --enable-preview 允许类依赖于此发行版的预览功能 要为长选项指定参数, 可以使用 --<名称>=<值> 或 --<名称> <值>。 C:\Users\Administrator>javac 用法: javac <options> <source files> 其中, 可能的选项包括: @<filename> 从文件读取选项和文件名 -Akey[=value] 传递给注释处理程序的选项 --add-modules <模块>(,<模块>)* 除了初始模块之外要解析的根模块; 如果 <module> 为 ALL-MODULE-PATH, 则为模块路径中的所有模块。 --boot-class-path <path>, -bootclasspath <path> 覆盖引导类文件的位置 --class-path <path>, -classpath <path>, -cp <path> 指定查找用户类文件和注释处理程序的位置 -d <directory> 指定放置生成的类文件的位置 -deprecation 输出使用已过时的 API 的源位置 --enable-preview 启用预览语言功能。要与 -source 或 --release 一起使用。 -encoding <encoding> 指定源文件使用的字符编码 -endorseddirs <dirs> 覆盖签名的标准路径的位置 -extdirs <dirs> 覆盖所安装扩展的位置 -g 生成所有调试信息 -g:{lines,vars,source} 只生成某些调试信息 -g:none 不生成任何调试信息 -h <directory> 指定放置生成的本机标头文件的位置 --help, -help, -? 输出此帮助消息 --help-extra, -X 输出额外选项的帮助 -implicit:{none,class} 指定是否为隐式引用文件生成类文件 -J<flag> 直接将 <标记> 传递给运行时系统 --limit-modules <模块>(,<模块>)* 限制可观察模块的领域 --module <module-name>, -m <module-name> 只编译指定的模块, 请检查时间戳 --module-path <path>, -p <path> 指定查找应用程序模块的位置 --module-source-path <module-source-path> 指定查找多个模块的输入源文件的位置 --module-version <版本> 指定正在编译的模块版本 -nowarn 不生成任何警告 -parameters 生成元数据以用于方法参数的反射 -proc:{none,only} 控制是否执行注释处理和/或编译。 -processor <class1>[,<class2>,<class3>...] 要运行的注释处理程序的名称; 绕过默认的搜索进程 --processor-module-path <path> 指定查找注释处理程序的模块路径 --processor-path <path>, -processorpath <path> 指定查找注释处理程序的位置 -profile <profile> 请确保使用的 API 在指定的配置文件中可用 --release <release> 针对特定 VM 版本进行编译。支持的目标: 6, 7, 8, 9, 10, 11 -s <directory> 指定放置生成的源文件的位置 -source <release> 提供与指定发行版的源兼容性 --source-path <path>, -sourcepath <path> 指定查找输入源文件的位置 --system <jdk>|none 覆盖系统模块位置 -target <release> 生成特定 VM 版本的类文件 --upgrade-module-path <path> 覆盖可升级模块位置 -verbose 输出有关编译器正在执行的操作的消息 --version, -version 版本信息 -Werror 出现警告时终止编译 C:\Users\Administrator>java -version java version "11.0.8" 2020-07-14 LTS Java(TM) SE Runtime Environment 18.9 (build 11.0.8+10-LTS) Java HotSpot(TM) 64-Bit Server VM 18.9 (build 11.0.8+10-LTS, mixed mode) C:\Users\Administrator>
正常输出如上信息，则配置成功
7.3.运行第一个java程序
- 正确使用路径
- [路径详解](# 2.Dos基础)（请点击）
- 运行java程序
- 与javac不同，必须使用相对路径，不能用绝对路径需要使用java.exe命令
- 首先测试java命令是否可用
- 使用方式:
- java类名
硬盘上有Helloworld.class,那么类名就是: Helloworld（这里指的是主类名public）
- java类名
- java Helloworld 运行java程序
- 注意:
- java命 令后面跟的不是文件路径，是一一个类的名字
- 首先你需要先将DOS窗口中的目录切换到Helloworld.class文件所在目录然后直接执行: java HelloWorld
- 执行过程（具体到算法初步详细讲解）：
- 打开Dos命令窗口，执行java Helloworld, 执行原理?java.exe命令会启动JVM，当JVM启动之后会启动类加载器ClassLoader
- classLoader会在硬盘上的某个位置搜索HelloWorld. class字节码文件，找到该文件则执行，找不到该文件则报错
- 疑问:ClassLoader是在哪个位置上搜索relloworld. class字节码文件的?
- 默认情况下，classLoader从当前路径下加载xxx . class字节码文件
- 当然，也可以让classLoader去某个指定的路径下加载字节码文件，这时需要配置环境变量classpath
- classPath
- classpath环境变量属于java语言中的环境变量，不属于windows操作系统[ PATH环境变量属于操作系统]
- classpath是给ClassLoader类加载器指路的。
- 设置这样的环境变量: classpath=pINcourse\JavaProjecta\02-JavaSE
- classpath环境变量没有配置的话，类加载器
默认从当前路径下找字节码文件
- classpath环境变量没有配置的话，类加载器
- 注意：没必要配置，配置会让运行更复杂
- 当classpath环境变量配置为某个指定的路径之后，类加载器
只会去指定的路径当中加载字节码文件。
综上所述，环境变量classpath不再配置，这样类加载器会自动从当前路径下加载class字节码文件。所以，每一次执行.class程序的时候，需要在DoS命令窗口中先切换到.class字节码文件所在的路径下，然后运行。 
8、java注释与源代码简介
8.1.java注释
-
java源程序当中的注释:
-
什么是注释?注释的作用是什么?
- 出现在java的源程序当中,对java源代码的解释说明,注释不会被编译到
.class字节码文件当中,一个好的开发习惯应该是多编写注释，这样程序的可读性比较强 - java中的注释怎么写呢?
- 单行注释
//单行注释,只注释当前行 - 多行注释
/*
多行注释
多行注释
多行注释
多行注释
多行注释;…
*/
- 单行注释
- 出现在java的源程序当中,对java源代码的解释说明,注释不会被编译到
-
javadoc注释
-
方法：
-
public class CommentTest{ /** *内容....... * */ public static void main(String [] args){ } } -
注意:这种注释是比较专业的注释，该注释信息会被javadoc.exe工具,解析提取并生成帮助文档。
了解性内容，后期有详解
8.2.源代码简介
//public表示公开的
//class表示定义一个类
//Hellowor1d表示一个类名
public class Helloworld{
//表示定义一个公开的类，
//起名:Helloworld
//类体【记住】 类的两个{}之间
//类体中不允许直接编写java语句【除声明变量之外】
//System.out.println("Hello world");
//报错
/*
public表示公开的
static表示静态的
void表示返回值为空
main表示方法名是main
(String [] args)是一个main方法
的形式参数列表
需要记住的是:
以下的方法是一个程序的"主方法"是程序的执行入口是SUN公司规定的固定编写方式。
*/
public static void main(String [] args){
//表示定义一个公开的静态的主方法
//方法体
System.out.println("Hello world!");
/*
java语句【java语句以";"终止,分号必须是半角分号】先记住:以下这样代码的作用，是向控制台输出一段消息
//以下的双引号必须是半角的双引号【是java语法的一部分】
//java中所有的"字符串"都使用双引号括起来。
System.out.println("Hello wor1ld!");
//再向控制台输出消息
System.out.println("Hello jackson!");
//输出中文
System.out.println("你好,杰克!");
//输出中文【提醒:以下程序员两边的双引号是"全角的",这里的双引号不是java语法的一部分，这里的全角的双引号只是一个普通的字符串】
System.out.print1n("我是一个“程序员");
*/
}
}
- 主方法中的 args 只是一个变量名字，是可以随意写的，但是建议用 args
👁🗨 class
-
public class 和class的区别:
-
一个java源文件当中可以定义多个class
-
一个java源文件当中
public的c1ass不是必须的, public class最多只能有一个 -
一个class被定义，就会定义生成一个xxx.class字节码文件
- 一个java源文件当中定义公开的类的话，
最多只能有一个，并且该类名称必须和java源文件名称一致 - 每一个class当中都可以编写main方法，都可以设定程序的入口，自主想执行哪个类，就执行哪个类，执行B.class中的main方法: java B
- 一个java源文件当中定义公开的类的话，
-
想执行 x.class 当中的main方法: java x
注意:当在命令窗口中执行java Hello，那么要求mello.class当中必须有主方法。否则出现运行错误，编译是没有问题的
文章目录
9、java语言基础
9.1.标识符与字面值
👁🗨 标识符
-
什么是标识符?
在java源程序当中凡是程序员有权利自己命名的单词都是标识符。标识符在EditP1us编辑器当中以黑色字体高亮显示，不同的编辑器略有不同 -
标识符可以标识什么元素呢?
-
类名
-
方法名
-
变量名
-
接口名
-
常量名
… …
-
-
标识符的命名规则?【不按照这个规则来，编译器会报错，这是语法】
-
总则：一个合法的标识符
只能由=="数字、字母、下划线_、美元符号$==组成，不能含有其它符号 -
细则：
- 不能数字开头
- 严格区分大小写
- 关建字不能做标识符
-
理论上无长度限制,但是最好不要太长
-
常见关键字
-
abstractassertbooleanbreakbytecasecatchcharclassconstcontinuedefaultdodoubleelseenumextendsfinalfinallyfloatforgotoifimplementsimportinstanceofintinterfacelongnativenewpackageprivateprotectedpublicreturnstrictfpshortstaticsuperswitchsynchronizedthisthrowthrowstransienttryvoidvolatilewhile
-
-
标识符的命名规范?【只是一种规范，不属于语法，不遵守规范编译器不会报错】
- 最好见名知意，否则时间久了自己都不知道是什么，别人阅读代码更是困难
- public class Userservice{
- public void login (string username ,string password){}
- 遵守驼峰命名方式
- SystemService
- UserService
- CustomerService
- 类名、接口名
- 首字母大写后面每个单词首字母大写。
- 变量名、方法名
- 首字母小写，后面每个单词首字母大写。
- 常量名
- 全部大写
- 最好见名知意，否则时间久了自己都不知道是什么，别人阅读代码更是困难
-
👁🗨 字面值
-
字面值:就是数据
-
-10 -100 3.14
-
“csd”
-
‘a’
-
true false
-
-
字面值是java源程序的组成部分之一。包括标识符和关键字它们都是java源程序的组成部分。
数据在现实世界当中是分门别类的，所以数据在计算机编程语言当中也是有类型的:【数据类型】-
10、100
属于整数型字面值 -
3.14
属于浮点型字面值
-
-
true,false
- 属于布尔型字面值
“abc” 、“中国人”
属于字符串型字面值
‘A’、‘人’
属于字符型字面值
- 属于布尔型字面值
-
注意:
-
双引号是半角（英文输入法），java语言当中所有的字符串型字面值必须使用双引号括起来
-
单引号是半角（英文输入法），java语言当中所有的字符型字面值必须使用单引号括起来
-
编译报错，因为单引号中只能存放单个字符，属于字符型字面值
System.out.println('ABC');//这里是三个字符
-
//100是一个字面值，是一个整数型数值，
//那么既然是数据存储在内存当中，必定会
//占用一定的内存空间。
System.out.println (1111100);
//不会报错，可以直接输出 1111100
9.2.变量
👁 变量简介
- 关于java语言当中的变量:
- 什么是变量?
- 本质上来说是内存中的一块空间，这块空间"有数据类型"、“有名字”、“有字面值” 。
- 变量包含三部分:
- 数据类型、名称、字面值【数据】
- 变量是内存中存储数据的最基本的单元
- 数据类型的作用?
- 不同的数据类型底层会分配不同大小的空间。
- 数据类型是指导程序在运行阶段应该分配多大的内存空间。
- 总之还是体现出硬件资源最大化的目的，避免浪费
- 变量中存储的
具体的"数据"必须和变量的"数据类型"一致，否则报错，字面值类型与数据类型一致
- 什么是变量?
👁 声明变量
-
声明/定义变量的语法格式:
-
数据类型 变量名; -
数据类型:
- 目前我们还没有学习数据类型，但是提前告诉大家有一种数据类型是整数型，叫做int
-
变量名:只要是合法的标识符就行。==规范中要求:==首字母小写，后面每个单词首字母大写。
例如:注意：规范！=规则，违背规则，编译报错，违背规范，编译不报错，只是别人觉得你菜-
int age;
-
int i;
-
int length;
-
int size;
-
int num;
其中int是数据类型，i, age , length, size , num都是变量名。
-
-
-
变量声明之后怎么赋值?
-
语法格式:
- 变量名 = 字面值;
- 要求:字面值的数据类型必须和变量的数据类型一致。
- = 等号是一个运算符，叫做赋值运算符，赋值运算符先运算等号右边的表达式，表达式执行结束之后的结果赋值给左边的变量。
-
声明和就值可以放到一起完成
int i = 10; -
变量赋值之后,可以重新赋值,变量的值可变化:
int i = 10;
System.out.println(i);//10i = 20;
System.out.println(i);//20i = 100;
System.out.printin(i)；//100
-
-
有了变量的概念之后，内存空间得到了重复的使用:
- int i =10 ;
System.out.println (i) ;一次使用
…
System.out.println (i);二次使用
- int i =10 ;
-
通常访问一个变量包括两种访问形式:
- 第一种:读取变量中保存的具体数据get/获取
- 第二种:修改变量中保存的具体数据set/设置
i = 20; //set
system.out.println (i) ; //get
-
变量在同一行，上可以声明多个
- int a,b,c;
-
变量必须先声明，再赋值，才能访问。若是成员变量则可以不用，成员变量会自动使用本数据类型默认值
public class VarTest01
{
public static void main (String[] args) {
//声明一个int类型的变量，起名i
int i;
//编译报错:变量i并没有初始化
System. out.println(i) ;
}
- 在方法体中的代码是==自上而下执行，==第二行的代码必须完整执行后，才会执行第三行代码
👁 局部变量必须赋值后才能通过编译
java中的变量必须先声明,再赋值,才能访问
/*
int i;
程序执行到这里，内存空间并没有开辟出来，变量i并没有初始化。所以没有赋值之前是无法访问
*/
public class VarTest01{
public static void main(String [] args){
//声明一个int类型的变量,起名i
int i;
//编译报错:变量i并没有初始化
System.out.println(i);
//给i变量赋值,i变量在这里完成初始化,内存开辟
i = 100;
System.out.println(i);//i再次重新赋值
i = 200;
}
}
👁 内存角度看待变量的重新赋值
- 局部变量 i = 10;开辟空间1，当i=1000执行，开辟空间二，10（空间1）没有变量指向它，经过就会被销毁，所以重新赋值前后独立
9.3.作用域与变量分类
👁 背景
- 时刻牢记，编译器只检查语法，不检查语义，有些认为一看就可以，符合人的逻辑、思考方式，没问题，编译器可能也会报错
- 在同一个作用域里，变量不能重名，但是可以重新赋值
- 在方法体中自上而下执行，本行完整执行后，才会执行下一行代码，所以上面的代码卡在int i = 90; 动不了，报错
👁 作用域
- 什么是作用域?
- 变量的作用域，其实描述的就是变量的有效范围。
- 在什么范围之内是可以被访问的，只要出了这个范围该变量就无法访问了。
- 变量的作用域只要记住- -句话: 出了大括号{}就不认识了
public class VarTest03{
static int k = 90;
//静态变量K的作用域是整个类体
public static void main (String[] args){
//变量1的作用域是main方法
//在整个main方法当中是有效的，可见的，可以访问的
int i = 100;
}
pub1ic static void dosome (){
//这里无法访问main方法当中的变量i
//已经出了变量的作用域。
//system. out .print1n(i) ;
System.out.println(k);
//K是静态变量，同类可以直接使用
}
}
作用域特例
- 即便num在类体
{ }范围内，也不能直接使用，但是他是堆内存中实例变量，需要用对象的引用来访问
package com.bjpowernode.javase.test002;
public class ThisTest {
//实例变量(引用-的方式访问》
int num = 10;
//带有static的方法
//JM晚责调用nain方法,JV是怎么调用的?
//ThisTest.main (String[]);
//leiming.main(String [])
public static void main (String[] args){
//没有当前对象this
//以下代码什么意思?
/访问“当前对象”的num属性
//System.out.println (num) ; //编译错误
//System.out.println (this.num) ; //编译错误
//想访问num怎么办?
ThisTest tt = new ThisTest();
System.out.println(tt.num);
}
}
public class Test{
public static void main(String [] args){
//例如
for(int i = 0; i < 5; i++){
System.out.println(i);
}
System.out.println(i);
//报错，i 超出了for循环作用域
for(int a=0;a<10;a++){
}
//a变量的
//作用域是整个for循环，for循环结束之后，
//a变量的内存就释放了
//这里无法访问a变量
//System.out.print1n(a) ;
int j; //作用域是main方法
for (j=0 ;j<10;j++) {
}
System.out.println(j);
//访问的是main方法中定义的变量
}
}
👁 变量分类
关于变量的分类:
- 根据变量声明的位置来分类:
- 局部变量
- 在
方法体当中声明的变量叫做局部变量
- 在
- 成员变量
- 在
方法体外[类体之内]声明的变量叫做成员变量 - 细分
- 有static修饰，静态变量，存储在方法区内存
- 无static修饰，实例变量，存储在堆内存
- 注意:存储位置硬记，面对对象章节会细讲
- 在
- 同名
- 在不同的作用域当中，变量名是可以相同的。
- 在同一个作用域变量是不可以同名的,否则编译器分不清楚到底是哪个，那就只能报错
- 局部变量
package StaticTest;
/**
* 实例变量与静态变量
* @author yanyu
*1.实例变量必须用引用来使用
*2.静态方法中不能用this
*3.静态变量，本类直接使用
*4.异类静态变量：类名.变量
*/
public class StaticVaviable {
String name;
static int id;
public static void main(String[] args) {
StaticVaviable t = new StaticVaviable();
System.out.println(t.name);
System.out.println(id);
// System.out.println(name);
System.out.println(Test001.age);
}
}
class Test001{
static int age;
}
//变量分类
public class VarTest04{
//成员变量中的实例变量
int k = 200;//整个类体
//主方法:入口
public static void main(String[] args){
//i变量就是局部变量
int i=10;
//就近原则
System.out.println(i);
}
//doSome方法
public static void doSome(){
//局部变量
int i=90;
//不调用不创建，一经掉用就会在“栈内存”中创建，分配内存空间
}
}
10、基本数据类型
10.1.数据
👁 数据类型分类
- 数据类型的作用是什么?
- 程序当中有很多数据，每一个数据都是有相关类型的，不同数据类型的数据占用空间大小不同。
- 数据类型的作用是指导JVM在运行程序的时候给该数据分配多大的内存空间。
- java中的数据类型包括两种:
- 基本数据类型
- 基本数据类型包括四大类八小种:
- 第一类:整数型
byte , short , int, 1ong - 第二类:浮点型
float, double - 第三类:布尔型
boolean - 第四类:字符型 单引号
char
- 第一类:整数型
- 基本数据类型包括四大类八小种:
- 注意：
字符串不属于基本数据类型
- 基本数据类型
- 引用数据类型[面对对象细讲]
- 类接口、数组、接口、字符串(双引号等)、程序员自己定义的引用类型
👁 基本数据类型占用内存大小
- 基本数据类型占用空间
| 基本数据类型 | 占用空间（字节） |
|---|---|
| byte | 1 |
| short | 2 |
| int | 4 |
| long | 8 |
| float（浮点数） | 4 |
| double（浮点数） | 8 |
| boolean | 1 |
| char | 2 |
- short 和 char 表示的容量大小一样，两个字节但是char没有负数，所以，char可以
0 --- 65535 2^16 - int 2147483648
- 10000000 00000000 00000000 00000000 2^32=4294967296 正负各一半
- 八种基本数据类型
- 一切向 0 看齐，**方法体变量（成员变量）**必须初始化，否则不能通过编译；
- 成员变量未进行初始化，会使用默认值，但是非静态的成员变量无法在静态上下文中通过编译，如静态方法main中
- 关于浮点型数据类型:
- float单精度【4个字节】
- double双精度【8个字节,精度较高】
- double的精度太低【相对来说的】，不适合做财务软件财务涉及到钱的问题，要求精度较高，所以SUN在基础SE类库当中为程序员准备了
精确度更高的类型，只不过这种类型是一种引用数据类型,不属于基本数据类型，它是:java.math.BigDecimal
- java中的数据表示
10.2.二进制
-
计算机是由电流驱动的，电流只有正极和负极，只有这两种状态，也就是说计算机底层实际上只能表示这两种状态，那他怎么能够表示现实世界中负责的数据呢？计算机就是采用二进制的方式来表示这些复杂数据的。
-
电流只有正极和负极，那么就可以表示基本的两个数字：1和0
-
而1和0这样的数字串组成的数字我们称为二进制。
-
二进制的特点：满2进1位 (1 10 11 100…)
-
十进制的特点：满十进1位 （1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20…）
-
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-w0ZxABXp-1665986594385)(https://yanyu666.oss-cn-beijing.aliyuncs.com/img/二进制.png)]
-
二进制转换成十进制？
- 公式：从二进制的最右边开始，2的0次幂，2的1次幂，2的2次幂，2的3次幂…以此类推，然后让每一位和对应的二进制位相乘，然后将每一个相乘的结果再求和，就是最终的十进制。
-
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YKU5mMdY-1665986594386)(https://yanyu666.oss-cn-beijing.aliyuncs.com/img/二进制转换成十进制.png)]
-
十进制转换成二进制？
-
公式：让十进制的数字除以2（不断的除以2，直到最后商是0为止），然后余数逆序输出，就是对应的二进制。
-
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-U77s2czI-1665986594388)(https://yanyu666.oss-cn-beijing.aliyuncs.com/img/十进制转换成二进制.png)]
-
-
进制转换不是必须掌握的，在实际开发中也用不上，如果遇到了，不会转换，可以使用计算器。
-
- 十进制：我们常用的就是（缺省）
- 八进制： 0—7 的数字组成，以 数字 0开头
- 十六进制：0----9、A—F ，以 0x开头
-
-
计算机在任何情况下都只能识别二进制。
只认识10101010100010101010101…
[现代的计算机底层采用交流电的方式，接通和断开就两种状态，计算机只识别1或0，其它不认识] -
什么是二进制?
数据的一种表示形式。十进制表示满十进一原则。二进制表示满二进一原则。
-
字节(byte):
1Byte=8bit
[1个字节= 8个比特位] 1个比特位表示-一个二进制位: 1/0
1KB=1024Byte
1MB=1024KB
1GB=1024MB
1TE=1024GB1 TB = 1024 * 1024 * 1024 * 1024 * 8 -
整数型当中的byte类型， 占用1个字节，所以byte类型的数据占用8个比特位。那么byte类型的取值范围是什么?
-
-128 ~ 127 256个数字，256个二进制数
-
关于java中的数字类型，数字都是有正负之分的，所以在数字的二进制当中有一-个二进制位被称为"符号位”。并且这个"符号位"在所有二进制位的最左边，0表示正数，1表示负数。
-
byte类型最大值: 0111111 [ 00000000 00000000 00000000 10000000 (二“ 进制) 减去1结果是: 00000000 0000000 00000000 01111111 (二进制) ★byte类型最大值: 2的7次方- 1，结果是: 127 ★byte类型最小值: -128 [具体的怎么用二进制表示，这个和原码、反码、补码有关] 计算机存储运算都是以补码进行
-
10.3.字符集/码表
-
什么是字符集（字符编码方式）？
- 对于计算机来说，只认识二进制，程序中的整数也好，浮点数也好，true和false也好，计算机都是可以很容易表示的，因为数字本身和二进制之间存在一种固定的转换规则，计算机本身是可以搞定的。但是在程序中出现的文字，计算机就无法表示了，这个时候需要人为的站出来，某个标准制定组织负责将文字与二进制之间的对照关系制定出来。像这种二进制码和文字之间的对照关系，这种对照表称为字符集，或者叫做字符编码方式。
- 每个国家都有自己的标准制定组织，每个国家都有自己的适合于计算机的编码方式。中国有汉字相关的编码方式，美国有英文的编码方式，日本有日语相关的编码方式等。
- 字符集就是对照表，可以理解成是一个字典，并且不是一本字典，不同的语言有不同的编码方式。
-
什么是编码？什么是解码？
- ASCII码：这个编码方式是最早出现的，主要用于显示现代英语和其他西欧语言
- 'a’对应的ASCII码是：97 'a’在底层对应的二进制是01100001
- 'A’对应的ASCII码是：65
- '0’对应的ASCII码是：48
- 'a’通过ASCII字符集转换成01100001的过程，叫做编码。
- 01100001通过ASCII字符集转换成’a’的过程，叫做解码。
- 编码：将文字采用某个字符集转换成二进制的过程。
- 解码：将二进制采用某个字符集转换成文字的过程。
-
字符集都有哪些？
-
ASCII (American Standard Code for Information Interchange) 是基于拉丁字母的一套电脑编码系统，主要用于显示现代英语和其他西欧语言。
-
‘a’ 对应 97 (‘b’ 对应 98，以此类推)
-
‘A’ 对应 65 (‘B’ 对应 66，以此类推)
-
‘0’ 对应 48 (‘1’ 对应 49，以此类推)
-
// 面试题 public class DataTypeTest16{ public static void main(String[] args){ // 97是int类型 // 要强制类型转换成char类型 // 结果的类型一定是char类型 // char类型是字符，所以结果会输出一个字符 System.out.println((char)97); // 'a' System.out.println((char)65); // 'A' System.out.println((char)48); // '0' System.out.println(2 + 'a'); // 99 System.out.println((char)(2 + 'a')); // 'c' System.out.println((char)(25 + 'a')); // z } }
-
-
ISO-8859-1编码是兼容ASCII码。又被称为Latin-1
-
支持中文的编码方式：GB2312 < GBK < GB18030
- GB2312支持6763个汉字
- GBK兼容GB2312，
支持21886个汉字 GB18030兼容GBK，支持70244个汉字
-
Big5（大五码，支持繁体中文）
-
Unicode编码方式
- Unicode编码方式的具体实现：UTF-8、UTF-16、UTF-32
- Unicode编码方式兼容全球所有的文字。
- Java语言为了全球通用，所以Java采用了Unicode编码方式。所以标识符可以含有中文。
- public class 学生{ }
-
-
char 怎么表示的是现实中的文字？
- 文字无法像数字一样，可以与二进制码进行转换
- 故人为编写字符编码：大家一起认同的，比如字母A用什么二进制码来表示
- 八种基本数据类型当中，byte, short, int, long, float , double ,boolean这7种，数据类型计算机在表示的时候比较容易，因为
底层都是数字，十进制的数字和二进制之间默认存在一种固定的转换规则。 - 八种基本数据类型当中
char类型表示的是现实世界中的文字，文字和计算机二进制之，间"默认"情况下是不存在任何转换关系的。 - 为了让计算机可以表示现实世界当中的文字，我们需要进行人为的干涉，需要人负责提前制定好“文字"和“二进制"之间的
对照关系。这种对照转换关系被称为:字符编码。 - 计算机最初只支持英文，
最先出现的字符编码是:ASCII码
‘a’ --> 97 [ 01100001 ]
‘A’–> 65
‘0’ --> 48 字符零对应的编码是48
'a’一> (按照ASCII解码)–> 01100001
01100001 —按 照ASCII编码–> 'a ’ - 随着计算机的发展，后来出现了一-种编码方式，是国际化标准组织Iso制定的，这种编码方式支持==西欧语言，==向上兼容ASCII码，仍然不支持中文。这种编码方式
是:IS0-8859-1， 又被称为latin-1 - 随着计算机向亚洲发展，计算机开始支持中文、日文、韩文等国家文字，其中支持简体中文的编码方式:
GB2312 < GBK < GB18030 容量依次增大 - 支持繁体中文：大五码 big5
- 后来出现了一种编码方式统一 了全球所有的文字，容量较大，这种编码方式叫做: unicode编码,unicode编码方式有多种具体的实现:
- UTF-8 企业开发中用得最多—统一编码方式
- UTE-16
- UTF-32
- java语言采用的是哪–种编码方式呢?
java语言源代码采用的是unicode编码方式，所以"标识符"可以用中文。
class 学生{ } -
什么是乱码，乱码是如何产生的？
-
什么是乱码？文字无法正常显示。
-
编码和解码使用一套编码表时，就不会乱码
- 编码和解码的时候采用同一套字典/对照表，不会出现乱码。
- 当解码和编码的时候采用的不是同一一套对照表，会出现乱码问题。
-
乱码产生的根本原因是：编码和解码的时候采用的不是同一张对照表（或者说采用的不是同一个字符集。），比如采用GBK的方式编码，然后采用UTF-8的方式解码，一定是乱码。
-
-
pub1ic class DataTypeTest02{
//这里的static必须加，别问为什么!
static int k = 1000;
//变量还是遵守这个语法:必须先声明，再赋值，才能访问。
//成员变量没有手动赋值系统会默认赋值[ 局部变量不会]
static int f; //成员变量
public static void main (String[] args) {
/*
int i; //局部变量
System.out.print1n(1);
*/
System.out.println(k);
System.out.print1n(f);//0
}
}
public class DataTypeTest01
{
public static void main (String[] args) {
//定义一个char类型的变量，起名c，同时赋值字符'a'
char c = 'a';
System.out.print1n(c);
//一个中文占用2个字节，char类型正好是2个字节
//所以java中的char类型可以存储一个中文字符
char x = '国';
System.out.println(x);
char f;
f = 'y';
}
}
10.4.转义字符
- 常见的转义字符
\ 转义字符---反斜杠
\n 换行
\t 制表符
\u 使用Unicode
\r 从首行开始
\\ 反斜杠
\“ 双引号
\‘ 单引号
- 换行符
public class DataTypeTest03{
public static void main (String[] args) {
//普通的n字符
char c1='n';
System.out.print1n(c1);
//依照目前所学知识，以下程序无法编译通过，因为显然是
//一个字符串，不能使用单引号括起来
//但是经过编译，发现编译通过了，这说明以下并不是一个字符串，而是“一个"字符
//这是一个“换行符"， 属于char类型的数据
//反斜杠在java语言当中具有转义功能。
char c2 = '\n';
System.out.println("He1lo");
System.out.println("world!");
//要求在控制台上输出“反斜杠字符"
//反斜杠将后面的单引号转义成不具备特殊含义的普通单引号字符
//左边的单引号缺少了结束的单引号字符,编译报错
/*
char k = '\;
System.out.print1n(k);
*/
/*
解释:第一个反斜杠具有转义功能，将后面的反斜杠转义为普通的反斜杠字符。
结论:在java当中两个反斜杠代表一个普通的反斜杠字符
*/
char k='\\';
System.out.print1n(k);
//在控制台.上输出一个普通的单引号字符
//java中不允许这样编写程序，编译报错
//char a ='';
//以下编译报错:第一个单引号和第二个单引号配对儿，最后的单引号找不到另一半儿!
//char a = ''';
//system. out .println(a) ;
//反斜杠具有转义功能，将第二个单引号转换成普通的单引号字符，
//第一个单引号和最后单引号配对儿。
char a= '\'';
System.out.print1n(a);
System.out.println("\"gfg\"");
// "gfg"
}
}
-
-
print 不会换行 println 换行
-
\t 制表符 （相当于tab 键，但是，二者的编码不同），“8”的整数倍个格子为一组
0 10 和 1之间还可以放7个0 -
JDK中自带的native2ascii.exe命令，可以将文字转换成unicode编码形式
10.5.数据转换
- 精度低向精度高的可以自动转换，但是高精度向低精度转换必须强制转换，并且，很可能精度丢失，慎用
public class DataTypeTest05{
public static void main(String[] args){
//100L是long类型字面值
//x是1ong类型变量
//不存在类型转换,直接赋值
long x = 10OL;
//×变量是1ong类型,8个字节
//y变量是int类型,4个字节/以下程序可以编译通过吗?
//编译报错,大容量不能直接赋值给小容量
int y = x;
//大容量转换成小容量,需要进行强制类型转换//强制类型转换需要加“强制类型转换符"
//加上强制类型转换符之后编译通过了,但是运行阶段可能损失精度。
//所以强制类型转换谨慎使用
/*原始数据: 00000000 00oooo00 000o0000 00000000 10000000 00000000 0000o000 00000000
强转之后的数据:10000000 00000000 00000000 00000000
10000000 00000000 00000000 00000000目前存储在计算机内部，计算机存储数据都是采用补码的形式 存,所以10000000 000000000 00000000 00000000现在是一个补码形式
最高位符号位为 1 ，也就是一个负数
将以上的补码转换到原码就是最终的结果*/
long k = 2147483648L;
int e = (int) k;
System.out.printin(e);//损失精度严重，结果是负数【-2147483648】
}
}
-
数据转换细节
-
分析以下程序是否可以编译通过?
依据目前所学内容,以下程序是无法编译通过
理由:- 50是
默认的int类型的字面值，b是byte类型的变量,显然是大容量int转换成小容量byte
大容量转换成小容量是需要添加强制类型转换符的，以下程序没有添加强转符号，所以编译报错。 - 但是，在实际编译的时候，以下代码编译通过了，这说明:在java语言当中，当一个整数型字面值,没有超出byte类型取值范围的话,该字面值可以直接赋值给byte类型的变量。
- short类型的同样的道理，在short范围内，不需要强制转换
- byte b= 50;//ok
byte c= 127;//ok
byte bi =128;//超出byte范围，int 无法直接转换为byte ，报错
- 50是
-
计算机二进制有三种表示形式:
- 原码
- 反码
-
补码
计算机在任何情况下底层表示和存储数据的时候采用了补码形式。 -
正数:原码反码补码三码合一
==负数的补码:最高位（符号位）不变，==负数的绝对值对应的二进制码所有二进制位取反，再加1 -
负数：
- 原码：数本身的二进制编码
- 反码：最高位（符号位0正数，1负数）保持不变，其它位按位运算取反
- 补码；反码+1
-
short类型的同样的道理，在short范围内，不需要强制转换
-
short s = 32767;//通过
short s1 =32768; //编译报错
65535是int类型,4个字节
cc是char类型,2个字节
按照以前所学知识点来说,以下程序是编译报错的。 -
char cc = 65535;//通过
cc = 65536;//编译报错
当一个整数字面值没有超出byte , short, char的取值范围，这个字面值可以直接赋值给byte , short,char类型的变量。这种机制SUN允许了，目的是为了方便程序员的编程。
-
10.6.浮点数
-
浮点数默认是double,3.0是double类型的字面值，d是double类型的变量
不存在类型转换
double d = 3.0;
System.out.print1n (d);
5.1是double类型的字面值，f是float类型的变量
大容量转换成小容量需要加强制类型转换符，所以以下程序编译错误。f1oat f = 5.1;
解决方案:
第一种方式:
f1oat f = (float) 5.1;
第二种方式
f1oat f = 5.1f; -
关于浮点型数据类型:
float单精度【4个字节】
double 双精度【8个字节,精度较高】
double的精度太低【相对来说的】，不适合做财务软件。
财务涉及到钱的问题，要求精度较高，所以sUN在基础sE类库当中为程序员准备了精确度更高的类型，只不过这种类型是一种引用数据类型,不属于基本数据类型，
它是:java.math.BigDecimal
其实java程序中stN提供了一套庞大的类库，java程序员是基于这套基础的类库来进行开发的。
基础的类库来进行开发的。所以要知道java的sE类库的字节码在哪儿,要知道java的SE类库的源码在哪儿?
SE类库字节码:c:\Program Files (x86)\Javaljdk1.7.0_75\jre\lib\rt.jar*SE类库源码:c:\Program’Tiles (x86)\Javaljdk1.7.0_75\src.zip
-
/* 例如:String java和String.class 1、我们的(String[]args)中的string使用的就String.class字节码文件 2、在java语言当中,所有的浮点型字面值【3.0】，默认被当做double类型来处理,要想该字面值当做f1oat类型来处理,需要在字面值后面添加 f */ public class DataTypeTest06{ public static void main (String[] args) { //13,0是double类型的字面值 //a是double类型的变量 //不存在类型转换 double d = 3.0; System.out.println(d); /* 5.1是double类型的字面值 f是float类型的变量 大容量转换成小容量需要加强制类型转换符，所以以下程序编译错误。 f1oat f = 5.1 ; 解决方案: 第一种方式:float f = (float) 5.1; 第二种方式：float f = 5.1f; */ } } -
注意:
-
double和float在计算机内部二进制存储的时候存储的都是
近似值,近似值也就意味着很多的问题 -
/* 经典的面试题 */ public class DataTypeTest11{ public static void main(String[] args){ // 关于运算符“==” // 这个运算符作用是判断两个数据是否相等。 // 如果相等，结果true // 如果不相等，结果是false int a = 100; int b = 100; System.out.println(a == b); // true // java中 * 是乘法运算。 int x = 2; int y = 3; System.out.println(x * y); // 6 // 关于浮点型数据的面试题 System.out.println(0.1 * 3 == 0.3); // false System.out.println(0.3 * 1 == 0.3); // true /* 本质区别： 1.Java中，任何数*1 结果都是其本身 2.浮点数不精确，0.1*3 0.1表面上是0.1，实质上 .1 后面还有很多 可能是0.1000000000000413，太小，近视为0.1 计算时：0.1000000000000413 * 3 怎么也不可能 = 0.3 */ } } -
在现实世界当中有一些数字是无限循环的，例如:3.333333333333333333333… .计算机的盗源是有限的，用有限的资源存储无限的数裾只能存储近似值。
-
10.7.布尔型
-
关于布尔型数据类型:
boolean- 在java语言当中boolean类型只有两个值:true、 false，没有其它值。不像c语言当中，0和1可以表示假和真。
- 在底层存储的时候boolean类型占用1个字节，因为实际存储的时候false底层是0，true底层是1。
布尔类型在实际开发当中非常重要，经常使用在逻辑运算和条件控制语句当中。
-
关于基本数据类型之间的互相转换:转换规则
-
1、八种基本数据类型当中除布尔类型之外剩下的7种类型之间都可以互相转换
-
2、小容量向大容量转换，称为自动类型转换，容量从小到大排序:
char <byte < short< int <long< float < double -
注:
任何浮点类型不管占用多少个字节,都比整数型容量大。
char和short可表示的种类数量相同，但是char可以取更大的正整数（char没有负数部分） -
3、大容量转换成小容量，叫做强制类型转换，需要加强制类型转换符，程序才能编译通过，但是在运行阶段可能会损失精度,所以谨慎使用。
-
4、当整数字面值没有超出byte ,short , char的取值范围，可以直接赋值给byte , short, char类型的变量。
-
5、byte , short, char混合运算的时候,各自先转换成int类型再做运算。
-
6、多种数据类型混合运算,先转换成容量最大的那种类型再做运算。
-
注意:编译器检查语法，不会去进行运算，运算是JVM的事
byte b= 3;可以编译通过,3没有超出byte类型取值范围
int i = 10;
byte b =i / 3;编译报错，编译器只检查语法，不会"运算"i/ 3(cpu的事)
-
-
public class DataTyperest08 { public static void main (String [] args){ //出现错误,1000超出了byte的范围 // byte a = 1000; //正确，因为20没有超出byte范围 byte a = 20; //同一个作用域变量不能重名 // short a = 1000 ; //正确,因为数值1000没有超出short类型的范围 //所以赋值正确 short b = 1000; //正确,因为默认就是int，并且没有超出int范圉 int c = 1000; //正确,可以自动转换 long d = c; //错误,出现精度丢失问题，大类型-->>小类型会出现问题 // int e = d; //将1ong强制转换成int类型 //因为值1000，没有超出int范围,所以转换是正确的 int e = (int)d; //因为java中的运算会会转成最大类型 //而10和3默认为int,所以运算后的最大类型也是int //所以是正确的 int f = 10 / 3; //31 //声明10为1ong类型 long g = 10; //出现错误,多个数值在运算过程中,会转换成容量最大的类型 //以下示例最大的类型为double，而h为int，所以就会出现大类型 //(1ong）到小类型（int) //的转换,将会出现精度丢失问题 //int h = g / 3 ; //可以强制转换，因运算结果没有超出int范围 //int h = (int) g / 3; //可以采用iong类型来接收运算结果 // long h = g / 3 ; //出现精度损失问题,以下问题主要是优先级的问题 //将g转换成int，然后又将int类型的g转换成byte,最后byte类型的 g 和 3 运算，那么 //它的运算结果类型就是int，所以int赋值给byte就出现了精度损失问题(主要问题出现在优先级) //byte h = (byte) (int) (g/3); //不能转换，还有因为优先级的问题,g/3结果为long型转为int报错 //byte h = (byte) g / 3; //可以转换,因为运算结果没有超出byte范圉 //byte h = (byte) (g / 3); //可以转换,因为运算结果没有超出short范围 //short h = (short) (g / 3); short i = 10; byte j = 5; //错误,short和byte运算,首先会转换成int再运算 //所以运算结果为int，int赋值给short就会出现精度丢失问题 //lshort k =+ j; //short范围内可以将运算结果强制转换成short //short k = (short)(i + j); //因为运算结果为int,所以可以采用int类型接收 int k = i + j; char 1 = 'a'; System.out.println(l); //输出结果为97,也就是a的ascii值 System.out.print1n( (byte)1); int m = l + 100; //输出结构为197,取得a的ascii码值,让后与100进行相加运算 System.out.println(m); double dd = 10 / 3; System.out.println(dd); //3.o dd = 10.0 / 3; System.out.print1n(dd); //3.3333333333333335 } }
```java
public class DataTypeTest07{
public static void main (String[] args) {
//编译错误:不兼容的类型
//boolean flag = 1;
boolean loginSuccess = true;
//if语句以后讲
if(loginSuccess){
System.out.println("恭喜你,登录成功");
}else{
System.out.println("对不起，用户名不存在或者密码误!");
}
}
}
11.补充知识
11.1.Java书籍推荐
-
java核心技术卷1和卷2
-
编程碰到的英语，尽量记下来
-
尤其是关键字和常用词
public class DataTypeTest07{
public static void main (String[] args) {
//编译错误:不兼容的类型
//boolean flag = 1;
boolean loginSuccess = true;
//if语句以后讲
if(loginSuccess){
System.out.print1n("恭喜你,登录成功");
}else{
System.out.println("对不起，用户名不存在或者密码误!");
}
}
}
11.2.java类库
-
在该路径下，可以查看到java类库
-
java之所以容易上手，就是因为Sun公司写好了java类库，只需要调用就可以了
-
java开发严格上并不是完整的程序员，而是在调用Sun公司搞好的类库
-
其实java程序中SUN提供了一套庞大的类库，java程序员是基于这套基础的类库来进行开发的。所以要知道java的sE类库的字节码在哪儿,要知道java的sE类库的源码在哪儿?
-
SE类库字节码:C:\Program Files (x86)\Javaljdk1.7.0_75\jre\lib\rt.jar*SE类库源码:C:AProgram Files (x86)\Java\jdk1,7.0_75\src.zip
-
例如：
- String.java String.class
- 我们的main方法中的(String[]) String.class
-
12.运算符
12.1.算术运算符
/*
关于java编程中运算符之:算术运算符
+ 求和
- 相减
* 乘积
/ 商
% 求余数【取模】 a % b = a - a / b * b
++ 自加1
-- 自减1
注意:
一个表达式当中有多个运算符，运算符有优先级，不确定的加小括号，优先级得到提升。没有必要去专门记忆运算符的优先级。
*/
public class operatorTest01{
public static void main(String [] args){
int i = 10;
int j= 3;
System.out.println( i + j); //13
System.out.println( i - j); //7
System.out.print1n( i * j); //30
System.out.println( i / j); //3
System.out.printin( i % j); //1
//以下以++为例，--运算符自学!
//关于+运算符【自加1】
int k = 10 ;
//++运算符可以出现在变量后面【单目运算符】k ++;
System.out.printin(k); //11
int y = 10;
//++运算符可以出现在变量前面【单目运算符】++ y;
System.out.println(y); //11
/*
小结:
++运算符可以出现在变量前，也可以出现在变量后，无论是变量前还是变量后只要++运算结束,该变量 中的值一定会自加1
*/
//++出现在变量后
//规则:先做赋值运算，再对变量中保存的值进行自加1.
int a = 100 ;
int b = a ++;
System.out.println(a);
//101
System.out.println(b); //100
//++出现在变量前
//规则:先进行自加1运算,然后再进行赋值操作。
int m = 20;
int n = ++m;
System.out.println(m);
//21
System.out.println(n);//21
}
}
-
-
println源码在控制台输出显示的都是字符串 -
int xx = 500; System.out.printin(xx); /* 将int转换为字符串类型，然后在输出 */ int e = 100; System.out.println(e++); //100 System.out.println(e); //101 -
调用的库是
-
-
-
println()与e++
-
-
/* class A{ public void m(int x){ System.out.println(x); /* m 这个成员方法是有参数的，当调用 m 这个方法时， i 的值 10 传入到 m 成员方法的参数中 所以，会打印出 字符串 10 */ } /* public static void main(String [] args){ int i = 10; m(i); } } 最终结果是，输出10 */ -
int s = 100; System.out.println(++s); //101 System.out.println(s); //101 System.out.println(--s); //100 System.out.println(s++); //100 System.out.println(s--); //101 System.out.println(s--); //100 System.out.println(s--); //99 System.out.println(s); //98
12.2.关系运算符
-
关系运算符:比较的变量保存的值（字面值），而不是比较内存地址
!= 不等于
= 是赋值运算符== 是关系运算符
< 小于 > 大于 <= 小于等于 >= 大于等于关系运算符的运算结果一定是布尔类型:true/false
-
public class operatorTest02{ public static void main (String [] args){ int a = 10 ; int b = 10; System.out.println(a >b);//false System.out.println(a >= b); //true System.out.println(a < b); //false System.out.println(a <= b); //true System.out.println(a = b); //true System.out.println(a != b); //false //基本的赋值运算符 int i = 10; System.out.println(i);//10 i = i + 5; System.out.println(i);//15 //扩展的赋值运算符【+二=运算符可以翻译为"追加/累加"】 i += 5;//等同于:i= i+ 5; System.out.println(i);//20 i -= 5;//等同于:i = i - 5; System.out.println(i); //15 } }
12.3.逻辑运算符
-
逻辑运算符:
- & 逻辑与【并且】(两边的算子都是true，结果才是true)
- | 逻辑或【或者】（两边的算子只要有一个是true，结果就是true)
- ！ 逻辑非（取反，!false就是true，!true就是false，这是一个单目运算符)
- ^ 逻辑异或(
两边的算子只要不一样,结果就是true) - &&短路与
- || 短路或
-
注意
- 逻辑运算符要求两边的算子都是布尔类型，并且逻辑运算符最终的运算结果也是一个布尔类型。
- 短路与和逻辑与最终的运算结果是相同的，只不过
短路与存在短路现象。 - 短路或和逻辑或最终的运算结果是相同的，只不过
短路或存在短路现象。 - 什么情况下发生短路现象呢?
- 什么时候选择使用逻辑与运算符?什么时候选择使用短路与运算符?
-
运算符优先级不确定,加小括号处理
-
System.out.println( 5>3 & 5 >2); // true
-
System.out.println ( 5 >3 & 5 >6); //false
-
System. out.println( 5 >3 | 5>6); // true
-
System.out.println (true & true) ; // true
-
System.out.println (true & false) ; //false
-
System.out.println (false & true) ; //false
-
System.out.println (false & false); //false
-
System.out.println (true | false) ; // true
-
System.out.print1n(false | false); //false
-
System. out.println ( !false); // true
-
System. out.println ( !true) ; //false
-
System.out.println (true ^ false) ; //true
-
System.out.print1n (false ^ fa1se) ; //false
-
System. out.println (true ^ true);//false
-
-
/* //逻辑与和短路与int x = 10; int y = 8;//逻辑与 System.out.println( x < y & ++x <y ); System.out.println(x);//11 不是短路与，即便前面判断出了为false， 也要继续执行 ++x 故 X =11 */ //逻辑与和短路与 int x = 10; int y = 8 ;//短路与 system.out.println ( false && ++x<y ) ; system.out.println (x) ; //10 /* 短路与，当前面已经判断出为false后， 后面的 ++x 就不在执行，故X = 10 */ -
什么情况下发生短路或?
-
第一个表达式执行结果是true，会发生短路或。
-
什么情况下发生短路与?
- 第一个表达式执行结果是false，会发生短路或。
12.4.位运算符（简介）
- 直接针对存储的二进制数（补码）进行操作，在一些要求执行效率较高的代码中，后面详细讲
- 面试：2 任何最快变成8 2 左移2位
12.5.赋值运算符
-
关于java中的赋值类运算符: 赋值类运算符包括两种: *基本的赋值运算符 = *扩展的赋值运算符（追加型） += -= *= /= 赋值类的运算符优先级:先执行等号右边 的表达式，将执行结果赋值给左边的变量。 -
赋值类的运算符优先级:先执行等号右边的表达式，将执行结果赋值给左边的变量。
-
注意以下代码:
-
byte i = 10;
i+=5;
等同于:i = (byte) (i +5); -
int k = 10;
k+=5;等同于:k =(int) (k + 5); -
long x = 10L;
int y = 20;
y+=x;
等同于:y =(int)(y + x);大容量—>小容量自动进行了强制转换
-
-
重要结论:
-
扩展类的赋值运算符不改变运算结果类型，假设最初这个变量的类型是 byte类型，无论怎么进行追加或追减，最终该变量的数据类型还是byte类型。 -
long x = 10L;
int y = 20;
y+=x;
等同于:y =(int)(y + x);变量y在进行追加操作，所以结果类型与y的类型一致，不一致会自动进行强制转
-
-
byte z = 0; z += 128; //等同于:z =(byte)(z + 128); System.out.print1n(z); //-128【损失精度】 z += 1000; //等同于:z = (byte)(z + 1000) System.out.println(z); //-112-
不会报错，代码可以运行
-
编译器只检查语法，上面语法没问题，只不过在运
行时会精度损失
-
-
关于java中的"+"运算符:
-
运算符在java语言当中有两个作用:
- 加法运算,求和
- 字符串的连接运算
-
当==+运算符两边的数据都是数字的话==，一定是进行加法运算。
-
当=="+”运算符两边的数据只要有一个数据是字符串==，一定会进行字符串连接运算。并且,连接运算之后的结果还是一个字符串类型。
- 数字＋数字–→数字【求和】
-
数字＋"字符串" -->“字符串”【字符串连接】
-
在一个表达式当中可以出现多个==+，在没有添加小括号的前提之下，遵循自左向右==的顺序依次运算。
-
System.out.print1n(10 + 20); //30这里的加号的求和 System.out.println(10 + 20 + 30); //60这里的加号也是求和 System.out.println(10 + 20 +"30"); //"3030”自左向右的顺序依次运算，第一个加号是求和, //第二个加号连接字符串 System.out.print1n(10 +(20 + "30")); //"102030" int a = 10; int b = 20; //要求在控制台上输出"10 +20= 30" System.out.print1n ( "10 +20 = 30") ; //注意:要求以动态的方式输出 //system.out.println() ; System.out.println( "10+ 20 = " +a + b); //"10 + 20 = 1020" System.out.println("10 +20 = "+(a + b)); System. out.print1n ( "a + 20 =" +(a + b)); System.out.println(a +" +20 =" + (a + b)); System.out.println(a + " +b = " +(a + b)) ; System.out.println(a +"+" + b+“= " + (a +b));
-
-
引用类型
String- string是sUN在JavasE当中提供的字符串类型
- string.class字节码文件
- int是基本数据类型,i是变量名,10是int类型的字面值
- int i = 10;
- String是引用数据类型，s是变量名，"abc"是String类型的字面值
- String s = “abc” ;
-
编译错误,类型不兼容 String ss = 10;//这个是整型
定义一个String类型的变量，起名username，赋值"zhangsan"-
string username = “zhangsan” ;
-
system.out.printin(“登录成功,欢迎username回来”) ;
-
system.out.println(“登录成功,欢迎"＋"回来”);
-
system.out.printin( “登录成功，欢迎” +username +“回来”);
-
userxame=“jack” ;
-
system.out.printin(“登录成功，欢迎” + username + “回来”);
-
12.6.三元运算符
-
三元运算符/三目运算符/条件运算符
-
语法规则:
- 布尔表达式? 表达式 1 : 表达式 2 （类型要兼容）
-
三元运算符的执行原理?
-
当布尔表达式的结果是true的时候，选择
表达式1作为整个表达式的执行结果 -
当布尔表达式的结果是false的时候，选择
表达式2作为整个表达式的执行结果
-
-
编译错误:不是一个完整的java语句
-
‘男’；
-
布尔类型的变量
-
boolean sex = false;
-
-
分析以下程序是否可以编译通过?
-
-
sex ?'男':'女';运算结束后，就一个 ‘女’；（这不是一个java语句，没有变量接受这个结果报错） -
正确写法
-
char c = sex ?‘男’:‘女’;
-
System.out.println © ;
- sex = true;
c = (sex ?‘男’:女’);
//不确定优先级用（）
System.out.println ©;
- sex = true;
-
-
注意
- 语法错误,编译报错，结果可能是String，也可能是char，50%概率也不能保证结果一定是char,但是前边不能用char来接收数据。类型不兼容
char c1 = sex ? “男” : ‘女’;
编译错误,类型不兼容
sex = false;
char c1 = sex ? “男” : ‘女’;
语法上的问题，不知道运算结果是字符还是字符串
-
public class Test0004{ // 三元运算符算子兼容性 public static void main(String [] args){ boolean boolean1 = true; byte a = 10; short b = 1000; int num = boolean1 ? a : b; System.out.println(num); } } // D:\dongli>javac Test0004.java // D:\dongli>java Test // 错误: 找不到或无法加载主类 Test // 原因: java.lang.ClassNotFoundException: Test // D:\dongli>java Test0004 // 10 //可以,避开了声明类型 System.out.print1n(sex ?’男‘:"女"); String s= sex ? "男的":"女的"; System.out.println(s) ;
- 语法错误,编译报错，结果可能是String，也可能是char，50%概率也不能保证结果一定是char,但是前边不能用char来接收数据。类型不兼容
421
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
