1、【Java基础、常用DOS命令、数据类型、运算符、方法入门】

day01 【前言、入门程序、常量、变量】

今日内容

Java 语言的发展历史
Java 开发环境搭建
编写 HelloWorld程序
常量和变量

教学目标

第一章开发前言

1.1 Java 语言概述

什么是Java语言

Java语言是美国Sun公司（Stanford University Network），在1995年推出的高级的编程语言。所谓编程语言，是计算机的语言，人们可以使用编程语言对计算机下达命令，让计算机完成人们需要的功能。

Java语言之父——詹姆斯高斯林：

编译型和解释型语言的区别

编译型语言：

需通过编译器（compiler）将源代码编译成机器码，之后才能执行的语言。一般需经过编译（compile）、链接（linker）这两个步骤。编译是把源代码编译成机器码，链接是把各个模块的机器码和依赖库串连起来生成可执行文件。

优点：编译器一般会有预编译的过程对代码进行优化。因为编译只做一次，运行时不需要编译，所以编译型语言的程序执行效率高。可以脱离语言环境独立运行。

缺点：编译之后如果需要修改就需要整个模块重新编译。编译的时候根据对应的运行环境生成机器码，不同的操作系统之间移植就会有问题，需要根据运行的操作系统环境编译不同的可执行文件。

代表语言：C、C++、Java、Pascal、Object-C、苹果新语言swift。
解释型语言：

解释性语言的程序不需要编译，相比编译型语言省了道工序，解释性语言在运行程序的时候才逐行翻译。

优点：有良好的平台兼容性，在任何环境中都可以运行，前提是安装了解释器（虚拟机）。灵活，修改代码的时候直接修改就可以，可以快速部署，不用停机维护。

缺点：每次运行的时候都要解释一遍，性能上不如编译型语言。

代表语言：JavaScript、Python、Erlang、PHP、Perl、Ruby

Java特性和优势

简单性
面向对象
可移植性
高性能
分布式
动态性
多线程
安全性
健壮性

重点有两个：开源，跨平台。

思考？Java为什么能够成功

Java语言发展历史

1995 年Sun公司发布Java1.0版本
1997 年发布Java 1.1版本
1998 年发布Java 1.2版本
2000 年发布Java 1.3版本
2002 年发布Java 1.4版本
2004 年发布Java 1.5版本
2006 年发布Java 1.6版本
2009 年Oracle甲骨文公司收购Sun公司，并于2011发布Java 1.7版本
2014 年发布Java 1.8版本
2017 年发布Java 9.0版本

Java三大版本

JavaSE：标准版（桌面程序控制台开发...）
JavaME：嵌入式开发（手机小家电…）

JavaME已经死掉了，不用学了。

JavaEE：企业级开发（web端，服务器开发...）

Java语言能做什么

Java语言主要应用在互联网程序的开发领域。常见的互联网程序比如天猫、京东、物流系统、网银系统等，以及服务器后台处理大数据的存储、查询、数据挖掘等也有很多应用。

1.2 计算机基础知识

什么是计算机

Computer：全称电子计算机，俗称电脑。
能够按照程序运行，自动、高速处理海量数据的现代化智能电子设备。
由硬件和软件所组成。
常见的形式有台式计算机、笔记本计算机、大型计算机等。
广泛应用在：科学计算，数据处理，自动控制，计算机辅助设计，人工智能，刚络等领域。

硬件及冯诺依曼结构

一些物理装置按系统结构的要求构成一个有机整体为计算机软件运行提供物质基础。
计算机硬件组成
- cPU
- 主板
- 内存
- 电源、主机箱
- 硬盘
- 显卡
- 键盘、鼠标
- 显示器
- 等

Windows常用快捷键

快捷键	功能
Ctrl+C	复制
Ctrl+V	粘贴
Ctrl+A	全选
Ctrl+X	剪切
Ctrl+Z	撤销
Ctrl+S	保存
Ctrl+W	关闭窗口
Alt+F4	关闭窗口
Shift+Delete	永久删除
Windows+R	打开运行窗口
Windows+E	打开我的电脑
Windows+Tab	切换应用窗口
Windows+M	窗口最小化
Windows+D	窗口最小化/最大化
Shift+字母键盘	字母大写
Ctrl+Shift+ESC	打开任务管理器
任务管理器-文件-运行新任务输入： explorer	打开Windows资源管理器（桌面）

进制

在Java中针对整数常量提供了四种表现形式：

二进制 由0，1组成。以0b开头。
八进制 由0，1，...7组成。以0开头。
十进制 由0，1，...9组成。整数默认是十进制。
十六进制 由0，1，...9,a,b,c,d,e,f(大小写均可)组成。以0x开头。

二进制

计算机中的数据不同于人们生活中的数据，人们生活采用十进制数，而计算机中全部采用二进制数表示，它只包含0、1两个数，逢二进一，1+1=10。

下面了解一下十进制和二进制数据之间的转换计算。

十进制数据转成二进制数据： 使用除以2获取余数的方式（除二取余倒排）

二进制数据转成十进制数据： 使用8421编码的方式

小贴士：
二进制数系统中，每个0或1就是一个位，叫做bit（比特）。

进制转换(了解)

其他进制到十进制
1. 系数：就是每一个位上的数值
2. 基数：x进制的基数就是x
3. 权：对每一个位上的数据，从右，并且从0开始编号，对应的编号就是该数据的权。
  
  结果：系数*基数^权次幂之和（按位乘权相加）
十进制到其他进制

除基取余，直到商为0，余数反转（除基取余倒排）
进制转换的快速转换法

A:十进制和二进制间的转换
8421码。
B:二进制到八进制，十六进制的转换

用十进制作为桥梁。

win10系统中，计算机内置的计算器，可以实现各种进制的数值的同步转换。

点击“计算器”的左上角菜单栏，切换到“程序员”模式，鼠标选择任一进制，在输入栏输入任意进制下的数值，其余进制会同步显示转换结果。

十六进制 HEX
十进制 DEC
八进制 OCT
二进制 BIN

只有0及0以上的整数单位，没有小数部分，不存在0.5字节一说。

小科普：存储在计算机中的最小单位是“位”。

电信宽带所给我们的网速（“电子数据”）是以“位”为计数单位的。而传输中电脑显示给我们的网速是以“字节”为单位的（字节为计算机中最小的存储单位），它们一个是数据传输单位，最小单位是bit，一个是数据存储单位，最小是字节。两者的换算关系为：1字节=8位。

故实际宽带与实际下载速度之比约为8:1

字节

