《Java 基础教程和代码实例讲解》—— 想学Java看这一篇文章就足够了

文章目录

• Java基础语法教程
• • 1. 数据类型
  • • 1.1 整型
    • 1.2 浮点型
    • 1.3 字符型
    • 1.4 布尔型
    • 1.5 字符串
  • 3. 控制结构
  • • 3.1 条件语句
    • 3.2 循环语句
    • 3.3 跳转语句
  • 4. 数组
  • 5. 方法
  • 6. 数组和方法的结合
  • • 6.1 数组作为方法的参数
    • 6.2 方法作为数组的元素
  • 7. 类和对象
  • 8. 继承
  • 9. 多态
  • 10. 异常处理
  • 11. 输入输出
  • 12. 集合框架
  • 13. 多线程
  • 14. 网络编程
  • 15. GUI编程
  • 16. 数据库编程
  • 17. 安全性编程
• 附：Java 技术生态介绍
• • 1. Java语言
  • 2. JVM
  • 3. Java框架
  • 4. 数据库
  • 5. Web开发
  • 6. 移动开发
  • 7. 云计算
  • 8. 其他技术

学习Java的第一步是了解基本概念和语法。以下是一些建议，帮助您开始学习Java:

1. 安装Java开发工具包(JDK):首先，您需要在计算机上安装Java开发工具包(JDK)。可以从Oracle官网下载并安装适合您操作系统的JDK版本。

2. 学习基本概念：了解Java的基本概念，如变量、数据类型、运算符、控制结构(if-else语句、循环等)、数组、方法等。

