Java程序设计入门教程

概述

Java程序设计是一种功能强大且易于学习的编程语言，广泛应用于各种开发领域，如Web应用、企业应用和移动应用开发。本文全面介绍了Java的基础语法、流程控制、面向对象编程等核心概念，并提供了丰富的示例代码来帮助读者深入理解Java程序设计。

Java简介
Java是一种广泛使用的编程语言，由Sun Microsystems（现为Oracle公司）于1995年推出。Java的设计目标是提供一种可移植、高性能的编程语言，使开发者能够编写一次代码，即可在任何支持Java的平台上运行。Java语言主要具有以下特点与优势：

Java的特点与优势

1. 跨平台性：Java程序可以在任何支持Java的平台上运行，无论是在Windows、Linux、macOS还是其他操作系统上。
2. 面向对象：Java语言支持面向对象的编程思想，包括封装、继承和多态。
3. 自动内存管理：Java使用自动垃圾回收机制，减少了内存泄漏的风险。
4. 安全性：Java具有严格的安全模型，可以防止恶意代码的运行，适用于各种安全环境。
5. 丰富的库支持：Java提供了大量的标准库，涵盖了网络通信、图形用户界面、数据库操作等众多领域。
6. 易于学习：Java语法简洁，结构清晰，易于理解和学习。
7. 强大的社区支持：Java拥有庞大的开发者社区，使得在遇到问题时容易获得帮助。

Java的应用领域

Java的应用范围非常广泛，包括但不限于以下几个领域：

1. Web应用程序：Java可以用来开发动态网页应用，如Spring等Web框架就是基于Java实现的。
2. 企业应用开发：Java是企业级应用开发的主要选择，如Java EE（Java Enterprise Edition）提供了开发企业级应用的完整解决方案。
3. 移动应用开发：Java可以用于开发Android应用，Android操作系统就是基于Java开发的。
4. 游戏开发：Java可以用于开发桌面游戏、手机游戏和Web游戏。
5. 大数据处理：Java可以用于处理大规模数据，如Apache Hadoop就是使用Java实现的。
6. 物联网（IoT）：Java在物联网领域也有广泛应用，可以用于开发智能家居、工业自动化等。

综上所述，Java是一种功能强大、应用广泛、易于学习和使用的编程语言，是现代软件开发的重要组成部分。

Java的历史与发展

Java语言的发展历程可以分为几个关键阶段：

1. 1991年：Java语言的前身“Oak”由Sun Microsystems的詹姆斯·戈斯林（James Gosling）和团队开始研发。
2. 1995年：Oak更名为Java，正式发布。Java 1.0版本发布，包括了Java虚拟机（JVM）、类库和开发工具。
3. 1996年：发布Java 1.1，引入了JavaBeans组件模型。
4. 1998年：发布Java 1.2，引入了Java平台的两个主要版本：Java SE（标准版）和Java EE（企业版）。
5. 2004年：发布Java 1.5，引入了泛型、增强的for循环、自动装箱等新特性。
6. 2014年：发布Java 8，增加了Lambda表达式、Stream API等新特性。
7. 2022年：发布Java 19，引入了Vector API、switch表达式的模式匹配等新功能。

Java语言的迭代发展，使得它不断地增强了功能，提高了开发效率和性能，使其成为现代软件开发的首选语言之一。

Java环境搭建
Java环境的搭建是开始学习Java编程的基础。本节将详细介绍如何安装Java开发环境、配置JDK和IDE，并编写并运行第一个Java程序。

安装Java开发环境

在开始之前，需要确保操作系统上已经安装了JDK（Java Development Kit）。JDK是Java开发的必要工具，因为它包含了编译Java源代码所需的编译器、运行时环境以及其他开发工具。以下是安装JDK的步骤：

Windows系统

