初识java

1. jdk

JRE是运行基于Java语言编写的程序所不可缺少的运行环境。也是通过它，Java的开发者才得以将自己开发的程序发布到用户手中，让用户使用。

JVM是整个Java实现跨平台的最核心的部分，所有的Java程序会首先被编译为.class的类文件，这种类文件可以在虚拟机上执行。也就是说class并不直接与机器的操作系统相对应，而是经过虚拟机间接与操作系统交互，由虚拟机将程序解释给本地系统执行

Java程序经编译后会产生byte code

2. main方法示例

1. 源文件（扩展名为 *.java) ：源文件带有类的定义。类用来表示程序的一个组件，小程序或许只会有一个类。类的内容必须包含在花括号里面。
2. 类：类中带有一个或多个方法。方法必须在类的内部声明。
3. 方法：在方法的花括号中编写方法应该执行的语句。
   

3. 注释

//单行注释

/*
多行注释
不可嵌套使用
*/

/**
文档注释
常见于方法和类之上描述方法和类的作用
可以被javadoc工具解析，生成一套以网页文件形式体现的程序说明文档
*/

无论是单行注释还是多行注释都不参与编译，即生成的.class文件都不包含注释信息

4. 标识符

在上面代码中，Test 为类名，main为方法名，也可以将它们称为标识符

标识符：在程序中由用户为类名，方法名或变量所取的名字

硬性规则：

标识符中可以包含：字母，数字 以及下划线 和 **$**符号等

标识符不能以数字开头，也不能是关键字，且严格区分大小写

建议：

类名：每个单词的首字母大写（大驼峰）

方法名：第一个单词的首字母小写，后面每个单词的首字母大写（小驼峰）

变量名：与方法名规则相同，小驼峰

关键字：由java语言提前定义好的有特殊含义的标识符 或保留字。

5. 变量

语法格式：

局部变量：定义在方法内部的变量

在java中，变量使用之前一定要赋初值，否则编译报错

给变量赋值时，不可超过变量的数据类型的表示范围，否则会造成溢出

6. 数据类型

数据类型分为基本数据类型 和引用数据类型

6.1 引用数据类型

数组，类，接口，枚举类型

字符串属于引用类型

6.2 基本数据类型

基本数据类型有四类八种：

1. 四类：整型、浮点型、字符型以及布尔型
2. 八种：

数据类型	关键字	包装类	占用内存	范围
字节型	byte	Byte	1字节	-128 ~ 127
短整型	short	Short	2字节	-32768 ~ 32767
整型	int	Integer	4字节	------
长整型	long	Long	8字节	------
单精度浮点型	float	Flooat	4字节	有范围，一般不关注
双精度浮点型	double	Double	8字节	有范围，一般不关注
字符型	char	Character	2字节	0 ~ 65535
布尔型	boolean	Boolean	无明确规定	true 和 false

整型和浮点型都是带有符号的

int的包装类型为Integer
double 类型的内存布局遵守 IEEE 754 标准 ( 和 C 语言一样 ), 尝试使用有限的内存空间表示可能无限的小数 , 势必会存在一定的精度误差，因此浮点数是个近似值，并不是精确值。
为了区分int和long类型，长整型变量的初始值后加 L 或者 l ，推荐加 L ， 如果是小数不加 L 编译不通过。
float 类型在 Java 中占四个字节 , 同样遵守 IEEE 754 标准 . 由于表示的数据精度范围较小 , 一般在工程上用到浮点数都优先考虑 double。
单精度浮点型的初始值后加 F 或 f , 如果是小数不加 F 编译不通过。
为什么 Double.MIN_VALUE 打印出来的值为 4.9E-324 ,而不是 -2^61 ？

System.out.println(Double.MIN_VALUE); //4.9E-324

在 Java 中，Double.MIN_VALUE 表示的是 double 类型能够表示的最小正数值，而不是最小负数值。Double.MIN_VALUE 的值是 4.9E-324，这是因为 double 类型使用的是 IEEE 754 二进制浮点数格式。在 IEEE 754 二进制浮点数格式中，一个 double 类型的数由一个符号位、一个指数位和一个尾数位组成。对于 Double.MIN_VALUE，它的值是最小的正数，其指数部分被设置为全零，尾数部分除了最高位是 1，其余都是 0。在二进制表示下，这个值是：

0 00000000001 000...000（其余位为 0）

