Java基础语法详解

九转成圣

发布于 2024-05-30 13:01:39

1330

发布于 2024-05-30 13:01:39

文章被收录于专栏：csdn

Java是一种广泛使用的面向对象编程语言，适用于开发跨平台的应用程序。本文将详细介绍Java的基础语法，帮助初学者打好扎实的编程基础。

1. Java程序的结构

一个基本的Java程序通常由类和方法组成。以下是一个简单的Java程序示例：

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

类（Class）：所有Java程序都是从类开始的。HelloWorld是这个程序的类名。
方法（Method）：main方法是程序的入口点，Java程序从main方法开始执行。
语句（Statement）：System.out.println("Hello, World!"); 是一个语句，用于打印输出。

2. 基本数据类型

Java提供了八种基本数据类型：

整数类型：
- byte：8位，取值范围是 -128 到 127
- short：16位，取值范围是 -32,768 到 32,767
- int：32位，取值范围是 -2^31 到 2^31-1
- long：64位，取值范围是 -2^63 到 2^63-1

示例：

byte myByte = 100;
short myShort = 10000;
int myInt = 100000;
long myLong = 100000L;

浮点类型：
- float：32位，单精度
- double：64位，双精度

示例：

float myFloat = 10.99f;
double myDouble = 99.99;

字符类型：
- char：16位，表示一个Unicode字符

示例：

char myChar = 'A';

布尔类型：
- boolean：表示真或假，取值为 true 或 false

示例：

boolean myBoolean = true;

3. 变量和常量

变量（Variable）：用来存储数据，可以改变。

int age = 25;
  age = 30; // 变量值可以改变

常量（Constant）：用 final 关键字定义，值不能改变。

final int DAYS_IN_WEEK = 7;
  // DAYS_IN_WEEK = 8; // 这将导致编译错误

4. 运算符

Java支持多种运算符：

算术运算符：+, -, *, /, %
赋值运算符：=, +=, -=, *=, /=
比较运算符：==, !=, >, <, >=, <=
逻辑运算符：&&, ||, !

示例：

int a = 10;
int b = 20;
int sum = a + b; // 算术运算
boolean isEqual = (a == b); // 比较运算
boolean logicalResult = (a > 5) && (b < 30); // 逻辑运算

5. 控制流

条件语句：if, else if, else

int score = 85;
if (score >= 90) {
    System.out.println("A");
} else if (score >= 80) {
    System.out.println("B");
} else {
    System.out.println("C");
}

循环语句：for, while, do-while

// for 循环
for (int i = 0; i < 5; i++) {
    System.out.println(i);
}

// while 循环
int j = 0;
while (j < 5) {
    System.out.println(j);
    j++;
}

// do-while 循环
int k = 0;
do {
    System.out.println(k);
    k++;
} while (k < 5);

6. 数组

数组是存储同类型数据的集合。

声明和初始化数组：

int[] numbers = new int[5];
int[] moreNumbers = {1, 2, 3, 4, 5};

访问数组元素：

numbers[0] = 10;
int firstNumber = moreNumbers[0];

遍历数组：

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

// 使用增强型 for 循环
for (int number : moreNumbers) {
    System.out.println(number);
}

7. 方法

方法是执行特定任务的代码块。

定义方法：

public static int add(int x, int y) {
    return x + y;
}

调用方法：

int result = add(5, 3); // result 为 8

方法的参数传递

Java支持值传递，即将参数的副本传递给方法。

public static void changeValue(int x) {
    x = 100;
}

public static void main(String[] args) {
    int num = 50;
    changeValue(num);
    System.out.println(num); // 输出：50
}

方法重载

方法重载是指同一个类中多个方法可以有相同的名称，但参数列表不同。

public class MathUtils {
    public static int add(int x, int y) {
        return x + y;
    }

    public static double add(double x, double y) {
        return x + y;
    }
}

public static void main(String[] args) {
    System.out.println(MathUtils.add(5, 3)); // 输出：8
    System.out.println(MathUtils.add(5.5, 3.3)); // 输出：8.8
}

8. 面向对象编程（OOP）基础

Java是一种面向对象的编程语言，核心概念包括类、对象、继承、多态、封装和抽象。

类和对象

类是对象的蓝图，而对象是类的实例。

public class Car {
    // 属性
    String color;
    int speed;

    // 方法
    void drive() {
        System.out.println("Car is driving");
    }
}

// 创建对象
Car myCar = new Car();
myCar.color = "red";
myCar.speed = 100;
myCar.drive();

构造方法

构造方法用于初始化对象。

public class Car {
    String color;
    int speed;

    // 构造方法
    public Car(String color, int speed) {
        this.color = color;
        this.speed = speed;
    }

    void drive() {
        System.out.println("Car is driving");
    }
}

Car myCar = new Car("red", 100);

继承

继承允许一个类继承另一个类的属性和方法。

public class Vehicle {
    void start() {
        System.out.println("Vehicle is starting");
    }
}