1. 访问Oracle官方网站或GitHub上的JDK下载页面。
2. 选择合适版本的JDK下载，注意选择对应的操作系统版本。
3. 下载完成后，运行下载的安装文件，按照提示完成安装过程。
4. 安装完成后，需要设置环境变量。在“此电脑”右键选择“属性”，点击“高级系统设置”，在“系统属性”窗口中点击“环境变量”按钮。
5. 在“系统变量”中找到名为“Path”的变量，点击“编辑”按钮，在变量值的末尾添加JDK的bin路径，格式如下：

   C:\Program Files\Java\jdk-11.0.11\bin

6. 确保安装过程中选择了默认安装路径，或者手动设置安装路径。

Linux系统

1. 打开终端，输入以下命令安装OpenJDK（通常默认安装的是OpenJDK）：

   sudo apt-get update
   sudo apt-get install openjdk-11-jdk

2. 检查是否安装成功，可以通过以下命令查看Java版本：

   java -version

macOS系统

1. macOS通常已经内置了JDK，但如果没有，可以通过Homebrew安装：

   brew install openjdk

2. 检查是否安装成功，可以通过以下命令查看Java版本：

   java -version

配置JDK和IDE

在安装完JDK之后，需要设置环境变量并选择合适的集成开发环境（IDE）来开发Java程序。环境变量的设置已经在安装JDK时完成，接下来是选择IDE。

选择IDE

常用的Java开发IDE包括Eclipse、IntelliJ IDEA和NetBeans等。这里以IntelliJ IDEA为例进行说明：

1. 访问IntelliJ IDEA的官方下载页面，下载对应版本的IDEA。
2. 安装IntelliJ IDEA，按照安装向导完成安装过程。
3. 启动IDEA，首次启动时会提示设置配置，选择合适的选项进行配置。

配置IDEA

1. 打开IDEA，选择“File” > “Settings”（或按快捷键Ctrl+Alt+S）。
2. 在设置窗口中选择“Appearance & Behavior” > “System Settings” > “Save file path”，设置默认项目目录。
3. 点击“OK”应用设置。
4. 创建一个新项目，选择“File” > “New” > “Project”，选择“Java”，点击“Next”，填写项目名称和位置，点击“Finish”。

编写并运行第一个Java程序

编写并运行第一个Java程序是学习Java编程的必备步骤。按照以下步骤操作：

1. 在IDEA中新建一个Java类，命名为HelloWorld.java。
2. 编写以下代码：

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

3. 保存文件并编译程序。在IDEA中，选择“Build” > “Make Project”。
4. 运行程序。在IDEA中，右键点击HelloWorld.java，选择“Run 'HelloWorld.main()'”。

运行结果将在IDEA的终端窗口中显示“Hello, World!”。至此，第一个Java程序已经成功运行。

通过以上步骤，你已经成功搭建了Java开发环境，并编写并运行了第一个Java程序。接下来，可以深入学习Java基础语法、流程控制、数组与字符串等知识。

Java基础语法
Java的基础语法是学习Java编程的关键，本节将详细讲解Java的基本语法结构、数据类型与变量、运算符与表达式等基本概念。通过这些知识，可以为后续更复杂的编程学习打下坚实的基础。

基本语法结构

Java程序的基本结构通常包括以下几个部分：

1. 包声明（Optional）：用于声明该程序所属的包。
2. 导入语句（Optional）：用于导入所需的类或接口。
3. 类声明：定义一个或多个类。
4. 主类声明：定义主类，包含main方法。
   • main方法是程序的入口点，格式为public static void main(String[] args)。
5. 代码主体：程序的主要逻辑代码。

示例代码：

// 包声明
package com.example;

// 导入语句
import java.util.Scanner;

// 类声明
public class HelloWorld {
    // 主类声明
    public static void main(String[] args) {
        // 代码主体
        System.out.println("Hello, World!");

        // 示例：读取用户输入
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入您的名字：");
        String name = scanner.nextLine();
        System.out.println("您好，" + name + "!");
    }
}

数据类型与变量

