1. 技术文章
  2. Java 基础语法学习整理笔记

Java 基础语法学习整理笔记

由 ☆樱花仙子☆ 提交于 2019-12-02 22:56:31

Java 基础语法学习整理笔记

文章目录

标识符

  • 标识符：是在程序当中，我们自定义的内容。比如类的名字、方法的名字和变量的名字等等

  • 命名规则：

    • 标识符可以包含：英文字母（区分大小写）、数字、字符 & 和 _
    • 标识符不能以数字开头
    • 标识符不能是关键字

  • 命名规范：

    • 类名规范：首字母大写，后面的每个单词首字母大写（大驼峰）
    • 变量名规范：首字母小写，后面每个单词首字母大写（小驼峰）
    • 方法名规范：通变量名

常量

常量的分类

  • 字符串常量
  • 整数常量
  • 浮点数常量
  • 字符常量
  • 布尔常量
  • 空常量

基本数据类型

  • 整数型
    • 字节型（byte）1 个字节，(−27,27−1)(-2^{7}, 2^{7}-1)
    • 短整型（short）2 个字节，(−215,215−1)(-2^{15}, 2^{15}-1)
    • 整形（int）4 个字节，(−231,231−1)(-2^{31}, 2^{31}-1)
    • 长整型（long）8 个字节，(−263,263−1)(-2^{63}, 2^{63}-1)
  • 浮点型
    • 单精度（float）4 个字节，(1.4013e−45,3.4028e38−1)(1.4013e^{-45}, 3.4028e^{38}-1)
    • 双精度（double） 8 个字节，(4.9e−324,1.7977e308−1)(4.9e^{-324}, 1.7977e^{308}-1)
  • 字符型（char）2 个字节，(0,216−1)(0, 2^{16}-1)
  • 布尔型（boolean）1 个字节，(true, flase)

注意事项：
1、字符串不是基本类型、而是引用类型
2、浮点型可能只是一个近似值，并非精确的值
3、数据范围与字节数不一定相关，例如 float 数据范围比 long 更加广泛，但是 float 是 4 个字节，long 是 8 个字节
浮点数当中默认类型是 double，如果一定要使用 float 类型，需要在后面加上一个 F 后缀。同理整数中默认类型是 int 类型，如果要使用 long 类型，需要加上一个后缀 L，推荐使用大写字母后缀

eg: 
System.out.println(100L)    // 输出 long
System.out.println(0.5F)    // 输出 float

引用数据类型

字符串、数组、类、接口、lambda

变量

注意事项

  • 1、如果创建多个变量，那么变量之间的名称不可以重复
  • 2、对于 float 和 long 来说，字母后缀 F 和 L 不要丢掉
  • 3、如果使用 byte 或者 short 类型的变量，那么右侧的数据值不能超过左侧类型的范围
  • 4、没有进行赋值的变量，不能直接使用，一定要赋值，才能使用
  • 5、变量使用不能超过作用域的范围：
    【作用域】：从定义变量的一行开始，一直到直接所属的大括号为止
  • 6、可以通过一个语句来创建多个变量，但是一般情况不建议使用

数据类型转换

自动类型转换（隐式）

1、特点：代码不需要进行特殊处理，自动完成
2、规则：数据范围从小到到大


// int --> long 
long num1 = 100;
// 输出：100

// float --> double
double num2 = 2.5F;
// 输出：2.5

// int --> float
float num3 = 30L;
// 输出：30.0

// 都符合从小到大的规则

强制类型转换（显式）

1、特点：代码需要进行特殊的格式处理，不能自动完成
2、格式：范围小的类型 范围小的变量名 = (范围小的类型)原本范围大的数据;


int num = (int)100L;
System.out.println(num);
// 输出：100

注意事项：
1、强制类型转换一般不推荐使用，因为有可能发生精度损失、数据溢出
2、byte / short / char 这三种类型都可以发生数学运算，比如加法
3、byte / short / char 这三种类型都可以发生数学运算，但是会首先提升成为 int 类型，然后再计算
4、boolean 类型不能转换数据类型转换


// 数据溢出，超出 int 的范围
int num2 = (int)6000000000L;
System.out.println(num2);

