java基础语法总结

导言：

Java语言是一种面向对象的编程语言，具有简单、可移植、安全、高性能等特点。本篇文章主要对java的基础的语法进行一个简单的总结和概述。

正文：

当涉及到Java语法的详细介绍时，每个模块都非常广泛，因此我将为您提供一个简要的概述，并为每个模块提供一个基本的代码示例，以便您更好地理解。

1. 数据类型与变量

Java有8种基本数据类型，包括整数类型、浮点类型、字符类型和布尔类型。变量是用来存储数据的内存位置，需要在使用前声明并分配内存空间

整数类型
- byte: 8位，范围为-128到127
- short: 16位，范围为-32768到32767
- int: 32位，范围为-2147483648到2147483647
- long: 64位，范围为-9223372036854775808到9223372036854775807
浮点类型
- float: 32位，范围为1.4E-45到3.4E+38，精度为6-7位小数
- double: 64位，范围为4.9E-324到1.8E+308，精度为15位小数
字符类型
- char: 16位，表示Unicode字符，范围为’\u0000’到’\uffff’
布尔类型
- boolean: 只有两个取值，true和false

变量是用来存储数据的内存位置，需要在使用前声明并分配内存空间。在Java中，变量的声明格式为：数据类型变量名 = 初始值;例如：

int num = 10;
double salary = 1000.50;
char grade = 'A';
boolean isStudent = true;

2. 运算符与逻辑控制

运算符包括算术运算符、关系运算符、逻辑运算符和位运算符等。逻辑控制包括条件控制语句（if-else）、循环语句（for、while、do-while）和跳转语句（break、continue）等。

运算符
- 算术运算符：用于执行基本的数学运算，如加法、减法、乘法、除法和取模等。例如：+, -, *, /, %
- 关系运算符：用于比较两个值之间的关系，返回布尔值true或false。例如：==, !=, >, <, >=, <=
- 逻辑运算符：用于对布尔值进行操作，进行逻辑与、逻辑或和逻辑非等操作。例如：&&, ||, !
- 赋值运算符：用于给变量赋值。例如：=, +=, -=, *=, /=
- 位运算符：用于对二进制位进行操作，如按位与、按位或、按位取反等操作。例如：&, |, ~, ^, >>
- 条件运算符（三元运算符）：用于根据条件选择两个值中的一个。例如：condition ? value1 : value2
逻辑控制结构
- 条件语句：用于根据条件执行不同的代码块。包括if语句、if-else语句、if-else if-else语句和switch语句。
- 循环语句：用于重复执行一段代码块。包括for循环、while循环和do-while循环。
- 跳转语句：用于改变程序的执行顺序。包括break语句、continue语句和return语句。

3. 方法

方法是一组执行特定任务的语句的集合，可以重复使用。方法由方法名、参数列表、返回类型和方法体组成。

下面是方法的组成部分的详细概述：

方法名：方法的名称用来唯一标识该方法。方法名应符合标识符的命名规则，通常采用驼峰命名法（首字母小写，后续单词首字母大写）。
参数列表：方法可以接受零个或多个参数，这些参数用于向方法传递数据。参数列表包括参数的数据类型和参数名称，多个参数之间用逗号分隔。
返回类型：方法可以返回一个值，也可以不返回任何值。如果方法返回一个值，则需要指定返回值的数据类型；如果方法不返回值，则使用关键字void表示。
方法体：方法体包含了实际的执行代码，用花括号{}括起来。在方法体中可以包含各种语句、表达式和控制结构，用于完成方法的具体功能。
访问修饰符：访问修饰符用于控制方法的访问权限，可以是public、protected、private或默认访问权限。它决定了方法可以被哪些其他类访问。

下面是一个简单的方法定义的示例：

public int add(int a, int b) {
    int sum = a + b;
    return sum;
}

4. 数组

数组是相同类型的数据项的集合，使用单个变量名来引用。数组的大小在创建后不能改变。

数组的声明和初始化：
- 声明数组：在声明数组时，需要指定数组的类型和数组名，例如：int[] arr; 表示声明了一个int类型的数组arr。
- 初始化数组：在声明数组后，需要为数组分配内存空间并初始化数组元素。可以使用new关键字来动态创建数组，也可以使用静态初始化来为数组赋初值。
数组的特点：
- 数组是一个固定长度的数据结构，一旦创建后，其长度不能改变。
- 数组中的元素可以通过索引来访问，索引从0开始，最大索引为数组长度减一。
- 数组可以存储基本数据类型（如int、double、char等）或者对象引用。
多维数组：
- Java支持多维数组，可以是二维、三维甚至更高维度的数组。多维数组的声明和访问方式与一维数组类似，只是需要使用多个索引来访问数组元素。
数组的操作：
- 访问元素：通过索引可以访问数组中的元素，例如arr[0]表示访问数组arr的第一个元素。
- 修改元素：可以通过索引来修改数组中的元素的值，例如arr[0] = 100; 表示将数组arr的第一个元素赋值为100。
- 遍历数组：可以使用循环结构（如for循环）来遍历数组中的所有元素，对每个元素进行操作。
数组的长度：
- 数组的长度可以通过数组的length属性来获取，例如arr.length表示数组arr的长度。
数组的初始化方式：
- 动态初始化：使用new关键字动态创建数组并指定数组长度。
- 静态初始化：在声明数组的同时为数组赋初值，例如int[] arr = {1, 2, 3, 4, 5};。