Java中的数据类型分为两类：基本类型和引用类型。基本类型包括8种：整型（byte、short、int、long）、浮点型（float、double）、字符型（char）和布尔型（boolean）。引用类型主要是类和接口。

基本类型

• 整型
  • byte：有符号8位整数，范围是-128到127。
  • short：有符号16位整数，范围是-32768到32767。
  • int：有符号32位整数，范围是-2147483648到2147483647。
  • long：有符号64位整数，范围是-9223372036854775808到9223372036854775807。
• 浮点型
  • float：单精度浮点数，范围是±1.4E-45到±3.4028235E38。
  • double：双精度浮点数，范围是±4.9E-324到±1.7976931348623157E308。
• 字符型
  • char：16位Unicode字符，范围是'\u0000'到'\uffff'。
• 布尔型
  • boolean：表示逻辑值，取值为true或false。

示例代码：

public class DataTypes {
    public static void main(String[] args) {
        byte b = 127;
        short s = 32767;
        int i = 2147483647;
        long l = 9223372036854775807L;
        float f = 3.1415f;
        double d = 2.71828;
        char c = 'A';
        boolean bool = true;

        System.out.println("byte: " + b);
        System.out.println("short: " + s);
        System.out.println("int: " + i);
        System.out.println("long: " + l);
        System.out.println("float: " + f);
        System.out.println("double: " + d);
        System.out.println("char: " + c);
        System.out.println("boolean: " + bool);
    }
}

变量声明

变量是用于存储数据的标识符。在Java中声明变量时需要指定变量的数据类型。示例代码：

public class VariableDeclaration {
    public static void main(String[] args) {
        // 声明整型变量
        int age = 25;
        // 声明浮点型变量
        double salary = 2500.50;
        // 声明布尔型变量
        boolean isEmployed = true;
        // 输出变量值
        System.out.println("年龄: " + age);
        System.out.println("工资: " + salary);
        System.out.println("是否在职: " + isEmployed);
    }
}

运算符与表达式

Java中的运算符包括算术运算符、关系运算符、逻辑运算符、位运算符、赋值运算符和条件运算符。理解这些运算符及其优先级是编写有效程序的关键。

基本运算符及其使用

• 算术运算符

  • +：加法
  • -：减法
  • *：乘法
  • /：除法
  • %：取模（求余）

• 关系运算符

  • <：小于
  • >：大于
  • <=：小于等于
  • >=：大于等于
  • ==：等于
  • !=：不等于

• 逻辑运算符

  • &&：逻辑与
  • ||：逻辑或
  • !：逻辑非

• 位运算符

  • &：按位与
  • |：按位或
  • ^：按位异或
  • ~：按位取反
  • <<：左移
  • >>：右移
  • >>>：无符号右移

• 赋值运算符

  • =：简单赋值
  • +=：加上并赋值
  • -=：减去并赋值
  • *=：乘以并赋值
  • /=：除以并赋值
  • %=：取模并赋值
• 条件运算符
  • ?:：三元运算符，格式为(expr1)?expr2:expr3。

示例代码：

public class Operators {
    public static void main(String[] args) {
        // 算术运算符
        int a = 10;
        int b = 5;
        int sum = a + b;
        int diff = a - b;
        int prod = a * b;
        int quot = a / b;
        int mod = a % b;

        System.out.println("a + b = " + sum);
        System.out.println("a - b = " + diff);
        System.out.println("a * b = " + prod);
        System.out.println("a / b = " + quot);
        System.out.println("a % b = " + mod);

        // 关系运算符
        boolean isGreater = a > b;
        boolean isEqual = a == b;
        boolean isNotEqual = a != b;

        System.out.println("a > b = " + isGreater);
        System.out.println("a == b = " + isEqual);
        System.out.println("a != b = " + isNotEqual);

        // 逻辑运算符
        boolean isTrue = true;
        boolean isFalse = false;

        System.out.println("true && false = " + (isTrue && isFalse));
        System.out.println("true || false = " + (isTrue || isFalse));
        System.out.println("!true = " + !isTrue);

        // 条件运算符
        int max = (a > b) ? a : b;
        System.out.println("max(a, b) = " + max);

        // 位运算符
        int x = 5; // 二进制表示为0101
        int y = 3; // 二进制表示为0011
        int and = x & y;
        int or = x | y;
        int xor = x ^ y;
        int not = ~x;

        System.out.println("x & y = " + and); // 0001
        System.out.println("x | y = " + or);   // 0111
        System.out.println("x ^ y = " + xor);  // 0110
        System.out.println("~x = " + not);     // 11111111111111111111111111111010
    }
}