// 精度丢失
int num3 = (int)3.5;
System.out.println(num3);   // 并不是四舍五入
// 输出：3

// 字符运算
char char_1 = 'A';
System.out.println(char_1 + 1);
// 输出：66

// byte 运算
byte num4 = 40;
byte num5 = 50;
// byte result = num4 + num5
int result1 = num4 + num5
System.out.println(result1);
// 输出：90

// short 运算
short num6 = 60;
int result2 = num4 + num6;
System.our.println(result2);
//输出：100

算数运算符

四则运算

加(+)、减(-)、乘(*)、除(/)

取模

%

10 % 3  = 1

注意事项
一旦运算当中有不同类型的数据，那么结果将会是数据类型范围大的那种


int x = 10;
double result = x + 2.5;
System.out.println(result);
//输出：12.5

加号的三种形式

1、对于数值类型
2、对于字符类型
3、对于字符串类型


String str1 = "Hello";
System.out.println("Hello" + "World");
// 输出：HelloWorld
System.out.pintln(str1 + "World");
// 输出：HelloWorld

String str2 = "Java";
System.out.println(str2 + 20);
// 输出：Java20

System.out.println(str2 + 20 + 30);
// 输出：Java2030

System.out.println(str + (20 + 30));
// 输出：Java50

自增和自减

自增：++
自减：–

常见区别


// 先自增，再使用
int num1 = 20;
System.out.println(++num1); // 21
System.out.println(num1);   // 21

// 先使用，再自增
int num2 = 30;
System.out.println(num2++); // 30
System.out.pirntln(num2);   // 31

赋值运算法

表示 功能
= 等号
+= 加等于
-= 减等于
*= 乘等于
/= 除等于
%= 取模等

比较运算符

表示 意义
== 比较符号两边的数据是否相等，相等为 true
< 比较符号左边的数据是否小于右边的数据，小于则为 true
> 比较符号左边的数据是否大于右边的数据，大于则为 true
<= 比较符号左边的数据是否小于或等于右边的数据，是则为 true
>= 比较符号左边的数据是否大于或等于右边的数据，是则为 true
!= 比较符号两边的数据是否相等，不相等则为 true

逻辑运算符

表示 意义
&&(非) 全都是 true，结果是 true，否则为 flase
||(或) 至少一个是 true，结果为 true，两个全为 flase，才是 flase
!(非) 本来是 true，变成 false。本来是 flase，变成 true

三元运算符

  • 一元运算符，取反、自增、自减
  • 二元运算符，两个数据运算
  • 三元运算符，三个数据运算

格式

数据类型 变量名称 = 条件判断 ? 表达式A : 表达式B

方法简单介绍

格式


修饰符 返回值类型 方法名 (参数列表) {
    ...code...
    return;
}

修饰符：常用 public static
返回值类型：void
方法名：定义的方法的名字，小驼峰

注意事项：
1、方法定义的先后顺序无所谓
2、方法的定义不能产生嵌套包含关系
3、方法定义好了之后，不会执行的。如果要想执行，一定要进行方法的调用

选择结构

判断结构

// 第一种方式
if (关系表达式) {
    语句体;
}

// 第二种方式
if (关系表达式) {
    语句体1;
}else {
    语句体2;
}

// 第三种方式
if (关系表达式1) {
    语句体1;
}else if(关系表达式2) {
    语句体2;
}else {
    语句体3;
}

switch 结构


switch (表达式) {
    case 常量值1: 语句体1; break;
    case 常量值2: 语句体2; break;
    case 常量值3: 语句体3; break;
    default: 语句体4; break;
}

注意事项：
1、多个 case 后面的数值不可以重复
2、switch 后面小括号当中只能是下面数据类型

  • 基本数据类型，byte / short / char / int
  • 引用数据类型，String 字符串、enum 美剧

3、switch 语句里面的 case 前后顺序可以颠倒，并且 break 语句可以省略。

循环结构

一般循环要进行的步骤

1、初始化语句。在循环最开始最初执行，而且只能唯一一次
2、条件判断。如果成立，则循环继续；不成立，循环退出
3、循环体。重复要做的事情
4、步进语句，每次循环之后都要进行的扫尾工作

for 循环


for (初始表达式; 布尔表达式; 步进表达式) {
    循环体;
}

while 循环

