Java基础

知识概念更新于 2026-08-16编辑本文

建议

了解一些关于面向对象编程(OOP)的基本概念，比如类（Classes），对象（Objects），方法（Methods），继承（Inheritance），封装（Encapsulation）和多态性（Polymorphism）。这些都是JAVA编程的基本概念，所以你在学习JAVA的过程中可以更快地掌握这些基础知识。

下面是一些学习Java的步骤和资源：

学习Java的基本语法：Java的语法和C++在许多方面都很相似，但也有一些关键的区别。例如，Java是完全面向对象的，所有的代码都必须位于类中。Java还有自己的内存管理机制，有自动的垃圾回收功能，所以你不需要像在C++中那样手动管理内存。
理解Java的面向对象编程：Java是一种面向对象的编程语言，对类和对象的理解非常重要。你需要理解如何在Java中创建和使用类和对象，以及如何使用继承，多态和封装等面向对象的概念。
学习Java的核心API：Java有一个非常丰富的核心API，包括集合（Collections），线程（Threads），输入/输出（I/O），网络编程等等。这些都是你在编写Java程序时需要了解和使用的。
学习Java的开发工具：Java有很多强大的开发工具，如Eclipse，IntelliJ IDEA等。学会使用这些工具可以大大提高你的开发效率。
实践编程：通过编写一些小项目，如简单的控制台应用程序，网络应用程序等，来提高你的编程技巧。

这里是一些在线资源，可以帮助你学习Java：

Oracle官方Java教程：https://docs.oracle.com/en/java/javase/11/docs/api/index.html
w3schools的Java教程：https://www.w3schools.com/java/
菜鸟教程：https://www.runoob.com/java/java-tutorial.html
Codecademy：https://www.codecademy.com/learn/learn-java
GeeksforGeeks Java教程：https://www.geeksforgeeks.org/java/

与C++的比较 Java和C++是两种非常强大的编程语言，它们都支持面向对象的编程（OOP），所以在一些基本的概念上还是有很大的相似性的，但是在一些语法和设计上有一些明显的区别。以下是它们之间的一些主要区别：

编程范式：

C++ 是一种支持多范式编程的语言，包括过程化编程，面向对象编程和泛型编程。

Java 是一种主要支持面向对象编程的语言。所有的代码都必须在一个类中。

内存管理：

在 C++ 中，程序员需要手动分配和释放内存。这为程序员提供了更大的控制，但也增加了内存泄漏的风险。

Java 有一个内存管理系统，叫做垃圾回收器（Garbage Collector），它自动处理不再使用的对象的内存释放。

错误处理：

C++ 使用异常处理机制，包括 try, catch, throw。

Java 也使用 try, catch, 但是增加了 finally 和 throws 关键字。

线程支持：

C++ 在标准库中支持线程，使用 <thread> 头文件。

Java 从语言级别就支持多线程，类如 Thread 类和 Runnable 接口。

库支持：

C++ 有一个广泛的标准库，包括容器类，算法，输入/输出流等。

Java 有一个庞大的类库，包括容器类，输入/输出流，网络编程，数据库编程，图形用户界面等。

继承：

C++ 支持多继承，即一个类可以从多个类继承属性和方法。

Java 只支持单继承，但可以通过接口（interfaces）来实现多继承。

运算符重载：

C++ 支持运算符重载。

Java 不支持运算符重载。

析构函数：

C++ 有构造函数和析构函数，析构函数在对象销毁时调用，用于清理工作。

Java 只有构造函数，没有析构函数。垃圾收集器负责清理工作。

指针和引用：

C++ 明确支持指针和引用。

Java 有引用，但不支持指针（即没有指针操作）。

0 Java与C++的语法对比

变量声明与初始化

C++:

int x;       //声明
x = 10;      //初始化
int y = 20;  //声明并初始化

Java:

int x;       //声明
x = 10;      //初始化
int y = 20;  //声明并初始化

数组

C++:

int arr[5] = {1, 2, 3, 4, 5};  //静态数组
int* arr = new int[5];          //动态数组，需要手动释放内存
delete [] arr;

Java:

int[] arr = new int[5];  //数组
//在Java中，不需要手动删除数组，垃圾回收器会自动处理

字符串

C++:

string s = "Hello World";  //使用标准库中的string类

Java:

String s = "Hello World";  //使用内置的String类，注意"S"是大写的

函数（方法）

C++:

void myFunction() {   //函数定义
   //函数体
}

myFunction();  //函数调用

Java:

public void myMethod() {  //方法定义，在类中定义
   //方法体
}

myMethod();  //方法调用，必须在一个方法内调用另一个方法

类和对象

C++:

class MyClass {  //类定义
   public:
      int myVariable;
      void myMethod() {
         //方法体
      }
};

MyClass obj;  //对象创建
obj.myVariable = 10;  //访问类的成员
obj.myMethod();       //调用类的方法

Java:

public class MyClass {  //类定义
   public int myVariable;
   public void myMethod() {
      //方法体
   }
}

MyClass obj = new MyClass();  //对象创建
obj.myVariable = 10;  //访问类的成员
obj.myMethod();       //调用类的方法

继承

C++:

class Parent {
   public:
      void myMethod() {
         //方法体
      }
};

class Child : public Parent {  //继承
   //子类的方法和属性
};

Child obj;
obj.myMethod();  //可以访问从父类继承的方法

Java:

public class Parent {
   public void myMethod() {
      //方法体
   }
}

public class Child extends Parent {  //继承
   //子类的方法和属性
}

Child obj = new Child();
obj.myMethod();  //可以访问从父类继承的方法

1. Java的基本语法：

以下是一个基本的Java语法入门教程：

1. 安装Java

首先，你需要在你的计算机上安装Java。你可以从Oracle的官方网站下载Java的最新版本。

2. Hello World

在Java中，每一个程序都从一个叫做main的方法开始运行。这是一个简单的Hello World程序：

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

在这个程序中，HelloWorld是一个类，main是一个方法，System.out.println是一个用于在控制台打印文本的方法。

3. 变量

在Java中，所有的变量都必须在使用前声明。例如：

int x;      // 声明一个整型变量x
x = 10;     // 给x赋值

你也可以在声明变量的同时给它赋值：

int x = 10;

4. 数据类型

Java有以下几种基本的数据类型：

整数：byte, short, int, long
浮点数：float, double
字符：char
布尔：boolean

数据类型	大小	示例
byte	1字节	byte a = 10;
short	2字节	short b = 300;
int	4字节	int c = 1000;
long	8字节	long d = 50000L;
float	4字节	float e = 20.0f;
double	8字节	double f = 50.0;
char	2字节	char g = ‘A’;
boolean	不明确指定	boolean h = true;

5. 条件语句

Java使用if, else if 和 else 关键字进行条件判断：

int x = 10;

if (x > 10) {
    System.out.println("x大于10");
} else if (x < 10) {
    System.out.println("x小于10");
} else {
    System.out.println("x等于10");
}

6. 循环

Java有两种主要的循环结构：for 循环和 while 循环。

这是一个for循环的例子：

for (int i = 0; i < 10; i++) {
    System.out.println(i);
}

这是一个while循环的例子：

int i = 0;
while (i < 10) {
    System.out.println(i);
    i++;
}

7. 数组

在Java中，数组是一种用来存储多个相同类型值的数据结构：

int[] numbers = new int[5]; // 创建一个能够存储5个整数的数组
numbers[0] = 1; // 给数组的第一个元素赋值

8. 类和对象

Java是一种面向对象的编程语言，这意味着你会使用类（Class）和对象（Object）来设计和实现你的程序。类是对象的蓝图，而对象是类的实例。

public class Car {
    // 类的属性
    String model;
    int speed;

    // 类的方法
    void accelerate() {
        speed = speed + 10;
    }
}

// 创建一个Car对象
Car myCar = new Car();
myCar.model = "Toyota";
myCar.speed = 0;
myCar.accelerate(); // 调用对象的方法