通过以上内容，你可以了解Java的基础语法结构、数据类型、变量声明以及运算符的基本用法。这些基础知识是后续深入学习的基础，务必熟练掌握。

流程控制
流程控制是Java编程中的重要概念，它允许程序根据特定条件执行不同的操作或循环执行特定代码块。本节将详细介绍条件语句、循环语句以及分支结构的应用实例。

条件语句

条件语句用来根据特定条件执行不同的代码块。Java中最常用的条件语句有if、if-else和switch。

if语句

if语句根据条件判断是否执行某个代码块。格式如下：

if (condition) {
    // 执行代码
}

示例代码：

public class IfStatement {
    public static void main(String[] args) {
        int age = 20;

        if (age >= 18) {
            System.out.println("成年人");
        }
    }
}

if-else语句

if-else语句在条件为真时执行一个代码块，否则执行另一个代码块。格式如下：

if (condition) {
    // 执行代码1
} else {
    // 执行代码2
}

示例代码：

public class IfElseStatement {
    public static void main(String[] args) {
        int age = 16;

        if (age >= 18) {
            System.out.println("成年人");
        } else {
            System.out.println("未成年人");
        }
    }
}

if-else if-else语句

if-else if-else语句允许在多个条件之间进行选择。格式如下：

if (condition1) {
    // 执行代码1
} else if (condition2) {
    // 执行代码2
} else {
    // 执行代码3
}

示例代码：

public class IfElseIfElseStatement {
    public static void main(String[] args) {
        int score = 85;

        if (score >= 90) {
            System.out.println("优秀");
        } else if (score >= 70) {
            System.out.println("良好");
        } else {
            System.out.println("一般");
        }
    }
}

switch语句

switch语句根据变量的值执行不同的代码块。格式如下：

switch (expression) {
    case value1:
        // 执行代码1
        break;
    case value2:
        // 执行代码2
        break;
    default:
        // 默认执行代码
}

示例代码：

public class SwitchStatement {
    public static void main(String[] args) {
        int day = 2;

        switch (day) {
            case 1:
                System.out.println("星期一");
                break;
            case 2:
                System.out.println("星期二");
                break;
            case 3:
                System.out.println("星期三");
                break;
            default:
                System.out.println("未知");
        }
    }
}

循环语句

循环语句允许程序重复执行某些代码块。Java中最常用的循环语句有for、while和do-while。

for循环

for循环通常用于已知循环次数的情况。格式如下：

for (初始化; 条件; 更新) {
    // 执行代码
}

示例代码：

public class ForLoop {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            System.out.println("数字: " + i);
        }
    }
}

while循环

while循环在条件为真时执行代码块。格式如下：

while (condition) {
    // 执行代码
}

示例代码：

public class WhileLoop {
    public static void main(String[] args) {
        int i = 0;
        while (i < 5) {
            System.out.println("数字: " + i);
            i++;
        }
    }
}

do-while循环

do-while循环与while循环类似，但首先执行一次循环体，然后检查条件。格式如下：

do {
    // 执行代码
} while (condition);

示例代码：

public class DoWhileLoop {
    public static void main(String[] args) {
        int i = 0;
        do {
            System.out.println("数字: " + i);
            i++;
        } while (i < 5);
    }
}