public class Car extends Vehicle {
    void honk() {
        System.out.println("Car is honking");
    }
}

Car myCar = new Car();
myCar.start(); // 继承自Vehicle类
myCar.honk(); // Car类自己的方法

多态

多态允许使用父类引用来调用子类的方法。

public class Animal {
    void sound() {
        System.out.println("Animal makes a sound");
    }
}

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

Animal myAnimal = new Dog();
myAnimal.sound(); // 输出：Dog barks

封装

封装通过将数据和方法封装在类中来保护数据。

public class Person {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

Person person = new Person();
person.setName("Alice");
System.out.println(person.getName()); // 输出：Alice

抽象

抽象类不能实例化，只能被子类继承。

abstract class Animal {
    abstract void makeSound();
}

class Cat extends Animal {
    void makeSound() {
        System.out.println("Cat meows");
    }
}

Animal myCat = new Cat();
myCat.makeSound(); // 输出：Cat meows

9. 常用类和库

Java标准库提供了丰富的类和库，常用的包括：

字符串处理

字符串是不可变的对象，用于表示字符序列。

String message = "Hello, World!";
String upperMessage = message.toUpperCase();
System.out.println(upperMessage); // 输出：HELLO, WORLD!

int length = message.length();
char firstChar = message.charAt(0);
String substring = message.substring(7, 12);

System.out.println("Length: " + length); // 输出：Length: 13
System.out.println("First Char: " + firstChar); // 输出：First Char: H
System.out.println("Substring: " + substring); // 输出：Substring: World

字符串连接

可以使用 + 运算符或 StringBuilder 进行字符串连接。

String firstName = "John";
String lastName = "Doe";
String fullName = firstName + " " + lastName;
System.out.println(fullName); // 输出：John Doe

StringBuilder sb = new StringBuilder();
sb.append("Hello");
sb.append(", ");
sb.append("World!");
String completeMessage = sb.toString();
System.out.println(completeMessage); // 输出：Hello, World!

集合框架

Java集合框架提供了多种数据结构，如 ArrayList, HashSet, HashMap。

import java.util.ArrayList;
import java.util.HashSet;
import java.util.HashMap;

ArrayList<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
list.remove("Apple");
System.out.println(list.size()); // 输出：1

HashSet<String> set = new HashSet<>();
set.add("Apple");
set.add("Banana");
System.out.println(set.contains("Apple")); // 输出：true

HashMap<String, Integer> map = new HashMap<>();
map.put("Apple", 10);
map.put("Banana", 20);
System.out.println(map.get("Apple")); // 输出：10

日期和时间处理

Java 8引入了新的日期和时间API。

import java.time.LocalDate;
import java.time.LocalTime;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

LocalDate today = LocalDate.now();
LocalTime now = LocalTime.now();
LocalDateTime dateTime = LocalDateTime.now();

DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
String formattedDateTime = dateTime.format(formatter);

System.out.println("Today's Date: " + today); // 输出当前日期
System.out.println("Current Time: " + now); // 输出当前时间
System.out.println("Formatted DateTime: " + formattedDateTime); // 输出格式化的日期时间

10. 异常处理

异常处理使程序能够捕获和处理错误，而不是直接崩溃。

try-catch 语句

try {
    int result = 10 / 0;
} catch (ArithmeticException e) {
    System.out.println("Cannot divide by zero");
}

finally 块

finally块中的代码总会执行，无论是否捕获到异常。

try {
    int result = 10 / 0;
} catch (ArithmeticException e) {
    System.out.println("Cannot divide by zero");
} finally {
    System.out.println("This block is always executed");
}

throws 关键字

throws关键字用于声明一个方法可能抛出的异常。

public void myMethod() throws IOException {
    throw new IOException("An error occurred");
}

11. 文件操作

Java提供了多种方式来处理文件操作。

读取文件

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;

public class ReadFile {
    public static void main(String[] args) {
        try {
            File file = new File("filename.txt");
            Scanner reader = new Scanner(file);
            while (reader.hasNextLine()) {
                String data = reader.nextLine();
                System.out.println(data);
            }
            reader.close();
        } catch (FileNotFoundException e) {
            System.out.println("An error occurred.");
            e.printStackTrace();
        }
    }
}

写入文件

import java.io.FileWriter;
import java.io.IOException;

public class WriteFile {
    public static void main(String[] args) {
        try {
            FileWriter writer = new FileWriter("filename.txt");
            writer.write("Hello, World!");
            writer.close();
            System.out.println("Successfully wrote to the file.");
        } catch (IOException e) {
            System.out.println("An error occurred.");
            e.printStackTrace();
        }
    }
}

通过上述内容，初学者可以全面了解Java的基础语法，从变量和数据类型到面向对象编程，再到常用类和异常处理，打下扎实的编程基础。掌握这些基本概念和技巧，将为日后的高级编程打下坚实的基础。

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2024-05-29，如有侵权请联系 cloudcommunity@tencent.com 删除

java