Java基础知识

重案组之虎222
36 阅读18分钟

Java基础知识

1、注释

注释是对代码的解释和说明文字。

//单行注释
/*多行注释*/

2、关键字

2.1、定义

在Java语言中被赋予特殊含义的小写单词

2.2、分类

//用于定义数据类型的关键字
class,interface,byte,short,int,long,float,double,char,boolean,void
//用于定义数据类型值的关键字
true,false,null
//用于定义流程控制的关键字
if,else,switch,case,default,while,do,for,break,continue,return
//用于定义访问权限修饰符的关键字
private,protected,public
//用于定义类，方法，变量修饰符的关键字
abstract,final,static,synchronized
//用于定义类与类之间关系的关键字
extends,implements
//用于建立实例、引用实例及判断实例的关键字
new,this,super,instanceof
//用于异常处理的关键字
try,catch,finally,throw,throws
//用于包的关键字
package,import
//其他修饰符关键字
native,strictfp,transient,volatile,assert

3、标识符

3.1、定义

标识符就是给常量、变量、类、方法起名字

3.2、注意事项

  • 标识符由字母、数字、下划线"_"、美元符号"$"组成
  • 标识符不能以数字开头
  • 标识符不能是关键字
  • 标识符严格区分大小写

3.3、格式要求

  • 常量：

    规则：每个单词都大写，单词与单词之间用下划线分隔

    举例：IS_TRUE

  • 变量和方法名：小驼峰命名法

    规则：首字母小写，从第二个单词开始每个单词的首字母大写

    举例：studentName

  • 类名：大驼峰命名法

    规则：每个单词的首字母都大写

    举例：StudentInfo

4、数据类型

4.1、分类

img

4.2、取值范围

  • 图解：

    img

  • 描述：

    • byte：

      • byte 数据类型是8位、有符号的，以二进制补码表示的整数；
      • 最小值是 -128（-2^7） ；
      • 最大值是 127（2^7-1） ；
      • 默认值是 0；
      • byte 类型用在大型数组中节约空间，主要代替整数，因为 byte 变量占用的空间只有 int 类型的四分之一；
      • 例子：byte a = 100，byte b = -50。

    • short：

      • short 数据类型是 16 位、有符号的以二进制补码表示的整数
      • 最小值是 -32768（-2^15） ；
      • 最大值是 32767（2^15 - 1） ；
      • Short 数据类型也可以像 byte 那样节省空间。一个short变量是int型变量所占空间的二分之一；
      • 默认值是 0；
      • 例子：short s = 1000，short r = -20000。

    • int：

      • int 数据类型是32位、有符号的以二进制补码表示的整数；
      • 最小值是 -2,147,483,648（-2^31） ；
      • 最大值是 2,147,483,647（2^31 - 1） ；
      • 一般地整型变量默认为 int 类型；
      • 默认值是 0 ；
      • 例子：int a = 100000, int b = -200000。

    • long：

      • long 数据类型是 64 位、有符号的以二进制补码表示的整数；
      • 最小值是 -9,223,372,036,854,775,808（-2^63） ；
      • 最大值是 9,223,372,036,854,775,807（2^63 -1） ；
      • 这种类型主要使用在需要比较大整数的系统上；
      • 默认值是 0L；
      • 例子： long a = 100000L，Long b = -200000L。 "L"理论上不分大小写，但是若写成"l"容易与数字"1"混淆，不容易分辩。所以最好大写。

    • float：

      • float 数据类型是单精度、32位、符合IEEE 754标准的浮点数；
      • float 在储存大型浮点数组的时候可节省内存空间；
      • 默认值是 0.0f；
      • 浮点数不能用来表示精确的值，如货币；
      • 例子：float f1 = 234.5f。

    • double：

      • double 数据类型是双精度、64 位、符合 IEEE 754 标准的浮点数；

      • 浮点数的默认类型为 double 类型；

      • double类型同样不能表示精确的值，如货币；

      • 默认值是 0.0d；

      • 例子：

        double   d1  = 7D ;
