java基础语法总结

导言：

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

目录

导言：

正文：

1. 数据类型与变量

2. 运算符与逻辑控制

3. 方法

4. 数组

5. 类和对象

6. 继承和多态

7.抽象类和接口

8.String类

9.异常 ​编辑

总结：

---

正文：

当涉及到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. 方法

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

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

1. 方法名：方法的名称用来唯一标识该方法。方法名应符合标识符的命名规则，通常采用驼峰命名法（首字母小写，后续单词首字母大写）。

2. 参数列表：方法可以接受零个或多个参数，这些参数用于向方法传递数据。参数列表包括参数的数据类型和参数名称，多个参数之间用逗号分隔。

3. 返回类型：方法可以返回一个值，也可以不返回任何值。如果方法返回一个值，则需要指定返回值的数据类型；如果方法不返回值，则使用关键字void表示。

4. 方法体：方法体包含了实际的执行代码，用花括号{}括起来。在方法体中可以包含各种语句、表达式和控制结构，用于完成方法的具体功能。

5. 访问修饰符：访问修饰符用于控制方法的访问权限，可以是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. 类和对象

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

类：

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

对象：

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

实例代码:

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();

类和对象的关系：

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

6. 继承和多态

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

继承：

1. 继承是一种面向对象编程的重要机制，它允许一个类（子类）继承另一个类（父类）的属性和方法。
2. 子类可以使用父类中的属性和方法，同时还可以添加自己的属性和方法。
3. 继承可以减少代码的重复，提高代码的复用性和可维护性。
4. 在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(); // 子类自己的方法
    }
}

多态：

1. 多态是面向对象编程中的一个重要概念，它允许不同的对象对同一消息（方法）作出不同的响应。
2. 多态可以提高代码的可扩展性和可维护性，使得程序更加灵活和易于扩展。
3. 在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类的一些重要特点和常用方法：

1. 字符串的创建：

   • 使用双引号创建字符串字面量：String str = "Hello, World!";
   • 使用String类的构造方法创建字符串对象：String str = new String("Hello");

2. 字符串的连接：

   • 使用"+"运算符进行字符串连接：String str = "Hello" + " " + "World";
   • 使用concat()方法进行字符串连接：String result = str1.concat(str2);

3. 字符串的比较：

   • 使用equals()方法比较字符串内容是否相等：boolean isEqual = str1.equals(str2);
   • 使用==运算符比较字符串对象是否相同：boolean isSame = (str1 == str2);

4. 字符串的查找和替换：

   • 使用indexOf()方法查找子串在字符串中的位置：int index = str.indexOf("lo");
   • 使用replace()方法替换字符串中的子串：String newStr = str.replace("Hello", "Hi");

5. 字符串的分割和拼接：

   • 使用split()方法根据指定的分隔符拆分字符串：String[] parts = str.split(",");
   • 使用join()方法拼接字符串数组：String result = String.join("-", "Java", "is", "cool");

6. 字符串的截取和转换：

   • 使用substring()方法截取子串：String subStr = str.substring(3, 7);
   • 使用toLowerCase()和toUpperCase()方法将字符串转换为小写或大写：String lower = str.toLowerCase(); String upper = str.toUpperCase();

7. 字符串的格式化：

   • 使用format()方法进行字符串格式化：String formatted = String.format("Hello, %s. Today is %tF", "Alice", new Date());

8. 字符串的长度和字符访问：

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