字节是我们常见的计算机中最小存储单元。计算机存储任何的数据，都是以字节的形式存储，右键点击文件属性，我们可以查看文件的字节大小。

8个bit（二进制位） 0000-0000表示为1个字节，写成1 byte或者1 B。

8 bit = 1 B
1024 B =1 KB
1024 KB =1 MB
1024 MB =1 GB
1024 GB = 1 TB

打开CMD的方式

菜单栏 - 开始 - 系统 - 命令提示符。
Win键+R - 输入cmd 回车 - 打开DOS的操作窗口（推荐使用）。
在任意的文件夹下，按住 shift键+鼠标右键点击，选择在此处打开Powershell窗口。
资源管理器的地址栏前面加上 cmd 路径。
在左下角的开始图标上，点击鼠标右键，选择windows Powershell。

管理员方式运行cmd

菜单栏 - 开始 - 系统 - 命令提示符，选择以管理员方式运行

在左下角的开始图标上，点击鼠标右键，选择windows Powershell（管理员）。

常用DOS命令

Java语言的初学者，学习一些DOS命令，会非常有帮助。DOS是一个早期的操作系统，现在已经被Windows系统取代，对于我们开发人员，目前需要在DOS中完成一些事情，因此就需要掌握一些必要的命令。

命令	操作符号
盘符切换命令	`盘符名 :`
查看当前文件夹	`dir`
进入文件夹命令	`cd 目录名`
退出文件夹命令	`cd..`
退出到磁盘根目录	`cd\`
创建文件夹	`md 目录名`
移除文件夹	`rd 目录名`
创建文件	`cd>文件名.扩展名`
删除文件	`del 文件名`
清屏	`cls`
退出终端	`exit`
查看电脑的ip	`ipconfig`
ping某个网址连接是否正常	例：`ping www.baidu.com`
打开计算器	`calc`
打开画图工具	`mspaint`
打开记事本	`notepad`

常用DOS命令（来自Windows CMD-help）

命令	功能
ASSOC	显示或修改文件扩展名关联。
ATTRIB	显示或更改文件属性。
BREAK	设置或清除扩展式CTRL+C检查。
BCDEDIT	设置启动数据库中的属性以控制启动加载。
CACLS	显示或修改文件的访问控制列表(ACL)。
CALL	从另一个批处理程序调用这一个。
CD	显示当前目录的名称或将其更改。
CHCP	显示或设置活动代码页数。
CHDIR	显示当前目录的名称或将其更改。
CHKDSK	检查磁盘并显示状态报告。
CHKNTFS	显示或修改启动时间磁盘检查。
CLS	清除屏幕。
CMD	打开另一个Windows命令解释程序窗口。
COLOR	设置默认控制台前景和背景颜色。
COMP	比较两个或两套文件的内容。
COMPACT	显示或更改NTFS分区上文件的压缩。
CONVERT	将FAT卷转换成NTFS。你不能转换当前驱动器。
COPY	将至少一个文件复制到另一个位置。
----------	----------
DATE	显示或设置日期。
DEL	删除至少一个文件。
DIR	显示一个目录中的文件和子目录。
DISKPART	显示或配置磁盘分区属性。
DOSKEY	编辑命令行、撤回Windows命令并创建宏。
DRIVERQUERY	显示当前设备驱动程序状态和属性。
ECHO	显示消息，或将命令回显打开或关闭。
ENDLOCAL	结束批文件中环境更改的本地化。
ERASE	删除一个或多个文件。
EXIT	退出CMD.EXE程序(命令解释程序)。
FC	比较两个文件或两个文件集并显示它们之间的不同。
FIND	在一个或多个文件中搜索一个文本字符串。
FINDSTR	在多个文件中搜索字符串。
FOR	为一组文件中的每个文件运行一个指定的命令。
FORMAT	格式化磁盘，以便用于Windows。
FSUTIL	显示或配置文件系统属性。
FTYPE	显示或修改在文件扩展名关联中使用的文件类型。
----------	----------
GOTO	将Windows命令解释程序定向到批处理程序中某个带标签的行。
GPRESULT	显示计算机或用户的组策略信息。
GRAFTABL	使Windows在图形模式下显示扩展字符集。
HELP	提供Windows命令的帮助信息。
ICACLS	显示、修改、备份或还原文件和目录的ACL。
IF	在批处理程序中执行有条件的处理操作。
LABEL	创建、更改或删除磁盘的卷标。
MD	创建一个目录。
MKDIR	创建一个目录。
MKLINK	创建符号链接和硬链接
MODE	配置系统设备。
MORE	逐屏显示输出。
MOVE	将一个或多个文件从一个目录移动到另一个目录。
----------	----------
OPENFILES	显示远程用户为了文件共享而打开的文件。
PATH	为可执行文件显示或设置搜索路径。
PAUSE	暂停批处理文件的处理并显示消息。
POPD	还原通过PUSHD保存的当前目录的上一个值。
PRINT	打印一个文本文件。
PROMPT	更改Windows命令提示。
PUSHD	保存当前目录，然后对其进行更改。
RD	删除目录。
RECOVER	从损坏的或有缺陷的磁盘中恢复可读信息。
REM	记录批处理文件或CONFIG.SYS中的注释(批注)。
REN	重命名文件。
RENAME	重命名文件。
REPLACE	替换文件。
RMDIR	删除目录。
ROBOCOPY	复制文件和目录树的高级实用工具
----------	----------
SET	显示、设置或删除Windows环境变量。
SETLOCAL	开始本地化批处理文件中的环境更改。
SC	显示或配置服务(后台进程)。
SCHTASKS	安排在一台计算机上运行命令和程序。
SHIFT	调整批处理文件中可替换参数的位置。
SHUTDOWN	允许通过本地或远程方式正确关闭计算机。
SORT	对输入排序。
START	启动单独的窗口以运行指定的程序或命令。
SUBST	将路径与驱动器号关联。
SYSTEMINFO	显示计算机的特定属性和配置。
TASKLIST	显示包括服务在内的所有当前运行的任务。
TASKKILL	中止或停止正在运行的进程或应用程序。
TIME	显示或设置系统时间。
TITLE	设置CMD.EXE会话的窗口标题。
TREE	以图形方式显示驱动程序或路径的目录结构。
TYPE	显示文本文件的内容。
VER	显示Windows的版本。
VERIFY	告诉Windows是否进行验证，以确保文件正确写入磁盘。
VOL	显示磁盘卷标和序列号。
XCOPY	复制文件和目录树。
WMIC	在交互式命令shell中显示WMI信息。

第二章 Java语言开发环境搭建

2.1 Java虚拟机——JVM

JVM （Java Virtual Machine ）：Java虚拟机，简称JVM，是运行所有Java程序的假想计算机，是Java程序的运行环境，是Java 最具吸引力的特性之一。我们编写的Java代码，都运行在JVM之上。
跨平台 ：任何软件的运行，都必须要运行在操作系统之上，而我们用Java编写的软件可以运行在任何的操作系统上，这个特性称为Java语言的跨平台特性。该特性是由JVM实现的，我们编写的程序运行在JVM上，而JVM运行在操作系统上。

如图所示，Java的虚拟机本身不具备跨平台功能的，每个操作系统下都有不同版本的虚拟机。

JVM就是JAVA程序的操作系统，JVM的可执行文件就是 .class文档。

另外，path变量和classpath变量是有差别的。

Java语言跨平台原理图解

Java语言跨平台原理图解

2.2 JDK,JRE,JVM的作用及关系(掌握)

JRE (Java Runtime Environment) ：是Java程序的运行时环境，包含JVM和运行时所需要的 核心类库 。
JDK (Java Development Kit)：是Java程序开发工具包，包含JRE和开发人员使用的工具。
JVM（Java Virtual Machine）：Java虚拟机，保证Java语言跨平台。

我们想要运行一个已有的Java程序，那么只需安装JRE即可。
我们想要开发一个全新的Java程序，那么必须安装JDK。

JDK&JRE&JVM关系示意图：

小贴士：
三者关系： JDK > JRE > JVM

2.3 JDK9 安装图解

小贴士：
安装路径中，不要包含中文和空格。

2.4 JAVA_HOME 环境变量的配置

配置环境变量作用

开发Java程序，需要使用JDK中提供的工具，工具在JDK9安装目录的bin目录下。

在DOS命令行下使用这些工具，就要先进入到JDK的bin目录下，这个过程就会非常的麻烦。

不进入JDK的bin目录，这些工具就不能使用，会报错。

为了开发方便，我们想在任意的目录下都可以使用JDK的开发工具，则必须要配置环境变量，配置环境变量的意义在于告诉操作系统，我们使用的JDK开发工具在哪个目录下。

配置环境变量步骤

Windows 7,8版本

计算机鼠标右键,选择 属性

选择 高级系统设置

高级 选项卡，点击 环境变量

点击新建，创建新的环境变量

变量名输入JAVA_HOME，变量值输入JDK9的安装目录 c:\Java9\jdk -9.0.1

选中Path环境变量，双击或者 点击编辑

在变量值的最前面，键入%JAVA_HOME%\bin; 分号必须要写，必须是英文格式。

环境变量配置完成，重新开启DOS命令行，在任意目录下输入javac命令，运行成功。

Windows 10 版本

文件资源管理器 --> 此电脑鼠标右键 --> 选择 属性

选择高级系统设置--> 选择 环境变量

点击下方系统变量的 新建，创建新的环境变量，变量名输入JAVA_HOME，变量值输入JDK9的安装目录 D:\02_DevelopTools\Java\jdk -9.0.1

选中Path环境变量，双击或者 点击编辑

点击新建，键入%JAVA_HOME%\bin，必须是英文格式。选中该行，上移到最上方，点击确定。

环境变量配置完成，重新开启DOS命令行，在任意目录下输入javac命令。

第三章 HelloWorld入门程序

3.1 程序开发步骤说明

开发环境已经搭建完毕，可以开发我们第一个Java程序了。

Java程序开发三步骤：编写、编译、运行。

3.2 编写Java源程序

在 d:\day01 目录下新建文本文件，完整的文件名修改为 HelloWorld.java ，其中文件名为 HelloWorld ，后缀名必须为 .java 。
用记事本打开
使用notepad++记事本软件。
在文件中键入文本并保存，代码如下：
```
public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
}
```
文件名必须是HelloWorld，保证文件名和类的名字是一致的，注意大小写。
每个字母和符号必须与示例代码一模一样。

第一个 HelloWord 源程序就编写完成了，但是这个文件是程序员编写的，JVM是看不懂的，也就不能运行，因此我们必须将编写好的Java 源文件编译成JVM可以看懂的字节码文件。

3.3 编译Java源文件

在DOS命令行中，进入Java源文件的目录，使用 javac 命令进行编译。
命令：

javac Java源文件名.后缀名

举例：

javac HelloWorld.java

编译成功后，命令行没有任何提示。打开 d:\day01 目录，发现产生了一个新的文件 HelloWorld.class ，该文件就是编译后的文件，是Java的可运行文件，称为字节码文件，有了字节码文件，就可以运行程序了。

Java源文件的编译工具javac.exe，在JDK安装目录的bin目录下。但是由于配置了环境变量，可以在任意目录下使用。

3.4 运行Java程序

在DOS命令行中，进入Java源文件的目录，使用 java 命令进行运行。

命令：

java 类名字

举例：

java HelloWorld

java HelloWord 不要写不要写不要写 .class

Java程序.class 文件的运行工具java.exe，在JDK安装目录的bin目录下。但是由于配置了环境变量，可以再任意目录下使用。

3.5 入门程序说明

编译和运行是两回事

编译：是指将我们编写的Java源文件翻译成JVM认识的class文件，在这个过程中， javac 编译器会检查我们所写的程序是否有错误，有错误就会提示出来，如果没有错误就会编译成功。
运行：是指将class 文件交给JVM去运行，此时JVM就会去执行我们编写的程序了。

关于main方法

main 方法：称为主方法。写法是固定格式不可以更改。main方法是程序的入口点或起始点，无论我们编写多少程序，JVM在运行的时候，都会从main方法这里开始执行。

3.6 添加注释comment

注释：就是对代码的解释和说明。其目的是让人们能够更加轻松地了解代码。为代码添加注释，是十分必须要的，它不影响程序的编译和运行。
Java 中有单行注释和多行注释
- 单行注释以 // 开头换行结束
- 多行注释以 /* 开头以*/结束
- 文档注释：
```
文档注释格式：

 /**
  * xxx
  * xxx
  * xxx
  */