double   d2  = 7.; 
double   d3  =  8.0; 
double   d4  =  8.D; 
double   d5  =  12.9867;

        7 是一个 int 字面量，而 7D，7. 和 8.0 是 double 字面量。

    • boolean：

      • boolean数据类型表示一位的信息；
      • 只有两个取值：true 和 false；
      • 这种类型只作为一种标志来记录 true/false 情况；
      • 默认值是 false；
      • 例子：boolean one = true。

    • char：

      • char 类型是一个单一的 16 位 Unicode 字符；
      • 最小值是 \u0000（十进制等效值为 0）；
      • 最大值是 \uffff（即为 65535）；
      • char 数据类型可以储存任何字符；
      • 例子：char letter = 'A';。

  • 整数取值范围的快速记忆：

    -2^(位数-1)~2^(位数-1)-1

    • 例如：byte 1个字节，8位，则取值范围为： -2^7~2^7-1

  • 浮点数范围的快速记忆：

    内存空间为四个部分：

    ------符号位指数符号位指数位尾数位总计
    float1172332
    double11105264
    作用用于保存浮点数的正负号（0：正，1：负）用于保存指数位的正负号影响浮点数的取值范围影响浮点数的精度

    以float为例：指数相关的内存占8bit，符号位1bit，指数位7bit。则指数的取值范围为[-127,128]

4.3、一些重要的字符集

  • ASCII字符集：共收录128个字符，包括空格、标点符号、数字、大小写字母和一些不可见字符。由于只有128个字符，所以可以使用一个字节来进行编码。
  • ISO 8859-1字符集（别名：Latin1） ：共收录256个字符，它在ASCII字符集的基础上又扩充了128个西欧常用字符（包括德法两国的字母）。它也可以使用一个字节来进行编码。
  • GB2312字符集：收录了汉字以及拉丁字母、希腊字母、日文平假名及片假名字母、俄语西里尔字母，收录汉字6763个，收录其他文字符号682个。这种字符同时又兼容ASCII字符集，所以在编码方式上有点奇怪：如果该字符在ASCII字符集中，则使用一字节编码；否则采用两字节编码。 （汉字采用2字节编码）
  • GBK字符集：GBK字符集只是在收录的字符范围上对GB2312字符集进行了扩充，编码方式兼容GB2312字符集。
  • UTF-8字符集：几乎收录了当今世界各国/地区使用的字符，而且还在不断的扩充。这种字符集兼容ASCII字符集，采用变长编码方式，编码一个字符时需要使用1~4字节。 （汉字采用3字节编码）
  • Unicode字符集：上面提到的UTF-8只是Unicode字符集的一种编码方案，Unicode字符集可以采用UNT-8、UTF-16、UTF-32这几种编码方案。UTF-8使用1~4字节编码一个字符，UTF-16使用2或4字节编注一个字符，UTF-32使用4字节编码一个字符。（Java语言采用的是Unicode编码，确切地说是 UTF - 16 编码来表示字符。）

5、常量

5.1、定义

在程序运行期间，其值不会发生改变的量，被称为常量

在Java中，利用关键字final指示常量。 例如：

//final修饰的变量只能赋值一次
final double TREE_LENGTH=30;

类常量，通常使用static final设置，可以被一个类中的多个方法同时使用，如果再加上public，那么其他类的方法也可以使用这个常量。 例如：

public class Example {
    //类常量 
    public static final int TREE_LENGTH = 10;
    
    public static void main(String[] args) {
        System.out.println(TREE_LENGTH);
    }
}

5.2、分类

常量类型说明举例
字符串常量用双引号括起来的内容"Hello world"
整数常量不带小数的数字666,-888
浮点数常量带小数的数字13.14,-5.20
字符常量用单引号括起来的单个内容'A','我','0'
布尔常量布尔值，表示真假true,false
空常量一个特殊的值，空值null

6、变量

6.1、定义

在程序运行期间，其值可以发生改变的量，被称为变量。

6.2、格式

变量类型 变量名 = 初始化值;

或

变量类型 变量名;
变量名=初始化值;

JDK10以后，可以用var来接收方法中的局部变量

6.3、注意事项

  • 同一对大括号内，变量名称不能重复
  • 在变量使用之前，必须要进行初始化
  • long数据后边需要加L、float数据后边需要加F
  • 整数默认是int类型、浮点默认是double类型

