Java基础知识速成笔记“超实用”学完就去实战！（一）

多宝气泡水

已于 2024-03-03 17:49:47 修改

阅读量1k

点赞数 24

分类专栏： Java编程知识文章标签：笔记 java 开发语言算法

于 2024-02-29 18:06:45 首次发布

本文链接：https://blog.csdn.net/wwwwwmmn/article/details/136373343

版权

一、数据类型与变量

1. 数据类型

1.1 基本数据类型

整型：byte、short、int、long

byte : -128 到 127（含）之间的整数值，占一个字节。

short：-32,768到32,767的整数，占2个字节。

int：-2,147,483,648到2,147,483,647之间整数，占4个字节。

long：-9,223,372,036,854,775,808 到 9,223,372,036,854,775,807，占8字节。

浮点型：float、double

float：3.4e^-38 到 3.4e^38，但是精度只有大约6-7位有效数字，占4字节。

double：1.7e^-308 到 1.7e^308，精度约为15-16位有效数字占8字节。

字符型：char（占2字节）
布尔型：boolean（true 或 false，通常认为占1个字节。）

1.2 引用数据类型

类型：类、接口、数组
包装类：用于封装基本数据类型，如Integer、Double、Boolean等

2. 变量

2.1 变量的定义与声明

声明语法：数据类型变量名;，例如 int age;
初始化：声明变量时可选择性地进行初始化，例如 int age = 25;

2.2 变量的命名规则

变量名由字母、数字、下划线和美元符号组成，不能以数字开头。
区分大小写，且不要使用Java关键字作为变量名。
采用驼峰命名法，即第一个单词首字母小写，后续单词首字母大写，例如 studentName。

2.3 常量

使用final关键字定义的常量，一旦赋值不可更改，例如 final int MAX_SIZE = 100;
使用 final 声明的常量只能赋值一次，通常在声明时或者构造函数中初始化。
final 修饰的类不能被继承，即不能有子类，但可以正常地实例化对象。
final 修饰的方法不能被子类重写，但可以被继承。

class Parent {
    final void display() {
        System.out.println("Parent display method");
    }
}

class Child extends Parent {
    // 无法重写父类中 final 修饰的方法
    // void display() { }
}

final 修饰的变量是值不变，引用不变的，但是如果引用的对象是可变的，那么对象的内容是可以修改的。

3. 数据类型转换

3.1 自动类型转换（隐式类型转换）

小类型转大类型，如 int 转 double

3.2 强制类型转换（显式类型转换）

大类型转小类型，需要进行强制转换，可能造成数据精度损失，需谨慎使用，例如 double 转 int

3.3 类型转换规则

从低精度类型到高精度类型的自动转换是安全的，如 int 转 double
从高精度类型到低精度类型的转换需要显式转换，并可能导致精度丢失，需要注意数据溢出的问题

double d = 10.5;
int i = (int) d; // 强制将 double 类型转换为 int 类型

System.out.println("Double: " + d); // 输出原始的 double 值
System.out.println("Int: " + i);    // 输出强制类型转换后的 int 值

在上面的示例中，double 类型的变量 d 被强制转换为 int 类型的变量 i。这里将 10.5 转换为整数，小数部分被舍弃，结果为 10。

4. 字面值

字面值是在程序中直接表示数据的值，例如 int num = 10; 中的 10 就是字面值。
支持十进制、八进制、十六进制表示法，如 int num1 = 10;、int num2 = 010;、int num3 = 0x10;
浮点型字面值默认为 double 类型，可以在末尾加上 f 或 F 表示 float 类型，如 float num = 10.5f;

5. 类型默认值

在Java中，局部变量需要显式初始化，否则编译器会报错。

public class Main {
    public static void main(String[] args) {
        int x; // 声明了一个整型变量x，但未初始化
        System.out.println(x); // 编译错误：变量x可能未被初始化
    }
}

在上面的示例中，变量 x 被声明为整型，但是没有被赋予初始值就被使用，这会导致编译错误。要解决这个问题，可以给变量 x 赋予一个初始值。