```

3.7 关键字keywords

关键字：是指在程序中，Java已经定义好的单词，具有特殊含义。
- HelloWorld 案例中，出现的关键字有 public 、 class 、 static 、 void 等，这些单词已经被Java定义好，全部都是小写字母，notepad++中颜色特殊。
- 关键字比较多，不能死记硬背，学到哪里记到哪里即可。
- goto和const作为保留字存在。

3.8 标识符

标识符 ：是指在程序中，我们自己定义的内容。比如类的名字、方法的名字、接口的名字和变量的名字等等，都是标识符。
- HelloWorld 案例中，出现的标识符有类名字 HelloWorld 。
命名规则： 硬性要求
- 标识符可以包含 英文字母 26个(区分大小写) 、 0 -9数字 、 $ （美元符号） 和 _ （下划线） 。
- 标识符不能以数字开头。
- 标识符不能是关键字。
命名规范： 软性建议(见名知意)
- 包：全部小写
  - 单级包：小写
    
    举例：liuyi,com
  - 多级包：小写，并用.隔开
    
    举例：cn.itcast com.baidu
  - 类或者接口
    - 一个单词：首字母大写
      举例：Student Demo
    - 多个单词：每个单词首字母大写
      
      举例：HelloWorld StudentName
  - 方法
    - 一个单词：首字母小写
      举例：name main
    - 多个单词：从第二个单词开始，每个单词首字母大写
      
      举例：studentAge showAllNames()
  - 常量：全部大写
    - 一个单词：大写
      举例：PI
    - 多个单词：大写，并用_隔开
      
      举例：STUDENT_MAX_AGE
  - 变量
    - 全部小写。

第四章常量

4.1 概述

常量：是指在Java程序中，其值固定不变的数据。

4.2 分类

类型	含义	数据举例
整数常量	所有的整数	0，1，567,-9
小数常量	所有的小数	0.0，-0.1，2.55
字符常量	单引号引起来,只能写一个字符,必须有内容	'a' ， '好'
字符串常量	双引号引起来,可以写多个字符,也可以不写	"A" ，"Hello" ，"你好" ，""
布尔常量	只有两个值（流程控制中讲解）	true ， false
空常量	只有一个值（引用数据类型中讲解）	null

4.3 练习

需求：输出各种类型的常量。

/*
常量：在程序运行期间，固定不变的量。

常量的分类：
1. 字符串常量：凡是用双引号引起来的部分，叫做字符串常量。例如："abc"、"Hello"、"123"
2. 整数常量：直接写上的数字，没有小数点。例如：100、200、0、-250
3. 浮点数常量：直接写上的数字，有小数点。例如：2.5、-3.14、0.0
4. 字符常量：凡是用单引号引起来的单个字符，就做字符常量。例如：'A'、'b'、'9'、'中'
5. 布尔常量：只有两种取值。true、false。
6. 空常量：null。代表没有任何数据。
*/
public class Demo01Const {
	public static void main(String[] args) {
		// 字符串常量
		System.out.println("ABC");
		System.out.println(""); // 字符串两个双引号中间的内容为空
		System.out.println("XYZ");
		
		// 整数常量
		System.out.println(30);
		System.out.println(-500);
		
		// 浮点数常量（小数）
		System.out.println(3.14);
		System.out.println(-2.5);
		
		// 字符常量
		System.out.println('A');
		System.out.println('6');
		// System.out.println(''); // 两个单引号中间必须有且仅有一个字符，没有不行。
		// System.out.println('AB'); // 两个单引号中间必须有且仅有一个字符，有两个不行。
		
		// 布尔常量
		System.out.println(true);
		System.out.println(false);
		
		// 空常量。空常量不能直接用来打印输出。
		// System.out.println(null);
	}
}

第五章变量和数据类型

5.1 变量概述

变量：常量是固定不变的数据，那么在程序中可以变化的量称为变量。

数学中，可以使用字母代替数字运算,例如 x=1+5 或者 6=x+5。

程序中，可以使用字母保存数字的方式进行运算，提高计算能力，可以解决更多的问题。比如x保存5，x也可以保存6，这样x保存的数据是可以改变的，也就是我们所讲解的变量。

Java中要求一个变量每次只能保存一个数据，必须要明确保存的数据类型。

5.2 数据类型

数据类型分类

Java的数据类型分为两大类：

基本数据类型 ：包括 整数 、 浮点数 、 字符 、 布尔 。
引用数据类型 ：包括 类 、 数组 、 接口、字符串、 Lambda。

基本数据类型

四类八种基本数据类型：

数据类型	关键字	内存占用	取值范围
字节型	byte	1个字节	-128~127
短整型	short	2个字节	-32768~32767
整型	int（默认）	4个字节	-231次方~2的31次方-1
长整型	long	8个字节	-2的63次方~2的63次方-1
单精度浮点数	float	4个字节	1.4013E-45~3.4028E+38
双精度浮点数	double（默认）	8个字节	4.9E-324~1.7977E+308
字符型	char	2个字节	0-65535
布尔类型	boolean	1个字节	true，false

引用数据类型

字符串、数组、类、接口、Lambda

注意事项：

字符串不是基本类型，而是引用类型。

浮点型可能只是一个近似值，并非精确的值。

数据范围与字节数不一定相关，例如float数据范围比long更加广泛，但是float是4字节，long是8字节。

Java中的默认类型：整数类型是int、浮点类型是double。

如果一定要使用float类型，需要加上一个后缀F或f。

如果是整数，默认为int类型，如果一定要使用long类型，需要加上一个后缀L或l。推荐使用大写字母后缀。

面试题：Java中的字符可以存储一个汉字吗?为什么呢?

答：可以。char型变量是用来存储Unicode编码字符的，unicode编码字符集中包含了汉字，所以，char型变量中可以存储汉字。不过，如果某个特殊的汉字没有被包含在unicode编码字符之中，那么这个char型变量中就不能存储这个特殊汉字。

说明：unicode编码占用两个字节，所以，char类型的变量也是占用两个字节。

5.3 变量的定义

变量定义的格式包括三个要素：数据类型、 变量名 、 数据值 。

格式

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

练习

定义所有基本数据类型的变量，代码如下：

public class Variable {
	public static void main(String[] args){    
           //定义字节型变量
           byte b = 100;
           System.out.println(b);
           //定义短整型变量
           short s = 1000;
           System.out.println(s);
           //定义整型变量
           int i = 123456;
           System.out.println(i);
           //定义长整型变量
           long l = 12345678900L;
           System.out.println(l);
           //定义单精度浮点型变量
           float f = 5.5F;
           System.out.println(f);
           //定义双精度浮点型变量
           double d = 8.5;
           System.out.println(d);
           //定义布尔型变量
           boolean bool = false;
           System.out.println(bool);
           //定义字符型变量
           char c = 'A';
           System.out.println(c);
   } 
}

long类型：建议数据后加L或l表示。
float类型：建议数据后加F或f表示。

练习

/*
变量：程序运行期间，内容可以发生改变的量。

创建一个变量并且使用的格式：

数据类型 变量名称; // 创建了一个变量
变量名称 = 数据值; // 赋值，将右边的数据值，赋值交给左边的变量

一步到位的格式：

数据类型 变量名称 = 数据值; // 在创建一个变量的同时，立刻放入指定的数据值
*/
public class Demo02Variable {
	public static void main(String[] args) {
		// 创建一个变量
		// 格式：数据类型 变量名称;
		int num1;
		// 向变量当中存入一个数据
		// 格式：变量名称 = 数据值;
		num1 = 10;
		// 当打印输出变量名称的时候，显示出来的是变量的内容
		System.out.println(num1); // 10
		
		// 改变变量当中本来的数字，变成新的数字
		num1 = 20;
		System.out.println(num1); // 20
		
		// 使用一步到位的格式来定义变量
		// 格式：数据类型 变量名称 = 数据值;
		int num2 = 25;
		System.out.println(num2); // 25
		
		num2 = 35;
		System.out.println(num2); // 35
		System.out.println("===============");
		
		byte num3 = 30; // 注意：右侧数值的范围不能超过左侧数据类型的取值范围
		System.out.println(num3); // 30
		
		// byte num4 = 400; // 右侧超出了byte数据范围，错误！
		
		short num5 = 50;
		System.out.println(num5); // 50
		
		long num6 = 3000000000L;
		System.out.println(num6); // 3000000000
		
		float num7 = 2.5F;
		System.out.println(num7); // 2.5
		
		double num8 = 1.2;
		System.out.println(num8); // 1.2
		
		char zifu1 = 'A';
		System.out.println(zifu1); // A
		
		zifu1 = '中';
		System.out.println(zifu1); // 中
		
		boolean var1 = true;
		System.out.println(var1); // true
		
		var1 = false;
		System.out.println(var1); // false
		
		// 将一个变量的数据内容，赋值交给另一个变量
		// 右侧的变量名称var1已经存在，里面装的是false布尔值
		// 将右侧变量里面的false值，向左交给var2变量进行存储
		boolean var2 = var1;
		System.out.println(var2); // false
	}
}

/*
使用变量的时候，有一些注意事项：

1. 如果创建多个变量，那么变量之间的名称不可以重复。
2. 对于float和long类型来说，字母后缀F和L不要丢掉。
3. 如果使用byte或者short类型的变量，那么右侧的数据值不能超过左侧类型的范围。
4. 没有进行赋值的变量，不能直接使用；一定要赋值之后，才能使用。
5. 变量使用不能超过作用域的范围。
【作用域】：从定义变量的一行开始，一直到直接所属的大括号结束为止。
6. 可以通过一个语句来创建多个变量，但是一般情况不推荐这么写。
*/
public class Demo03VariableNotice {
	public static void main(String[] args) {
		int num1 = 10; // 创建了一个新的变量，名叫num1
		// int num1 = 20; // 又创建了另一个新的变量，名字也叫num1，错误！
		
		int num2 = 20;
		
		int num3;
		num3 = 30;
		
		int num4; // 定义了一个变量，但是没有进行赋值
		// System.out.println(num4); // 直接使用打印输出就是错误的！
		
		// System.out.println(num5); // 在创建变量之前，不能使用这个变量
		
		int num5 = 500;
		System.out.println(num5); // 500
		
		{
			int num6 = 60;
			System.out.println(num6); // 60
		}
		// int num6;
		// System.out.println(num6); // 已经超出了大括号的范围，超出了作用域，变量不能再使用了
		
		// 同时创建了三个全都是int类型的变量
		int a, b, c;
		// 各自分别赋值
		a = 10;
		b = 20;
		c = 30;
		System.out.println(a); // 10
		System.out.println(b); // 20
		System.out.println(c); // 30
		
		// 同时创建三个int变量，并且同时各自赋值
		int x = 100, y = 200, z = 300;
		System.out.println(x); // 100
		System.out.println(y); // 200
		System.out.println(z); // 300
	}
}

5.4 注意事项

变量名称：在同一个大括号范围内，变量的名字不可以相同。
变量赋值：定义的变量，不赋值不能使用。

day02 【数据类型转换、运算符、方法入门】

今日内容

数据类型转换
算数运算符
比较运算符
逻辑运算符
三元运算符
简单方法定义和调用

教学目标

第一章数据类型转换

Java程序中要求参与的计算的数据，必须要保证数据类型的一致性，如果数据类型不一致将发生类型的转换。

1.1 自动转换

一个int 类型变量和一个byte类型变量进行加法运算，结果会是什么数据类型？

int i = 1;
byte b = 2;

运算结果，变量的类型将是int类型，这就是出现了数据类型的自动类型转换现象。

自动转换：将取值范围小的类型自动提升为取值范围大的类型。

public static void main(String[] args) {
    int i = 1;
    byte b = 2;
   // byte x = b + i; // 报错  
    //int类型和byte类型运算，结果是int类型
    int j = b + i;
    System.out.println(j);
}

转换原理图解

byte 类型内存占有1个字节，在和int类型运算时会提升为int类型，自动补充3个字节，因此计算后的结果还是int类型。

同样道理，当一个int类型变量和一个double变量运算时，int类型将会自动提升为double类型进行运算。

public static void main(String[] args) {
    int i = 1;
    double d = 2.5;
    //int类型和double类型运算，结果是double类型
    //int类型会提升为double类型
    double e = d+i;
    System.out.println(e);
}

转换规则

boolean类型不参与转换。
取值范围小的类型向范围大的类型提升：

byte、short、char‐‐>int‐‐>long‐‐>float‐‐>double

byte 、short、char之间不相互转换，运算时直接提升成int类型参与运算。

1.2 强制转换

将1.5赋值到int类型变量会发生什么？产生编译失败，肯定无法赋值。

int i = 1.5; // 错误

double 类型内存8个字节，int类型内存4个字节。1.5是double类型，取值范围大于 int 。可以理解为double是8升的水壶， int 是4升的水壶，不能把大水壶中的水直接放进小水壶去。

想要赋值成功，只有通过强制类型转换，将double类型强制转换成int类型才能赋值。

强制类型转换 ：将取值范围大的类型强制转换成取值范围小的类型。
可能会有精度的损失，一般不建议这样使用。
比较而言，自动转换是Java自动执行的，而强制转换需要我们自己手动执行。

转换格式：

目标数据类型 变量名 = （目标数据类型）被转换的数据；

将1.5赋值到int类型，代码修改为：

// double类型数据强制转成int类型，直接去掉小数点。
int i = (int)1.5;

同样道理，当一个short类型与1相加，我们知道会类型提升，但是还想给结果赋值给short类型变量，就需要强制转换。

public static void main(String[] args) {
     //short类型变量，内存中2个字节
     short s = 1;
     /*
       出现编译失败
       s和1做运算的时候，1是int类型，s会被提升为int类型
       s+1后的结果是int类型，将结果在赋值会short类型时发生错误
       short内存2个字节，int类型4个字节
       必须将int强制转成short才能完成赋值
     */
     s = s + 1；//编译失败
     s = (short)(s+1);//编译成功
}

1584516957266

转换原理图解

强烈注意

浮点转成整数，直接取消小数点，可能造成数据损失精度。
int 强制转成short砍掉2个字节，可能造成数据丢失。

// 定义s为short范围内最大值
short s = 32767;
// 运算后，强制转换，砍掉2个字节后会出现不确定的结果
s = (short)(s + 10);

1.3 ASCII 编码表

public static void main(String[] args) {
  //字符类型变量
  char c = 'a';
  int i = 1;
  //字符类型和int类型计算
  System.out.println(c+i);//输出结果是98
}

在计算机的内部都是二进制的0、1数据，如何让计算机可以直接识别人类文字的问题呢？就产生出了编码表的概念。

编码表 ：就是将人类的文字和一个十进制数进行对应起来组成一张表格。

人们就规定：

字符	数值
0	48
9	57
A	65
Z	90
a	97
z	122

将所有的英文字母，数字，符号都和十进制进行了对应，因此产生了世界上第一张编码表 ASCII（American Standard Code for Information Interchange 美国标准信息交换码）。

字符参与运算

是查找ASCII里面的值：

字符	ASCII值
'a'	97
'A'	65
'0'	48

小贴士：

在char类型和int类型计算的过程中，char类型的字符先查询编码表，得到97，再和1求和，结果为98。char类型提升为了int类型。char类型内存2个字节，int类型内存4个字节。

/*
强制类型转换
	1. 特点：代码需要进行特殊的格式处理，不能自动完成。
	2. 格式：范围小的类型 范围小的变量名 = (范围小的类型) 原本范围大的数据;

注意事项：
	1. 强制类型转换一般不推荐使用，因为有可能发生精度损失、数据溢出。
	2. byte/short/char这三种类型都可以发生数学运算，例如加法“+”.
	3. byte/short/char这三种类型在运算的时候，都会被首先提升成为int类型，然后再计算。
	4. boolean类型不能发生数据类型转换
*/
public class Demo02DataType {
	public static void main(String[] args) {
		// 左边是int类型，右边是long类型，不一样
		// long --> int，不是从小到大
		// 不能发生自动类型转换！
		// 强制转换格式：范围小的类型 范围小的变量名 = (范围小的类型) 原本范围大的数据;
		int num = (int) 100L;
		System.out.println(num);
		
		// long强制转换成为int类型
		int num2 = (int) 6000000000L;
		System.out.println(num2); // 1705032704
		
		// double --> int，强制类型转换
		int num3 = (int) 3.99;
		System.out.println(num3); // 3，这并不是四舍五入，而是所有的小数位都会被舍弃掉
		
		char zifu1 = 'A'; // 这是一个字符型变量，里面是大写字母A
		System.out.println(zifu1 + 1); // 66，也就是大写字母A被当做65进行处理
		// 计算机的底层会用一个数字（二进制）来代表字符A，就是65
		// 一旦char类型进行了数学运算，那么字符就会按照一定的规则翻译成为一个数字
		
		byte num4 = 40; // 注意！右侧的数值大小不能超过左侧的类型范围
		byte num5 = 50;
		// byte + byte --> int + int --> int
		int result1 = num4 + num5;
		System.out.println(result1); // 90
		
		short num6 = 60;
		// byte + short --> int + int --> int
		// int强制转换为short：注意必须保证逻辑上真实大小本来就没有超过short范围，否则会发生数据溢出
		short result2 = (short) (num4 + num6);
		System.out.println(result2); // 100
	}
}

第二章运算符

2.1 算数运算符

算数运算符包括：
+	加法运算，字符串连接运算
-	减法运算
*	乘法运算
/	除法运算
%	取模运算，两个数字相除取余数
++、 --	自增自减运算

Java中，整数使用以上运算符，无论怎么计算，也不会得到小数。

例：1234 / 1000 = 1  （因为1234为int类型，没有小数1*1000 = 1000）

public static void main(String[] args) {
   int i = 1234; 
   System.out.println(i/1000*1000);//计算结果是1000  
}

++ 运算，变量自己增长1。反之，--运算，变量自己减少1，用法与++一致。
- 独立运算：
  - 变量在独立运算时，前 ++和后 ++没有区别。
  - 变量前 ++：例如 ++i。
  - 变量后 ++：例如 i++。
- 混合运算：
  - 和其他变量放在一起，前 ++和后 ++就产生了不同。
  - 变量前 ++：变量a自己加1，将加1后的结果赋值给b，也就是说a先计算。a和b的结果都是2。
```
public static void main(String[] args) {
    int a = 1;
    int b = ++a;
    System.out.println(a);//计算结果是2
    System.out.println(b);//计算结果是2
}
```
  - 变量后 ++：变量a先把自己的值1，赋值给变量b，此时变量b的值就是1，变量a自己再加1。a的结果是2，b的结果是1。
```
public static void main(String[] args) {
    int a = 1;
    int b = a++;
    System.out.println(a);//计算结果是2
    System.out.println(b);//计算结果是1
}
```

/*
注意事项：
	1. 一旦运算当中有不同类型的数据，那么结果将会是数据类型范围大的那种。
	2.两个常量之间可以进行数学运算
	3.两个变量之间也可以进行数学运算
	4.变量和常量之间可以混合使用
*/
public class Demo04Operator {
	public static void main(String[] args) {
		// 两个常量之间可以进行数学运算
		System.out.println(20 + 30);
		
		// 两个变量之间也可以进行数学运算
		int a = 20;
		int b = 30;
		System.out.println(a - b); // -10
		
		// 变量和常量之间可以混合使用
		System.out.println(a * 10); // 200
		
		int x = 10;
		int y = 3;
		
		int result1 = x / y;
		System.out.println(result1); // 3
		
		int result2 = x % y;
		System.out.println(result2); // 余数，模，1
		
		// int + double --> double + double --> double
		double result3 = x + 2.5;
		System.out.println(result3); // 12.5
	}

+符号在字符串中的操作：
- +符号在遇到字符串的时候，表示连接、拼接的含义。
- "a"+"b" 的结果是“ab”，连接含义
```
public static void main(String[] args){
  System.out.println("5+5="+5+5);//输出5+5=55
}
```

/*
四则运算当中的加号“+”有常见的三种用法：

1. 对于数值来说，那就是加法。
2. 对于字符char类型来说，在计算之前，char会被提升成为int，然后再计算。
char类型字符，和int类型数字，之间的对照关系表：ASCII、Unicode
3. 对于字符串String（首字母大写，并不是关键字）来说，加号代表字符串连接操作。
任何数据类型和字符串进行连接的时候，结果都会变成字符串
*/
public class Demo05Plus {
	public static void main(String[] args) {
		// 字符串类型的变量基本使用
		// 数据类型 变量名称 = 数据值;
		String str1 = "Hello";
		System.out.println(str1); // Hello
		
		System.out.println("Hello" + "World"); // HelloWorld
		
		String str2 = "Java";
		// String + int --> String
		System.out.println(str2 + 20); // Java20
		
		// 优先级问题
		// String + int + int
		// String		+ int
		// String
		System.out.println(str2 + 20 + 30); // Java2030
		
		System.out.println(str2 + (20 + 30)); // Java50
	}
}

2.2 赋值运算符

赋值运算符包括：
=	等于号
+=	加等于
-=	减等于
*=	乘等于
/=	除等于
%=	取模等

赋值运算符，就是将符号右边的值，赋给左边的变量。
扩展的赋值运算符的特点：隐含了自动强制转换。

public static void main(String[] args){
     int i = 5;
     i+=5;//计算方式 i=i+5 变量i先加5，再赋值变量i
     System.out.println(i); //输出结果是10
  }

2.3 比较运算符

比较运算符包括：
`==`	比较符号两边数据是否相等，相等结果是true。
`<`	减等于比较符号左边的数据是否小于右边的数据，如果小于结果是true。
`>`	比较符号左边的数据是否大于右边的数据，如果大于结果是true。
`<=`	比较符号左边的数据是否小于或者等于右边的数据，如果小于结果是true。
`=`	比较符号左边的数据是否大于或者等于右边的数据，如果小于结果是true。
`！=`	不等于符号，如果符号两边的数据不相等，结果是true。

比较运算符，是两个数据之间进行比较的运算，运算结果都是布尔值true或者false。

public static void main(String[] args) {
    System.out.println(1==1);//true
    System.out.println(1<2);//true
    System.out.println(3>4);//false
    System.out.println(3<=4);//true
    System.out.println(3>=4);//false
    System.out.println(3!=4);//true
}

2.4 逻辑运算符

逻辑运算符包括：
`&&` 短路与	1. 两边都是true，结果是true; 2. 一边是false，结果是false; 短路特点：符号左边是false，右边不再运算
`
`！` 取反	1. ! true 结果是false;2. ! false结果是true

