Java（最详细基础讲解，不定期增加内容）新手入门首选

Java

Java概述

DOS命令（了解）（磁盘操作命令）

1. dir：查看当前目录有什么
2. cd：切换磁盘,切换文件目录
3. cd…：切换到上一级
4. cd\：切换到根目录

相对路径—绝对路径

相对路径：从当前目录开始定位，形成的一个路径

绝对路径：从根目录开始定位，形成的一个路径

JDK,JRE,JVM的关系

1. JDK = JRE + JAVA开发工具
2. JRE = JVM + 核心类库

环境变量path的配置以及作用

1. 环境变量的作用是为了在DOS的任意目录，可以去使用java和javac命令
2. 先配置JAVA_HOME = 指向JDK安装的主目录
3. 编辑path环境变量，增加 %JAVA_HOME%\bin

java编写步骤

1. 编写java的源代码
2. javac 编译，得到对应的 .class 字节码文件
3. java 运行，本质就是把 .class 加载到jvm 中运行

Java编写的七个规范

1. 类，方法的注释，使用javadoc的方式，即文档注释
2. 非javadoc注释，往往是对代码的说明（给程序的维护者），说明如何修改，注意事项
3. 使用tab,整体将代码右移，使用shift+tab整体左移
4. 运算符和 = 的两边，给空格，代码看上去清楚
5. 源码文件使用utf-8编码
6. 行宽字符不超过 80
7. 代码编程风格有两种 次行风格和行尾风格

//一个程序就是一个世界

java API文档

API:java提供的基本编辑接口（java提供的类还有相关方法）

API中文在线文档

变量

• 变量是程序的基本组成单位

变量的三个基本要素: 类型+名称+值

概念:变量相当于内存中一个数据空间的表示,你可以把变量看做是一个房间的门牌号,通过门牌号我们可以找到房间,而通过变量名可以访问到变量值

变量的基本使用:

1. 声明变量: int a;
2. 赋值：a = 50;
3. 使用System.out.println(a);打印

变量的使注意事项：

1. 变量表示内存中的一个存储区域（不同的变量，类型不同，占用的空间大小不同，比如：int 4个字节，double就是8个字节）
2. 该区域有自己的名称[变量名]和[数据类型]
3. 变量必须先声明，后使用，即有顺序
4. 该区域的数据（值）可以在同一类型范围内不断变化
5. 变量在同一个作用域内不能重名
6. 变量=变量名+值+数据类型（变量三要素）

程序中“+”的使用：

1. 当左右两边都是数值型时，则做加法运算
2. 当左右两边有一方为字符串，则做拼接运算

数据类型

每一种数据都定义了明确的数据类型，在内存中分配了不同大小的内存空间（字节）

Java数据类型：

1. 基本数据类型：

数值型：
    整数类型，存放整数：byte[1],short[2],int[4],long[8]
    浮点型（小数）：float[4],double[8]
    字符型： char[2],存放单个字符'a'
    布尔型： boolean[1],存放true,false;

​ 2.引用数据类型：

类：class
接口：interface
数组：[]

使用细节：

整数类型:

1. java各整数类型有固定的范围和字段长度，不受具体OS(操作系统)的影响，以保证Java程序的可移植性；

2. Java的整型常量（具体值）默认为int型，声明long型常量后须加"l"或"L";

3. Java程序中常变量声明为int型，除非不足以表示大数，才使用long;

4. bit：计算机中最小存储单位

   byte：计算机中基本存储单元

   1byte = 8bit

浮点类型：

1. 浮点数在机器中存放的形式：浮点=符号位+指数位+尾数位

2. 位数部分可能丢失，造成精度损失（小数都是近似值）

3. 与整数类型类似，java浮点类型也有固定的范围和字段长度， 不受具体OS的影响，[float 4个字节，double 8个字节]

4. java的浮点型常量（具体值）默认为double型，声明float型常量，须加"f"或"F"

5. 浮点型常量有两种表现形式：

   十进制数形式：5.12 512.0f .512(必须有小数点)

   科学计数法形式：5.12e2,[5.12*10的2次方]，5.12E-2 [5.12/10的2次方]

6. 通常情况下,应该使用double型，因为他比float型更精确

7. 浮点数使用陷阱：2.7和8.1/3比较（当我们对运算结果是小数的进行相等判断时，要小心！应该是以两个数的差值的绝对值，在某个精度范围类进行判断）

字符类型

1. 字符常量是用单引号括起来的单个字符
2. java中允许使用转义字符 ''来讲其后的字符转变为特殊字符型常量
3. 在java中，char的本质是一个整数，在输出时，是Unicode码对应的字符
4. 可以直接给char赋一个整数，然后输出时，会按照对应的Unicode字符输出
5. char类型是可以进行运算的，相当于一个整数，因为它都对应有Unicode码

