JavaSE系列Java基础

Posted 一宿君

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了JavaSE系列Java基础相关的知识，希望对你有一定的参考价值。

这里写目录标题

一、运行环境

1.1 Java虚拟机–JVM

  • JVM（Java Virtual Machine ）：Java虚拟机，简称JVM，是运行所有Java程序的假想计算机，是Java程序的 运行环境，是Java 最具吸引力的特性之一。我们编写的Java代码，都运行在 JVM 之上。

  • 跨平台：任何软件的运行，都必须要运行在操作系统之上，而我们用Java编写的软件可以运行在任何的操作系 统上，这个特性称为Java语言的跨平台特性。该特性是由JVM实现的，我们编写的程序运行在JVM上，而JVM 运行在操作系统上。

1.2 JRE和JDK

  • JRE (Java Runtime Environment) ：是Java程序的运行时环境，包含 JVM 和运行时所需要的 核心类库 。
  • JDK (Java Development Kit)：是Java程序开发工具包，包含 JRE 和开发人员使用的工具。 我们想要运行一个已有的Java程序，那么只需安装 JRE 即可。 我们想要开发一个全新的Java程序，那么必须安装 JDK 。

$$
小贴士：

三者之间的关系：JDK > JRE > JVM
$$

二、编译和运行

2.1 编译和运行是两回事

  • 编译：是指将我们编写的Java源文件翻译成JVM认识的.class文件，在这个过程中， javac 编译器会检查我们所写的程序是否有错误，有错误就会提示出来，如果没有错误就会编译成功。
  • 运行：是指将.class文件交给虚拟机JVM去运行，此时JVM就会去执行我们编写的程序了。

2.2 标识符

  • 标识符
    • HelloWorld案例中，出现的标识符有类名字 HelloWorld 。
  • 命名规则
    • 标识符可以包含 英文字母26个(区分大小写) 、 0-9数字 、 $（美元符号） 和 _（下划线） 。
    • 标识符不能以数字开头。
    • 标识符不能是关键字。
  • 命名规范
    • 类名规范：首字母大写，后面每个单词首字母大写（大驼峰式）,例如HelloWorld。
    • 方法名规范： 首字母小写，后面每个单词首字母大写（小驼峰式），例如getAllByUsername。
    • 变量名规范：全部小写，例如id、username、password。

三、常量和变量

3.1 常量

  • 常量：是指在java程序中固定不变的数据。
  • 常量的分类
类型含义数据举例
整数常量所有的整数0，1， 567， -9
小数常量所有的小数0.0， -0.1， 2.55
字符常量单引号引起来,只能写一个字符,必须有内容‘a’ , ‘好’
字符串常量双引号引起来,可以写多个字符,也可以不写“A” ，“abc” ，“你好” ，“”
布尔常量只有两个值（流程控制中讲解）true ， false
空常量只有一个值（引用数据类型中讲解）null

3.2 变量

  • 变量：常量是固定不变的数据，那么在程序中可以变化的量称为变量。

数学中，可以使用字母代替数字运算,例如 x=1+5 或者 6=x+5。
程序中，可以使用字母保存数字的方式进行运算，提高计算能力，可以解决更多的问题。比如x保存5，x也可 以保存6，这样x保存的数据是可以改变的，也就是我们所讲解的变量。

注意事项：
1.Java中要求一个变量每次只能保存一个数据，必须要明确保存的数据类型。
2.变量名称：在同一个大括号范围内，变量的名字不可以相同。
3.变量赋值：定义的变量，不赋值不能使用

四、数据类型

4.1 数据类型分类

java数据类型分为两大类：引用数据类型和基本数据类型。

  • 引用数据类型

    • 包括类、数组、接口。

  • 基本数据类型（ 4类8种数据类型）

    数据类型关键字内存占用取值范围
    字节型byte1个字节-128~127
    短整型short2个字节-32768~32767
    整型int(默认)4个字节-2147483648~2147483647
    长整型long8个字节-2的63次方~2的63次方
    单精度浮点数float4个字节1.4013E~3.4028E+38
    双精度浮点数double(默认)8个字节4.9E-324~1.7977E+308
    字符型char2个字节0~65535
    布尔类型boolean1个字节true，false

    小贴士：
    Java中的默认类型：整数类型是 int 、浮点数类型是 double 。

    long类型：建议数据后加L表示。

    float类型：建议数据后加F表示。