初始化表达式;
while (布尔表达式) {
    循环体;
    步进表达式;
}

do while 循环


初始化表达式;
do {
    循环体;
    步进表达式;
}while (布尔表达式);

方法的重载（Overload）

  对于功能类似的方法来说，因为参数列表不一样，却需要记住那么多不同的方法名称，很麻烦。

  方法的重载，多个方法的名称一样，但是参数列表不一样
好处：只需要记住唯一一个方法名称，就可以实现类似的多个功能

注意:
1、参数个数不同
2、参数类型不同
3、参数的多类型顺序不同

方法重载与下列因素无关
1、与参数的名称无关
2、与方法的返回值类型无关

练习：


public class test {

    // 比较两个 byte
    public static boolean isSame(byte a, byte b) {
        System.out.println("比较两个 byte: ");
        return a == b;
    }

    // 比较两个 short
    public static boolean isSame(short a, short b) {
        System.out.println("比较两个 short: ");
        return a == b;
    }

    // 比较两个 int
    public static boolean isSame(int a, int b) {
        System.out.println("比较两个 int: ");
        return a == b;
    }

    // 比较两个 long
    public static boolean isSame(long a, long b) {
        System.out.println("比较两个 long: ");
        return a == b;
    }

    // main
    public static void main(String[] args) {

        System.out.println(isSame((byte)30, (byte)30));

        System.out.println(isSame(10, 20));

        System.out.println(isSame((short)10, (short) 20));

        System.out.println(isSame((long) 20, (long)20));
    }
}

输出：


比较两个 byte:
true
比较两个 int:
false
比较两个 short:
false
比较两个 long:
true

数组

数组是一种容器，可以同时存放多个数据值。

特点：
1、数组是一种引用数据类型
2、数组当中的多个数、类型必须统一
3、数组的长度在程序运行期间不可改变

数组初始化

在内存当中创建一个数组，并且向其中赋予一些默认值

两种常见的初始化方法：
1、动态初始化（指定长度）

在创建数组的时候，直接指定数组当中的数据元素个数

格式：


数据类型[] 数组名称 = new 数据类型(数组长度)

含义：

  • 左侧数据类型，就是数组中要保存的统一数据类型
  • 左侧的中括号，代表一个数组
  • 左侧的数组名称，给数组定义一个名字
  • 右侧的 new 代表创建数组的动作
  • 右侧的数据类型，必须和左边的额数据类型保持一致
  • 右侧中括号的长度，也就是数组当中可以保存的数据的长度，是一个 int 数据

// 创建一个 int 数组，存放 20 个数据
int[] arrayA = new int[20];

// 创建一个 double 数组，存放 10 个数据
double[] arrayB = new double[10];

// 创建一个 String 数组，存放 4 个数据
String[] arrayC = new String[4];

对于动态初始化的数组，其中的元素会自动拥有一个默认值
整形，默认为 0
浮点，默认为 0.0
字符，默认为 ‘\u0000’
布尔，默认为 false
引用，默认为 null

2、静态初始化（指定内容）

在创建数组的时候，不直接指定数据个数的多少，而是直接将具体的数据内容进行指定

格式：

数据类型[] 数组名称 = new 数据类型[] {元素1, 元素2, ……};

基本格式：


// 创建一个数组，里面全是 int 型数据
int[] arrayA = new int[] {5, 15, 10};

// 创建一个数组，里面全是 Stirng 型数据
String[] arrayB = new String[] {"c++", "Java", "Python"};

省略格式：


int[] arrayA = {10, 20, 30};

注意事项：
1、虽然静态初始化没有直接告诉长度，但是根据大括号里面的元素具体内容，也可以自动推算出来长度
2、静态初始化标准格式可以拆分成为两个步骤
3、动态初始化也可以拆分成为两个步骤
4、静态初始化一旦使用省略格式，就不能拆分成为两个步骤了


// 静态初始化拆分为两个步骤
int[] arrayA;
arrayA = new int[] {10, 20, 30};

// 动态初始化拆分成为两个步骤
int[] arrayB;
arrayB = new int[5];

// 错误写法
int[] arrayC;
arrayC = {10, 20, 30};

使用建议：如果不确定数组当中的具体内容，用动态初始化；反之已经确定了具体的内容，用静态初始化。