2 理解Java的面向对象编程

Java是一种面向对象的编程语言，对类和对象的理解非常重要。需要理解如何在Java中创建和使用类和对象，以及如何使用继承，多态和封装等面向对象的概念。

提供一些关于Java面向对象编程的基本示例，包括类、对象、继承、多态和封装。

类和对象

类是对象的蓝图或模板。它定义了一组属性（变量）和方法（函数）。

//定义一个类
public class Dog {
    //类变量（属性）
    String breed;
    String size;
    int age;
    String color;

    //定义类方法
    public String getInfo() {
        return ("Breed is: "+breed+" Size is:"+size+" Age is:"+age+" color is: "+color);
    }
}

对象是类的实例。我们可以创建上面定义的类的实例（对象）。

public class Main {
    public static void main(String[] args) {
        //创建Dog类的对象
        Dog maltese = new Dog();
        maltese.breed = "Maltese";
        maltese.size = "Small";
        maltese.age = 2;
        maltese.color = "white";
        System.out.println(maltese.getInfo());
    }
}

在Java中，public static void main(String[] args)是一个特殊的方法，称为”main方法”。Java程序的执行从main方法开始，也从main方法结束。这是一个程序入口点的约定。是一个可以从命令行接收参数并且被任何地方访问的静态方法。

来解析一下这行代码：

public：这是一个访问修饰符，表示该方法可以被任何其他类访问。

static：这是一个关键字，表示这个方法不依赖于任何对象，可以直接使用类名来调用。也就是说，不需要创建一个对象实例就可以调用main方法。

void：这是该方法的返回类型。void意味着这个方法不返回任何值。

main：这是方法的名字，是固定的，Java虚拟机会特别识别这个方法名。

String[] args：这是main方法的参数。String[]是一个字符串数组类型，args是变量名。它用于从命令行接收任何命令行参数。例如，如果你从命令行运行java MyProgram hello world，那么args[0]的值就是”hello”，args[1]的值就是”world”。

继承

继承是一个类获取另一个类的属性和方法的过程。在Java中使用关键字extends来继承一个类。

//父类
public class Animal {
    public void eat() {
        System.out.println("I can eat");
    }
}

//子类
public class Dog extends Animal {
    public void display() {
        System.out.println("I am a dog");
    }
}

public class Main {
    public static void main(String[] args) {
        //创建Dog类的对象
        Dog dog1 = new Dog();
        //调用父类的方法
        dog1.eat();
        //调用子类的方法
        dog1.display();
    }
}

多态

多态是允许一个对象采取多个形态的能力。最常见的多态类型是方法的重写和接口。

//父类
public class Animal {
    public void sound() {
        System.out.println("The animal makes a sound");
    }
}

//子类
public class Dog extends Animal {
    //重写父类的方法
    public void sound() {
        System.out.println("The dog says: woof ");
    }
}

public class Main {
    public static void main(String[] args) {
        //创建Dog类的对象
        Animal obj = new Dog();
        //调用重写后的方法
        obj.sound();
    }
}

封装

封装是一种将数据（变量）和操作数据的方法结合在一起的机制，封装可以隐藏对象的内部结构并保护对象内部数据。

public class Employee {
    //私有变量
    private String name;

    //公有的getter和setter方法
    public String getName() {
        return name;
    }

    public void setName(String newName) {
        name = newName;
    }
}

public class Main {
    public static void main(String[] args) {
        //创建Employee类的对象
        Employee emp = new Employee();
        //使用setter设置name
        emp.setName("John");
        //使用getter获取name
        System.out.println(emp.getName());
    }
}

3 ava的核心API

Java的核心API非常丰富，涵盖了许多功能。以下是一些关键的Java API以及如何使用它们的简单教程：

1. 集合（Collections）

Java集合框架提供了一套用于操作和管理组的接口和类。它定义了用于存储和操作组（或者称为集合）的数据结构。以下是Java集合框架中最常用的一些接口和类：

List接口和ArrayList类