4.2、数据类型转换

  • 自动类型转换

  • 转换规则：将取值范围小的类型自动提升为取值范围大的类型 。

  • ```java
    public static void main(String[] args)
    int a = 10;
    double b = 2.5;
    //int自动提升为double类型
    //自动类型转换时，取值范围小的类型直接转换为取值范围大的类型
    double c = a + b;
    System.out.println©;

小贴士（取值范围由小->大）：
byte、short、char‐‐>int‐‐>long‐‐>float‐‐>double

  • 强制类型转换

    • 转换规则：将取值范围大的类型强制转换成取值范围小的类型 。
    • 转换格式：数据类型 变量名 = （数据类型）被转数据值;
    public static void main(String[] args) 
        //short短整型变量，内存中占2个字节
        short s = 1;
        /*
        出现编译失败
        s和1做运算的时候，1是int类型，s会被提升为int类型
        s+1后的结果是int类型，将结果在赋值成short类型时会发生错误
        short内存占2个字节，int类型占4个字节
        必须将int强制转成short才能完成赋值成功
        */
        s = s + 1;//编译失败
        s = (short)(s+1);//编译成功①
        s+=1;//编译成功②，②是①通过内部强转得到的

特别注意：

比较而言，自动转换是Java自动执行的，而强制转换需要我们自己手动执行；

浮点数转成整数，直接取消小数点及小数点后的数据，可能造成数据损失精度。

4.3 常用ASCII编码表(美国标准信息交换码)

字符数值
048
957
A65
Z90
a97
z122

五、运算符

5.1 算数运算符（Java中，整数使用这些算数运算符，无论怎么计算，也不会得到小数）

算术运算符包括：+、-、* 、/、%、++、- -。

  • ++运算/–运算：变量自增1/自减1

    • 独立运算：独立运算时，变量前++和变量后++没有区别；
    • 混合运算（i=1）
      • 变量前++（++i）：先加一再赋值。
      • 变量后++（i++）：先赋值再加一。
    public static void main(String[] args) 
        int a = 5;
        //先对a进行+1操作，再把a的值作为++a的值,赋值给b
        int b = ++a;//此时a=6,b=6
        //先取a的值作为a++的值，赋值给c，在对a进行+1操作
        int c = a++;//此时c=5，a=6
        System.out.println(a+","+b);//6,6
        System.out.println(a+","+c);//6,5

  • +符号在字符串中的操作

    • 加法：纯数字的加法操作；
    • 连接/拼接：在遇到字符串的时候，表示连接、拼接的含义。
    public static void main(String[] args) 
       int a = 5;
       int b = 6;
       String c = "Hello";
       System.out.println(a+b);//11：进行纯数字加操作
       System.out.println(a+c);//5Hello：进行字符串拼接操作

5.2 赋值运算符

赋值运算符包括：=、+=、-=、*=、/+、%=。

  • 赋值运算符，就是将符号右边的值，赋给左边的变量。

5.3 比较运算符

比较运算符包括：==、<、>、<=、>=、!=。

  • 比较运算符，是两个数据之间进行比较的运算，运算结果都是布尔值 true 或者 false 。

5.4 逻辑运算符

逻辑运算符包括：&&、||、！。

  • 逻辑运算符，是用来连接两个布尔类型结果的运算符，运算结果都是布尔值 true 或者 false。

5.5 三元运算符

  • 三元运算符格式：

    数据类型 变量名 = 布尔类型表达式 ? 结果1 : 结果2

  • 三元运算符运算方式：

    • 布尔类型表达式结果是true，三元运算符整体结果为结果1，赋值给变量；
    • 布尔类型表达式结果是false，三元运算符整体结果为结果2，赋值给变量。

六、流程控制语句

6.1 判断语句

  • if语句

    if(关系表达式)
	语句体;
｝

执行流程：
首先判断关系表达式看其结果是true还是false
如果是true就执行语句体
如果是false就不执行语句体

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dKqPoX1X-1658191090673)(C:\\Users\\wang’bo’shi\\AppData\\Roaming\\Typora\\typora-user-images\\image-20210126201647096.png)]

  • if…else语句

    if(关系表达式)
	语句体1;
else
	语句体2;

执行流程：
首先判断关系表达式看其结果是true还是false
如果是true就执行语句体1
如果是false就执行语句体2

  • if…else if…else语句

    if(判断条件1)
	执行语句1;
else if(判断条件2)
	执行语句2;

……
else if(判断条件n)
	执行语句n;
else
	执行语句n+1;

执行流程：
首先判断关系表达式1看其结果是true还是false
如果是true就执行语句体1
如果是false就继续判断关系表达式2看其结果是true还是false
如果是true就执行语句体2
如果是false就继续判断关系表达式…看其结果是true还是false
…
如果没有任何关系表达式为true，就执行语句体n+1

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eN8QVZ3Z-1658191090675)(C:\\Users\\wang’bo’shi\\AppData\\Roaming\\Typora\\typora-user-images\\image-20210126201822055.png)]

  • if语句与三元运算符的互换

    public static void main(String[] args) 
      int a = 20;
      int b = 10;
      //定义变量，保存a和b的最大值
      int c;
      if (a > b)
          c = a;
      else 
          c = b;
      
      System.out.println("1.输出最大值为："+c);
      //用三元运算符代替if...else判断语句，结果相同
      c = a > b ? a : b;
      System.out.println("2.输出最大值为："+c);

6.2 选择语句

  • 选择语句–switch

    switch(表达式)
	case 常量值1:
		语句体1;
		break;
	case 常量值2:
		语句体2;
		break;
	...
	default:
		语句体n+1;
		break;

    执行流程：
    首先计算出表达式的值
    其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束。
    最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。

  • case的穿透性
    在switch语句中，如果case的后面不写break，将出现穿透现象，也就是不会在判断下一个case的值，直接向后运行，直到遇到break，或者整体switch结束。

    public static void main(String[] args) 
      int a = 5;
      switch (a)
          case 0:
              System.out.println("执行case0");
              break;
          case 5:
              System.out.println("执行case5");
          case 10:
              System.out.println("执行case10");
          default:
              System.out.println("执行default");
      
      /*最后程序执行结果是
      执行case5
      执行case10
      执行default
      */

    小贴士：
    上述程序中，执行case5后，由于没有break语句，程序会一直向后走，不会在判断case，也不会理会break，直接运行完整体switch。由于case存在穿透性，因此初学者在编写switch语句时，必须要写上break。

    switch语句中，表达式的数据类型，可以是byte，short，int，char，enum（枚举），JDK7版本后可以接收字符串。

6.3 循环语句

  • for循环

    for(初始化表达式①; 布尔表达式②; 步进表达式④)
	循环体③

    执行流程：
    执行顺序：①②③④>②③④>②③④…当②不满足时才会停止循环，执行其他语句。
    ①负责完成循环变量初始化
    ②负责判断是否满足循环条件，不满足则跳出循环
    ③具体执行的语句
    ④循环后，循环条件所涉及变量的变化情况

  • while循环

    初始化表达式①
while(布尔表达式②)
	循环体③
	步进表达式④

    执行流程：
    执行顺序：①②③④>②③④>②③④…②不满足为止。
    ①负责完成循环变量初始化。
    ②负责判断是否满足循环条件，不满足则跳出循环。
    ③具体执行的语句。
    ④循环后，循环变量的变化情况。

  • do…while循环

    初始化表达式①
do
	循环体③
	步进表达式④
while(布尔表达式②);

    执行流程：
    执行顺序：①③④>②③④>②③④…②不满足为止。
    ①负责完成循环变量初始化。
    ②负责判断是否满足循环条件，不满足则跳出循环。
    ③具体执行的语句
    ④循环后，循环变量的变化情况

    public static void main(String[] args) 
        //使用循环输出10次HelloWorld
        //1.for循环
        for (int i = 0;i < 10;i++)
            System.out.println("HelloWorld"+i);
        
        //2.while循环
        int j = 1;
        while (j <= 10)
            System.out.println("HelloWorld"+j);
            //步进表达式
            j++;
        
        //3.do...while循环
        int x = 1;
        do 
            System.out.println("HelloWorld"+x);
            x++;
        while (x <= 10)

  • 嵌套循环

    所谓嵌套循环，是指一个循环的循环体是另一个循环。比如for循环里面还有一个for循环，就是嵌套循环。总共的循环次数=外循环次数*内循环次数

    for(初始化表达式①;循环条件②;步进表达式⑦)
  	for(初始化表达式③;循环条件④;步进表达式⑥)
  		执行语句⑤;

    执行流程：
    执行顺序：①②③④⑤⑥>④⑤⑥>⑦②③④⑤⑥>④⑤⑥
    外循环一次，内循环多次。
    比如跳绳：一共跳5组，每组跳10个。5组就是外循环，10个就是内循环。

    public static void main(String[] args) 
        //使用嵌套循环，打印5*8的矩形
        //5*8的矩形，打印5行*号，每行8个(5行8列)
        //外循环5次，内循环8次
        for (int i = 0;i < 5;i++)
            for (int j = 0;j < 8;j++)
                System.out.print("*");
            
            //内循环打印8个*后，需要一次换行
            System.out.println();

  • 死循环

    死循环：也就是循环中的条件永远为true，死循环的是永不结束的循环。例如：while(true)。

  • 跳出语句

  • break

    使用场景：终止switch或者循环

  • continue

    使用场景：结束本次循环，继续下一次的循环

    public static void main(String[] args) 
        for (int i = 1;i <= 10;i++)
            if (i == 3)
                /*
                break;
                输出 HelloWorld1 HelloWorld2
                */
                /*
                continue;
                输出 除了HelloWorld3其他全都输出
                */
            
            System.out.println("HelloWorld"+i);

[^for 和 while 的小区别：]: 控制条件语句所控制的那个变量，在for循环结束后，就不能再被访问到了，而while循环结束还可以继 续使用，如果你想继续使用，就用while，否则推荐使用for。原因是for循环结束，该变量就从内存中消 失，能够提高内存的使用效率。 在已知循环次数的时候使用推荐使用for，循环次数未知的时推荐使用while。

七、数组

7.1 数组的定义和访问

  • 数组的概念

    数组的概念：数组就是存储数据长度固定的容器，保证多个数据的数据类型要一致。

  • 数组的定义（三种）

  • #### 格式一：

  • [ ]

数组存储的数据类型[] 数组名字 = new 数组存储的数据类型[长度]；
int[] arr = new int[3];

int 数组存储的数据类型：创建的数组容器可以存储什么数据类型。
[]:表示数组。
数组名字：为定义的数组起个变量名，满足标识符规范，可以使用名字操作数组。
new：关键字，创建数组使用的关键字。
int 数组存储的数据类型：创建的数组容器可以存储什么数据类型。
[长度]：数组的长度，表示数组容器中可以存储多少个元素。
注意：数组有定长特性，长度一旦指定，不可更改。
（和水杯道理相同，买了一个2升的水杯，总容量就是2升，不能多也不能少。）

  • #### 格式二：

    数据类型[] 数组名 = new 数据类型[]元素1,元素2,元素3...;
int[] arr = new int[]1,2,30;

  • #### 格式三：

    数据类型[] 数组名 = 元素1,元素2,元素3...;
int[] arr = 1,2,3,4,5;

  • 数组的访问

    • 索引：每一个存储到数组的元素，都会自动的拥有一个编号，从0开始，这个自动编号称为数组索引(index)，可以通过数组的索引访问到数组中的元素。

    • 格式：

    • ```java
      数组名[索引]

    • [ ]

    • 数组的长度属性：每个数组都具有长度，而且是固定的，Java中赋予了数组的一个属性，可以获取到数组的长度，语句为：数组名.length，属性length的执行结果是数组的长度，int类型结果。由此可以推断出，数组的最大索引值为 数组名.length-1。

    • ```java
      public static void main(String[]args)
      int[] arr=new int[]1,2,3,4,5;//打印数组的长度属性，输出结果是5
      System.out.println(arr.length);

    • [ ]

    • 索引访问数组中的元素：

    • ```java
      数组名[索引] = 数值; //为数组中的元素赋值
      变量 = 数组名[索引]; //获取出数组中的元素

      
```java
public static void main(String[]args)
  	//定义存储int类型数组，赋值元素1，2，3，4，5
  	int[] arr = 1,2,3,4,5;
  	//为0索引元素赋值为6
  	arr[0]=6;
  	//获取数组0索引上的元素
  	int i  = arr[0];
  	System.out.println(i);
  	//直接输出数组0索引元素
  	System.out.println(arr[0]);

7.2 数组原理内存图

  • 内存概述

    内存是计算机中的重要原件，临时存储区域，作用是运行程序。我们编写的程序是存放在硬盘中的，在硬盘中的程序是不会运行的，必须放进内存中才能运行，运行完毕后会清空内存。

    Java虚拟机要运行程序，必须要对内存进行空间的分配和管理。

  • java虚拟机的内存划分

    JVM的内存划分：

区域名称作用
寄存器给CPU使用，和我们开发无关。
本地方法栈JVM在使用操作系统功能的时候使用，和我们开发无关。
方法区存储可以运行的class文件。
堆内存存储对象或者数组，new是用来创建的，都存储在堆内存。
方法栈方法运行时使用的内存，比如main方法运行，进入方法栈中执行。