实例代码

int[] numbers = {1, 2, 3, 4, 5};
for (int i = 0; i < numbers.length; i++) {
  System.out.println(numbers[i]);
}

5. 类和对象

类是对象的模板，用来创建对象的蓝图。对象是类的实例，具有状态和行为。

类：

类是用来描述具有相同属性和方法的对象的抽象模板。它定义了对象的属性和行为。
类由属性（成员变量）和方法（成员函数）组成，用于描述对象的状态和行为。
类可以看作是一种数据类型，它定义了对象的类型。
类可以被实例化为对象，一个类可以有多个对象实例。
类的定义包括类名、属性、方法、构造方法等部分。

对象：

对象是类的实例，它是类的具体化。在内存中，对象占据一定的空间，包含了类中定义的属性和方法。
对象具有状态（属性）和行为（方法），可以通过对象的方法来改变对象的状态。
对象是类的实体，它是可以被创建、操作和销毁的。
对象之间可以相互调用对方的方法，从而实现对象之间的交互和协作。

实例代码:

class Car {
  String color;
  int speed;

  void start() {
    System.out.println("Car started");
  }
}

Car myCar = new Car();
myCar.color = "Red";
myCar.speed = 60;
myCar.start();

类和对象的关系：

类是对象的模板，描述了对象的属性和行为。
对象是类的实例，具体化了类的定义。
一个类可以有多个对象实例，每个对象实例都有自己的属性和状态。

6. 继承和多态

继承允许一个类继承另一个类的属性和方法。多态允许父类的引用变量指向子类的对象。

继承：

继承是一种面向对象编程的重要机制，它允许一个类（子类）继承另一个类（父类）的属性和方法。
子类可以使用父类中的属性和方法，同时还可以添加自己的属性和方法。
继承可以减少代码的重复，提高代码的复用性和可维护性。
在Java中，使用关键字extends来实现继承。

代码实例：

class Animal {
    public void move() {
        System.out.println("Animal can move");
    }
}

class Dog extends Animal {
    public void bark() {
        System.out.println("Dog can bark");
    }
}

public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.move(); // 继承自父类Animal的方法
        dog.bark(); // 子类自己的方法
    }
}

多态：

多态是面向对象编程中的一个重要概念，它允许不同的对象对同一消息（方法）作出不同的响应。
多态可以提高代码的可扩展性和可维护性，使得程序更加灵活和易于扩展。
在Java中，多态可以通过继承和接口实现。

代码实例：

class Animal {
    public void move() {
        System.out.println("Animal can move");
    }
}

class Dog extends Animal {
    public void move() {
        System.out.println("Dog can run and walk");
    }

    public void bark() {
        System.out.println("Dog can bark");
    }
}

public class Test {
    public static void main(String[] args) {
        Animal animal = new Animal();
        Dog dog = new Dog();
        Animal animal1 = new Dog();

        animal.move(); // 输出Animal can move
        dog.move(); // 输出Dog can run and walk
        animal1.move(); // 输出Dog can run and walk，因为animal1是Dog类型的引用，调用的是Dog类中的move方法
    }
}

7.抽象类和接口

抽象类抽象类是一种特殊的类，它不能被实例化，只能用来被继承。抽象类中可以包含抽象方法和非抽象方法。抽象方法没有实现，只有方法签名，需要被子类实现。非抽象方法有实现，可以被子类继承或重写。抽象类可以用来定义一些通用的行为和属性，让子类来实现具体的行为和属性。

代码示例：

public abstract class Animal {
    private String name;

    public Animal(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public abstract void move();
}

public class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }

    public void move() {
        System.out.println(getName() + " can run and walk");
    }
}

public class Cat extends Animal {
    public Cat(String name) {
        super(name);
    }

    public void move() {
        System.out.println(getName() + " can jump and climb");
    }
}

public class Test {
    public static void main(String[] args) {
        Animal dog = new Dog("Tom");
        Animal cat = new Cat("Jerry");

        dog.move(); // 输出Tom can run and walk
        cat.move(); // 输出Jerry can jump and climb
    }
}

接口接口是一种特殊的抽象类，它只包含抽象方法和常量，没有非抽象方法和实例变量。接口用于定义行为规范，让实现该接口的类来实现具体的行为。一个类可以实现多个接口，从而实现多重继承。接口可以用来实现代码的解耦和模块化。

代码示例：

public interface Animal {
    public void move();
}

public class Dog implements Animal {
    public void move() {
        System.out.println("Dog can run and walk");
    }
}

public class Cat implements Animal {
    public void move() {
        System.out.println("Cat can jump and climb");
    }
}

public class Test {
    public static void main(String[] args) {
        Animal dog = new Dog();
        Animal cat = new Cat();

        dog.move(); // 输出Dog can run and walk
        cat.move(); // 输出Cat can jump and climb
    }
}