List接口表示一个元素的有序集合（称为列表）。元素可以被插入到列表中的任何位置，并且可以根据它们在列表中的位置进行访问（索引从0开始）。

ArrayList是List接口的一种实现。它是一个动态数组，其大小可以动态地增加和减少。

下面是一个ArrayList的例子：

import java.util.*;

public class ArrayListExample {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();  // 创建一个空的ArrayList
        list.add("Java");  // 将"Java"添加到列表中
        list.add("Python");  // 将"Python"添加到列表中

        String firstElement = list.get(0);  // 获取列表中的第一个元素
        System.out.println(firstElement);  // 打印元素到控制台
    }
}

Set接口和HashSet类

Set接口表示一个不包含重复元素的集合。它最多包含一个null元素。

HashSet是Set接口的一种实现。它不保证元素的顺序，并且允许使用null元素。

下面是一个HashSet的例子：

import java.util.*;

public class HashSetExample {
    public static void main(String[] args) {
        Set<String> set = new HashSet<>();  // 创建一个空的HashSet
        set.add("Java");  // 将"Java"添加到集合中
        set.add("Python");  // 将"Python"添加到集合中
        set.add("Java");  // 试图将"Java"再次添加到集合中

        for (String element : set) {  // 遍历集合中的每一个元素
            System.out.println(element);  // 打印元素到控制台
        }
    }
}

Map接口和HashMap类

Map接口表示一个键值对的映射。它不能包含重复的键，每个键最多可以映射到一个值。

HashMap是Map接口的一种实现。它不保证键值对的顺序，并且允许使用null键和null值。

下面是一个HashMap的例子：

import java.util.*;

public class HashMapExample {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();  // 创建一个空的HashMap
        map.put("Java", 10);  // 将键为"Java"，值为10的键值对添加到映射中
        map.put("Python", 20);  // 将键为"Python"，值为20的键值对添加到映射中

        Integer javaValue = map.get("Java");  // 获取键为"Java"的值
        System.out.println(javaValue);  // 打印值到控制台
    }
}

这些都是Java集合框架中最常用的一些接口和类。你还可以探索其他的接口和类，如LinkedList，TreeSet，LinkedHashSet，TreeMap，LinkedHashMap等。

线程（Threads）

Java对多线程编程提供了基本的支持。线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一个进程中可以同时运行多个线程。多线程的目的是最大限度地利用CPU资源。

class MyRunnable implements Runnable {  // 定义一个类MyRunnable，实现Runnable接口
    public void run() {  // 实现Runnable接口的run方法
        // 在run方法中，打印出当前运行的线程名字
        System.out.println("Thread is running: " + Thread.currentThread().getName());
    }
}

public class ThreadExample {
    public static void main(String[] args) {  // 程序的入口点
        MyRunnable myRunnable = new MyRunnable();  // 创建MyRunnable对象
        Thread thread1 = new Thread(myRunnable);  // 创建一个新的线程，传入Runnable对象
        thread1.start();  // 启动线程，会调用Runnable对象的run方法

        Thread thread2 = new Thread(myRunnable);  // 创建另一个新的线程
        thread2.start();  // 启动第二个线程
    }
}

队列（Queue）

import java.util.*;

public class QueueExample {
    public static void main(String[] args) {
        Queue<String> queue = new LinkedList<>();  // 创建一个空的LinkedList
        queue.offer("Java");  // 将"Java"添加到队列末尾
        queue.offer("Python");  // 将"Python"添加到队列末尾

        while(!queue.isEmpty()) {  // 当队列不为空时，循环执行以下操作
            String head = queue.poll();  // 获取并删除队列头部的元素
            System.out.println(head);  // 打印元素到控制台
        }
    }
}

映射（Map）

import java.util.*;