这里的 0 表示正数，00000000001 表示指数部分为全零（此时的偏移值为 1023，因为指数部分是 11 位，所以偏移量为 2^(11-1) - 1），000...000 表示尾数部分除了最高位以外都是 0。当将这个二进制数转换为十进制时，由于指数部分是全零，所以要乘以 2 的 (-1022) 次方（因为有一个偏移量），尾数部分最高位是 1，所以结果就是 2^(-1022)。但由于尾数部分还有其他位，所以实际上会比这个值稍大一点，因此 Double.MIN_VALUE 的值是 2^(-1022) 乘以一个小于 1 的数，最终结果是 4.9E-324。只有当指数部分为全 1 并且尾数部分全为 0 时，才能表示最小负数，其值是 -2^(-1022)，但这不是 Double.MIN_VALUE 表示的值。相反，Double.MIN_VALUE 表示的是能够表示的最小正数。

6.2.1 字符型变量

Java 中使用 单引号 + 单个字母 的形式表示字符字面值。
计算机中的字符本质上是一个整数 . 在 C 语言中使用 ASCII 表示字符 , 而 Java 中使用 Unicode 表示字符， 因此一个字符占用两个字节, 表示的字符种类更多 , 包括ASCII 表示的字符和 中文 。

public static void main(String[] args) {
        char a='好';
        char b='a';
        char c='b';
        int i=10;
        System.out.println(a);
        System.out.println(b);
        System.out.println(b-c);
        System.out.println(a+i);
    }

为什么 b-c 和 a+i 输出的结果为整型？

当执行System.out.println(b-c)时，Java会将字符'b'对应的Unicode码值减去字符'c'对应的Unicode码值，然后得到一个整数作为结果输出。当执行System.out.println(a+i)时，变量a对应的Unicode码值会被加上整数变量i的值，得到的结果同样会被自动转换成整型输出。这是因为在表达式中涉及到char类型变量时，Java会将这些char类型自动转换为其对应的Unicode码值进行计算，最后的结果会被自动转换成整型。

6.2.2 布尔型变量

1. boolean 类型的变量只有两种取值 , true 表示真, false 表示假.
2. Java 的 boolean 类型和 int 不能相互转换 , 不存在 1 表示 true, 0 表示 false 这样的用法 .

public static void main(String[] args) {
        boolean a=true;
        boolean b=false;
        System.out.println(a);
        System.out.println(b);
    }

7. 类型转换

在 Java 中，当参与运算数据类型不一致时，就会进行类型转换。 Java 中类型转换主要分为两类：自动类型转换 ( 隐式) 和 强制类型转换 ( 显式 ) 。

7.1 自动类型转换（隐式）

代码不需要经过任何处理，在代码编译时，编译器会自动进行处理 。特点： 数据类型范围小的转为数 据类型范围大的时会自动进行 。
整型默认为int型，浮点型默认为double型。

由于计算机的 CPU 通常是按照 4 个字节为单位从内存中读写数据. 为了硬件上实现方便,打印一个数字，在表达式中，如果操作数的类型比 int 类型小在使用之前先转换成 int 类型。

在表达式中如果操作数类型不同， 比int 类型小的操作数在使用之前先转换成 int 类型，比 int 类型大的操作数转换成表达式中 类型最大的操作数类型。

    public static void main(String[] args) {
        System.out.println(10); //整型默认为int型
        System.out.println(3.14); //浮点型默认为double型
        byte b=10;
        char c='h';
        System.out.println(b+c);//将b和c转换成int类型在进行计算
        int m=100;
        long n=10l;
        n=m;//long类型比int类型的范围大,将m赋值给n时，编译器会自动将m提升到long类型，然后赋值
        //m=n;//err 类型不兼容：long类型比int类型的范围大，从long转换到int可能会有数据丢失，报错
        System.out.println(n);
        int e=100;
        float f=3.14f;
        f=e;
        //e=f;//err 类型不兼容
        System.out.println(f);
        //byte y=128;//err 128超过了byte类型的范围，数据丢失
    }

7.2 强制类型转换（显性）