逻辑运算符，是用来连接两个布尔类型结果的运算符，运算结果都是布尔值true或者 false

public static void main(String[] args)  {
      System.out.println(true && true);//true
      System.out.println(true && false);//false
      System.out.println(false && true);//false，右边不计算

    System.out.println(false || false);//falase
    System.out.println(false || true);//true
    System.out.println(true || false);//true，右边不计算

    System.out.println(!false);//true
}

2.5 三元运算符

三元运算符格式：

数据类型 变量名 = 布尔类型表达式？结果1：结果2

三元运算符计算方式：
- 布尔类型表达式结果是 true，三元运算符整体结果为结果1，赋值给变量。
- 布尔类型表达式结果是 false，三元运算符整体结果为结果2，赋值给变量。

public static void main(String[] args) {
    int i = (1==2 ? 100 : 200);
    System.out.println(i);//200
    int j = (3<=4 ? 500 : 600);
    System.out.println(j);//500
}

第三章方法入门

3.1 概述

我们在学习运算符的时候，都为每个运算符单独的创建一个新的类和main方法，我们会发现这样编写代码非常的繁琐，而且重复的代码过多。能否避免这些重复的代码呢，就需要使用方法来实现。

方法：就是将一个功能抽取出来，把代码单独定义在一个大括号内，形成一个单独的功能。