7、类型转换

  • 自动类型转换：

    把小范围数据类型赋值给大范围数据类型，由于精度并不会丢失，因此这种转换是自动的

    如图：

    img

  • 强制类型转换：

    把大范围数据类型赋值给小范围数据类型，由于精度可能会丢失，因此需要进行强制转换

    格式：目标数据类型 变量名 = (目标数据类型)(表达式或变量);

8、运算符和表达式

  • 运算符：对常量或者变量进行操作的符号
  • 表达式：用运算符把常量或者变量连接起来符合Java语法的式子被称为表达式

8.1、算术运算符

符号作用举例说明
+加7+37+3=10
-减7-37-3=4
*乘7*37-3=21
/除7/37/3=2
%取余7%37%3=1

8.2、自增和自减

符号作用举例说明
++自增int i = 10; i++;i=11
--自减int i = 10; i--;i=9

注意： ++i、i++、--i、i--的区别

int i = 0;
i = i++; 
System.out.println("i = " + i); //0

int a = 2; 
int b = (3 * a++) + a;
System.out.println(b);//9

int a = 2; 
int b = a + (3 * a++);
System.out.println(b);//8

int i = 1;
int j = 1;
int k = i++ + ++i + ++j + j++; 
System.out.println(k);//8

int a = 0;
int b = 0;
a = a++;//a=0
b = a++;//b=0;a=1
System.out.println("a = " + a + ", b = " + b);//a = 1, b = 0

  • 原理：

    i++ 即后加加，原理是：先自增，然后返回自增之前的值 ++i 即前加加，原理是：先自增，然后返回自增之后的值

8.3、赋值运算符

符号作用举例说明
=赋值a=10将10赋值给变量a
+=加后赋值a+=b将a+b的值给变量a
-=减后赋值a-=b将a-b的值给变量a
*=乘后赋值a*=b将a*b的值给变量a
/=除后赋值a/=b将a/b的值给变量a
%=取余后赋值a%=b将a%b的值给变量a

注意：

short s = 10;
s = s + 10;  //此行代码报错，因为运算中s提升为int类型，运算结果int赋值给short可能损失精度
​
short s = 10;
s += 10;     //此行代码正确，隐含了强制类型转换，相当于 s = (short)(s + 10);

8.4、关系运算符

符号作用举例说明
==判断是否相等a==b判断a和b的值是否相等，成立为true，不成立为false
!=判断是否不等a!=b判断a和b的值是否不等，成立为true，不成立为false
判断是否大于a>b判断a是否大于b，成立为true，不成立为false
>=判断是否大于等于a>=b判断a是否大于等于b，成立为true，不成立为false
<判断是否小于a<b判断a是否小于b，成立为true，不成立为false
<=判断是否小于等于a<=b判断a是否小于等于b，成立为true，不成立为false

8.5、逻辑运算符

符号作用说明
&逻辑与“与”，并且的关系，只要表达式中有一个值为false，结果即为false
|逻辑或“或”，或者的关系，只要表达式中有一个值为true，结果即为true
!逻辑非true变false、false变true
逻辑异或如果两边相同，结果为false，如果两边不同，结果为true
&&短路与作用和&相同，但是有短路效果，如果左边为false，右边就不执行了
||短路或作用和相同，但是有短路效果，如果左边为true，右边就不执行了

8.6、三元运算符

  • 格式： 格式：关系表达式 ? 表达式1 : 表达式2;
  •   int a = 10;
  int b = 20;
  int max = a > b ? a : b;//关系表达式为true,max=a;为false，max=b
  System.out.println(max);//20

9、数据输出和输入

  • 数据输出：

    • 输出后换行

      System.out.println(常量/变量/方法返回值/对象/表达式);

    • 输出不换行

      System.out.print(常量/变量/方法返回值/对象/表达式);

    • 格式化输出：沿用了C语言函数库中的printf方法

      //例如：打印x:包含8个字符，精度为小数点后两位
System.out.printf("%8.2f",x)
//可以是多个参数
System.out.printf("Hello,%s.Next year,you`ll be %d",name,age)
//可以使用标志位
System.out.printf("%,.2f",10000.0/3.0)//输出3，333.33  逗号为标志

      prinft转换符和prinft标志自行百度

  • 数据输入：

    import java.util.Scanner;
