[Java知识库]Java 基础入门（未完成持续更新）

Java 基础入门

1. Java 概述

1.1 Java 语言发展史

语言：人与人交流沟通的表达方式

计算机语言：人与计算机之间进行信息交流沟通的一种特殊语言

1.1.1 Java 语言

Java 语言是美国Sun公司（Stanford University Network)在1995年推出的计算机语言

Java 之父：詹姆斯·高斯林（James Gosling）

1.1.2 Java 语言发展史

1.2 Java语言跨平台原理

1.2.1 平台

指的是操作系统

• Windows
• Mac
• Linux

1.2.2 跨平台

Java 程序可以在任意操作系统上运行

1.2.3 跨平台原理

图例:

Java 开发工具想要在不同的平台上运行,需要依赖 JVM 充当翻译功能,从而达到跨平台的效果

总结：在需要运行 Java 应用程序的操作系统上

安装一个与操作系统相对应的 Java 虚拟机（JVM Java Virtual Machine）即可

1.3 JRE和JDK

1.3.1 JRE (Java Runtime Environment)

作用：

是 Java 程序运行时的环境，包含 JVM 和运行时所需要的核心类库

我们想要运行一个已有的 Java 程序，那么只需要安装 JRE 即可

1.3.2 JDK（Java Development Kit）

作用：

是 Java 程序开发工具包，包含 JRE 和开发人员使用的工具

其中的开发工具：

编译工具（javac.exe）和运行工具（java.exe）

我们想要开发一个全新的 Java 程序，那么就必须安装 JDK

1.3.3 JDK , JRE 和 JVM 的关系

图例：

1.4 JDK的下载和安装

1.4.1 JDK 的下载

通过官方网站获取 JDK

http://www.oracle.com

注意：针对不同的操作系统，下载对应的 JDK

1.4.2 JDK 的安装目录

其余文件为说明性文档

2. 常用 DOS 命令

2.1 打开命令提示符窗口

1. 按下 win + R

   

2. 输入 cmd

3. 按下回车键（enter）

2.2 常用命令

1. 切换盘符

2. dir 查看当前路径的文件

3. cd 目录 进入下一级文件夹

4. 回退目录

5. 想直接进入指定文件夹 例如直接进入课程工具包

6. 想直接一次性回退到盘符目录 例如E盘

3. Path 环境变量的配置

3.1 为什么要配置 Path 环境变量

开发 Java 程序，需要使用 JDK 提供的开发工具，而这些工具在 JDK 的安装目录的 bin 目录下

直接使用 cmd 命令运行 javac：

想使用 cmd命令 直接运行 javac 或者 java 需要加上开发工具的路径

小技巧：在 cmd 命令窗口使用👆键，可以查看输入历史从而减少输入时间

直接使用 cmd 命令运行 Java：

在win10 系统中，Java path 环境变量已经提前设置好了，不需要输入路径了

配置 Path 环境变量步骤：

https://www.bilibili.com/video/BV18J411W7cE?p=6&spm_id_from=pageDriver

4. HelloWorld 案例

4.1 Java 程序开发运行流程

开发 Java 程序，需要三个步骤：编写程序，编译程序，运行程序

图例：

4.2 HelloWorld 案例的编写

1. 新建文本文档，修改名称为 HelloWorld.java

2. 用记事本打开 HelloWorld.java 文件，输入程序内容

public class HelloWorld   //定义了一个类名，叫HelloWord
{
    public static void main(String[] args)
    {
        System.out.println("HelloWorld");
    }
}

4.3 HelloWorld 案例的编译和运行

打开命令提示符窗口，进入到HelloWorld.java 所在的目录，输入指令编译和执行

编译语法：javac 文件名.java

范例：javac HelloWorld.java

执行语法：java 类名

范例：java HelloWorld

操作步骤:

1. 进入 HelloWorld.java 文件所在的目录

2. 编译文件

3. 执行文件

5. HelloWorld 案例常见问题

5.1 BUG

由来：