类成员变量会自动初始化，基本数据类型默认为对应的零值（如 0、0.0、false），引用类型默认为 null。

public class MyClass {
    // 声明了几种类型的成员变量，但未初始化
    int intValue;
    double doubleValue;
    boolean booleanValue;
    String stringValue;

    public void printDefaultValues() {
        System.out.println("int默认值: " + intValue); // 输出 0
        System.out.println("double默认值: " + doubleValue); // 输出 0.0
        System.out.println("boolean默认值: " + booleanValue); // 输出 false
        System.out.println("String默认值: " + stringValue); // 输出 null
    }

    public static void main(String[] args) {
        MyClass myClass = new MyClass();
        myClass.printDefaultValues();
    }
}

在上述示例中，MyClass 类包含了几种不同类型的成员变量，分别是 int、double、boolean 和 String。这些成员变量在声明时未初始化，但在实例化 MyClass 对象后，可以看到它们分别被赋予了默认值。

6. 常见问题与注意事项

数据类型选择应根据需求和数据范围来决定，避免浪费内存空间。
在进行数据类型转换时，要注意数据范围和精度问题，避免数据丢失或溢出。
命名规范和良好的注释可以增加代码的可读性和可维护性。

二、运算符与表达式

1. 运算符类型

1.1 算术运算符

加法 +、减法 -、乘法 *、除法 /、取模 % 等。
注意整数除法和浮点数除法的区别，以及取模运算的特点。

1.2 赋值运算符

赋值 =、复合赋值运算符（如 +=、-=、*=、/= 等）。

1.3 比较运算符

相等 ==、不等 !=、大于 >、小于 <、大于等于 >=、小于等于 <=。

1.4 逻辑运算符

逻辑与 &&、逻辑或 ||、逻辑非 !。

1.5 位运算符

位与 &、位或 |、位异或 ^、位非 ~、左移 <<、右移 >> 等。

1.6 条件运算符

三元条件运算符 ? :，用于简单的条件判断。

三元条件运算符是 Java 中的一种特殊运算符，也称为条件运算符。它由三部分组成：一个条件表达式，一个真值表达式和一个假值表达式。根据条件表达式的结果，选择返回真值表达式或假值表达式的值。其语法如下：

condition ? trueExpression : falseExpression

如果条件表达式的结果为 true，则返回 trueExpression 的值；如果条件表达式的结果为 false，则返回 falseExpression 的值。

1.7 instanceof 运算符

用于判断对象是否属于某个类或其子类。

instanceof 运算符用于在运行时检查对象是否是特定类的实例，或者是否是该类的子类的实例。它的语法形式如下：

object instanceof ClassName

如果 object 是 ClassName 类的一个实例，或者是 ClassName 类的子类的一个实例，则 instanceof 运算符返回 true；否则返回 false。

以下是一个示例，演示了 instanceof 运算符的使用：

class Animal {}
class Dog extends Animal {}

public class Main {
    public static void main(String[] args) {
        Animal animal = new Dog();
        
        // 使用 instanceof 运算符检查 animal 是否是 Dog 类的实例
        if (animal instanceof Dog) {
            System.out.println("animal 是 Dog 类的实例");
        } else {
            System.out.println("animal 不是 Dog 类的实例");
        }
        
        // 使用 instanceof 运算符检查 animal 是否是 Animal 类的实例
        if (animal instanceof Animal) {
            System.out.println("animal 是 Animal 类的实例");
        } else {
            System.out.println("animal 不是 Animal 类的实例");
        }
    }
}

在这个示例中，我们首先创建了一个 Dog 类，它是 Animal 类的子类。然后创建了一个 Animal 类型的对象 animal，并将其初始化为 Dog 类的实例。接着使用 instanceof 运算符分别检查 animal 是否是 Dog 类的实例和 Animal 类的实例。由于 animal 是 Dog 类的实例，所以第一个 if<