​
public class Main {
    public static void main(String[] args) {
        //构造标准输入流System.in关联的Scanner对象
        Scanner sc = new Scanner(System.in);
        //使用Scanner提供的各种方法读取输入
        int i = sc.nextInt();
        System.out.println(i);
    }
}

10、分支结构（if、switch）

10.1、if语句

  • 格式一：

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

  • 流程一：

    • 首先计算关系表达式的值
    • 如果关系表达式的值为true就执行语句体
    • 如果关系表达式的值为false就不执行语句体
    • 继续执行后面的语句内容

  • 格式二：

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

  • 流程二：

    • 首先计算关系表达式的值
    • 如果关系表达式的值为true就执行语句体1
    • 如果关系表达式的值为false就执行语句体2
    • 继续执行后面的语句内

  • 格式三：

    if (关系表达式1) {
    语句体1;
} else if (关系表达式2) {
    语句体2;
}
...
else {
    语句体n+1;
}

  • 流程三：

    • 首先计算关系表达式1的值
    • 如果值为true就执行语句体1；如果值为false就计算关系表达式2的值
    • 如果值为true就执行语句体2；如果值为false就计算关系表达式3的值
    • ....
    • 如果没有任何关系表达式为true，就执行语句体n+1。

10.2、switch语句

  • 格式：

    switch (关系表达式) {
    case 1:
        语句体1;
        break;
    case 2:
        语句体2;
        break;
    ...
    default:
        语句体n+1;
        [break;]
}

  • 流程：

    • 首先计算出关系表达式的值
    • 和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束
    • 如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉，注意default中的break可以省略

  • 注意：

    • 关系表达式的取值可以是byte、short、int、char
    • JDK5以后可以是枚举
    • JDK7以后可以是String

11、循环结构（for、while、do...while）

11.1、for语句

  • 格式：

    for (初始化语句;条件判断语句;条件控制语句) {
    循环体语句;
}

  • 流程：

    • 执行初始化语句
    • 执行条件判断语句，看其结果是true还是false，如果是false，循环结束，如果是true，继续执行
    • 执行循环体语句
    • 执行条件控制语句
    • 回到 第二条 继续

11.2、while语句

  • 格式：

    初始化语句;
while (条件判断语句) {
    循环体语句;
    条件控制语句;
}

  • 流程：

    • 执行初始化语句
    • 执行条件判断语句，看其结果是true还是false，如果是false，循环结束，如果是true，继续执行
    • 执行循环体语句
    • 执行条件控制语句
    • 回到 第二条 继续

11.3、do...while语句

  • 格式：

    初始化语句;
do {
    循环体语句;
    条件控制语句;
}while(条件判断语句);

  • 流程：

    • 执行初始化语句
    • 执行循环体语句
    • 执行条件控制语句
    • 执行条件判断语句，看其结果是true还是false，如果是false，循环结束，如果是true，继续执行
    • 回到 第二条 继续

11.4、死循环语句

第一种：
for(;;){
    
}
第二种：
while(true){
    
}
第三种：
do{
    
}while(true);

12、跳转控制

goto作为Java保留关键字，实际上并没有使用。

break：//跳出所有循环，循环语句结束
continue：//跳过本次循环，继续下次循环
for (int i = 0; i < 5; i++) {
    if (i==2) {
        //continue;//结果为0 1 3 4
        break;//结果为 0 1
    }
    System.out.println(i);
}

13、数组

13.1、定义

  • 数组是用于储存多个相同类型数据的有序集合。
  • 组成数组的各个变量称为数组的分量，也称为数组的元素，有时也称为下标变量。
  • 用于区分数组的各个元素的数字编号称为下标。

13.2、格式

第一种：数据类型[] 数组名;
第二种：数据类型 数组名[];

13.3、初始化

动态初始化
含义：数组动态初始化就是只给定数组的长度，由系统给出默认初始化值
格式：数据类型[] 数组名 = new 数据类型[数组长度];
举例：int[] arr = new int[3];
​
静态初始化
含义：在创建数组时，直接将元素确定，由系统给出数组长度
格式：数据类型[] 数组名 = new 数据类型[]{元素1,元素2,...};
简化：数据类型[] 数组名 = {元素1,元素2,...};
举例：int[] arr = {1, 2, 3};

13.4、数组遍历