布尔类型（Boolean）

不可以用0或非0的整数替代false和true，这点和C语言不同

基本数据类型转换

自动类型转换

• 当java程序在进行赋值或者运算时，精度小的类型自动转换为精度大的数据类型

char -> int -> long -> float -> double
byte -> short -> int -> long -> float -> double

使用细节和注意

1. 有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类型，然后进行计算
2. 当我们把精度（容量）大的数据类型赋值给精度（容量）小的数据类型时会报错，反之就会进行自动类型转换
3. （byte，short）和char 之间不会相互自动转换（当把具体数赋给byte时，先判断该数是否在byte范围内，如果是就可以）
4. byte，short，char，三者可以计算，在计算时首先转换为int类型
5. Boolean不参与转换
6. 自动提升原则：表达式结果的类型自动提升为操作数中最大的类型

强制类型转换

• 自动类型转换的逆过程，将容量最大的数据类型转换为容量小的数据类型，使用时要加上强制转换符()，但可能造成精度降低或者溢出，格外要注意

使用细节和注意

1. 当进行数据的大小从大——>小，就需要使用强制类型转换
2. 强转符号只针对于最近的操作数有效，往往会使用小括号提升优先级
3. char类型可以保存int的常量值，但不能保存int的变量值，需要强转
4. byte和short，char类型进行运算时，当做int类型处理

基本数据类型和String类型的转换

• 基本类型转Sting类型

  将基本类型的值+""即可

• 通过基本类型的包装类调用parseXX方法即可

基本数据类型和String类型的转换注意和细节

1. 在将String类型转成基本数据类型时，要确保String类型能够转成有效的数据，比如，我们可以把“123”，转成一个整数，但是不能把“hello”转成一个整数；
2. 如果格式不正确，就会抛出异常，程序就会终止，这个问题在异常处理章节中处理

运算符

基本运算符

算数运算符

1. 自增： ++

   作为独立的语句使用啥的：前++和后++都完全等价于i=i+1;

   作为表达式使用：

   前++：++i先自增后赋值

   后++：i++先赋值后自增

2. 自减：–

关系运算符（比较运算符）

1. 关系运算符的结果都是Boolean型的，也就是要么是true，要么是false；
2. 关系表达式经常用在if结构的条件中或循环结构的条件中

细节说明：

• 关系运算符组成的表达式，我们称为关系表达式
• 比较运算符"==“不能误写成”="

逻辑运算符

用于连接多个条件（多个关系表达式），最终的结果也是一个Boolean值

逻辑运算规则：

1. a&b: &叫逻辑与

   规则：当a和b同时为true，则结果为true，否则为false；

2. a&&b: &&叫短路与

   规则：当a和b同时为true，则结果为true，否则为false；

   区别：

   对于&&短路与而言，如果第一个条件为false，后面的条件不再判断效率高；

   对于&逻辑与而言，如果第一个条件为false，后面的条件仍然会判断，效率低；

3. a|b：|叫逻辑或

   规则：当a和b，有一个为true，则结果为true，否则为false；

4. a||b：||叫短路或

   规则：当a和b，有一个为true,则结果为true，否则为false；

   区别:

   对于||短路或：如果第一个条件为true，则第二个条件不会判断，最终结果为true，效率高；

   对于|逻辑或：不管第一个条件是否为true，第二个条件都要判断，效率低；

5. !a：叫取反，或者非运算

   规则：当a为true，则结果为false，当a为false时，结果为true；

6. a^b：叫逻辑异或

   规则：当a和b不同时，则结果为true,否则为false;

赋值运算符

赋值运算符就是将某个运算后的值，赋给指定的变量

分类：

1. 基本赋值运算符：=

2. 复合赋值运算符：+=，-+，*=，/=等

   a+=b => a = a+b;

   a-=b => a = a-b;

特点：

1. 运算顺序从右向左

2. 赋值运算符的左边只能是变量，右边可以是变量，常量，表达式

3. 复合赋值运算符会进行类型转换：

   byte b = 2;

   b += 3;(等价 b = (byte)(b + 2));

   b++;(b = (byte)(b+1));

三元运算符

基本表达式：条件表达式?表达式1:表达式2；

1. 如果条件表达式为true，运算后的结果是表达式1；

2. 如果条件表达式为false，运算后的结果是表达式2；

   口诀:[一灯大师：一真大师]

注意：

1. 表达式1和表达式2要为可以赋给接受变量的类型（或可以自动转换）
2. 三元运算符可以转成if–else语句