Bug一词的原意是臭虫或虫子。第一代计算机是由许多庞大的真空管组成，并利用大量的电力来使真空管发光。引得一只小虫子Bug钻进了一支真空管内，导致整个计算机无法工作。研究人员费了半天时间，总算发现原因所在，把这只小虫子从真空管中取出后，计算机又恢复正常。后来，Bug这个名词就沿用下来。

与Bug相对应，人们将发现Bug并加以纠正的过程叫做“Debug”，意即“捉虫子”或“杀虫子”。遗憾的是，在中文里面，至今仍没有与“Bug”准确对应的词汇，于是只能直接引用“Bug”一词。虽然也有人使用“臭虫”一词替代“Bug”，但容易产生歧义，所以推广不开。

5.2 BUG 的解决

1. 具备识别 BUG 的能力：多看

2. 具备分析 BUG 的能力：多思考，多查阅资料

3. 具备解决 BUG 的能力：多尝试，多总结

提供以下代码：

public class HelloWorld
{
    public static void main(Sting[] args)
    {
        system.out.println("HelloWorld")；
    }
}

运行后出现的结果：

解读：

Java:5 说明错误在第5行，先看第二个，需要 ‘ ; ’ 说明是 HelloWorld 后面出问题了，修改后再编译

Java:5 说明错误在第5行，system不存在，很可能是我们写错了导致的

6. Notepad 软件的安装和使用

6.1 为什么要安装 Notepad 软件

• 方便对错误行进行操作

6.2 Notepad 软件的配置

6.3 Notepad 软件的使用

使用：通过 Notepad 软件编写 HelloWorld 案例

小技巧：在命令提示符窗口下写 javac HelloWorld.java 时，只需要写 javac H 然后按下 Tab 键

系统就会自动补齐剩下的所有内容

非常方便的哈！

7. 基础语法

7.1 注释

概述：

• 注释是在程序指定位置添加的说明性信息
• 注释不参与程序运行，仅仅起到说明作用

注释分类：

• 单行注释

格式：// 注释信息

• 多行注释

格式：/* 注释信息 */

• 文档注释（目前用不上，暂时不做了解）

格式：/** 注释信息 **/

示例：

/*
	Java程序中最基本的组成单位是类
	类的定义格式：
		public class 类名{
		
		}
	这是我定义的HelloWorld类
*/
public class HelloWorld{
	/*
		这是main方法
		main方法是程序的入口方法，代码的执行是从main方法开始的
	*/
	public static void main(String[] args){
		// 这是输出语句，""里面的内容是可以改变的
		System.out.println("Hello");
	}
}

7.2 关键字

概述：

就是被 Java 语言赋予了特定含义的单词

特点：

1. 关键字的字母全部小写
2. 常用的代码编辑器，针对关键字有特殊的颜色标记，非常直观

标紫的就是关键字：

public class HelloWorld{
	public static void main(String[] args){
		System.out.println("Hello");
	}
}

7.4 常量

常量的概念：在程序运行过程中，其值不可以发生改变的量

常量的分类：

示例：

/*
	常量：
		在程序运行过程中，其值不可以发生改变的量
	常量的分类：
		| 字符串常量 | 用双引号括起来的内容 | "hellworld" , "黑马程序员" |
		|  整数常量  |    不带小数的数字    |          666，88           |
		|  小数常量  |     带小数的数字     |       13.14   -5.12        |
		|  字符常量  | 用单引号括起来的内容 |   ‘ a ’ , ' 0 '  ,  '我'   |
		|  布尔常量  |   布尔值，表示真假   |  只有两个值：ture , false  |
		|   空常量   |  一个特殊的值，空值  |         值是：null         |
*/
public class ConstantDemo{
	public static void main(String[] args){
		//字符串常量
		System.out.println("hellworld");
		System.out.println("黑马程序员");
		System.out.println("-----------");  //分割线
		
		//整数常量
		System.out.println(666);
		System.out.println(-88);
		System.out.println("-----------");
		
		//小数常量
		System.out.println(13.14);
		System.out.println(-5.21);
		System.out.println("-----------");
		
		//字符常量
		System.out.println('A');
		System.out.println('0');
		System.out.println('我');
		System.out.println("-----------");
		
		//布尔常量
		System.out.println(true);  //关键字
		System.out.println(false);  //关键字
		System.out.println("-----------");
		
		//空常量
		//报错，空常量是不能直接输出的
		System.out.println(null);  //关键字
	}
}