8.String类

String类用于操作字符串，提供了丰富的字符串操作方法。下面是对Sring的总结：

String类是Java中的一个类，用于表示字符串。
String类是不可变的，一旦创建了一个String对象，就不能再修改它的值。
String类提供了很多方法，用于操作字符串，例如substring、indexOf、replace等等。
String类可以通过+运算符进行字符串拼接，也可以使用StringBuilder类或StringBuffer类进行字符串拼接。
String类可以通过构造方法或字面值的方式创建对象。
String类是线程安全的，因为它是不可变的，多个线程可以同时访问同一个String对象而不会发生冲突。

代码示例：

public class Test {
    public static void main(String[] args) {
        String str1 = "Hello";
        String str2 = new String("World");
        String str3 = str1 + str2;
        String str4 = "HelloWorld";
        
        System.out.println(str1); // 输出Hello
        System.out.println(str2); // 输出World
        System.out.println(str3); // 输出HelloWorld
        System.out.println(str4); // 输出HelloWorld
        
        System.out.println(str1.length()); // 输出5
        System.out.println(str2.charAt(0)); // 输出W
        System.out.println(str3.substring(5)); // 输出World
        System.out.println(str4.indexOf('o')); // 输出4
    }
}

下面是关于Java中String类的一些重要特点和常用方法：

字符串的创建：
- 使用双引号创建字符串字面量：String str = “Hello, World!”;
- 使用String类的构造方法创建字符串对象：String str = new String(“Hello”);
字符串的连接：
- 使用”+”运算符进行字符串连接：String str = “Hello” + ” ” + “World”;
- 使用concat()方法进行字符串连接：String result = str1.concat(str2);
字符串的比较：
- 使用equals()方法比较字符串内容是否相等：boolean isEqual = str1.equals(str2);
- 使用==运算符比较字符串对象是否相同：boolean isSame = (str1 == str2);
字符串的查找和替换：
- 使用indexOf()方法查找子串在字符串中的位置：int index = str.indexOf(“lo”);
- 使用replace()方法替换字符串中的子串：String newStr = str.replace(“Hello”, “Hi”);
字符串的分割和拼接：
- 使用split()方法根据指定的分隔符拆分字符串：String[] parts = str.split(“,”);
- 使用join()方法拼接字符串数组：String result = String.join(“-“, “Java”, “is”, “cool”);
字符串的截取和转换：
- 使用substring()方法截取子串：String subStr = str.substring(3, 7);
- 使用toLowerCase()和toUpperCase()方法将字符串转换为小写或大写：String lower = str.toLowerCase(); String upper = str.toUpperCase();
字符串的格式化：
- 使用format()方法进行字符串格式化：String formatted = String.format(“Hello, %s. Today is %tF”, “Alice”, new Date());
字符串的长度和字符访问：
- 使用length()方法获取字符串的长度：int len = str.length();
- 使用charAt()方法访问字符串中的单个字符：char ch = str.charAt(0);

9.异常

异常是指在程序执行过程中发生的错误或意外情况。当程序出现异常时，会抛出一个异常对象，如果该异常没有被捕获处理，程序就会终止运行。Java中的异常处理机制可以让程序在出现异常时，能够进行适当的处理，保证程序的正常运行。

Java中的异常分为两种：Checked Exception和Unchecked Exception。Checked Exception是指在编译时就可以被检查出来的异常，例如IOException、SQLException等，必须在代码中进行处理，否则会产生编译错误。Unchecked Exception是指在运行时才能被检查出来的异常，例如NullPointerException、ArrayIndexOutOfBoundsException等，可以不进行处理，但是如果不进行处理，程序就会终止运行。

Java中的异常处理机制通过try-catch-finally语句块来实现。try块中包含可能会抛出异常的代码，catch块用于捕获并处理异常，finally块用于在代码执行完毕后进行清理工作，例如释放资源等。

代码示例：

public class Test {
    public static void main(String[] args) {
        try {
            int[] arr = {1, 2, 3};
            System.out.println(arr[3]); // 抛出ArrayIndexOutOfBoundsException异常
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("数组下标越界");
        } finally {
            System.out.println("程序执行完毕");
        }
    }
}

除了try-catch-finally语句块，Java还提供了throws关键字和throw语句来处理异常。throws关键字用于声明方法可能会抛出的异常，throw语句用于手动抛出异常对象。

代码示例：

public class Test {
    public static void main(String[] args) throws Exception {
        throw new Exception("抛出异常");
    }
}

总结：

总而言之，Java语法简单清晰，易于学习和使用，在学习的过程中要多复习多上手敲代码，保持自己语言学习的连贯性。本文章主要对基础语法进行了一个简单的概述，想要进一步深入学习可以多看看其它更加具体化的文章和资料，希望本文对你有所帮助。

文章出处登录后可见！

已经登录？立即刷新

java基础语法总结

导言：

正文：

1. 数据类型与变量

2. 运算符与逻辑控制

3. 方法

4. 数组

5. 类和对象

6. 继承和多态

7.抽象类和接口

8.String类

9.异常

总结：

相关推荐