当我们需要这个功能的时候，就可以去调用。这样即实现了代码的复用性，也解决了代码冗余的现象。

3.2 方法的定义

定义格式：

修饰符 返回值类型 方法名 （参数列表）｛
        代码...   
        return ;
}

定义格式解释：
- 修饰符：目前固定写法 public static。
- 返回值类型：目前固定写法 void，其他返回值类型在后面的课程讲解。
- 方法名：为我们定义的方法起名，满足标识符的规范，用来调用方法。
- 参数列表：目前无参数，带有参数的方法在后面的课程讲解。
- return ：方法结束。因为返回值类型是void，方法大括号内的return可以不写。
举例：

public static void methodName() {
   System.out.println("这是一个方法");  
}

3.3 方法的调用

方法在定义完毕后，方法不会自己运行，必须被调用才能执行，我们可以在主方法main中来调用我们自己定义好的方法。在主方法中，直接写要调用的方法名字就可以调用了。

public static void main(String[] args) {
    //调用定义的方法method
    method();
}
//定义方法，被main方法调用
public static void method() {
   System.out.println("自己定义的方法，需要被main调用运行");  
}

3.4 调用练习

将三元运算符代码抽取到自定义的方法中，并调用。

public static void main(String[] args) {
    //调用定义的方法operator
    operator();
}
//定义方法，方法中定义三元运算符
public static void operator() {
    int i = 0;
    i = (1==2 ? 100:200);
    System.out.println(i);
    int j = 0 ;
    j = (3<=4 ? 500:600);
    System.out.println(j);
}

