[Java知识库]java的基础语法总结（第一篇）

1. java语言是面向对象的（oop）
2. java语言是健壮的。java的强类型机制、异常处理、垃圾的自动收集等是Java程序健壮性的重要保证。
3. java语言是跨平台性的。
4. java语言是解释性的
   解释性语言：javascript、PHP、java ； 编程性语言：C/C++
   区别是：解释性语言，编译后代码，不能直接被机器执行，需要解释器来执行，
   编译性语言，编译后的代码，可以直接被机器执行，c/c++

开发细节

1. Java源文件以.java 为扩展名。源文件的基本组成部分是类（class），如本类中的Hell类。
2. Java应用程序的执行入口是main()方法。它有固定的书写格式：

public static void main(String[] args){…}

3. Java语言严格区分大小写。

4. Java方法由一条条语句构成，每个语句以“;”结束。

5. 大括号都是成对出现的，缺一不可。[习惯，先写{}再写代码]

6. 一个源文件中最多只能有一个public类。其它类的个数不限。[演示]

7. 如果源文件包含一个public类，则文件名必须按该类名命名！[演示」

8. 一个源文件中最多只能有一个public类。其它类的个数不限，也可以将main方法写在非public类中，然后指定运行非public 类，这样入口方法就是非public 的main方法

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编写7个规范

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

初学者java易犯错误

1. 编译或者运行时，找不到文件 javac Hell0.java, 把文件名或者目录找对
2. 主类名和文件名不一致 , 修改时保持一致即可
3. 缺少;
4. 拼写错误，比如 1 -> l 0->0, void -> viod , 要求写代码时，一定要小心

强调: 先思考->自己练习->看评讲

整数类型细节

整型的使用细节 IntDetail

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

2. Java的整型常量（具体值）默认为 int 型，声明long型常量须后加或“T3.java程序中变量常声明为int型，除非不足以表示大数，才使用long?4. bit:计算机中的最小存储单位。byte:计算机中基本存储单元,1byte = 8 bit。[二进制再详细说，简单举例一个 byte 3 和 short 3]

思考题: long 类型，有几个 bit[8 *8 = 64 bit] long n = 3://内存中

浮点类型细节

?浮点型使用细节 FloatDetail

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

2. Java 的浮点型常量(具体值)默认为double型，声明float型常量，须后加f或“F*

3. 浮点型常量有两种表示形式十进制数形式：如：5.12 512.0f 512 （必须有小数点）科学计数法形式:如：5.12e2 [5.1210的2次方] 5.12E2~[5.1210的2次方」

4. 通常情况下，应该使用double型，因为它比float型更精确。[举例说明]double num9 = 2.1234567851; float num10 = 2.1234567851F;

5. 浮点数使用陷阱: 2.7 和 8.1 / 3 比较

解决办法

double num7 = 2.7;
double num8 =8.1/3;
if(Math.abs(num7-num8)<000001){
Systerm.out.printin(“相等");
}

字符类型使用细节（char）

1. 字符常量是用单引号(’’)括起来的单个字符。例如:char c1 =‘a’； char c2 =‘中’; char c3 =‘9’;

2. Java中还允许使用转义字符“\来将其后的字符转变为特殊字符型常量。例如：char c3 =“\n’；//’\n’表示换行符

3. 在java中，char的本质是一个整数，在输出时，是unicode码对应的字符。unicode码

4. 可以直接给char赋一个整数，然后输出时，会按照对应的unicode 字符输出[97-》a]

5. char类型是可以进行运算的，相当于一个整数，因为它都对应有Unicode码.

int n1 = 'a' + 'b';
char char1 = 'a' + 2;
System.out.println(n1);	//97 + 98 = 195 -->?
SYstem.out.println(char1);//c


		char c1 = 'a';
        char c2 = '\t';
        char c3 = '小';
        char c4 = 97; //说明：字符类型可以直接存放一个数字
        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c3);
        System.out.println(c4); 

字符类型本质探讨

1.字符型存储到计算机中，需要将字符对应的码值（整数）找出来，
比如 ’ a ’ 存储：‘ a ’ > 码值 97 == >二进制(110 0001) > 存储
读取：二进制(110 0001)=> 97 ===> ’ a ’ =>显示

2.字符和码值的对应关系是通过字符编码表决定的(是规定好)

?介绍一下字符编码表[sublime测试]
ASCII (ASCIl 编码表一个字节表示一个128 个字符,实际上一个字节可以表示256个字符,只用128个)
Unicode (Unicode 编码表固定大小的编码使用两个字节来表示字符，字母和汉字统一都是占用两个字节，这样浪费空间）
utf-8（编码表，大小可变的编码字母使用1个字节，汉字使用3个字节）

gbk(可以表示汉字，而且范围广，字母使用1个字节，汉字2个字节)
gp2312(可以表示汉字，gb2312 < gbk）
big5 码(繁体中文,台湾，香港)

基本数据类型转换

自动类型转换

√介绍当java程序在进行赋值或者运算时，精度小的类型自动转换为精度大的数据类型，这个就是自动类型转换。
数据类型按精度(容量)大小排序为(背，规则)

char —> int — > long — > float — > double

byte — >short — > int — > long — > float — > double

int a =‘C’:/错
double d = 80://对

强制类型转换

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

强制类型转换细节

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

  char c1 = 100;// ok
  int m = 100;//ok
  char c2 = m;// 错误
  char c3 = (char)m;// ok
  System.out.println(c3);//d

4. byte 和 short ,char类型在进行运算时，当做int类型处理

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

1.基本类型转String类型语法：将基本类型的值+""即可

  		int n1 = 100;
        float f1 = 1.1F;
        double d1 = 4.5;
        boolean b1 = true;
        String s1 = n1 + "";
        String s2 = f1 + "";
        String s3 = d1 + "";
        String s4 = b1 + "";

        System.out.println(s1 + " " + s2 + " " + s3 + " " + s4 );

2.String类型转基本数据类型语法：通过基本类型的包装类调用parseXX方法即可。

		String s5 = "123";
 
        int num1 = Integer.parseInt(s5);
        byte num2 = Byte.parseByte(s5);
        short num3 = Short.parseShort(s5);
        long num4 = Long.parseLong(s5);
        float num5 = Float.parseFloat(s5);
        double num6 = Double.parseDouble(s5);
        boolean b = Boolean.parseBoolean("true");

% 取模，取余

   // 在 % 的本质 看一个公式 a % b = a - a / b * b
    // -10 % 3 => -10 - (-10) / 3 * 3 = -10 + 9 = -1
    // 10 % -3 = 10 - 10 / (-3) * (-3) = 10 - 9 = 1
    // -10 % -3 = (-10) - (-10) / (-3) * (-3) = -10 + 9 = -1
    System.out.println(10 % 3); // 1

    System.out.println(-10 % 3); // -1
    System.out.println(10 % -3); // 1
    System.out.println(-10 % -3); // -1

逻辑运算符

&& 和& 基本规则

&& 和&使用区别

1. &&短路与：如果第一个条件为false，则第二个条件不会判断，最终结果为false,效率高
2. &逻辑与：不管第一个条件是否为false，第二个条件都要判断，效率低
3. 开发中，我们使用的基本是短路与&&,效率高

||和|基本规则

|| 和 | 使用区别

1)|短路或：如果第一个条件为true，则第二个条件不会判断，最终结果为true，效率高
2)|逻辑或：不管第一个条件是否为true，第二个条件都要判断，效率低
3)开发中，我们基本使用 ||

！取反基本规则

a^b:叫逻辑异或，当 a 和 b 不同时，则结果为true,否则为false

^逻辑异或，System.out.printin((4 < 1) ^ (6 > 3)): // False

赋值运算符的特点

1. 运算顺序从右往左 int num = a + b + c
2. 赋值运算符的左边 只能是变量 右边 可以是变量 、 表达式、 常量值
3. 复合赋值运算符等价于下面的效果
   比如 ： a += 3; 等价于 a = a + 3; 其他类推
4. 复合赋值运算符会进行类型转换。
   byte b = 2; b += 3; b++;

//例子

byte b = 1;
b++; // b = (byte)(b + 1)
b += 1; // b = (byte)(b + 1)
b = b + 1;// b = b + 1 // 错误的 b + 1 ---> int

三元运算符

1. 基本语法
   条件表达式 ？ 表达式1 : 表达式2 ;

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

3. 如果条件表达式为false, 运算后的结果是表达式2：

4. 细节

三元运算符可以转成if – else 语句
int res = a > b ? a++ : --b;
if(a > b) res = a++;
else res = --b;

运算符优先级

运算符有不同的优先级，所谓优先级就是表达式运算中的运算顺序。

只有单目运算符、赋值运算符是从右向左运算的

1. () , {} 等
2. 单目运算符 ++ –
3. 算术运算符
4. 位移运算符
5. 比较运算符
6. 逻辑运算符
7. 三元运算符
8. 赋值运算符

标识符的命名规则和规范

标识符概念

1.Java 对各种变量、方法和类等命名时使用的字符序列称为标识符
2.凡是自己可以起名字的地方都叫标识符 int num1 = 90;

标识符的命名规则(必须遵守)

1.由26个英文字母大小写，0-9 ，或$组成
2.数字不可以开头。 int 3ab = 1; //错误
3.不可以使用关键字和保留字，但能包含关键字和保留字。
4.Java中严格区分大小写，长度无限制。int totalNum = 10; int n = 90;
5.标识符不能包含空格。int a b = 90；

四种进制

二进制转换成十进制

规则：从最低位(右边)开始，将每个位上的数提取出来，乘以2的(位数-1)次方，然后求和。

例子
0b1011
0b1011 = 1 * 2⁰+1 * 2¹+0 * 2² + 1 * 2³ = 1 + 2 + 0 + 8 = 11

八进制转换成十进制

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

例子
0234
0234 = 4 * 8⁰+3 * 8¹+2 * 8²= 4 + 24 + 128 = 156

十六进制转换成十进制

规则：从最低位(右边)开始，将每个位上的数提取出来，乘以16的(位数-1)次方，然后求和。

例子：
0x23A
0x23A = 10 * 16⁰ + 3 * 16¹+2 * 16² = 10 + 48 + 512 =570

十进制转换成二进制

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

例子
34
34 / 2 ……0
17 / 2 ……1
8 / 2 …… 0
4 / 2 …… 0
2 / 2 …… 0
1
二进制为 0b100010

十进制转换成八进制

规则：将该数不断除以8，直到商为0为止，然后将每步得到的余数倒过来，就是对应的二进制。

例子
131
131 / 8 ……3
16 / 8 ……0
2
八进制为 0203

十进制转换成十六进制

规则：将该数不断除以16，直到商为0为止，然后将每步得到的余数倒过来，就是对应的二进制。

例子
237
237 / 16 ……D
14 ……E
十六进制为 0xED

二进制转换成八进制

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

0b11010101
ob 11(3) 010(2) 101(5) = > 0325

二进制转换为十六进制

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

0b11010101
ob 1101(D) 0101(5) = > 0xD5

八进制转换成二进制

规则：将八进制数每1位，转成对应的一个3位的二进制数即可。

0237
0 2(010) 3(011) 7(111) = 0b10011111

十六进制转换成二进制

规则：将十六进制数每1位，转成对应的一个四位的二进制数即可。

0x23B
0x 2(0010) 3(0011) B(1011) = 0b001000111011

原码、反码、补码(重点难点)

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

位运算符

java中有7个位运算(&、|、^、~、>>、<<和>>>）

分别是按位与&、按位或|、按位异或^,按位取反~,它们的运算规则是:

比如： 2&3=? ~ -2=？ ~2=? 2|3=? 2^3=？

还有3个位运算符>>、<<和>>>，运算规则：
1.算术右移>>：低位溢出,符号位不变,并用符号位补溢出的高位
2.算术左移<<:符号位不变,低位补0
3.>>>逻辑右移也叫无符号右移,运算规则是:低位溢出，高位补 0
4.特别说明：没有<<<符号

switch分支结构

switch注意事项和细节讨论
1.表达式数据类型，应和case 后的常量类型一致，或者是可以自动转成可以相互比较的类型，比如输入的是字符，而常量是 int
2.switch(表达式)中表达式的返回值必须是:(byte,short,int,char，enum[枚举],String）

3.case子句中的值必须是常量,而不能是变量
4. default子句是可选的，当没有匹配的case时，执行default
5. 5.break语句用来在执行完一个case分支后使程序跳出switch语句块；如果没有写break，程序会顺序执行到switch结尾,除非遇到break；

数组

声明方式

1. 使用方式1
   动态初始化数组的定义

数据类型 数组名[] = new 数据类型[大小]

int a[]=new int[5];//创建了一个数组，名字a,存放5个int说明：这是定义数组的一种方法。

2. 使用方式2
   动态初始化
   先声明数组语法:

数据类型数组名[];
也可以数据类型[] 数组名:
int a[];或者 int[] a；

创建数组语法:

数组名=new 数据类型[大小]：
a=new int[10]：

3. 使用方式3
   静态初始化

初始化数组语法:
数据类型数组名0={元素值,元素值…」 int
all={2.5,6.7,8,89,90,34,56},如果知道数组有多少元素，具体值

上面的用法相当于：

int a[l=new
int[9];
a[0] = 2; a[1] = 5; a[2] = 6: a[3] =7 ; a[4] = 8; a[5] = 89 ; a[6] = 90 ; a[7] = 34 ;
a[8] = 56;

二维数组使用方式

就比一维数组多了一种

		int[][] arr = new int[10][];
        for(int i = 0; i < arr.length; i++) {
            // 给每个一维数组开辟空间 new
            // 如果没有给一维数组 new ， 那么 arr[i]就是null
            arr[i] = new int[i + 1];
            }

数组使用注意事项和细节

1. 数组是多个相同类型数据的组合，实现对这些数据的统一管理

2. 数组中的元素可以是任何数据类型，包括基本类型和引用类型，但是不能混用。

3. 数组创建后:如果没有赋值有默认值

int0, short 0, byte 0, long 0,
float 0.0,double 0.0,
char \u0000,
boolean false,
String null

4. 使用数组的步骤 1.声明数组并开辟空间 2 给数组各个元素赋值 3 使用数组

5. 数组的下标是从0开始的。

6. 数组下标必须在指定范围内使用，否则报：下标越界异常，比如int[]arr=new int[5];则有效下标为 0-4

7. 数组属引用类型，数组型数据是对象(object)

数组赋值机制

1. 基本数据类型赋值，这个值就是具体的数据，而且相互不影响

int n1 = 2;
int n2 = n1;
// 改变n2的值，n1也不会变

2. 数组在默认情况下是引用传递，赋的值是地址

int[] arr1 = {1, 2, 3};
int[] arr2 = arr1;
arr2[0] = 10;
// 这个时候改变了arr2的第一个元素，arr1的元素也会跟着改变
// 变成{10, 2, 3}

二维数组使用细节和注意事项

1. 一维数组的声明方式有:int[] x 或者int x[]

2. 二维数组的声明方式有：int[][] y 或者 int[] y[] 或者 int y[][]

3. 二维数组实际上是由多个一维数组组成的，它的各个一维数组的长度可以相同,也可以不相同。
   比如： map[][] 是一个二维数组
   int map []={{1,2),{3,4,5}}
   由于 map[0]是一个含有两个元素的一维数组，map[1]是一个含有三个元素的一维数组构成，我们也称为列数不等的二维数组。

重点例题

-10.5 % 3 = ？
a % b 当 a 是小数时， 公式 = a - (int) a / b * b
-10.5 % 3 = -10.5 - (-10) / 3 * 3 = -10.5 + 9 = -1.5
注意：有小数运算，得到的结果是近似值

声明： int[] x,y[]; 以下选项允许通过编译的是( b e ):
说明： x是int类型一维数组，y是int类型的二维数组
a) x[0] = y; //错误 int[][] -> int
b) y[0] = x; //正确 int[] -> int[]
c) y[0][0] = x; // 错误 int[] ->int
d) x[0][0] = y; // 错误 x[0][0] 是错误的
e) y[0][0] = x[0]; // 正确 int->int
f ) x = y; // 错误 int[][] -> int[]

下面数组定义正确的有 —
A. String strs[] = { ‘a’, ‘b’, ‘c’};
B. String[] atrs = { “a”, “b”, “c”};
C. String[] strs = new String{ “a”, “b”, “c”};
D. String strs[] = new String[]{ “a”, “b”, “c”};
E. String[] strs = new String[3]{“a”, “b”, “c”};
答案为 B D

以上内容基本全部来之于韩顺平