分支结构的应用实例

以下是一个综合应用条件语句和循环语句的示例，计算并输出1到100之间所有偶数的和。

示例代码：

public class SumEvenNumbers {
    public static void main(String[] args) {
        int sum = 0;

        for (int i = 1; i <= 100; i++) {
            if (i % 2 == 0) {
                sum += i;
            }
        }

        System.out.println("1到100之间所有偶数的和: " + sum);
    }
}

通过以上内容，你已经掌握了Java中的条件语句、循环语句以及分支结构的应用实例。这些知识点是编写复杂程序的基础，务必熟练掌握。

数组与字符串
数组和字符串是Java编程中非常常用的数据结构，用于存放一组相关数据。本节将详细介绍数组的概念与使用、字符串的处理与操作，以及常用字符串处理方法。

数组的概念与使用

数组是一种用于存储一组相同类型数据的数据结构。Java中的数组分为一维数组和多维数组。

一维数组

一维数组是最基本的数组形式，用于存储一系列相同类型的元素。定义和初始化数组的基本语法如下：

// 定义数组
int[] numbers = new int[5];
// 初始化数组
numbers[0] = 1;
numbers[1] = 2;
numbers[2] = 3;
numbers[3] = 4;
numbers[4] = 5;

// 使用数组
for (int i = 0; i < numbers.length; i++) {
    System.out.println("数组元素 " + i + ": " + numbers[i]);
}

示例代码：

public class OneDimensionalArray {
    public static void main(String[] args) {
        int[] numbers = new int[5];

        // 初始化数组
        for (int i = 0; i < numbers.length; i++) {
            numbers[i] = i + 1;
        }

        // 使用数组
        for (int i = 0; i < numbers.length; i++) {
            System.out.println("数组元素 " + i + ": " + numbers[i]);
        }
    }
}

多维数组

多维数组是由多个一维数组构成的数组。最常见的是二维数组，其语法如下：

// 定义二维数组
int[][] matrix = new int[3][3];
// 初始化二维数组
for (int i = 0; i < matrix.length; i++) {
    for (int j = 0; j < matrix[i].length; j++) {
        matrix[i][j] = i * 3 + j + 1;
    }
}

示例代码：

public class TwoDimensionalArray {
    public static void main(String[] args) {
        int[][] matrix = new int[3][3];

        // 初始化二维数组
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[i].length; j++) {
                matrix[i][j] = i * 3 + j + 1;
            }
        }

        // 使用二维数组
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[i].length; j++) {
                System.out.print(matrix[i][j] + " ");
            }
            System.out.println();
        }
    }
}

字符串的处理与操作

字符串在Java中被定义为String类的对象。字符串是一系列字符的序列，Java提供了丰富的API来处理字符串，包括常用的方法和操作。

基本字符串操作

创建字符串的几种方式：

// 使用双引号创建字符串
String str1 = "Hello";
// 使用new关键字创建字符串
String str2 = new String("World");

// 获取字符串长度
int length = str1.length();

// 获取某个索引处的字符
char charAt = str1.charAt(1);

// 拼接字符串
String concat = str1 + " " + str2;

// 比较字符串
boolean equals = str1.equals(str2);

// 查找子串
int indexOf = str1.indexOf("e");

示例代码：

public class BasicStringOperations {
    public static void main(String[] args) {
        String str1 = "Hello";
        String str2 = new String("World");

        // 获取字符串长度
        int length = str1.length();
        System.out.println("字符串长度: " + length);

        // 获取某个索引处的字符
        char charAt = str1.charAt(1);
        System.out.println("索引处的字符: " + charAt);

        // 拼接字符串
        String concat = str1 + " " + str2;
        System.out.println("拼接后的字符串: " + concat);

        // 比较字符串
        boolean equals = str1.equals(str2);
        System.out.println("是否相等: " + equals);

        // 查找子串
        int indexOf = str1.indexOf("e");
        System.out.println("子串索引位置: " + indexOf);
    }
}

