万字文肝Java基础知识
Posted Amo Xiang
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了万字文肝Java基础知识相关的知识，希望对你有一定的参考价值。
一、 前言、入门程序、常量
1.1 Java 语言概述。
Java 是一种高级编程语言，而且是面向对象的编程语言。Java 语言是美国 Sun 公司(Stanford University Network)，在 1995 年推出的高级的编程语言。Java 语言共同创始人之一：詹姆斯·高斯林 (James Gosling)，被称为 Java之父。Java 语言的版本：1.0-1.4，5.0…8.0…13.0，本文笔记用的 jdk 版本为 8.0。
1.2 Java 语言能做什么
Java 语言主要应用在互联网程序的开发领域，网上购物商城、物流、金融、各行各业的门户网站。
1.3 Java 语言的跨平台实现原理
(1) JVM: Java 虚拟机，是专门用来运行 Java 程序的。
(2) 平台：指的就是操作系统，比如 Windows、linux、MacOS 等。
(3) 跨平台: 我们编写的一个 Java 程序，可以做多个操作系统上运行一次编译，到处运行。
(4) 问题思考，如下：
1. Java 程序是跨平台的? ⇒ 正确的 ⇒ 一次编译到处运行。
2. JVM 是跨平台的? ⇒ 错误的 ==> JVM 是实现 Java 程序跨平台的基石。针对不同的操作系统提供不同的 JVM。
而程序在 JVM 中运行。
3. Java 程序的跨平台是依靠 JVM 的不跨平台实现的。正确的
1.4 JDK、JRE、JVM 的组成和作用
- JVM: Java 虚拟机，是专门用来运行 Java 程序的，但是不能单独安装。
- JRE: Java 运行环境，包含 JVM(Java 虚拟机，是专门用来运行 Java 程序的)和核心类库。
- JDK: Java 开发工具包，包含 JRE 和开发工具。
- 三者关系： JDK > JRE > JVM
1.1 Java 语言开发环境搭建
JDK 安装，注意事项：
- 注意操作系统是 Windows、linux、MacOS
- 注意操作系统的位数是 32 位还是 64 位
- 安装 java 相关软件的时候: 安装路径中不允许出现中文和空格(任何开发软件都最好不要安装在中文路径下)
由于安装步骤截图较多，但比较简单，网上一大把，笔者这里就不再赘述，如果有问题，可以私聊笔者！
1.2 常用 DOS 命令的使用
键盘图示如下：
如何进入DOS 命令操作窗口?
-
开始/命令提示符
-
开始/搜索程序和文件 输入 cmd
-
Windows 键 + R --> 输入 cmd
-
窗口空白处/按住 shift 键 + 鼠标右键单击 /在此处开命令窗口
-
常用命令如下表所示：
操作 说明 盘符名称 盘符切换。D: 回车，表示切换到D盘 dir 查看当前路径下的内容 cd 目录 进入单级目录 cd 目录1\\目录2… 进入多级目录 cd … 回退到上一级目录 cd \\ 回退到盘符目录 cls 清屏 exit 退出命令提示窗口
1.3 环境变量 JAVA_HOME 的配置
记事本软件的启动方式?
1.开始/程序/附件/记事本
2.C:/windows/找到notepad.exe命令,双击启动
3.如果在DOS窗口的命令中:
C:\\windows> notepad.exe 回车 运行这个命令
首先在C:\\windows路径下,寻找是否存在notepad.exe,发现有,直接运行
D:\\abc> notepad.exe 回车 运行这个命令
首先:在 D:\\abc 路径下,寻找是否存在 notepad.exe,发现没有
其次: 如果发现在当前路径 D:\\abc 没有要运行的 notepad.exe 命令,到系统环境变量 path 中寻找
path:... C:\\Windows;...,发现path中配置的路径 C:\\Windows 有该命令,直接运行.
如果path中配置的所有的路径中都没有要运行的命令,运行报错了.
给Java配置环境变量的意义/目的/作用?
让我们可以在任意路径下运行java开发的相关工具(javac: 编译工具,java: 运行工具)
比如jdk的安装路径:C:\\develop\\Java\\jdk1.8.0_162
配置步骤:
1.创建名称为 JAVA_HOME 的环境变量,取值是 C:\\develop\\Java\\jdk1.8.0_162
2.把步骤1中创建的名称为 JAVA_HOME 的环境变量,添加到系统环境变量 path 中
找到系统环境变量path, 在前面添加: %JAVA_HOME%\\bin;...
3.如果在DOS窗口的命令中:
C:\\develop\\Java\\jdk1.8.0_162\\bin> javac.exe 回车 运行这个命令
首先在C:\\develop\\Java\\jdk1.8.0_162\\bin路径下,寻找是否存在javac.exe,发现有,
直接运行
D:\\abc> javac.exe 回车 运行这个命令 首先:在D:\\abc路径下,寻找是否存在javac.exe,发现没有
其次: 如果发现在当前路径 D:\\abc 没有要运行的 javac.exe 命令,到系统环境变量path中寻找
path:... %JAVA_HOME%\\bin;..., 发现 path 中配置的名称为 JAVA_HOME 的环境变量,对应的路径
C:\\develop\\Java\\jdk1.8.0_162\\bin 中有要运行的 javac.exe 命令,直接运行,
如果 path 中配置的所有路径中,都没有要运行的 javac.exe 命令,运行报错了
寻找名称为JAVA_HOME的环境变量,找到后,使用其配置的具体路径进行替换:
path:... C:\\develop\\Java\\jdk1.8.0_162\\bin;...,
替换后的路径: C:\\develop\\Java\\jdk1.8.0_162\\bin 中有 javac 命令,就可以直接运行
二、HelloWorld 入门程序
2.1 程序开发的步骤
1. 源程序：
- 程序员写的程序；
- 程序员在自己可以看得懂得程序；
- 程序：字母、数字、其他符号；
源程序是程序员编写的，程序员自己可以看得懂得程序，本质就是一个文本文件，但是扩展名不是 .txt，而是 .java。
2. 生产JVM可以执行的字节码(.class)文件
- JVM：叫做 Java 虚拟机，是专门用来运行 Java 程序的。但是 JVM 是一个二货，只能识别 0 和 1，而存储 0 和 1 的文件叫做 字节码文件(.class文件)
- 如何把源文件(程序)翻译成JVM能够执行的字节码文件(程序)呢? 使用 javac 命令(编译命令)， 使用格式：javac 文件名.java 例如：编译HelloWorld.java 源文件: javac HelloWorld.java，生成一个字节码文件：HelloWorld.class
3. 把字节码文件交给JVM执行
不管是源文件(程序)还是字节码文件(程序)都存储在硬盘中? 不会自动执行，如何把字节码文件交给 JVM 执行呢? 使用 java 命令(运行命令)。 使用格式: java 文件名 例子：java HelloWorld
2.2 HelloWorld 案例的编写编译运行
1. 编写源文件。 创建一个名称为 HelloWorld.txt 的文本文件，把扩展名修改为 .java，打开 HelloWorld.java 源文件，输入以下内容，并保存(ctrl+s)。
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello World!");
}
}
2. 编译: javac命令。 根据 .java源文件 生产对应的 .class文件(字节码文件)。 使用 javac 命令的格式：javac 文件名.java。javac HelloWorld.java。注意：
- 保证当前路径下 javac命令 可以使用。
- 保证当前路径下有要进行编译的 源(.java)文件。
- 使用编译javac命令时，文件名后面必须写 扩展名.java。
3.运行: java命令。 把 字节码(.class)文件 交给 jvm 执行。使用 java 命令的格式：java 文件名，java HelloWorld，同样要注意：
- 保证当前路径下 java 命令 可以使用。
- 保证当前路径下有要进行运行的 字节码(.class)文件。
- 使用运行 java 命令 时，文件名后面不能写 扩展名.class。
2.3 初学者编写 HelloWorld 常见问题
- 非法字符问题。Java 中的符号都是英文格式的。
- 大小写问题。Java 语言对 大小写敏感(区分大小写)。
- 在系统中显示文件的扩展名，避免出现 HelloWorld.java.txt 文件。
- 编译命令后的 java文件名需要带文件后缀 .java。
- 运行命令后的 class文件名(类名) 不带文件 后缀.class。
- 不要把 main 写成 mian。
2.4 Notepad++ 软件的安装和配置
软件下载地址：
链接：https://pan.baidu.com/s/15DaxTdbiVqGVjrRlU2lXbQ
提取码：6y7p
--来自百度网盘超级会员V6的分享
三、注释和关键字
3.1 注释
概念： 在代码中添加注释可提高代码的可读性。注释中包含了程序的信息，可以帮助程序员更好地阅读和理解程序。在 Java 源程序文件 的任意位置都可以添加注释，且 Java 编译器不编译代码中的注释，也就是说代码中的注释对程序不产生任何影响。所以开发者不仅可以在注释中编写代码的说明文字、设计者的个人信息，还可以使用注释来屏蔽某些不希望执行的代码。
分类： Java 提供了 3 种代码注释，分别为单行注释、多行注释和文档注释。
1、单行注释：// 为单行注释标记，从符号 // 开始直到换行为止的所有内容均作为注释而被编译器忽略。语法格式如下：
// 注释内容
int age ; // 声明int型变量，用于保存年龄信息
2、多行注释： /* */ 为多行注释标记，符号 /* 与 */ 之间的所有内容均为注释内容。注释中的内容可以换行。语法格式如下：
/*
注释内容1
注释内容2
…
*/
3、文档注释： /**…*/ 为文档注释标记。符号 /** 与 */ 之间的内容均为文档注释内容。当文档注释出现在声明(如类的声明、类的成员变量声明、类的成员方法声明等)之前时，会被 Javadoc 文档工具 读取作为 Javadoc 文档内容。文档注释的格式与多行注释的格式相同。对于初学者而言，文档注释并不是很重要，了解即可。示例如下：
说明：一定要养成良好的编码习惯。软件编码规范中提到 可读性第一，效率第二，所以程序员必须要在程序中添加适量的注释来提高程序的可读性和可维护性。建议程序中的注释总量要占程序代码总量的 20%~50%。
3.2 关键字
引入：邮箱: @前面是用户名，@后面是使用的是哪家的邮箱。
zhangsan@163.com 正确的
zhangsan@qq.com 正确的
zhangsan_nigulasi@qq.com 正确的
zhangsan@nigulasi@qq.com 错误的
@理解为在邮箱当中具有特殊的含义和使用方式，不能胡乱用，看做邮箱名称中的关键字
换而言之，关键字是 Java 中已经被赋予特定意义的一些单词，不可以把这些字作为标识符来使用。关键字中的所有字母都是小写的，或者在高级编辑器中彩色显示。
Java中的关键字如下表所示：
| int | public | this | finally | boolean | abstract |
|---|---|---|---|---|---|
| continue | float | long | short | throw | throws |
| return | break | for | static | new | interface |
| if | goto | default | byte | do | case |
| strictfp | package | super | void | try | switch |
| else | catch | implements | private | final | class |
| extends | volatile | while | synchronized | instanceof | char |
| proteced | import | transient | dafault | double |
3.3 标识符
标识符可以简单地理解为一个名字，用来标识类名、变量名、方法名、数组名等的有效字符序列。Java 规定标识符由 任意顺序的字母、下划线(_)、美元符号($)和数字组成，并且第一个字符不能是数字。标识符不能是 Java 中的保留关键字。 示例：
// 合法标识符如下：
time
akb48
_interface
O_o
BMW
$$$
// 下面这些都不是合法的标识符：
300warrior // 不可以用数字开头
public // 不可以使用关键字
User Name // 不可以用空格断开
常见错误：用中文命名标识符是非常不好的编码习惯。当编译环境的字符编码集发生改变后，代码中所有的中文标识符全部会显示成乱码，程序将无法维护。因为 Java 是一种可以跨平台的开发语言，所以发生中文标识符显示成乱码这种情况的概率非常大。编写 Java 代码有一套公认的命名规范：
- 类名：通常使用名词，第一个单词字母必须大写，后续单词首字母大写。(大驼峰式)
- 方法名：通常使用动词，第一个单词首字母小写，后续单词首字母大写。(小驼峰式)
- 变量：第一个单词首字母小写，后续单词首字母大写。(小驼峰式)
- 常量：所有字母均大写。
- 单词的拼接：通常使用 userLastName 方式拼接单词，而不是 user_last_name。
四、常量与变量
4.1 常量的概念和分类
引入：
数学中有常数的概念：
y = x + 5; //数字5是一个常数,其值不可以发生改变
b = a + 5.5; //数字5.5是一个常数,其值不可以发生改变
数学中对常数进行了分类：
数字5是一个整数常数, 其值不可以发生改变
数字5.5是一个小数数常数, 其值不可以发生改变
数学中的常数，对应到 java 中叫常量，数学中的常数有分类，java 中的常量也有分类，而且比数学中的分类更加丰富。
1、概念： 在程序的执行过程中，其值不可以发生改变的量。
2、分类：
-
整数常量：1314、520
-
小数常量：13.14、5.20
-
字符常量：java 中规定字符常量必须使用单引号
''引起来，而且单引号''中只能写一个字符(不能不写，也不能写2个以上) 举例：A:'a' 正确的 B: '' 里面什么都没有写,错误的 C:' ' 里面有一个空格,正确的 D:'ab' 错误的 E: '好' 正确的 F: '女子' 错误的 -
布尔常量：只有两个值 true 和 false。true：表示肯定的，对的，是的，正确的，成立的。false：表示否定的，错的，不是的，却无的，不成立的。
-
字符串常量：java 中规定字符串常量必须使用双引号
""引起来，而且双引号""中可以写多个字符(0个、1个、2个…)， 举例：A:"a" 正确的 B: "" 里面什么都没有写 正确的 C:" " 里面有一个空格 正确的 D："ab" 正确的 E："好" 正确的 F："女子"正确的 -
空常量：null
4.2 打印不同类型的常量
同 C语言 一样，Java 程序想要在控制台输出文字，需要调用一个已有的方法，方法如下：
System.out.print("Hello!"); // 此方法输出"Hello"后不会自动换行，光标停留同一行的末尾
但与 C语言 不同的是，Java 又提供了一个输出文字后自动换行的方法，这个方法在原有的 print 后面加上了 ln 后缀，方法如下：
System.out.println("Hello!"); // 此方法输出"Hello"后会自动换行，光标停留下一行的开头
打印不同类型的常量，示例如下：
public class SystemOutDemo {
public static void main(String[] args) {
//你之前怎么写常量的，就直接在println()小括号中怎么写，就可以在控制台输出指定的常量。
//(1)整数常量:1314 520
System.out.println(1314);
System.out.println(520);
//(2)小数常量: 13.14 5.20
System.out.println(13.14);
System.out.println(5.20);
//(3)字符常量:
System.out.println('a');
//System.out.println('');//错误的: ''不能没有字符
System.out.println(' ');//正确的: ' '有一个空格
System.out.println('好');//正确的: ' '有一个空格
//System.out.println('女子');//错误的: '女子'不能写2个及以上的字符
//(4)字符串常量
System.out.println("a");
System.out.println("");
System.out.println(" ");
System.out.println("ab");
System.out.println("好想你");
System.out.println("女子");
//(5)布尔常量
System.out.println(true);
System.out.println(false);
//(6)空常量
//System.out.println(null);//错误: 不能直接打印空常量null
}
}
4.3 变量和数据类型【重要】
引入：
数学中有个常数的概念：
y = x + 10; //整数数字10是不可以发生变化的
b = a + 6.6; //小数数字6.6是不可以发生变化的
数学中的数字(常量)是有分类的,对应java中的常量也是有分类的,之前已经说过
x,y 是可以发生变化的
x: 2 y: 12、x: 6 y: 16，x,y 中的数据是可以发生变化的,而且x,y内部的数据也是有类型(整数)
a,b 是可以发生变化的
a: 2.2 b: 8.8、a: 3.3 b: 9.9 a,b 中的数据是可以发生变化的,而且 a,b 内部的数据也是有类型(小数)
像x,y,a,b 这样东西,里面的数据是可以发生变化的,而且数据是有类型的,我们把这样的东西称为变量(容器: 里面只能放一个数据)
变量为什么要有这么多的分类: 不同的分类,占用的字节数不同,取值范围就不同,使用的场景也就不同
1、变量概念： 在程序的执行过程中，其值可以在一定范围内发生改变的量。可以把变量理解成为一个 容器，例如一个空烧杯，给变量赋值就相当于给烧杯倒水。如下图所示的那样，变量可以不断更换值，就像烧杯可以反复使用一样：
2、分类：
1.整数：
byte 1个字节 -128到127
short 2个字节 正负3万多
int 4个字节 正负21亿 整数默认int类型
long 8个字节 大概19位数字 表示long类型数据后面需要加 L/l
2.小数：
float 4个字节 表示float数据后面需要加 F/f
注意: 虽然float占4个字节,但是由于采用科学计数法,取值范围远远超过long
double 8个字节 小数默认double类型
3.字符：
char 2个字节
4.布尔：
boolean 1个字节 取值为true或者false
3、变量定义格式图解分析：
变量的理解：
1.变量的本质就是内存中的一块空间,空间的大小由数据类型决定。
2.要想找到变量对应的内存空间的数据,需要给变量对应的内存空间起个名字,叫做变量名称。对于变量的命名并不是任意的，
应遵循以下几条规则：
a.变量名必须是一个有效的标识符。
b.变量名不可以使用 Java 中的关键字。
c.在同一个大括号范围内,变量名不能重复。
d.应选择有意义的单词作为变量名。
说明：在 Java 中允许使用汉字或其他语言文字作为变量名，如 **int 年龄 = 21;** 在程序运行时不会出现错误，但建议尽量不要使用
这些语言文字作为变量名。
3.变量对应的内存空间中必须有数据才能使用,这种向变量内存空间中,存储数据的过程叫做初始化或者赋值
变量的定义格式一(先挖坑,然后种萝卜):
数据类型 变量名称;//先挖坑
变量名称 = 数据值;//再种萝卜
变量的定义格式二(挖坑,同时种萝卜):
数据类型 变量名称 = 数据值;//挖坑,同时种萝卜
变量的定义格式三(先挖多个坑,然后分别向每个坑中种萝卜):
数据类型 变量名称1,变量名称2,变量名称3;//先挖多个坑
变量名称1 = 数据值1;//向第一个坑中种萝卜
变量名称2 = 数据值2;//向第二个坑中种萝卜
变量名称3 = 数据值3;//向第三个坑中种萝卜
变量的定义格式四(挖多个坑,同时分别向每个坑中种萝卜):
数据类型 变量名称1 = 数据值1,变量名称2 = 数据值2,变量名称3 =数据值3;
图解：
为什么要声明变量呢？简单地说，就是要告诉编译器这个变量属于哪一种数据类型，这样编译器才知道需要分配多少空间给它，以及它可以存放什么样的数据。
4、定义8种变量1：
public class VariableDemo {
public static void main(String[] args) {
/*
变量的定义格式一(先挖坑,然后种萝卜):
数据类型 变量名称;//先挖坑
变量名称 = 数据值;//再种萝卜
*/
byte a;//挖了一个byte类型(1个字节)的坑,给这个坑起个名字叫a
a = 66;//把数字66存储到byte类型的坑a中
System.out.println(a);//打印byte类型(1个字节)的坑a中的内容: 66
a = 88;//把数字88存储到byte类型的坑a中,原有的数据66将被替换
System.out.println(a);//打印byte类型(1个字节)的坑a中的内容: 88
/*
变量的定义格式二(挖坑,同时种萝卜):
数据类型 变量名称 = 数据值;//挖坑,同时种萝卜
*/
short b = 100;//挖了一个short类型(2个字节)的坑,给这个坑起个名字叫b,同时向这个坑中存储数字100
System.out.println(b);//打印short类型(2个字节)的坑b中的内容: 100
/*
变量的定义格式三(先挖多个坑,然后分别向每个坑中种萝卜):
数据类型 变量名称1,变量名称2,变量名称3;//先挖多个坑
变量名称1 = 数据值1;//向第一个坑中种萝卜
变量名称2 = 数据值2;//向第二个坑中种萝卜
变量名称3 = 数据值3;//向第三个坑中种萝卜
*/
int c, d, e;//挖了三个int类型(4个字节)的坑,给每个坑分别起名为c,d,e
c = 200;//把数字200存储到int类型的坑c中
d = 300;//把数字300存储到int类型的坑d中
e = 500;//把数字500存储到int类型的坑e中
System.out.println(c);//打印int类型(4个字节)的坑c中的内容: 200
System.out.println(d);//打印int类型(4个字节)的坑d中的内容: 300
System.out.println(e);//打印int类型(4个字节)的坑e中的内容: 500
/*
变量的定义格式四(挖多个坑,同时分别向每个坑中种萝卜):
数据类型 变量名称1 = 数据值1,变量名称2 = 数据值2,变量名称3 =数据值3 ;
*/
//挖了三个long类型的坑,名字分别叫做f,g,h
//同时把600L存储到坑f中
//同时把700L存储到坑g中
//同时把800L存储到坑h中
long f = 600L, g = 700L, h = 800L;
System.out.println(f);//打印long类型(8个字节)的坑f中的内容: 600
System.out.println(g);//打印long类型(8个字节)的坑g中的内容: 700
System.out.println(h);//打印long类型(8个字节)的坑h中的内容: 800
}
}
5、定义8种变量2：
public class VariableDemo {
public static void main(String[] args) {
//float类型
//定义float类型变量a,并初始化
//大萝卜不能直接存储到小坑中
//float a = 6.6;//错误: 6.6默认是double类型,占8个字节,不能存储到4个字节的float变量中
float a = 6.6F;
System.out.println(a);//打印变量a中的内容
//double类型
//定义double类型变量b,并初始化
double b = 8.8;
System.out.println(b);//打印变量b中的内容
//char类型
//定义char类型变量c1,并初始化
char c1 = 'a';
System.out.println(c1);//打印变量c1中的内容
//char c2 = '';//错误: ''中不能不写字符
//System.out.println(c2);//打印变量c2中的内容
//char c3 = 'ab';//错误: ''中不能写2个及以上的字符
//System.out.println(c3);//打印变量c3中的内容
//boolean类型: 只能存储true或者false
//定义boolean类型变量d1,并初始化
boolean d1 = true;
System.out.println(d1);//打印变量d1中的内容
d1 = false;//把false存储到变量d1中,原有的数据将被替换
System.out.println(d1);//打印变量d1中的内容
//d1 = 100;//错误: 数据类型不匹配
//System.out.println(d1);//打印变量d1中的内容
}
}
变量的注意事项：定义的变量，不赋值不能使用。定义 long 类型的变量时，需要在整数的后面加 L(大小写均可，建议大写)。同理，定义 float 类型的变量时，需要在小数的后面加 F(大小写均可，建议大写)。
4.4 数据类型转换
类型转换是将一个值从一种数据类型更改为另一种数据类型的过程。例如，可以将 String 类型数据 457 转换为一个数值型，而且可以将任意类型的数据转换为 String 类型。数据类型转换有两种方式，即 隐式转换与显式转换。 如果从低精度数据类型向高精度数据类型转换，则永远不会溢出，并且总是成功的；而把高精度数据类型向低精度数据类型转换则必然会有信息丢失，甚至有可能失败。这种转换规则就像下图所示的两个场景，高精度相当于一个大水杯，低精度相当于一个小水杯，大水杯可以轻松装下小水杯中所有的水，但小水杯无法装下大水杯中所有的水，装不下的部分必然会溢出。
从低级类型向高级类型的转换，系统将自动执行，程序员无须进行任何操作。这种类型的转换称为 隐式转换，也可以称为自动转换。 下列基本数据类型会涉及数据转换(不包括逻辑类型)，这些类型按精度从 “低”到“高” 排列的顺序为 byte < short < int < long < float < double，可对照下图，其中 char 类型比较特殊，它可以与部分 int 型数字兼容，且不会发生精度变化。
隐式转换具体分析如下：
Java 程序中要求参与的计算的数据，必须要保证数据类型的一致性，如果数据类型不一致将发生类型的转换。
int + int
int + long ==> long + long (把int转换成long: 从小到大,自动类型转换,不需要代码的干预)
int + long ==> int + int (把long转成int: 从大到小,强制类型转换,必须手动代码完成)
总结：
1.隐式转换(自动类型转换)概念:
取值范围小的数据或者变量可以直接赋值给取值范围大的变量(小萝卜可以直接放入大坑中)
2.特点:
(1)自动类型转换是自动完成的,不需要代码的干预
(2)byte/short/char类型数据,只要参加运算会自动转换为int类型
(3)byte、short、char-->int-->long-->float-->double
举例：有一个byte类型(1个字节)的数字5: 00000101
byte类型自动类型转换成short类型(2个字节)：在左侧补充1个字节的0,因为左侧补充的都是0,对原有数据是没有影响的,仍然是5,
00000000 00000101
byte类型自动类型转换成int类型(4个字节):
在左侧补充3个字节的0,因为左侧补充的都是0,对原有数据是没有影响的,仍然是5
00000000 00000000 00000000 00000101
byte类型自动类型转换成long类型(8个字节):
在左侧补充7个字节的0,因为左侧补充的都是0,对原有数据是没有影响的,仍然是5
00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000101
总结:根据需求,在数据前面补充若干字节的0,因为补充的都是0,对原有数据大小是没有影响的(打肿脸充胖子)
示例代码1，如下：
public class ConvertDemo {
public static void main(String[] args) {
int i = 1;
byte b = 2;
/*
b是byte类型,i是int类型,运算时类型不一致,会发生自动类型转换
byte类型(1个字节)的b会自动转换成int类型(4个字节):在byte类型的b左侧补充3个字节的0
最终变成了两个int数据相加,结果是int类型(占用4个字节),不能直接赋值给左侧的byte类型的变量x,占用1个字节
大萝卜不能直接放入小坑中
*/
//byte x = b + i;
//System.out.println(x);
/*
b是byte类型,i是int类型,运算时类型不一致,会发生自动类型转换
byte类型(1个字节)的b会自动转换成int类型(4个字节):在byte类型的b左侧补充3个字节的0
最终变成了两个int数据相加,结果是int类型(占用4个字节),可以直接赋值给左侧的int类型的变量y,占用4个字节
大萝卜可以直接放入大坑中
*/
int y = b + i;
System.out.println(y);//3
}
}
示例代码2，如下：
public class ConvertDemo {
public static void main(String[] args) {
int i = 1;
double d = 2.5;
/*
i是int类型,d是double类型,运算时类型不一致,会发生自动类型转换
int类型(4个字节)的i会自动转换成double类型(8个字节): 最终效果就是在整数后面添加.0 比如: 1变成1.0
最终变成了两个double数据相加,结果是double类型(占用8个字节),不能直接赋值给左侧的int类型的变量x,占用4个字节
大萝卜不能直接放入小坑中
*/
//int x = i + d;
//System.out.println(x);
/*
i是int类型,d是double类型,运算时类型不一致,会发生自动类型转换
int类型(4个字节)的i会自动转换成double类型(8个字节): 最终效果就是在整数后面添加.0 比如: 1变成1.0
最终变成了两个double数据相加,结果是double类型(占用8个字节),可以直接赋值给左侧的double类型的变量y,占用8个字节
大萝卜可以直接放入大坑中
*/
double y = i + d;
System.out.println(y);
}
}
显式转换具体分析如下：
当把高精度的变量的值赋给低精度的变量时，必须使用显式类型转换(又称强制类型转换)，
当执行显式类型转换时可能会导致精度缺失。语法如下：
(类型名) 要转换的值
取值范围大的数据或者变量不能直接赋值给取值范围小的变量(大萝卜不能直接放入小坑中),解决方案：
(1) 把坑变大
(2) 把萝卜变小(强制类型转换)
2.格式：
转后类型 变量名称 = (转后类型) 转前数据或者变量;
long类型(8个字节)的数字5:
long num = 5L;
long类型强制类型转换成int类型(4个字节):
int a = (int)num;//把num中的数据强制类型转换成int类型,并把结果赋值给int变量a
举例: 有一个long类型(8个字节)的数字5:
00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000101
long类型强制类型转换成int类型(4个字节):
砍掉左侧的四个字节的内容,因为砍掉的都是数字0,所以对最终的结果数据没有影响仍然是5
00000000 00000000 00000000 00000101
long类型强制类型转换成short类型(2个字节):
砍掉左侧的六个字节的内容,因为砍掉的都是数字0,所以对最终的结果数据没有影响仍然是5
00000000 00000101
long类型强制类型转换成byte类型(1个字节):
砍掉左侧的七个字节的内容,因为砍掉的都是数字0,所以对最终的结果数据没有影响仍然是5
00000101
总结: 根据需求,砍掉数据左侧的若干字节的数据,只要砍掉的都是0,对原数据没有影响
但是只要砍掉的数据中包含1,就会对原数据产生影响(可能会损失精度)
示例代码3，如下：
public class ConvertDemo {
public static void main(String[] args) {
double d = 1.5;
/*
左侧d是double类型(占8个字节),右侧的int类型的变量x(占4个字节)
相当于: 左侧是较大的数据,右侧的变量比较小
大萝卜不能直接放入小坑中
*/
//int x = d;
//System.out.println(x);
/*
左侧d是double类型(占8个字节),右侧的int类型的变量x(占4个字节)
double数据是不能直接赋值给int变量的: 大萝卜不能直接放入小坑中
但是进行了强制类型转换,把double数据强制转换成int数据
double强制类型转换成int: 直接把小数部分干掉,会损失精度
*/
int y = (int) d;
System.out.println(y);
}
}
示例代码4，如下：
public class ConvertDemo {
public static void main(String[] args) {
short s = 1;
/*
s是short类型,1是int类型,运算时类型不一致,会发生自动类型转换
short类型(2个字节)的s会自动转换成int类型(4个字节):在short类型的s左侧补充2个字节的0
最终变成了两个int数据相加,结果是int类型(占用4个字节),不能直接赋值给左侧的short类型的变量s,占用2个字节
大萝卜不能直接放入小坑中
*/
//s = s + 1;
以上是关于万字文肝Java基础知识的主要内容，如果未能解决你的问题，请参考以下文章
建议收藏|熬夜爆肝万字文带你了解DOM，文末有彩蛋嗷!!!!✨✨✨