运算符优先级

1. 运算符有不同的优先级，所谓优先级就是表达式运算中的运算顺序，如下表（上一行运算符总优先于下一行）：

2. 只有单目运算符，赋值运算符是从右向左运算的

标识符的命名规则和规范

概念

1. java对各种变量，方法和类等命名时使用的字符序列为标识符；
2. 凡是自己可以起名的地方都叫标识符

命名规则：

1. 由26个英文字母大小写，0-9，或$组成；
2. 数字不可以开头；
3. 不可以使用关键字和保留字，但能包含关键字和保留字；
4. java中严格区分大小写，长度无限制；
5. 标识符不能包含空格；

规范：

1. 包名：多单词组成时所有字母都大小写；aaa.bbb.ccc
2. 类名，接口名：多单词组成时，所有单词首字母大写；XxxYyyZzz(大驼峰)
3. 变量名，方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写；xxxYyyZzz(小驼峰，简称，驼峰法)
4. 常量名：所有字母都大写，多单词时每个单词用下划线连接：XXX_YYY_ZZZ;

关键字：

定义：被java语言赋予了特殊含义，用做转梦用途的字符串

保留字：

现有java版本尚未使用，但以后版本可能会作为关键字使用，自己命名标识符要避免使用这些保留字：

进制

对于整数，有四种表示方式：

进制转换

• 转十进制

  二进制转换十进制：

  从最低位（右边）开始，将每个位上的数提取出来乘以2的（位数-1）次方，然后求和

  八进制转换十进制：

  从最低位（右边）开始，将每个位上的数提取出来乘以8的（位数-1）次方，然后求和

  十六进制转换十进制：

  从最低位（右边）开始，将每个位上的数提取出来乘以16的（位数-1）次方，然后求和

• 十进制转其他

  转二进制：

  将该数不断除以2，直到商为零为止，然后将每步得到的余数倒过来，就是对应的二进制

  转八进制：

  将该数不断除以8，直到商为零为止，然后将每步得到的余数倒过来，就是对应的八进制

  转十六进制：

  将该数不断除以16，直到商为零为止，然后将每步得到的余数倒过来，就是对应的十六进制

• 二进制转其他：

  转八进制：

  从最低位开始，将二进制数每三位一组，转成对应的八进制数即可

  转十六进制：

  从最低位开始，将二进制数每四位一组，转成对应的十六进制数即可

• 八进制转二进制：

  将八进制数每一位，转成对应的一个3位的二进制数即可

• 将十六进制转成二进制：

  将十六进制数每一位，转成对应的4位的一个二进制数即可

原码，反码，补码（对于有符号的）

1. 二进制的最高位是符号位：0表示正数，1表示负数
2. 正数的原码，反码，补码都一样（三码合一）
3. 负数的反码=它的原码符号位不变，其他位取反
4. 负数的补码=它的反码+1，负数的反码=负数的补码-1
5. 0的反码，补码都为0
6. java没有无符号数，换言之，java中的数都是有符号的
7. 在计算机运算的时候，都是以补码的方式来运算的
8. 当我们运算结果的时候，要看它的原码

位运算符（&，|，^，~，>>，<<，>>>）

• 按位与&：两位全为1，结果为1，否则为0；
• 按位或|：两位有一个为1，结果为1，否则为0；
• 按位异或^：两位一个为0，一个为1，结果为1，否则为0；
• 按位取反~：0->1，1->0;
• 算数右移>>：低位溢出，符号位不变，并用符号位补溢出的高位；本质：该数除以n个2
• 算数左移<<：符号位不变，低位补0；本质：该数乘以n个2
• 逻辑右移>>>：也叫无符号右移，规则：低位溢出，高位补0

控制结构

顺序控制

• 程序从上到下逐行的执行，中间没有任何判断和跳转

分支控制

if-else:

1. 单分支

   基本语法：

   if(条件表达式){
   	执行代码块（可以有多条语句）
   }
   

2. 双分支

   基本语法：

   if(条件表达式){
   	执行代码块（可以有多条语句）
   }
   else{
   	执行代码块（可 以有多条语句）
   }
   

3. 多分支

   基本语法：

   if(条件表达式){
   	执行代码块（可以有多条语句）
   }
   else if{
       执行代码块（可 以有多条语句）
   }
   .......
   else{
       执行代码块（可 以有多条语句)
   }
   

   注意：

   1. 多分支可以没有else，如果所有的条件表达式都不成立，则一个执行入口都没有
   2. 如果有else，如果所有的条件表达式都不成立，则默认执行else代码块
      嵌套分支:
      在一个分支结构中又完整的嵌套了另外一个完整的分支结构，里面的分支结构称为内层分支，外面的分支结构称为外层分支（不要超过3层，可读性不好）