8. 数据类型

8.1 计算机存储单元

我们知道计算机是可以用来存储数据的，但是无论是内存还是硬盘，计算机存储设备的最小信息单元叫 “位（bit）”

我们又称之为 “比特位”，通常用小写的字母 “b“ 表示。而计算机最小的存储单元叫 ”字节（byte）“

通常用大写字母 ”B“ 表示，字节是由连续的8个位组成。

除了字节外还有一些常用的存储单位，大家比较熟悉，我们一起来看看：

1B（字节） = 8bit

1KB = 1024B

1MB = 1024KB

1GB = 1024MB

1TB = 1024GB

8.2 数据类型

Java 语言是强类型语言，对于每一种数据都给出了明确的数据类型，不同的数据类型也分配了不同的内存空间

所以他们表示的数据大小也是不一样的

8.3 数据类型内存占用和取值范围

说明：E + 38表示的是乘以10的38次方，同样，E - 45表示乘以10的负45次方

9. 变量

假设我需要修改数值，但是数据输出太多了，这种方法的工作量大。因此我们引入一个变量来暂存数据

把输出位置设定为暂存数据，那么我们只要修改暂存数据，输出的值也会随之改变

概述：在程序运行过程中，其值可以发生改变的量

从本质上讲，变量是内存中一小块区域

9.1 变量定义

语法格式：数据类型 变量名 = 变量值

范例： int a = 10；

对暂存位置做一个标记 —> 变量名

因为 Java 是强语言，所以我们要给这个变量一个明确的数据类型

而且这个变量还得有值，这样才有意义

9.2 变量的使用

变量的使用：取值和修改值

• 取值格式：变量名

• 范例：a

• 修改格式：变量名 = 变量值

• 范例：a = 20；

示例：

/*
	变量定义格式：
		数据类型变量名=变量值；
	
	基本数据类型：
		byte,short,int,long,float,double,char,boolean
	
	变量的使用：
		取值格式：变量名
		
		修改值格式：变量名=变量值；
*/
public class VariableDemo01{
	public static void main(String[] args){
		//定义变量
		int a = 10;
		
		//输出变量
		System.out.println(a);  //a = 10
		
		//修改变量
		a = 900;
		System.out.println(a);  //a = 900
	}
}

9.3 变量使用的注意事项

1. 变量名不能重复

2. 变量未赋值，不能使用

3. long 类型的变量定义的时候，为了防止整数过大，后面要加L

4. float 类型定义的时候为了防止类型不兼容，后面要加F

10. 标识符

概念：就是给类，方法，变量等起名字的符号

定义规则：

1. 由 数字，字母，下划线(_) 和 美元符($) 组成
2. 不能以数字开头
3. 不能是关键字
4. 区分大小写

判断下面哪些变量名不符合规则：

bj b2 2b

class _2b #ithema

ak47 Class helloworld

为了使变量清晰易懂，我们对变量的命名做一些约定：

小驼峰命名法：针对 方法 和 变量 的命名规则

1. 标识符是一个单词的时候，首字母小写 例如：name

2. 标识符是由多个单词组成的时候，第一个单词首字母小写，其他单词首字母大写

   例如：firstName

大驼峰命名法：针对 类 的命名规则

1. 标识符是一个单词的时候，首字母大写 例如：Student

2. 标识符由多个单词组成的时候，每个单词的首字母大写

   例如：GoodStudent

11. 类型转换分类

11.1 自动类型转换

把一个表示数据范围小的数值或者变量赋值给另一个表示数据范围大的变量

例如：double d = 10;

byte 强转成 char 的结果：

11.2强制类型转换

把一个表示数据范围大的数值或者变量赋值给另一个表示数据范围小的变量

语法格式：目标数据类型 变量名 = （目标数据类型）值或者变量;

注意：这里的 值或者变量 要比 目标数据类型 所表示的 范围 要大