3.5 注意事项

方法定义注意事项：
- 方法必须定义在一类中方法外
- 方法不能定义在另一个方法的里面

方法体：也就是大括号当中可以包含任意条语句。
方法名称的命名规则和变量一样。（建议使用小驼峰式）
方法定义的先后顺序无所谓。调用中，分先后顺序。
方法定义好了之后，不会执行的。如果要执行，一定要进行方法的[调用]。

public class Demo {
    public static void main(String[] args){
    }
    //正确写法，类中，main方法外面可以定义方法
    public static void method(){}
}

main也是一个方法，它可以调用其他方法，但是不能在它这个方法里定义其他的方法。

任何方法，都不能定义在另一个方法里面，只能定义在一类中的方法外。

public class Demo {
    public static void main(String[] args){
        //错误写法，一个方法不能定义在另一方法内部
        public static void method(){}
    }
}

第四章 JShell脚本工具

JShell脚本工具是JDK9的新特性

什么时候会用到JShell工具呢，当我们编写的代码非常少的时候，而又不愿意编写类，main方法，也不愿意去编译和运行，这个时候可以使用JShell工具。

启动JShell工具，在DOS命令行直接输入JShell命令。退出Jshell工具时，在jshell > 后面输入/exit（有斜杠）即可退出。

接下来可以编写Java代码，无需写类和方法，直接写方法中的代码即可，同时无需编译和运行，直接回车即可退出。