public class MapExample {
    public static void main(String[] args) {
        Map<String, Integer> map = new HashMap<>();  // 创建一个空的HashMap
        map.put("Java", 10);  // 将键为"Java"，值为10的键值对添加到映射中
        map.put("Python", 20);  // 将键为"Python"，值为20的键值对添加到映射中

        for (String key : map.keySet()) {  // 遍历映射中的所有键
            Integer value = map.get(key);  // 获取给定键对应的值
            System.out.println(key + ": " + value);  // 打印键和值
        }
    }
}

输入/输出（I/O）

下面是一个简单的文件输入输出示例，首先读取一个文件的内容，然后将这些内容写入到另一个文件中。

import java.io.*;

public class IOExample {
    public static void main(String[] args) {
        try {
            // 创建一个FileReader，用于读取名为"input.txt"的文件
            FileReader reader = new FileReader("input.txt");
            char[] buffer = new char[1024];
            int length = reader.read(buffer);  // 读取文件内容到字符数组中
            reader.close();  // 关闭文件输入流

            // 创建一个FileWriter，用于写入名为"output.txt"的文件
            FileWriter writer = new FileWriter("output.txt");
            writer.write(buffer, 0, length);  // 将字符数组的内容写入到文件中
            writer.close();  // 关闭文件输出流
        } catch (IOException e) {
            e.printStackTrace();  // 打印异常信息
        }
    }
}

网络编程

下面是一个简单的网络编程示例，创建一个服务器套接字，接受客户端连接并读取客户端发送的数据。

import java.io.*;
import java.net.*;

public class ServerExample {
    public static void main(String[] args) {
        try {
            ServerSocket serverSocket = new ServerSocket(6666);  // 创建绑定到特定端口的服务器套接字
            System.out.println("Server is waiting for client connection...");

            Socket clientSocket = serverSocket.accept();  // 监听并接受到此套接字的连接
            System.out.println("Client connected");

            BufferedReader reader = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));  // 创建一个BufferedReader，用于读取客户端发送的数据
            String line = reader.readLine();  // 读取一行数据
            System.out.println("Received from client: " + line);
        } catch (IOException e) {
            e.printStackTrace();  // 打印异常信息
        }
    }
}

开发工具

Java开发者有多种开发工具可以选择，这些工具提供了编码、调试、测试和部署Java应用程序的各种功能。以下是最常用的一些Java开发工具：

1. **集成开发环境（IDEs）**

- **Eclipse**：Eclipse是一个开源的集成开发环境，广泛应用于Java开发。Eclipse不仅提供了代码编辑、构建、调试等基本功能，还有丰富的插件支持，可以通过安装不同的插件来支持不同的开发需求。你可以在[Eclipse官网](https://www.eclipse.org/)下载并安装Eclipse。

- **IntelliJ IDEA**：IntelliJ IDEA是一款强大的Java IDE，有免费的社区版和付费的专业版。IntelliJ IDEA具有出色的代码分析功能，能够提供准确的自动完成和代码重构建议。你可以在[IntelliJ IDEA官网](https://www.jetbrains.com/idea/)下载并安装IntelliJ IDEA。

- **NetBeans**：NetBeans是一款免费的开源Java开发工具，提供了全面的软件开发功能。NetBeans的特色之一是其良好的Swing GUI设计支持。你可以在[NetBeans官网](https://netbeans.apache.org/)下载并安装NetBeans。

2. **构建工具**

- **Maven**：Maven是一款优秀的项目管理工具，它可以帮助你处理项目的构建、报告和文档等需求。你可以在[Maven官网](https://maven.apache.org/)下载并安装Maven。

- **Gradle**：Gradle是一款开源的自动化构建工具，设计上灵活且性能优越。Gradle支持多种语言和框架，包括Java、Groovy和Kotlin。你可以在[Gradle官网](https://gradle.org/)下载并安装Gradle。

3. **版本控制系统**

- **Git**：Git是目前最流行的版本控制系统。你可以使用Git来跟踪代码的变化，同时支持多人协作开发。你可以在[Git官网](https://git-scm.com/)下载并安装Git。

每个工具都有其特点和使用场景，你可以根据你的需求选择适合你的工具。

来源：CSDN 原文，首次发布于 2023-07-18。