例如：int k = (int)88.88;

88.88 属于 浮点类型的数值，int 是整数类型的数值，整型 所表示的范围 < 浮点型 所表示的范围

无强制转换的结果：

示例：

/*
	类型转换
*/
public class ConversionDemo{
	public static void main(String[] args){
		
		//自动类型转换
		double d = 10;
		System.out.println(d);   //10.0
		//说明10本身是整数，而赋值给浮点型double后，转换成了浮点型数值
		
		//定义byte类型的变量
		byte b = 10;
		short s = b;
		int i = b;
		//char c = b;		//报错，显示类型不兼容
		System.out.println(b);
		
		//强制类型转换
		//int k = 88.88;    //报错，显示类型不兼容
		int k = (int)88.88;
		System.out.println(k);  //88,转换成了整数，不建议这么操作容易造成数据丢失
	}
}

12. 运算符

12.1 运算符和表达式

• 运算符：对常量或者变量进行操作的符号

• 表达式：用运算符把常量或者变量连接起来==符合 Java 语法的式子就可以称为表达式

  ? 不同运算符连接的表达式体现的是不同类型的表达式

举例说明：

? int a = 10;

? int b = 20;

? int c = a + b;

+：是运算符，并且是算术运算符

a + b：是表达式，由于 + 是算数运算符，所以这个表达式叫算术表达式

12.1.1 算术运算符

总结1：/ 取结果的商，% 取结果的余数

总结2：整数操作只能得到整数，要想得到小数，必须有浮点数参与运算

示例：

/*
	算术运算符
*/
public class OperatorDemo01{
	public static void main(String[] args){
		//定义两个变量
		int a = 10;
		int b = 20;
		//int c = a + b;
		System.out.println(a + b);	//30
		System.out.println(a - b);	//-10
		System.out.println(a * b);	//200
		System.out.println(a / b);	//0,整数相除只能得到整数部分且没有四舍五入
		System.out.println(a % b);	//10
		
		//整数相除只能得到整数部分，要想得到小数部分必须要有浮点数的参与
		a = 6;
		b = 4;
		System.out.println(a / b);	  //1
		System.out.println(6.0 / 4);  //1.5
	}
}

12.1.2 字符的 “ + ” 操作

概述：拿字符在计算机底层对应的数值来进行计算的

算术表达式中包含多个基本类型的值的时候，整个算术表达式的类型会自动进行提升

提升规则：

• byte 类型，short 类型和 char 类型将被提升到 int 类型

• 整个表达式的类型自动提升到表达式中最高等级操作数同样的类型

  等级顺序：byte , short , char —> int —> long —> float —> double

示例：