循环控制

Switch循环控制

基本语法：

switch(表达式){
        case 常量1：
            语句块1;
        break;
        case 常量2：
            语句块2;
        break;
        ......
        case 常量n：
            语句块n;
        break;
        default:
        default语句块;
        break;
}

介绍：

1. Switch 关键字，表示Switch分支
2. 表达式对应一个值
3. case 常量1：当表达式的值等于常量1，就执行语句块1
4. break：表示退出Switch
5. 如果一个都没有匹配上，就执行default

注意事项和细节讨论：

1. 表达式数据类型，应和case后的常量类型一致，或者是可以自动转成可以相互比较的类型
2. switch(表达式)中表达式的返回值必须是：（byte,short,int,char,enum,String）
3. case子句中的值必须是常量，而不能是变量
4. default子句是可选的，当没有匹配的case时，执行default
5. break语句用来在执行完一个case分支后使程序跳出Switch语句块；如果没有写break，程序会顺序执行到switch结尾，直到遇到break

switch和if的比较

1. 如果判断的具体数值不多，而且符合byte，short，int，char，enum，String这六种类型，虽然两个语句都可以使用，建议使用Switch语句；
2. 其他情况，对区间判断，对结果为Boolean类型判断，使用if，if的使用范围更广；

for循环控制

基本语法：

for(循环变量初始化;循环条件;循环变量迭代){
    循环操作(操作);
}

介绍：

1. for有关键字，表示循环控制
2. for有四要素：
   • 循环变量初始化
   • 循环条件
   • 循环操作
   • 循环变量迭代
3. 循环操作，这里可以有多条语句，也就是我们要循环执行的代码
4. 如果循环操作语句只有一条语句，可以省略{}，建议不要省略{}

注意事项和细节讨论：

1. 循环条件是返回一个布尔值的表达式
2. for(;循环判断条件;)中的初始化和变量迭代可以写到其他地方，但是两边的分号不能省略
3. 循环初始值可以有多条初始化语句，但要求类型一样，并且中间用逗号隔开，循环变量迭代也可以有多条变量迭代语句，中间用逗号隔开

while循环控制

基本语法：

循环变量初始化;
while(循环条件){
    循环体(语句);
    循环变量迭代;
}

介绍：

1. while循环也有四要素只是四要素放的位置和for不一样

注意事项和细节讨论：

1. 循环条件是返回一个布尔值的表达式
2. while循环是先判断在执行语句

do…while循环控制

基本语法：

do{
    循环体(语句);
    循环变量迭代;
}while(循环条件);

介绍：

1. do while 是关键字
2. 也有循环四要素，只是位置不一样
3. 先执行，在判断，也就是说，一定会至少执行一次
4. 最后还有一个分号

注意事项和细节讨论：

1. 循环条件是返回一个布尔值的表达式
2. do…while循环是先执行，在判断，因此它至少执行一次

多重循环控制(重点!)

介绍：

1. 将一个循环放在另外一个循环体内，就形成了嵌套循环，其中，for,while,do…while,均可以作为外层循环和内层循环（建议一般使用两层，最多不要超过三层，否则，代码的可读性很差）
2. 实质上，嵌套循环就是把内层循环当成外层循环的循环体，当只有内层循环的循环条件为false时，才会跳出内层循环，才可结束外层的当次循环，开始下一次的循环
3. 设外层循环次数为m次，内层为n次，则内层循环体实际上需要执行m*n次

跳转控制语句—break

介绍：break语句用于终止某个语句的执行，一般使用在switch或者循环(for,while,do…while)当中

语法：

{
    ......
        break;
    ......
}

注意事项和细节讨论：

1. break语句出现在多层嵌套的语句中时，可以通过标签指明要终止的是那一层语句块

2. 标签的基本使用：

   label1:{......
       label2{......
           label3{		......
               		break label2;
                  		.....
           }
       }
   }
   

   • break语句可以指定退出那层
   • label1 是标签，名字由程序员指定
   • break后指定到那个label就退出到哪里
   • 在实际的开发中，尽量不要使用标签（可读性变差）
   • 如果没有指定break，默认退出最近的循环体

跳转控制语句—continue

介绍：

1. continue语句用于结束本次循环，继续执行下一次循环
2. continue语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环，和前面标签的使用规则是一样

语法：

{
    ......
    continue;
    ......
}

跳转控制语句—return

介绍：

return使用在方法，表示跳出所在的方法

• 如果return写在main方法中，退出程序