常用字符串处理方法

除了基本操作，Java还提供了许多字符串处理方法，包括分割字符串、替换字符、去掉空格、转换大小写等。

// 分割字符串
String[] split = str1.split(",");
// 替换字符串
String replace = str1.replace("l", "L");
// 去掉字符串前后的空格
String trim = str1.trim();
// 转换为大写
String upperCase = str1.toUpperCase();
// 转换为小写
String lowerCase = str1.toLowerCase();

示例代码：

public class StringMethods {
    public static void main(String[] args) {
        String str1 = "Hello, World!";

        // 分割字符串
        String[] split = str1.split(",");
        for (String s : split) {
            System.out.println(s);
        }

        // 替换字符串
        String replace = str1.replace("l", "L");
        System.out.println("替换后的字符串: " + replace);

        // 去掉字符串前后的空格
        String trim = str1.trim();
        System.out.println("去除前后空格后的字符串: " + trim);

        // 转换为大写
        String upperCase = str1.toUpperCase();
        System.out.println("转换为大写后的字符串: " + upperCase);

        // 转换为小写
        String lowerCase = str1.toLowerCase();
        System.out.println("转换为小写后的字符串: " + lowerCase);
    }
}

通过以上内容，你已经掌握了Java中数组和字符串的基本概念与使用方法。这些知识对于编写高效、可读性强的程序非常关键。

面向对象编程
面向对象编程（Object-Oriented Programming，OOP）是Java编程的核心。本节将详细介绍面向对象编程的基本概念，包括类与对象、封装、继承和多态，并通过实例分析面向对象编程的实现。

类与对象的概念

面向对象编程的核心在于类和对象。类是对象的模板，定义了对象的属性和行为。对象是类的实例，具有特定的属性值。

类的定义

类由属性（字段）和方法（函数）组成。属性表示对象的状态，方法表示对象的行为。类的定义格式如下：

class ClassName {
    // 属性
    private int attribute;

    // 方法
    public int getAttribute() {
        return attribute;
    }

    public void setAttribute(int attribute) {
        this.attribute = attribute;
    }
}

示例代码：

public class Person {
    // 属性
    private String name;
    private int age;

    // 构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 方法
    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

对象的创建

对象是通过类的实例化创建的。格式如下：

ClassName objectName = new ClassName();

示例代码：

public class Main {
    public static void main(String[] args) {
        Person person = new Person("张三", 25);
        System.out.println(person.getName());
        System.out.println(person.getAge());
    }
}

封装

封装是指将对象的状态信息（属性）和操作（方法）结合在一起，把类的内部实现细节隐藏起来，只提供公共访问的方法。封装的主要目的是提高代码的可维护性和安全性。

// 封装示例
public class Car {
    private String brand;
    private int year;

    public Car(String brand, int year) {
        this.brand = brand;
        this.year = year;
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public int getYear() {
        return year;
    }

    public void setYear(int year) {
        this.year = year;
    }

    @Override
    public String toString() {
        return "Car{" +
                "brand='" + brand + '\'' +
                ", year=" + year +
                '}';
    }
}

示例代码：

public class Main {
    public static void main(String[] args) {
        Car car = new Car("Toyota", 2021);
        System.out.println(car.getBrand());
        System.out.println(car.getYear());
    }
}

继承

继承是指一个类可以继承另一个类的属性和方法。被继承的类称为父类或基类，继承的类称为子类或派生类。继承可以提高代码的复用性。

// 父类
class Animal {
    private String name;
    private int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void eat() {
        System.out.println("动物正在吃东西");
    }