3. 阅读教程：有很多优秀的Java教程可以帮助您入门。例如，菜鸟教程(https://www.runoob.com/java/java-tutorial.html)提供了详细的Java教程，从基础到进阶内容都有涉及。

4. 动手实践：通过编写简单的Java程序来巩固所学知识。可以从“Hello World”开始，逐步尝试更复杂的程序。

5. 参加在线课程：有许多在线平台提供Java课程，如Coursera、Udemy、edX等。这些课程通常由专业讲师授课，可以帮助您更系统地学习Java。

6. 加入社区：加入Java相关的论坛、微信群、QQ群等，与其他学习者和开发者交流心得，提高自己的技能。

7. 阅读官方文档：Oracle官方文档是学习Java的重要资源，可以了解Java的最新特性和技术。访问Oracle官网(https://docs.oracle.com/en/java/)获取相关文档。

8. 学习面向对象编程(OOP):Java是一种面向对象的编程语言，因此了解OOP的概念和原则对学习Java非常重要。

9. 学习Java标准库：熟悉Java标准库中的常用类和方法，如集合框架、输入输出流、多线程等。

10. 实践项目：参与实际项目的开发，将所学知识应用于实际问题解决中，提高自己的编程能力。

坚持学习和实践，您会逐渐掌握Java编程技能。祝您学习顺利！

Java基础语法教程

Java是一种面向对象的编程语言，具有跨平台、安全性高、易学易用等特点。本文将介绍Java的基础语法，包括数据类型、运算符、控制结构、数组、方法等内容。

1. 数据类型

Java有8种基本数据类型，分别是：

• 整型：byte、short、int、long
• 浮点型：float、double
• 字符型：char
• 布尔型：boolean
• 字符串：String
• 包装类：Integer、Double、Long等
• 数组：Object[]
• 枚举类型：enum

1.1 整型

Java中的整型分为32位和64位两种，分别对应int和long类型。它们的取值范围如下：

byte:-128 ~ 127 (0xff)short:-32768 ~ 32767 (0xffff)int:-2147483648 ~ 2147483647 (0x7fffffff)long:-9223372036854775808 ~ 9223372036854775807 (0x7fffffffffffffffL)

1.2 浮点型

Java中的浮点型分为单精度和双精度两种，分别对应float和double类型。它们的取值范围如下：

float:3.4E-45 ~ 3.4E+38 (0.0f ~ 1.7976931348623157E+38)double:1.6E-45 ~ 1.7976931348623157E+38 (0.0d ~ 1.7976931348623157E+38)

1.3 字符型

Java中的字符型使用char类型表示，它只能存储一个ASCII码对应的字符。例如，字符’A’的ASCII码为65。

1.4 布尔型

Java中的布尔型使用boolean类型表示，它的取值只有两个：true和false。在Java中，可以使用关键字Boolean来声明一个布尔类型的变量。例如：

boolean isTrue = true; // 声明一个布尔类型的变量isTrue,并赋值为true

1.5 字符串

Java中的字符串使用String类型表示，它是一个不可变的对象。字符串可以通过以下方式创建：

String str1 = "Hello"; // 通过字面量创建字符串str1,值为"Hello"String str2 = new String("World"); // 通过构造函数创建字符串str2,值为"World"

3. 控制结构

Java中的控制结构用于对程序进行流程控制，包括条件语句、循环语句等。以下是一些常用的控制结构：

3.1 条件语句

• if-else语句：if (condition) { ... } else { ... }
• if-else if-else语句：if (condition1) { ... } else if (condition2) { ... } else { ... }
• switch-case语句：switch (expression) { case value1: ... break; case value2: ... break; ... default: ... break; }

3.2 循环语句

• for循环：for (initialization; condition; increment) { ... }
• while循环：while (condition) { ... }
• do-while循环：do { ... } while (condition);

3.3 跳转语句

• goto语句：goto label;
• break语句：break;
• continue语句：continue;
• return语句：return;

4. 数组

Java中的数组是一种数据结构，用于存储一组相同类型的数据。数组的声明和初始化如下：

int[] arr = new int[5]; // 声明一个长度为5的整型数组arr,并将其初始化为0

访问数组元素的方法有以下几种：

arr[index] // 通过下标访问数组元素，index为0~4之间的整数arr.get(index) // 通过getter方法访问数组元素，index为0~4之间的整数

Java中的数组支持多维数组，例如二维数组可以这样声明：

int[][] arr = new int[3][4]; // 声明一个3行4列的整型二维数组arr,并将其初始化为0

5. 方法

Java中的类可以包含方法，方法是一段具有特定功能的代码块。方法的声明和定义如下：

public class MyClass {    // 类的成员变量和方法}// 方法的声明public void myMethod() {    // 方法的实现}

方法可以有返回值，也可以没有返回值。如果方法有返回值，可以使用以下语法声明：

public int myMethod() {    // 方法的实现}

如果方法没有返回值，可以使用以下语法声明：

public void myMethod() {    // 方法的实现}

方法可以有参数，参数是传递给方法的数据。方法的参数使用以下语法声明：

public void myMethod(int param1, String param2) {    // 方法的实现}

在方法中，可以使用以下语法访问参数：

public void myMethod(int param1) {    int anotherParam = param1 * 2; // 直接访问参数param1,并赋值给另一个参数anotherParam}

6. 数组和方法的结合

Java中的数组可以作为方法的参数，也可以作为方法的返回值。以下是一些示例：

6.1 数组作为方法的参数

public static int sum(int[] arr) {    int total = 0;    for (int i = 0; i < arr.length; i++) {        total += arr[i];    }    return total;}public static void main(String[] args) {    int[] arr = {1, 2, 3, 4, 5};    int result = sum(arr);    System.out.println("数组之和为：" + result);}

6.2 方法作为数组的元素

public static void printArray(int[] arr) {    for (int i = 0; i < arr.length; i++) {        System.out.print(arr[i] + "\t"); // 用制表符分隔每个元素    }    System.out.println(); // 在末尾添加一个换行符}public static void main(String[] args) {    int[] arr = {1, 2, 3, 4, 5};    printArray(arr); // 将printArray方法作为参数传递给printArray方法，并将结果打印出来}

7. 类和对象

Java中的类是一种抽象的数据类型，用于描述一类具有相同属性和方法的对象。类的定义如下：

public class MyClass {    // 类的成员变量和方法}

在Java中，每个对象都是类的一个实例。对象的创建需要通过以下语法：

MyClass obj = new MyClass(); // 创建一个MyClass类型的对象obj,并将其初始化为空引用

对象可以使用类名来访问其成员变量和方法，例如：

MyClass obj = new MyClass();obj.myMethod(); // 调用MyClass类中的方法myMethod()

Java中的构造方法是一种特殊的方法，用于创建对象时进行初始化。构造方法的定义如下：

public class MyClass {    int myVar; // 成员变量        // 构造方法    public MyClass(int var) {        myVar = var; // 将传入的参数var赋值给成员变量myVar    }}

在创建对象时，可以调用构造方法对对象进行初始化，例如：

MyClass obj = new MyClass(10); // 创建一个MyClass类型的对象obj,并使用构造方法对其进行初始化，将myVar赋值为10

8. 继承

Java中的继承是一种面向对象编程的特性，用于创建一个新类，该类从现有类中继承属性和方法。子类可以重写父类的方法，以实现自己的功能。以下是一些示例：

// 父类public class Animal {    public void eat() {        System.out.println("Animal is eating");    }}// 子类public class Dog extends Animal {    public void bark() {        System.out.println("Dog is barking");    }}// 主程序public static void main(String[] args) {    Animal myAnimal = new Animal(); // 创建一个Animal类型的对象myAnimal,并将其初始化为空引用    myAnimal.eat(); // 调用Animal类中的方法eat()        Dog myDog = new Dog(); // 创建一个Dog类型的对象myDog,并将其初始化为空引用    myDog.bark(); // 调用Dog类中的方法bark()}

在上述示例中，Dog类继承了Animal类，因此它可以使用Animal类中的方法eat()。同时，Dog类还可以重写Animal类中的方法bark(),以实现自己的功能。

9. 多态

Java中的多态是一种面向对象编程的特性，用于创建一个新类，该类可以具有与现有类相同的属性和方法，但其行为可以根据不同的上下文而有所不同。以下是一些示例：

// 父类public class Animal {    public void eat() {        System.out.println("Animal is eating");    }}// 子类1public class Dog extends Animal {    public void bark() {        System.out.println("Dog is barking");    }}// 子类2public class Cat extends Animal {    public void meow() {        System.out.println("Cat is meowing");    }}// 主程序public static void main(String[] args) {    Animal myAnimal = new Animal(); // 创建一个Animal类型的对象myAnimal,并将其初始化为空引用    myAnimal.eat(); // 调用Animal类中的方法eat()        Dog myDog = new Dog(); // 创建一个Dog类型的对象myDog,并将其初始化为空引用    myDog.bark(); // 调用Dog类中的方法bark()        Cat myCat = new Cat(); // 创建一个Cat类型的对象myCat,并将其初始化为空引用    myCat.meow(); // 调用Cat类中的方法meow()}

在上述示例中，Dog和Cat类都继承了Animal类，因此它们可以使用Animal类中的方法eat()。同时，Dog和Cat类还可以重写Animal类中的方法bark()和meow(),以实现自己的功能。在主程序中，我们可以将Animal类型的对象赋值给Dog或Cat类型的对象，这将导致编译器根据实际类型调用相应的方法。这就是Java中的多态性。

10. 异常处理

Java中的异常处理是一种机制，用于处理程序运行时可能出现的错误或异常情况。以下是一些示例：

public class Main {    public static void main(String[] args) {        try {            int result = divide(10, 0); // 调用divide方法，可能会抛出除以零的异常            System.out.println("Result is " + result);        } catch (ArithmeticException e) {            System.out.println("Error: " + e.getMessage()); // 捕获并处理除以零的异常        } finally {            System.out.println("Finally block executed"); // 无论是否发生异常，都会执行finally块中的代码        }    }        public static int divide(int a, int b) throws ArithmeticException {        if (b == 0) {            throw new ArithmeticException("Cannot divide by zero"); // 如果除数为零，则抛出异常        } else {            return a / b; // 否则返回商        }    }}

在上述示例中，我们使用try-catch-finally语句来处理可能发生的异常。在try块中，我们调用divide方法，该方法可能会抛出ArithmeticException异常。如果发生异常，则会跳转到catch块中进行处理。在catch块中，我们捕获并打印异常信息。无论是否发生异常，finally块中的代码都会被执行。

11. 输入输出

Java中的输入输出是一种机制，用于从用户或其他程序中读取数据，并将数据写入文件或其他输出设备。以下是一些示例：

import java.io.*; // 导入输入输出类库public class Main {    public static void main(String[] args) {        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in)); // 从标准输入流中读取数据        try {            String line = reader.readLine(); // 读取一行数据            System.out.println("You entered: " + line); // 将读取的数据打印到控制台        } catch (IOException e) {            System.out.println("Error reading input: " + e.getMessage()); // 如果发生异常，则打印错误信息        } finally {            try {                reader.close(); // 无论是否发生异常，都会关闭输入流            } catch (IOException e) {                System.out.println("Error closing input stream: " + e.getMessage()); // 如果发生异常，则打印错误信息            }        }    }}

在上述示例中，我们使用BufferedReader类来从标准输入流中读取数据。我们可以使用readLine()方法读取一行数据，并将其存储在String类型的变量line中。然后，我们将读取的数据打印到控制台。最后，我们使用try-catch-finally语句来处理可能发生的异常。在finally块中，我们尝试关闭输入流，以确保资源得到正确释放。

12. 集合框架

Java中的集合框架是一种用于存储和操作一组对象的机制。以下是一些示例：

import java.util.*; // 导入集合框架类库public class Main {    public static void main(String[] args) {        List<String> names = new ArrayList<>(); // 创建一个字符串列表        names.add("Alice"); // 向列表中添加元素        names.add("Bob");        names.add("Charlie");                Set<String> uniqueNames = new HashSet<>(names); // 将列表转换为不重复的字符串集合        System.out.println("Unique names: " + uniqueNames); // 打印不重复的字符串集合    }}

在上述示例中，我们使用ArrayList类来创建一个字符串列表，并向其中添加了三个元素。然后，我们使用HashSet类将列表转换为不重复的字符串集合，并将其打印到控制台。HashSet类是一种基于哈希表实现的集合，它可以快速地查找和插入元素，并且不包含重复元素。

13. 多线程

Java中的多线程是一种机制，用于同时执行多个任务。以下是一些示例：

public class Main {    public static void main(String[] args) {        // 创建两个线程对象        MyThread thread1 = new MyThread("Thread 1");        MyThread thread2 = new MyThread("Thread 2");                // 启动线程        thread1.start();        thread2.start();    }}class MyThread extends Thread {    private String name; // 线程名称        public MyThread(String name) {        this.name = name;    }        @Override    public void run() {        for (int i = 0; i < 5; i++) {            System.out.println(name + " is running"); // 在子线程中打印线程名称和运行状态            try {                Thread.sleep(1000); // 让线程休眠1秒钟            } catch (InterruptedException e) {                e.printStackTrace(); // 如果发生异常，则打印错误信息            }        }    }}

在上述示例中，我们创建了两个MyThread类的实例，并分别指定了它们的名称。然后，我们调用start()方法来启动这两个线程。在run()方法中，我们让每个线程打印它的名称和运行状态，并让它们休眠1秒钟。由于线程是并发执行的，因此这两个线程将同时运行，并在控制台上打印出不同的输出。

14. 网络编程

Java中的网络编程是一种机制，用于在不同的计算机之间传输数据。以下是一些示例：

import java.io.*; // 导入输入输出类库import java.net.*; // 导入网络类库public class Main {    public static void main(String[] args) throws IOException {        ServerSocket serverSocket = new ServerSocket(8080); // 创建一个服务器套接字，监听端口号为8080的连接请求        Socket socket = serverSocket.accept(); // 等待客户端连接并接受连接请求        BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream())); // 从客户端套接字中读取数据        PrintWriter out = new PrintWriter(socket.getOutputStream(), true); // 将数据写入客户端套接字                String line;        while ((line = in.readLine()) != null) { // 循环读取客户端发送的数据            System.out.println("Received: " + line); // 在控制台上打印接收到的数据            out.println("Hello from server!"); // 将响应数据发送回客户端        }                in.close(); // 关闭输入流        out.close(); // 关闭输出流        socket.close(); // 关闭套接字连接    }}

在上述示例中，我们使用ServerSocket类来创建一个服务器套接字，并监听端口号为8080的连接请求。当有客户端连接时，我们使用accept()方法接受连接请求，并返回一个Socket对象。然后，我们从客户端套接字中读取数据，并将响应数据写入客户端套接字。最后，我们关闭输入流、输出流和套接字连接。

15. GUI编程

Java中的GUI编程是一种机制，用于创建图形用户界面。以下是一些示例：

import javax.swing.*; // 导入Swing类库public class Main {    public static void main(String[] args) {        JFrame frame = new JFrame("My Application"); // 创建一个窗口对象        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // 设置窗口关闭时的操作                JPanel panel = new JPanel(); // 创建一个面板对象        frame.add(panel); // 将面板添加到窗口中                JButton button = new JButton("Click me!"); // 创建一个按钮对象        panel.add(button); // 将按钮添加到面板中                frame.pack(); // 调整窗口大小以适应内容        frame.setVisible(true); // 显示窗口    }}

在上述示例中，我们使用Swing类库来创建一个窗口和一个面板。我们创建了一个按钮对象，并将其添加到面板中。然后，我们将面板添加到窗口中，并调整窗口大小以适应内容。最后，我们显示窗口。

16. 数据库编程

Java中的数据库编程是一种机制，用于在应用程序中访问和管理数据库。以下是一些示例：

import java.sql.*; // 导入JDBC类库public class Main {    public static void main(String[] args) {        Connection conn = null; // 创建一个数据库连接对象        try {            conn = DriverManager.getConnection("jdbc:mysql://localhost/mydatabase", "username", "password"); // 获取数据库连接            Statement stmt = conn.createStatement(); // 创建一个语句对象                        ResultSet rs = stmt.executeQuery("SELECT * FROM mytable"); // 从数据库中查询数据            while (rs.next()) { // 循环读取查询结果                System.out.println(rs.getString("column_name")); // 在控制台上打印查询结果的列值            }                        rs.close(); // 关闭结果集            stmt.close(); // 关闭语句对象        } catch (SQLException e) {            e.printStackTrace(); // 如果发生异常，则打印错误信息        } finally {            if (conn != null) { // 如果数据库连接对象不为空，则关闭连接                try {                    conn.close();                } catch (SQLException e) {                    e.printStackTrace(); // 如果发生异常，则打印错误信息                }            }        }    }}

在上述示例中，我们使用JDBC类库来创建一个数据库连接对象，并获取一个语句对象。然后，我们从数据库中查询数据，并将查询结果打印到控制台上。最后，我们关闭结果集、语句对象和数据库连接。

17. 安全性编程

Java中的安全性编程是一种机制，用于保护应用程序免受安全漏洞的攻击。以下是一些示例：

import javax.crypto.Cipher; // 导入加密类库import javax.crypto.spec.SecretKeySpec; // 导入密钥规范类库public class Main {    public static void main(String[] args) throws Exception {        String plaintext = "Hello, world!"; // 要加密的明文数据        SecretKeySpec key = new SecretKeySpec("mysecretkey".getBytes(), "AES"); // 创建一个密钥对象        Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding"); // 获取一个加密器对象        cipher.init(Cipher.ENCRYPT_MODE, key); // 初始化加密器对象        byte[] encrypted = cipher.doFinal(plaintext.getBytes()); // 对明文数据进行加密        System.out.println("Encrypted: " + new String(encrypted)); // 在控制台上打印加密后的数据    }}

在上述示例中，我们使用加密类库和密钥规范类库来创建一个密钥对象和一个加密器对象。然后，我们对明文数据进行加密，并将加密后的数据打印到控制台上。请注意，这只是一个简单的示例，实际应用中需要考虑更多的安全性问题。

附：Java 技术生态介绍

Java技术栈生态是指Java生态系统中的各种技术和工具，包括Java语言、JVM、Java框架、数据库、Web开发、移动开发、云计算等。下面将对Java技术栈生态进行总结。

1. Java语言

Java是一种面向对象的编程语言，具有跨平台性、安全性、可靠性等特点。Java语言的核心是类和对象，通过继承、多态等特性实现了代码的复用和扩展。Java语言还提供了丰富的API和工具，方便开发者进行开发和调试。

2. JVM

JVM(Java虚拟机)是Java程序运行的基础，它负责将Java字节码转换为机器码并执行。JVM还提供了垃圾回收机制，自动管理内存，避免了内存泄漏等问题。JVM还支持多种操作系统和硬件平台，使得Java程序可以在不同的环境中运行。

3. Java框架

Java框架是一组预先编写好的类库和工具，用于简化Java应用程序的开发和部署。常见的Java框架包括Spring、Hibernate、MyBatis等。这些框架提供了丰富的功能和组件，如依赖注入、ORM映射、AOP等，可以帮助开发者快速构建高质量的应用程序。

4. 数据库

数据库是存储和管理数据的系统，常用的数据库有MySQL、Oracle、SQL Server等。Java应用程序通常需要与数据库进行交互，使用JDBC(Java Database Connectivity) API可以实现对数据库的操作。此外，还有ORM框架(如Hibernate)可以简化数据库操作。

5. Web开发

Web开发是指使用HTML、CSS、JavaScript等技术构建Web应用程序的过程。在Java技术栈中，常用的Web框架有Spring MVC、Struts2、Play等。这些框架提供了路由、模板引擎、表单验证等功能，可以帮助开发者快速构建Web应用程序。

6. 移动开发

移动开发是指使用Java技术栈构建移动应用程序的过程。常用的移动开发框架有Android SDK、Eclipse MOBIUS等。这些框架提供了UI组件、网络通信、数据存储等功能，可以帮助开发者快速构建高质量的移动应用程序。

7. 云计算

云计算是指通过互联网提供计算资源和服务的过程。在Java技术栈中，常用的云计算平台有AWS、Azure、Google Cloud等。这些平台提供了弹性计算、存储、数据库等功能，可以帮助开发者快速构建分布式应用程序。

8. 其他技术

除了上述技术外，Java技术栈还包括其他一些技术和工具，如Maven、Gradle、Jenkins等项目管理工具；Git、SVN等版本控制工具；Docker、Kubernetes等容器化技术；Jenkinsfile等持续集成/持续部署工具等。这些技术和工具可以帮助开发者提高开发效率和质量。

来源地址：https://blog.csdn.net/universsky2015/article/details/131136037