从头到尾重学JAVA——JAVA编程基础
从头到尾重学 JAVA
- 章节跳转目录
- 第一个JAVA程序
- 使用 IDE 编程
-
- IDE是啥？
- 编程基础
-
- 1 基本语法
-
- 1.1 基本格式
- 1.2 注释
- 1.3 标识符、关键字、常量
- 2 变量
-
- 定义
- 作用域
- 3 数据类型
-
- 整数类型变量
- 浮点类型变量
- 字符类型变量
- 布尔类型变量
- 类型转换
-
- 自动类型转换
- 强制类型转换
- 4 结构语句
-
- 顺序结构
- 选择结构
-
- if 结构
- switch 结构
- 循环结构
-
- while 循环 do... while 循环
- for 循环
- 增强 for 循环
- 5 方法
-
- 含义
- 基本格式
- 重载
- 6 数组
-
- 数组定义
- 数组操作
-
- 声明数组变量
- 创建数组
- 初始化数组
- 多维数组
- 调用
- 7 运算符
今天讲编程基础！后续章节会慢慢更新鸭。
章节跳转目录
JAVA简介
JAVA环境配置
JAVA编程基础
JAVA面向对象
JAVA API 未更新
JAVA 集合类 未更新
JAVA IO 未更新
JAVA GUI 未更新
JAVA JDBC 未更新
JAVA 多线程 未更新
JAVA 网络编程 未更新
第一个JAVA程序
使用IDE进行编程之前先讲如何用记事本写代码，/汪汪
环境配置章节说了如何配置环境变量，配置完环境变量之后，就可以使用命令行编译运行JAVA程序了。
这里推荐使用 Git Bash 来操作，hhh，我觉得更熟悉方便。当然 CMD 命令行也是可以的。
编写一个简单程序，也就是第一章 JAVA介绍 的时候说到的。自己打打代码吧，这里就不贴代码出来了。
然后另存为 test.java，记得文件类型选所有文件，可以存在桌面的一个文件夹。
然后呢，打开 cmd 命令行（前面讲过），这里也不用 cd 命令，直接在文件夹文件拖拽到 命令行，然后在前面加上 javac ，就是编译了。然后再来个 java 命令就是执行了。（我试了下直接 java 执行.class 文件不行，还得 cd 进那个文件夹）：
就运行成功了，出现了 Hello World 字样。
使用 IDE 编程
IDE是啥？
集成开发环境（IDE，Integrated Development Environment ）是用于提供程序开发环境的应用程序，一般包括代码编辑器、编译器、调试器和图形用户界面等工具。集成了代码编写功能、分析功能、编译功能、调试功能等一体化的开发软件服务套。
也就是说，IDE 是一套工具，它能够帮助我们进行代码开发。
IDE 有很多，不同的 IDE 针对的开发环境不一样。如 VS（Visual Studio 比较全能，适用于多种开发）、NetBeans（开源免费 Java 集成开发）、IntelliJ IDEA（Jet Brains出品 必属精品，用于 JAVA 开发）、Eclipse （开源免费 Java 开发）、Code:: Block（C、C++、Fortran 开发）等等，这里不讲那么多，我最喜欢拿来做 Java 开发的就是 IDEA ，想必也看出来了。
IDEA的安装，自己搜索，我这里随便丢一个别人的链接。
具体使用我也不作讲解，配置等等自行搜索。
编程基础
1 基本语法
1.1 基本格式
Java 程序代码挺特别，所有代码都会放在类中。而一个文件需要一个主类（该类并高包含main函数），且类名与文件名相同。类需要使用 class 关键字定义，在 class 前可以有一些修饰符，如下：
修饰符 class 类名{
代码
}
变量名、类名的定义十分重要这里可以了解以下驼峰命名法和匈牙利命名法（如果有空我会写来介绍，没写就自行 search），在后期复杂开发里面体现的尤为深刻。
编写代码时需要注意：
（1）java 程序代码可分为结构定义语句和功能执行语句。其中结构定义语句用于声明一个类或方法；功能执行语句用于实现具体功能，每条功能执行语句的最后都需要用分号（;）结束。（同时功能执行语句依托于结构定义语句，以下可以看出）
public class test{ // 结构定义语句
public static void main(String[] args) {//结构定义语句
System.out.println("Hello World!");//功能执行语句
}
}
（2）java 语言严格区分大小写（大多数语言都会区分）。
（3）代码尽量美观。（学到后面你就会发现很重要了，这个和命名方式一样，属于代码规范）
1.2 注释
便于代码阅读，所以和其他语言一样，都有自己的注释（它不会参加编译），这里用{//}来表示：
- 单行注释 {//}
- 多行注释 {/* */}
- 文档注释 {/** /} /**开头 / 结束
当然说到这里，还有种东西叫注解。Java 注解（Annotation）又称 Java 标注，是JDK5.0 引入的一种注释机制。Java 语言中的类、方法、变量、参数和包等都可以被标注。这里只是提及一下，在深入了解后再来学习注解。
1.3 标识符、关键字、常量
在编程过程中，需要在程序中使用符号定义一系列的名称，比如类名、包名、变量名、参数名、方法名等，这些符号我们称之为标识符。
标识符命名规则：1、必须由字母、数字、下划线{ _ }及美元符号{ $ }组成；2、不能以数字开头；3、不能与关键字冲突；4、不能和java类库的类名冲突；
这里又提到了关键字。关键字是语言里事先定义的，有特别意义的标识符，有时又叫保留字（keyword）。（目前共有53个关键字，具体含义与作用这里也是自行搜索，我只丢出一个别人的博客）
至于提到的包（package），在面向对象里会解释。
而常量呢，是程序中固定不变的值。Java 中包括，整型常量、浮点数常量、布尔常量以及符号常量等。
这个常量解释也许有点迷惑，其实很简单，比如: 1 就是一个整型常量，01 也是整型常量不过是二进制；2e35 是一个浮点数常量，浮点数是什么呢，这个涉及数据结构，是一种数字的表示方法，自行搜索。说白了，常量就是一个固定的数。
常量之间的转换，进制转换，都是一个需要了解熟悉的问题，在开发过程中会有涉及到。
2 变量
定义
变量来源于数学，是计算机语言中能储存计算结果或能表示值的抽象概念。在 Java 中，变量被明确为是可以表示可变状态、具有存储空间的抽象。
实质：程序运行期间，会产生临时数据，应用程序会将这些数据保存在内存单元中，每个内存单元使用一个标识符进行标识，这些内存单元，我们称之为变量。而那些标识符则为变量名，内存单元中存储的值为变量值。
比如：
int a = 1,b;
b = a + 1;
不同的变量声明和操作也会让内存分配方法不同，比如不同的 java 字符串赋值方法，也会有不同，这个和常量池有关，后续会提到。
作用域
当然，变量需要在它的作用范围内才可以被使用，不然经常定义变量，程序也容易出现命名重复等情况。这个作用范围我们称之为变量的作用域。
java 也和其他编程语言类似，变量一定会被包括在某一对大括号中（全局变量除外），该大括号便是该变量的作用域。
当然，全局变量的“大括号”也就是整个程序文件的开头结尾；有些单行不定义大括号，那也是省略了的，比如：
for(int i = 0; i < x; i ++)
a ++;
其实和有括号是一样的。
for(int i = 0; i < x; i ++) {
a ++;
}
3 数据类型
Java 作为静态语言，即强类型语言（Java 简介有提到），所以变量在赋值时都必须赋予和变量同一种类型的值，否则会报错。
所以，有不同的数据类型来区分和存储，不同的变量和数据。具体分类如下图：
整数类型变量
该类型变量用于存储整数数值，即无小数部分的值。
该类型变量分为四种类型：字节型（byte）、短整型（short）、长整型（long）、整型（int）：
| 类型 | 占用空间 | 取值范围 |
|---|---|---|
| byte | 8位（1 byte） | − 2 7 -2^7 −27 ~ 2 7 − 1 2^7-1 27−1 |
| short | 16位（8 byte） | − 2 15 -2^{15} −215 ~ 2 15 − 1 2^{15}-1 215−1 |
| long | 32位（16 byte） | − 2 31 -2^{31} −231 ~ 2 31 − 1 2^{31}-1 231−1 |
| int | 64位（32 byte） | − 2 63 -2^{63} −263 ~ 2 63 − 1 2^{63}-1 263−1 |
使用 long 类型变量赋值需要注意：所赋值数后需要 加上一个 “L”（大小写均可），说明为 long 类型。（因为不加 L 它会默认该常量为 int 类型，当值超出 int 取值范围时，会报错）
long 22222200000L
浮点类型变量
浮点类型变量用于存储小数值。
该变量类型分为两种：单精度浮点数（float）、双精度浮点数（double）。
| 类型 | 占用空间 | 取值范围 |
|---|---|---|
| float | 32位（4 byte） | 1.4E-45 ~ 3.4E+38，-3.4E+38 ~ -1.4E-45 |
| double | 64位（8 byte） | 4.9E-324 ~ 1.7E+308，-1.7E+308 ~ -4.9E-324 |
取值范围解释：科学计数法，E 表示以10为底的指数，后面的“+”“-”号表示正负指数，如 1.4E-45 表示 1.4 × 1 0 − 45 1.4\times10^{-45} 1.4×10−45。和 long 类型数字末尾加 “L” 一样，float 也需要加 F/f，double 后面加 D/d。同时 浮点类型变量也可以存储其他类型，如int、short等。
字符类型变量
字符类型变量用于存储一个单一字符，用 char 表示。
每个字符占用 2 byte，赋值时，字符常量需要用单引号包含，如 char v = ‘a’。也可以赋值 0~65535（ 2 16 − 1 2^{16}-1 216−1）整数，它会自动将整数转换为对应的字符，这个也和编码有关，比如ASCII码。
布尔类型变量
布尔类型变量用来存储布尔值，用 boolean 表示，该类型变量只有两个值，和 C++ 的 bool 相对应，也就是 true 和 false 。
对于引用类型，这些涉及面向对象以及一些基础，在后续会讲到。
类型转换
当一种数据类型的值赋给另一种数据类型的变量时，由于他们数据类型不同，所以就需要类型转换。根据转换类型分，数据类型转换分为：自动转换和强制转换。
自动类型转换
又叫隐式转换，意思是，两种数据类型的转换不需要显式声明，由系统自动进行类型转换。但是需要满足两个条件：
- 转换的两种类型互相兼容（系统支持）
- 目标类型的取值范围大于源类型取值范围
变量在表达式运算中，也会出现自动类型转换。
强制类型转换
又叫显式转换，意思是，两种数据类型的转换需要显式声明，编写代码时需要有特定的格式。当不满足自动类型转换的条件时，想进行类型转换，可使用强制类型转换。如下：
目标类型 变量 = (目标类型) 源类型值
当然强制类型转换，既然是不满足自动类型转换的，所以会发生精度丢失，这个精度丢失怎么理解呢，之前讲过所有的数据类型占用的字节数，在计算机内，其实所有数据都是用二进制存储的，比如：
int a = 1000; 那么其实二进制存储的就是 1111101000 int 的 64 位 存储了 10 位 byte b = (byte) a; 那么我们将 a 转换为 byte 类型的 b 由于 byte 只有 8 位，那么他就只会截取最后八位，也就是 11101000 即： b = 463;
4 结构语句
顺序结构
正常情况下，同一作用域内语句执行从上到下。
选择结构
if 结构
if 通常用于表达式判断。三种结构：单选择、双选择、多选择（每个选择表达式不为真则向下继续判断，为真则进入该表达式下的执行语句）（无表达式的 else 直接进入）
1.
if(表达式){
执行语句
}
2.
if(表达式){
执行语句
}
else{
执行语句
}
3.
if(表达式){
执行语句
}
else if(表达式){
执行语句
}
.....
else{
执行语句
}
三元表达式和 if 结构有相同的效果。条件判断为真，则执行语句1，为假则执行语句2
条件判断？语句1:语句2
switch 结构
switch 结构通常用于值的匹配。结构如下
switch(表达式或变量){
//case 作为 匹配值，当switch括号内内容与case后的 x 匹配时，会进入对应的执行语句。
case x1:
执行语句
//当遇到break时，跳出switch，若无break则继续向下执行。
break;
case x2:
执行语句
break;
case x3:
执行语句
break;
//所有case均不匹配时，执行default内语句
default：
执行语句
}
JDK7以后switch支持字符串的匹配。原理：每一个对象都会默认分配一个HashCode,根据哈希值匹配元素。
循环结构
while 循环 do… while 循环
while 循环语句和 if 有类似之处，都是当表达式为真时进入执行语句。区别是，while 的表达式不是假时，会重复执行并判断直到表达式为假结束：
while(表达式){
循环内容 即执行语句
}
do…while 和 while 唯一的区别是先执行再判断表达式：
do{
循环内容 即执行语句
}while(表达式)
for 循环
for 循环语句是支持迭代的通用结构，是最有效，最灵活的循环结构。
结构如下：
for(初始化表达式;布尔表达式;步进表达式){
循环体
}
①初始化表达式：只执行一次，用于数据初始化。（可以不写，但是分号需要）
②布尔表达式：该次循环是否执行循环体取决于该布尔表达式是否为真。
④步进表达式：布尔表达式及其循环体执行结束后运行，运行后开始循环。
③循环体：执行语句。
例子：9x9乘法表
public class HelloWorld {
public static void main(String []args) {
for(int i = 1; i <= 9; i ++){
for(int j = 1; j <= 9; j ++)
System.out.println(i+" x "+j+" = "+(i*j)+"\t");
System.out.println();
}
}
}
增强 for 循环
增强 for 循环，JDK5引入的，主要用于遍历数组和集合，和 python 的for in 有点相似，可以解读为：for each element in arrayName do {…}：
for(声明语句: 表达式){
循环体
}
比如这个循环例子：
int[] array = {1,2,3,4,5,6};
for(int i: array){
System.out.print(i);
}
另外循环的嵌套实现，这里不作过多说明，自行实现熟悉。
break continue 对于所有结构语句都有效。
break：终止循环，强行退出循环。
continue：终止某次循环，跳过循环体中尚未执行 的语句，开始执行下一循环。
有人会问，有没有goto，回答是没有，它只是一个保留关键字，无作用；但是 java 使用了 lable（标签）来实现 goto 的机制，与 break continue 连用。（可作自行了解）
5 方法
含义
在我们的日常生活中，方法可以理解为要做某件事情，而采取的解决办法。在编程中，接触过的也许知道，这个叫函数（function）。而在 java 里，实现 function 功能的叫方法，但是这个方法有所不同，函数是可以单独定义与使用的，但是方法，依赖于类或对象。如果这个方法添加了修饰符static，这个方法就属于这个类，否则的话，这个方法属于这个类的实例。（因为 java 是一个面向对象的语言，它的面向对象的特性会在后续章节讲到）
基本格式
方法，和所谓的函数有相像之处，基本格式如下：
修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2,．．．．．．){
执行语句
………
return 返回值;//void类型无返回值
}
修饰符：方法修饰符比较多，有告诉编译器如何调用该方法的（如 static），也有定义该方法访问类型的（public），不同类型可叠加使用。
返回值类型：限定方法的返回值的数据类型。
方法名：标识符。
参数：括号内的属于方法的传入参数，可选。
return：结束方法的关键字。
返回值：该值会返回给调用者。
如果方法中没有返回值，返回值类型要声明为void，此时，方法中return语句可以省略。
static 变量是专属于类的，不能在方法定义里面使用。同样 某人 提醒了我，方法中是不能定义方法的，但是是可以在方法里定义一个类，再在类里面定义方法。这里也是方法 method 和函数 function 的区别，方法栈是需要一个载体的（方法不是一等公民），这个载体就是Class，如果一个方法的上一级不是一个类，就说明没有载体。以前可以用匿名类，现在可以在方法里定义lambda表达式来实现方法里定义方法的效果。
举个例子：
public class example {
public static void main(String[] args) {
int result = plus(2,3);
System.out.println(" 2 + 3 = " + result);
}
public static int plus(int x, int y) {
int temp = x + y;
return temp;
}
}
调用过程：
int result = plus(2,3); -------plus(int x, int y)--------------
- - - -
- ---------> 为 x ,y 分配内存并传值- x=2 y=3 -
- - temp=5 -
-<-----------------------返回结果 <--------return temp -
- x ,y 释放 -
- -------------------------------------
至于修饰符的含义，会在后面面向对象的内容中提到。这里暂不作说明。
我们用到的 System.out.println() 也是一个方法，System 是系统类，out 是标准输出对象，println() 是文本打印的方法。
重载
是不是很熟悉，C++ 也有函数重载，这里的方法重载，也是一个类型，创建另一个有相同名字但参数不同的方法，Java 编译器根据方法签名判断哪个方法应该被调用。重载的方法必须拥有不同的参数列表，你不能仅仅依据修饰符或者返回类型的不同来重载方法。（这里提到的参数列表，也就是括号内的传入参数的序列集合）。
例子：
public class example {
public static void main(String[] args) {
int result1 = plus(2,3); 调用第一个重载
double result2 = plus(2.0,3.0); 调用第二个重载
System.out.println(" 2 + 3 = " + result1);
}
public static int plus(int x, int y) {
int temp = x + y;
return temp;
}
public static double plus(double x, double y) {
double temp = x + y;
return temp;
}
}
方法内定义的变量，可以称为局部变量，局部变量的作用域从声明开始，直到包含它的块结束。方法的参数范围涵盖整个方法。参数实际上也是一个局部变量。
6 数组
数组定义
数组对于每一门编程语言来说都是重要的数据结构之一，当然不同语言对数组的实现及处理也不尽相同。Java 语言中提供的数组是用来存储固定大小的同类型元素。我们可以说，数组是一组数据的集合，同时它也是变量的一种，属于一种数据类型。
数组操作
声明数组变量
必须声明数组变量，才能在程序中使用数组：
int []x;
或 int x[]; 效果相同
创建数组
java 使用 new 操作符来创建数组：
x = new int[10];
int []x = new int[10]; 连用形式 创建一个大小为10的数组，然后赋值给变量 x 。
内存说明图：
初始化数组
一种是动态初始化，就是当用的时候再去赋值；
int []x = new int[10];
x[0]=1;
x[1]=2;
........
一种是静态初始化，在定义数组的同时，为每个元素赋值：
1. int []x = new int[]{1,2,3,4,5,6,7,8,9,10};
2. int []x = {1,2,3,4,5,6,7,8,9,10};
多维数组
我们可以理解为是嵌套数组。先看如何创建：
以二维数组为例子：
int [][] x = new int[10][10];
我们用内存图就很容易理解了：
第一个数组的每个元素分别是一个一维数组的首地址。
调用
和其他语言的数组相似：
System.out.println(x[1]);
7 运算符
计算机的最基本用途之一就是执行数学运算，作为一门计算机语言，Java也提供了一套丰富的运算符来操纵变量。运算符可以分为以下几种：
- 算术运算符
- 关系运算符
- 位运算符
- 逻辑运算符
- 赋值运算符
- 其他运算符
具体的运算符有哪些，如何用，我们可以参照菜鸟教程。
有一个重要概念叫做 运算符优先级，记得去菜鸟教程了解。