访问数组元素

如果直接输出数组名称，那么输出的结果将是当前数组的内存地址的哈希值，[ 符号代表是数组类型，I 代表是 int 型，@ 后面的是十六进制

格式：
数组名称[索引值]
索引值范围：0 ~ index-1


// 直接输出
int[] arrayA = {10, 20, 30};
System.out.println(arrayA);
// [I@50cbc42f

// 获取元素
int num1 = arrayA[0];
System.out.println(num1);
// 10

// 赋值操作
arrayA[2] = 20;
System.out.println(arrayA[2]);
// 20

注意：在访问数组元素的时候，索引编号并不存在，那么将会发生数组索引越界异常 ArrayIndexOutofBoundsException

Java 内存划分

  Java中的内存分为以下五个部分
1、栈（Stack）：存放的方法中的局部变量，方法的运行也在栈中
2、堆（Head）：凡是 new 出来的东西，都在堆中。堆里面的东西都有一个地址值，用 16 进制表示。堆内存当中的数据，都有默认值。如下：

类型 默认值
整数 0
浮点数 0.0
字符 ‘/u0000’
布尔 flase
引用类型 null

3、方法区（Method Area）：存储 .class 相关信息，包含方法的信息，真正的运行一定是在栈中
4、本地方法栈（Native Method Stack）：与操作系统相关
5、寄存器（pc Register）：与 CPU 相关

简单理解：


public class test {

    // main
    public static void main(String[] args) {

        // 新创建一个数组 arrayA
        System.out.println("新创建一个数组 arrayA: ");
        int[] arrayA = new int[3];
        System.out.println("arrayA-address: " + arrayA);
        System.out.print("arrayA-init: ");
        System.out.println(arrayA[0] + "," + arrayA[1] + "," + arrayA[2]);
        System.out.println("对 arrayA 里的部分元素进行赋值: ");
        arrayA[0] = 3;
        arrayA[2] = 5;
        System.out.print("arrayA: ");
        System.out.println(arrayA[0] + "," + arrayA[1] + "," + arrayA[2]);

        // 把 arrayA 赋值给 arrayB
        System.out.println("\n把 arrayA 赋值给 arrayB: ");
        int[] arrayB = arrayA;
        System.out.println("arrayB-address: " + arrayB);
        System.out.print("arrayB-init: ");
        System.out.println(arrayB[0] + "," + arrayB[1] + "," + arrayB[2]);
        System.out.println("对 arrayB 里的部分元素进行赋值: ");
        arrayA[0] = 10;
        arrayA[2] = 20;
        System.out.print("arrayB: ");
        System.out.println(arrayB[0] + "," + arrayB[1] + "," + arrayB[2]);

        // 最后再来看一下 arrayA
        System.out.println("\n最后再来看一下 arrayA: ");
        System.out.println("arrayA-address: " + arrayA);
        System.out.print("arrayA: ");
        System.out.println(arrayA[0] + "," + arrayA[1] + "," + arrayA[2]);

    }
}

输出：


新创建一个数组 arrayA: 
arrayA-address: [I@7c30a502
arrayA-init: 0,0,0
对 arrayA 里的部分元素进行赋值: 
arrayA: 3,0,5

把 arrayA 赋值给 arrayB: 
arrayB-address: [I@7c30a502
arrayB-init: 3,0,5
对 arrayB 里的部分元素进行赋值: 
arrayB: 10,0,20

最后再来看一下 arrayA: 
arrayA-address: [I@7c30a502
arrayA: 10,0,20

数组异常种类

1、越界异常 ArrayIndexOutofBoundsException

在访问数组元素的时候，索引编号并不存在，那么将会发生数组索引越界异常


int[] arrayA = new int[3];
System.out.println(arrayA[3]);
// 索引超出范围，引发越界异常

2、空指针异常 NullPointerException


int[] arrayA = null;
System.out.println(array[0]);
// 前面说过，新建的数组没有进行 new 的话就没有地址，这个数组就是空壳，所以我们访问这个数组的时候会产生空指针异常

数组的常见操作

1、获取数组长度

在 Java 中，用数组的 length 属性可以获取该数组的长度


// 新创建一个数组 arrayA
int[] arrayA = new int[] {10, 30, 50, 23, 54};
System.out.println("这个数组的长度是： " + arrayA.length);

2、数组的遍历

一般用循环来进行数组的遍历


public class test {

    // main
    public static void main(String[] args) {

        // 新创建一个数组 arrayA
        int[] arrayA = new int[] {10, 30, 50, 23, 54};
        System.out.println("这个数组的长度是： " + arrayA.length);

        for (int i = 0; i < arrayA.length ; i++) {
            System.out.println("array[" + i + "] = " + arrayA[i]);
        }
    }
}

输出：


这个数组的长度是： 5
array[0] = 10
array[1] = 30
array[2] = 50
array[3] = 23
array[4] = 54

3、数组中的最值

最大值和最小值：


public class test {

    // main
    public static void main(String[] args) {

        // 新创建一个数组 arrayA
        int[] arrayA = new int[] {10, 30, 50, 23, 54};

        // 最大值
        int max = arrayA[0];
        for (int i = 1; i < arrayA.length ; i++) {
            if (max < arrayA[i])
                max = arrayA[i];
        }
        System.out.println("数组中的最大值为：" + max);

        // 最小值
        int min = arrayA[0];
        for (int i = 1; i < arrayA.length ; i++) {
            if (min > arrayA[i])
                min = arrayA[i];
        }
        System.out.println("数组中的最小值为：" + min);
    }
}

输出：


数组中的最大值为：54
数组中的最小值为：10

4、数组元素的反转

第一种方法


public class test {

    // main
    public static void main(String[] args) {

        // 新创建一个数组 arrayA
        int[] arrayA = new int[] {1, 2, 3, 4};

        // 打印数组
        System.out.print("原来的数组：");
        for (int i = 0; i < arrayA.length; i++) {
            System.out.print(arrayA[i] + "\t");
        }
        System.out.println();

        // 元素的反转
        for (int i = 0; i < (arrayA.length / 2); i++) {
            int temp = arrayA[i];
            arrayA[i] = arrayA[arrayA.length - i - 1];
            arrayA[arrayA.length - i - 1] = temp;
        }

        // 打印数组
        System.out.print("反转后数组：");
        for (int i = 0; i < arrayA.length; i++) {
            System.out.print(arrayA[i] + "\t");
        }
        System.out.println();
    }
}

第二种方法


// 元素的反转
for (int min = 0, max = arrayA.length - 1; min < max; min++, max--) {
    int temp = arrayA[min];
    arrayA[min] = arrayA[max];
    arrayA[max] = temp;
}

5、数组方法传递

使用数组作为方法传递的时候，传递的实际上是数组的地址值


public class test {

    public static void printArray(int[] array) {
        // 打印数组
        System.out.print("Array：");
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i] + "\t");
        }
        System.out.println();
    }

    // main
    public static void main(String[] args) {

        // 新创建一个数组 arrayA
        int[] arrayA = new int[] {1, 2, 3, 4, 6};

        printArray(arrayA);

    }
}

输出：


Array：1	2	3	4	6

6、数组作为方法返回值

数组作为方法的返回值，返回的其实也是数组的地址值


public class test {

    // 计算后返回数组
    public static int[] calc(int[] array) {
        int sum = 0;
        // 求和
        for (int i = 0; i < array.length; i++) {
            sum += array[i];
        }
        // 求平均
        int avg = sum / array.length;
        // 把 sum 和 avg 放在一个数组里面
        int[] result = {sum, avg};
        return result;
    }

    // main
    public static void main(String[] args) {

        // 新创建一个数组 arrayA
        int[] arrayA = new int[] {1, 2, 3, 4, 6};
        // 接受计算后返回的数组
        int[] result = calc(arrayA);
        int sum = result[0];
        int avg = result[1];
        System.out.println("sum = " + sum);
        System.out.println("avg = " + avg);
    }
}

输出：


sum = 16
avg = 3

以上是在学习 Java 中整理的一些基础语法。如有错误，请留言改正

标签
switch case语句
字节数组
循环语句
python数组操作
指针初始化
赋值语句
for循环
string
初始化
数组
易学教程内所有资源均来自网络或用户发布的内容，如有违反法律规定的内容欢迎反馈！
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!