小贴士:
JShell工具，只适合片段代码的测试，开发更多内容，建议编写在方法中。

第五章扩展知识点

5.1 += 符号的扩展（强制转换）

下面的程序有问题吗？

public static void main(String[] args){
  short s = 1;
  s+=1;
    //注意 s = s + 1 和 s += 1 的区别，后者的“ += ”带有强制转换的特点。
  System.out.println(s);
}

分析： s += 1逻辑上看作是 s = s + 1，这里，普通的 s = s + 1是进行两次运算，计算结果是被提升为int类型，再向short类型赋值时会发生错误，因为不能将取值范围大的类型赋值到取值范围小的类型。但是， s += 1中的+=是一个运算符，它只运算一次，并带有强制转换的特点，也就是说s += 1等价于s = (short)(s + 1)，因此程序没有问题，编译通过，运行结果是2。

5.2 常量和变量的运算

下面的程序有问题吗？

public static void main(String[] args){
  byte b1=1;
  byte b2=2;
  byte b3=1 + 2;
  byte b4=b1 + b2;
  System.out.println(b3);
  System.out.println(b4);
}

分析：b3 = 1 + 2， 1 和 2是常量，为固定不变的数据，在编译的时候（编译器javac），已经确定了1+2的结果并没有超过byte类型的取值范围，可以赋值给变量b3，因此b3=1 + 2是正确的。
反之，b4 = b2 + b3，b2和 b3是变量，变量的值是可能变化的，在编译的时候，编译器javac不确定b2+b3的结果是什么，因此会将结果以int类型进行处理，所以int类型不能赋值给byte类型，因此编译失败。

