java基础语法总结

导言:

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

目录

导言:

正文:

1. 数据类型与变量

2. 运算符与逻辑控制

3. 方法

4. 数组

5. 类和对象

6. 继承和多态

7.抽象类和接口

8.String类

9.异常 ​编辑

总结:


正文:

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

1. 数据类型与变量

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

java基础语法总结_第1张图片

  • 整数类型

    • 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. 方法

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

java基础语法总结_第2张图片

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

  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. 类和对象

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

java基础语法总结_第3张图片

类:

  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. 继承和多态

java基础语法总结_第4张图片

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

继承:

  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.抽象类和接口

java基础语法总结_第5张图片

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

代码示例:

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基础语法总结_第6张图片

异常是指在程序执行过程中发生的错误或意外情况。当程序出现异常时,会抛出一个异常对象,如果该异常没有被捕获处理,程序就会终止运行。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,开发语言)