    @Override
    public String toString() {
        return "Animal{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

// 子类
class Dog extends Animal {
    public Dog(String name, int age) {
        super(name, age);
    }

    public void bark() {
        System.out.println("汪汪汪");
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + getName() + '\'' +
                ", age=" + getAge() +
                '}';
    }
}

示例代码：

public class Main {
    public static void main(String[] args) {
        Dog dog = new Dog("旺财", 3);
        System.out.println(dog.getName());
        System.out.println(dog.getAge());
        dog.eat();
        dog.bark();
    }
}

多态

多态是指同一个行为具有多个不同表现形式或形态的能力。多态主要通过方法的重写（Override）实现。当基类的引用指向派生类的对象时，调用方法时会调用派生类中的方法。

// 父类
class Animal {
    public void eat() {
        System.out.println("动物正在吃东西");
    }
}

// 子类
class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗狗正在吃骨头");
    }
}

// 子类
class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫咪正在吃鱼");
    }
}

示例代码：

public class Main {
    public static void main(String[] args) {
        Animal dog = new Dog();
        Animal cat = new Cat();

        dog.eat(); // 输出：狗狗正在吃骨头
        cat.eat(); // 输出：猫咪正在吃鱼
    }
}

实例分析面向对象编程的实现

通过一个简单的例子来综合应用类、对象、封装、继承和多态。假设我们需要创建一个简单的银行系统，包括账户和客户。

// 父类：Account
class Account {
    private String accountNumber;
    private double balance;

    public Account(String accountNumber, double balance) {
        this.accountNumber = accountNumber;
        this.balance = balance;
    }

    public String getAccountNumber() {
        return accountNumber;
    }

    public double getBalance() {
        return balance;
    }

    public void deposit(double amount) {
        balance += amount;
    }

    public void withdraw(double amount) {
        balance -= amount;
    }

    @Override
    public String toString() {
        return "Account{" +
                "accountNumber='" + accountNumber + '\'' +
                ", balance=" + balance +
                '}';
    }
}

// 子类：CheckingAccount
class CheckingAccount extends Account {
    private double overdraftLimit;

    public CheckingAccount(String accountNumber, double balance, double overdraftLimit) {
        super(accountNumber, balance);
        this.overdraftLimit = overdraftLimit;
    }

    public double getOverdraftLimit() {
        return overdraftLimit;
    }

    @Override
    public String toString() {
        return "CheckingAccount{" +
                "accountNumber='" + getAccountNumber() + '\'' +
                ", balance=" + getBalance() +
                ", overdraftLimit=" + overdraftLimit +
                '}';
    }
}

// 子类：SavingAccount
class SavingAccount extends Account {
    private double interestRate;

    public SavingAccount(String accountNumber, double balance, double interestRate) {
        super(accountNumber, balance);
        this.interestRate = interestRate;
    }

    public double getInterestRate() {
        return interestRate;
    }

    @Override
    public String toString() {
        return "SavingAccount{" +
                "accountNumber='" + getAccountNumber() + '\'' +
                ", balance=" + getBalance() +
                ", interestRate=" + interestRate +
                '}';
    }
}

// 客户类
class Customer {
    private String name;
    private Account account;

    public Customer(String name, Account account) {
        this.name = name;
        this.account = account;
    }

    public String getName() {
        return name;
    }

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

    public Account getAccount() {
        return account;
    }

    public void setAccount(Account account) {
        this.account = account;
    }

    @Override
    public String toString() {
        return "Customer{" +
                "name='" + name + '\'' +
                ", account=" + account +
                '}';
    }
}

示例代码：

public class Main {
    public static void main(String[] args) {
        CheckingAccount checkingAccount = new CheckingAccount("123456", 1000, 500);
        SavingAccount savingAccount = new SavingAccount("789012", 2000, 0.05);

        Customer customer1 = new Customer("张三", checkingAccount);
        Customer customer2 = new Customer("李四", savingAccount);

        System.out.println(customer1.getName());
        System.out.println(customer1.getAccount().getAccountNumber());
        System.out.println(customer1.getAccount().getBalance());
        System.out.println(customer2.getName());
        System.out.println(customer2.getAccount().getAccountNumber());
        System.out.println(customer2.getAccount().getBalance());
    }
}