在jshell中体现：

ASCII 码表

ASCII值	控制字符	ASCII值	控制字符	ASCII值	控制字符	ASCII值	控制字符
0	NUT	32	(space)	64	@	96	、
1	SOH	33	！	65	A	97	a
2	STX	34	”	66	B	98	b
3	ETX	35	#	67	C	99	c
4	EOT	36	$	68	D	100	d
5	ENQ	37	%	69	E	101	e
6	ACK	38	&	70	F	102	f
7	BEL	39	,	71	G	103	g
8	BS	40	(	72	H	104	h
9	HT	41	)	73	I	105	i
10	LF	42	*	74	J	106	j
11	VT	43	+	75	K	107	k
12	FF	44	,	76	L	108	l
13	CR	45	-	77	M	109	m
14	SO	46	.	78	N	110	n
15	SI	47	/	79	O	111	o
16	DLE	48	0	80	P	112	p
17	DCI	49	1	81	Q	113	q
18	DC2	50	2	82	R	114	r
19	DC3	51	3	83	X	115	s
20	DC4	52	4	84	T	116	t
21	NAK	53	5	85	U	117	u
22	SYN	54	6	86	V	118	v
23	TB	55	7	87	W	119	w
24	CAN	56	8	88	X	120	x
25	EM	57	9	89	Y	121	y
26	SUB	58	:	90	Z	122	z
27	ESC	59	;	91	[	123	{
28	FS	60	<	92	/	124	\|
29	GS	61	=	93	]	125	}
30	RS	62	>	94	^	126	~
31	US	63	?	95	—	127	DEL


NUL	空	VT	垂直制表	SYN	空转同步
SOH	标题开始	FF	走纸控制	ETB	信息组传送结束
STX	正文开始	CR	回车	CAN	作废
ETX	正文结束	SO	移位输出	EM	纸尽
EOY	传输结束	SI	移位输入	SUB	换置
ENQ	询问字符	DLE	空格	ESC	换码
ACK	承认	DC1	设备控制1	FS	文字分隔符
BEL	报警	DC2	设备控制2	GS	组分隔符
BS	退一格	DC3	设备控制3	RS	记录分隔符
HT	横向列表	DC4	设备控制4	US	单元分隔符
LF	换行	NAK	否定	DEL	删除

posted @ 2020-06-06 19:10 卡洛蒙阅读(270) 评论(0) 收藏举报

刷新页面返回顶部

卡洛蒙

1、【Java基础、常用DOS命令、数据类型、运算符、方法入门】

day01 【前言、入门程序、常量、变量】

今日内容

教学目标

第一章 开发前言

1.1 Java 语言概述

什么是Java语言

编译型和解释型语言的区别

Java特性和优势

Java语言发展历史

Java三大版本

Java语言能做什么

1.2 计算机基础知识

什么是计算机

硬件及冯诺依曼结构

Windows常用快捷键

进制

二进制

进制转换(了解)

字节

打开CMD的方式

管理员方式运行cmd

常用DOS命令

常用DOS命令（来自Windows CMD-help）

第二章 Java语言开发环境搭建

2.1 Java虚拟机——JVM

2.2 JDK,JRE,JVM的作用及关系(掌握)

2.3 JDK9 安装图解

2.4 JAVA_HOME 环境变量的配置

配置环境变量作用

配置环境变量步骤

Windows 7,8版本

Windows 10 版本

第三章 HelloWorld入门程序

3.1 程序开发步骤说明

3.2 编写Java源程序

3.3 编译Java源文件

3.4 运行Java程序

3.5 入门程序说明

编译和运行是两回事

关于main方法

3.6 添加注释comment

3.7 关键字keywords

3.8 标识符

第四章 常量

4.1 概述

4.2 分类

4.3 练习

第五章 变量和数据类型

5.1 变量概述

5.2 数据类型

数据类型分类

基本数据类型

引用数据类型

5.3 变量的定义

5.4 注意事项

day02 【数据类型转换、运算符、方法入门】

今日内容

教学目标

第一章 数据类型转换

1.1 自动转换

转换原理图解

转换规则

1.2 强制转换

转换原理图解

强烈注意

1.3 ASCII 编码表

字符参与运算

第二章 运算符

2.1 算数运算符

2.2 赋值运算符

2.3 比较运算符

2.4 逻辑运算符

2.5 三元运算符

第三章 方法入门

3.1 概述

3.2 方法的定义

3.3 方法的调用

3.4 调用练习

第一章开发前言

第四章常量

第五章变量和数据类型

第一章数据类型转换

第二章运算符

第三章方法入门

第五章扩展知识点