/*	字符的 " + " 操作*/public class OperatorDemo02{	public static void main(String[] args){		//定义两个变量		int i = 10;		char c = 'A';		System.out.println(i + c);	//75,推出字符 'A' 的值是65				c = 'a';		System.out.println(i + c);	//107,推出字符 'a' 的值是97				c = '0';		System.out.println(i + c);	//58,推出字符 '0' 的值是48				//假设我定义一个变量来存放 i + c 的值		//char a = i + c;		//报错，显示不兼容		//为什么？char会被自动提升到int类型，所以应该用int类型来接收数值		int j = i + c;		System.out.println(i + c);  //58				//int k = 10 + 13.14;		//报错，显示不兼容		//所以使用double类型来接收数值		double k = 10 + 13.14;		System.out.println(k);	//23.14	}}

12.1.3 字符串的 " + "操作

当 " + " 操作出现在字符串时，这个 " + " 是字符串连接符，而不是算术运算

• “itheima” + 666 = itheima666

在 " + " 操作中，如果出现了字符串，就是连接运算符，否则就是算术运算，当连续进行 " + " 操作时，从左到右逐个执行

• 1 + 99 + “年黑马” = 100年黑马

示例：

/*	字符串的 " + " 操作*/public class OperatorDemo03{	public static void main(String[] args){		System.out.println("it" + "heima");	//itheima		System.out.println("itheima" + 666); //itheima666		System.out.println(666 + "itheima"); //666itheima		System.out.println("黑马" + 6 + 66); //黑马666		System.out.println(1 + 99 + "年黑马"); //100年黑马	}}

12.1.4 赋值运算符

注意：扩展的赋值运算符底层隐含了强制转换

示例：

public class OperatorDemo04{
	public static void main(String[] args){
		//把10赋值给int类型的变量i
		int i = 10;
		System.out.println("i:" + i);  //i:10
		
		// += 把左边和右边的数据做加法操作，结果赋值给左边
		i += 20;	//相当于 i = i + 20;
		System.out.println("i:" + i);  //i:30
		
		//注意：
		short s = 10;
		s += 20;
		System.out.println("s:" + s);  //s:30
		
		//看到这里你可能会猜测s += 20 等价于 s = s + 20
		s = s + 20;
		System.out.println("s:" + s);  //报错，显示不兼容
		//代码解读：
		s = s + 20中属于字符的 "+" 操作，有short和int类型，所以表达式自动提升到int类型运算
		因此 s + 20 应该用int类型来接收数值而不是用short类型
		
        //改正操作：
		s = (short)(s + 20);		//强转成short类型，一般不建议这样写
		System.out.println("s:" + s);	//s:50
		
		//因此，扩展的赋值运算符底层隐含了强制转换
	}
}

12.1.5 自增自减运算符

注意事项：

• ++ 和 – 既可以放在变量的后边，也可以放在变量的前边。
• 单独使用的时候，++ 和 – 无论是放在变量的前边还是后边，结果是一样的
• 参与操作的时候，如果放在变量的后边，先拿变量参与操作，后拿变量做++或者–
• 参与操作的时候，如果放在变量的前边，先拿变量做 ++ 或者 – ，后拿变量参与操作

最常见的用法：单独使用

示例：

/*
	自增自减运算符
*/
public class OperatorDemo05{
	public static void main(String[] args){
		//定义变量
		int i = 10;
		System.out.println("i:" + i);  //i:10
		
		//++ 的单独使用
		i++;
		System.out.println("i:" + i);  //i:11		
		++i;
		System.out.println("i:" + i);  //i:12
		System.out.println("----------------");
		
		//参与操作使用
		i = 10;		//初始化一下
		int j = i++;
		System.out.println("i:" + i);   //i:11
		System.out.println("j:" + j);   //j:10
		System.out.println("----------------");
		
		i = 10;		//初始化一下
		j = ++i;
		System.out.println("i:" + i);	//i:11
		System.out.println("j:" + j);	//j:11
	}
}

12.1.6 关系运算符

示例：

/*
	关系运算符
*/
public class exp1{
	public static void main(String[] args){
		//定义变量
		int i = 10;
		int j = 20;
		int k = 10;
		
		//==
		System.out.println(i == j);  //false
		System.out.println(i == k);  //true
		System.out.println("---------------");
		
		//!=
		System.out.println(i != j);  //true
		System.out.println(i != k);  //false
		System.out.println("---------------");
		
		//>
		System.out.println(i > j);  //false
		System.out.println(i > k);  //false
		System.out.println("---------------");
		
		//>=
		System.out.println(i >= j);  //false
		System.out.println(i >= k);  //true
		System.out.println("---------------");
		
		//不小心把 == 写成 =
		System.out.println(i = j);  //20
		//相当于把j的值赋值给了i，然后输出i的值
	}
}

注意：关系运算符的结果都是Boolean类型，要么是true，要么是false

千万不要把 " == " 写成 ” = “

12.1.7 逻辑运算符

概述：在数学中，一个数据x，大于3，小于6，我们可以这样来表示：3 < x < 6

在 Java 中，需要把上面的式子先进行拆解，再进行合并表达

• 拆解为：x > 3 和 x < 6
• 合并后：x > 3 && x < 6

&&其实就是一个逻辑运算符
我们可以这样说，逻辑运算符，是用来连接关系表达式的运算符
当然，逻辑运算符也可以直接连接布尔类型的常量或者变量

示例：

/*
	逻辑运算符
*/
public class exp2{
	public static void main(String[] args){
		//变量
		int i = 10;
		int j = 20;
		int k = 30;
		
		//& 有false则false
		System.out.println((i > j) & (i > k));  //false & false = false
		System.out.println((i < j) & (i > k));  //true & false = false
		System.out.println((i > j) & (i < k));  //false & true = false
		System.out.println((i < j) & (i < k));  //true & true = true
		System.out.println("----------");
		
		//| 有true则true
		System.out.println((i > j) | (i > k));  //false | false = false
		System.out.println((i < j) | (i > k));  //true | false = true
		System.out.println((i > j) | (i < k));  //false | true = true
		System.out.println((i < j) | (i < k));  //true | true = true
		System.out.println("----------");
		
		//^ 相同为false不同为true
		System.out.println((i > j) ^ (i > k));  //false ^ false = false
		System.out.println((i < j) ^ (i > k));  //true ^ false = true
		System.out.println((i > j) ^ (i < k));  //false ^ true = true
		System.out.println((i < j) ^ (i < k));  //true ^ true = false
		System.out.println("----------");
		
		//!
		System.out.println((i > j));  //false = false
		System.out.println(!(i > j));  //!false = true
		System.out.println(!!(i > j)); //!!false = false
		System.out.println(!!!(i > j)); //!!!false = true		
	}
}

12.1.8 短路逻辑运算符

注意事项：

• 逻辑与==&，无论左边真假，右边都要执行
  短路与&&，如果左边为真，右边执行；如果左边为假，右边不执行==
• 逻辑或==|，无论左边真假，右边都要执行
  短路或||，如果左边为假，右边执行；如果左边为真，右边不执行==

最常用的逻辑运算符：&&，||，！

示例：

/*
	短路逻辑运算符
*/
public class exp3{
	public static void main(String[] args){
		//定义变量
		int i = 10;
		int j = 20;
		int k = 30;
		
		//&& 有false则false
		System.out.println((i > j) && (i > k));  //false && false = false
		System.out.println((i < j) && (i > k));  //true && false = false
		System.out.println((i > j) && (i < k));  //false && true = false
		System.out.println((i < j) && (i < k));  //true && true = true
		System.out.println("----------");
		
		//|| 有true则true
		System.out.println((i > j) || (i > k));  //false || false = false
		System.out.println((i < j) || (i > k));  //true || false = true
		System.out.println((i > j) || (i < k));  //false || true = true
		System.out.println((i < j) || (i < k));  //true || true = true
		System.out.println("----------");
		
		//&&和&的区别
		System.out.println((i++ > 100) & (j++ > 100));  //false & false = false
		System.out.println((i++ > 100) && (j++ > 100));  //false && false = false
		
		System.out.println((i++ > 100) & (j++ > 100));
		System.out.println("i:" + i);	//11
		System.out.println("j:" + j);	//21
		
		i = 10;  //初始化
		j = 20;  //初始化
		System.out.println((i++ > 100) && (j++ > 100));
		System.out.println("i:" + i);	//11
		System.out.println("j:" + j);	//20
		//代码解读：
		//&& 在运行完(i++ > 100)判断为false
		//故判断整个表达式为false，就不再运行右边的(j++ > 100)，所以j = 20
		//同理，||只要左边为true，那么就不再运行右边的代码
	}
}

12.1.9 三元运算符

语法：关系表达式 ? 表达式1 : 表达式2;

范例：a > b ? a : b;

计算规则：

首先计算关系表达式的值

如果值为true，表达式1的值就是运算结果

如果值为false，表达式2的值就是运算结果

示例：

/*
	三元运算符
	语法：关系表达式 ? 表达式1 : 表达式2;

	范例：a > b ? a : b

	计算规则：
		首先计算关系表达式的值
		如果值为true，表达式1的值就是运算结果
		如果值为false，表达式2的值就是运算结果
*/
public class exp4{
	public static void main(String[] args){
		//定义两个变量
		int a = 10;
		int b = 20;
		
		//获取两个数据的较大值
		int max = a > b ? a : b;
		System.out.println("max = " + max);  //max = 20;
	}
}