当进行操作时，代码需要经过一定的格式处理，不能自动完成。特点：数据范围大的到数据范围小的。
如果需要把范围大的类型赋值给范围小的 , 需要强制类型转换 , 但是 可能精度丢失
将一个字面值常量进行赋值的时候 , Java 会自动针对数字范围进行检查。
boolean类型和任何类型都不能转换。

    public static void main(String[] args) {
        float a=100.14f;
        int b=(int)a; // 强制类型转换 float -> int
        System.out.println(b);
        char c=(char)b; //强制类型转换 int ->char
        System.out.println(c);
        int d=100;
        char e=(char)d; //强制类型转换 int -> char
        System.out.println(e);
        char f=(char)a; //强制类型转换 float -> char
        System.out.println(f);
        float g=d;//隐式提升 int -> float
        System.out.println(g);
        int h=258;
        byte i=(byte)h;//h数值超出byte类型的范围
        System.out.println(i);
        byte j=100;
        byte k=38;
        //byte l=j+k;// err 类型不兼容：j和k首先整型提升成int类型再进行运算，得到一个整型数字，超出byte类型的范围，从int转换到byte可能会有数据丢失
    
    }

8. 字符串类型

如果 + 左右两边有一个字符串，则代表字符串的拼接。

8.1 int 转 String

 public static void main(String[] args) {
          String str1="hello ";
          String str2="world";
          int i=20;
          int j=30;
          String str3=String.valueOf(i);//调用String这个类型的方法，将整数转换成字符串
          String str4=i+"123";// + 将i与字符串123拼接变成一个新的字符串
        System.out.println(str4);
        System.out.println(str3+1);
        System.out.println(str1+str2);//+ 将两个字符串拼接
        System.out.println(i+j+str1);//先执行i+j整数相加操作，然后将字符串hello赋在后面
        System.out.println(str1+i+j);//先将字符串str1与i拼接变成一个字符串在与j拼接得到一个字符串
    }

8.2 String 转 int

  public static void main(String[] args) {
        String str="123";
        int i= Integer.valueOf(str);//调用Integer方法，将字符串转换成int类型
        System.out.println(i+1);
        int j=Integer.parseInt(str);//调用Integer方法，将字符串转换成int类型
        System.out.println(i+1);
    }

9. 运算符

这里只指出与c语言不同之处，详细说明请跳转： C语言---操作符plus版-CSDN博客

在c语言中以0表示真，非0表示假，但在java中并没有这一说法，而是以 true 表示真，false 表示假。

9.1 算数运算符

做除法（/）和取模（%）时，右操作数不能为0（除数不能为0）

9.1.1 /

 public static void main(String[] args) {
        System.out.println(10/3);//3
        System.out.println(10/(float)3);//3.3333333
        System.out.println((float) 10/3);//3.3333333
        System.out.println((float) (10/3));//3.0
    }

9.1.2 %

如果%左边的操作数为负数，则表达式的结果为负数。

 public static void main(String[] args) {
        System.out.println(10%3);//1
        System.out.println(-10%3);//-1
        System.out.println(10%-3);//1
        System.out.println(-10%-3);//-1
    }

在java中取模运算（%）也可以用于浮点型（float，double）

public static void main(String[] args) {
        float a=13.8f;
        float b=2.5f;
        System.out.println(a%b);
        double c=13.8;
        double d=2.5;
        System.out.println(c%d);
    }

9.2 增量运算符 += -= *= /= %= 等

增量运算符会帮我们进行类型转换

//以+=运算符为例
public static void main(String[] args) {
        int a=20;
        byte b=100;
        //b=b+a;//err 类型不兼容：从int类型转换到byte类型可能会有数据丢失
        b+=a;// b=(int)b+a //这里的+=运算符帮我们进行了类型转换
        System.out.println(b);//120
    }

关系运算符主要有六个：== != > < >= <=,其计算结果为true或false

当需要进行多次判断时不能连着写，为什么？以 a=8；3<a<5 为例

因为在java中判断的结果为true或false，3<a 的结果为 true ，但true<5 却没有办法比较。

短路求值:
对于 && , 如果 左侧表达式值为 false, 则表达式结果一定是 false, 无需计算右侧表达式 .
对于 ||, 如果 左侧表达式值为 true, 则表达式结果一定是 true, 无需计算右侧表达式 .
无符号右移运算符（<<<)：右边抛弃，左边补0。

注意：

1. 左移 1 位 , 相当于原数字 * 2. 左移 N 位 , 相当于原数字 * 2 的 N 次方 .
2. 右移 1 位 , 相当于原数字 / 2. 右移 N 位 , 相当于原数字 / 2 的 N 次方 .
3. 由于计算机计算移位效率高于计算乘除 , 当某个代码正好乘除 2 的 N 次方的时候可以用移位运算代替 .

4. 移动负数位或者移位位数过大都没有意义 .