public class Main {
    public static void main(String[] args) {
        //定义数组
        int[] arr = {11, 22, 33, 44, 55};
        //数组遍历 arr.length：代表数组个数
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
        //增强for循环 循环对象必须是数字或者一个实现了Iterable接口的类对象（例如ArrayList）
        for (int i : arr) {
            System.out.println(i);
        }
    }
}

  • 常见异常：

    • ArrayIndexOutOfBoundsException：数组下标越界异常
    • NullPointerException：空指针异常

13.5、数组拷贝

在Java中，允许将一个数组变量拷贝到另一个数组变量。

  • 两个变量引用一个数组：

    int[] oldArr = {11, 22, 33, 44, 55};
int[] newArr = oldArr;

  • 将数组拷贝到一个新数组里面：

    int[] oldArr = {11, 22, 33, 44, 55};
//第二个为新数组的长度，可以增加数组的大小，如果长度小于原始数组的长度，则只拷贝前面的值
int[] newArr = Arrays.copyOf(oldArr,2*oldArr.leangth);

13.6、数组排序

要想对数组进行排序，可以使用Arrays类的sort方法

int[] a = new int[1000];
//赋值...
Arrays.sort(a);

Arrays还提供了很多便捷的方法，具体可参照相关API;

13.7、命令行参数

我们已经见到很多次main方法上的args字符串参数。其实我们javac将主类编译成class文件执行时，可以这样用到：

java Message a1 a2 a3 `main方法所在类名`

此时 args 数组值为

args = {"a1","a2","a3"}

13.8、二维数组（矩阵）

13.8.1、创建
  • 数据类型[][] 数组名 = new 数据类型[行长度] [列长度];
  • 数据类型[][] 数组名 = new 数据类型[][]{{元素1,元素2,...},{元素1,元素2,...},...};
  • 数据类型[][] 数组名 = {{元素1,元素2,...},{元素1,元素2,...},...};
13.8.2、遍历
int[][] matrix = {
        {16, 3, 3},
        {2, 5, 8},
        {11, 4, 8},
        {3, 7, 66}
};
//第一种，下标循环
for (int i = 0; i < matrix.length; i++) {
    for (int j = 0; j < matrix[i].length; j++) {
        System.out.print(matrix[i][j] + " ");
    }
    System.out.println();
}
System.out.println("-------------------");
//第二种，增强for
for (int[] row : matrix) {
    for (int val : row) {
        System.out.print(val+" ");
    }
    System.out.println();
}
System.out.println("-------------------");
//第三种：工具类
System.out.println(Arrays.deepToString(matrix));

image-20230716001444124

14、方法

14.1、定义

是将具有独立功能的代码块组织成为一个整体，使其具有特殊功能的代码集

14.2、格式

[权限修饰符] [static] 返回值类型 方法名(参数列表) {
    方法体;
    return 数据;
}

14.3、形参实参

  • 形参：方法定义中的参数
  • 实参：方法调用中的参数

14.4、参数传递

  • 方法参数传递基本类型：基本数据类型的参数，形式参数的改变，不会影响实际参数
  • 方法参数传递引用类型：对于引用类型的参数，形式参数的改变，影响实际参数的值

14.5、可变参数

    //参数为可变参数，可以传0个或多个参数进去
    public static void method1(Integer... args){ }
    //参数为数组,必须要传数组参数进去
    public static void method2(Integer[] args){ }
  • 可变参数是指在调用方法时传入不定长度的参数，本质上是基于数组实现的
  • 在定义方法时，在最后一个形参上加"…"就表示该形参可以接受多个参数值，多个参数值被当做数组传入。
  • 可变参数只能做为函数的最后一个参数，前面有没有其他参数都可以，一个函数最多只能有一个可变参数。

14.6、方法重载

指同一个类中定义的多个方法之间的关系，满足下列条件的多个方法相互构成重载

  • 多个方法在同一个类中
  • 多个方法具有相同的方法名
  • 多个方法的参数不相同：参数类型或者数量不同

14.7、注意事项

  • 方法不能嵌套定义，但是方法可以嵌套调用
  • 方法必须先定义，后调用，否则程序将报错
  • 方法定义时，多个参数之间使用逗号(,)分隔
  • void表示无返回值，return可省略也可不省
avatar
文章
阅读
粉丝