Java编程入门教程-原创手记-慕课网

本文详细介绍了如何搭建Java编程环境，包括安装Java开发工具包（JDK）和配置环境变量的步骤。此外，文章还涵盖了Java的基础语法、控制结构、数组与字符串操作、方法与类的定义以及面向对象编程的基本概念。通过这些内容，读者可以快速入门Java编程并掌握基本技能。

Java编程环境搭建

安装Java开发工具包（JDK）

在开始学习Java编程前，你需要安装Java开发工具包（JDK）。JDK是Java开发的基础工具包，包含了编译Java程序和运行Java程序所需的工具。

访问Oracle官方网站，下载最新版本的JDK。下载完成后，根据操作系统不同，安装步骤略有不同。
在Windows系统上，双击下载的安装程序，按照提示完成安装。默认安装路径可以选择C:\Program Files\Java\jdk-版本号，也可以自定义安装路径。
在Mac OS上，下载完成后双击安装包，拖动JDK到Applications中即可完成安装。

配置环境变量

安装完成后，你需要配置环境变量以确保Java命令可以在命令行中正常使用。

Windows系统：
1. 打开“我的电脑”右键选择“属性”。
2. 点击“高级系统设置”。
3. 点击“环境变量”。
4. 在“系统变量”中，新建一个变量名为JAVA_HOME，变量值为JDK的安装路径（例如C:\Program Files\Java\jdk-版本号）。
5. 在“系统变量”中，找到Path变量，点击“编辑”，在变量值的最后添加;%JAVA_HOME%\bin，确保分号的存在。
Mac OS系统：
1. 打开终端。
2. 使用以下命令设置JAVA_HOME环境变量：
```
export JAVA_HOME=/Library/Java/JavaVirtualMachines/jdk-版本号.jdk/Contents/Home
```
3. 使用以下命令设置PATH环境变量：
```
export PATH=$JAVA_HOME/bin:$PATH
```

示例代码：

// 示例代码：Windows系统配置环境变量
import java.util.Properties;

public class EnvConfig {
    public static void main(String[] args) {
        Properties props = System.getProperties();
        props.setProperty("JAVA_HOME", "C:\\Program Files\\Java\\jdk-版本号");
        props.setProperty("Path", "%JAVA_HOME%\\bin;%Path%");
    }
}

// 示例代码：Mac OS系统配置环境变量
import java.util.Properties;

public class EnvConfig {
    public static void main(String[] args) {
        Properties props = System.getProperties();
        props.setProperty("JAVA_HOME", "/Library/Java/JavaVirtualMachines/jdk-版本号.jdk/Contents/Home");
        props.setProperty("Path", "$JAVA_HOME/bin:$Path");
    }
}

或者直接提供示例脚本或命令：

# Windows系统
setx JAVA_HOME "C:\Program Files\Java\jdk-版本号"
setx PATH "%JAVA_HOME%\bin;%PATH%"

# Mac OS系统
export JAVA_HOME=/Library/Java/JavaVirtualMachines/jdk-版本号.jdk/Contents/Home
export PATH=$JAVA_HOME/bin:$PATH

测试安装是否成功

为了确认JDK安装成功，你可以在命令行中输入以下命令来测试：

java -version

如果命令执行成功并且显示了Java的版本信息，则说明JDK安装成功。

Java基础语法

输出语句

Java使用System.out.println来输出信息到控制台。例如：

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

变量和数据类型

在Java中，变量用来存储数据。变量有数据类型，比如整型、浮点型、布尔型等。

整型：
- byte：8位，取值范围-128到127。
- short：16位，取值范围-32768到32767。
- int：32位，取值范围-2147483648到2147483647。
- long：64位，取值范围-9223372036854775808到9223372036854775807。
浮点型：
- float：32位，用于表示浮点数。
- double：64位，用于表示双精度浮点数。
布尔型：
- boolean：只有true和false两种值。

以下是一个示例：

public class DataTypes {
    public static void main(String[] args) {
        byte myByte = 100;
        short myShort = 1000;
        int myInt = 1000000;
        long myLong = 1000000000L;
        float myFloat = 0.25f;
        double myDouble = 0.125;
        boolean myBoolean = true;

        System.out.println(myByte);
        System.out.println(myShort);
        System.out.println(myInt);
        System.out.println(myLong);
        System.out.println(myFloat);
        System.out.println(myDouble);
        System.out.println(myBoolean);
    }
}

运算符

Java中的运算符类型包括算术运算符、关系运算符、逻辑运算符等。

算术运算符

+：加法，-：减法，*：乘法，/：除法，%：取余。

public class ArithmeticOperators {
    public static void main(String[] args) {
        int a = 10;
        int b = 5;

        System.out.println(a + b);  // 输出15
        System.out.println(a - b);  // 输出5
        System.out.println(a * b);  // 输出50
        System.out.println(a / b);  // 输出2
        System.out.println(a % b);  // 输出0
    }
}

关系运算符

==：等于，!=：不等于，>：大于，<：小于，>=：大于等于，<=：小于等于。

public class RelationOperators {
    public static void main(String[] args) {
        int a = 10;
        int b = 5;

        System.out.println(a == b);  // 输出false
        System.out.println(a != b);  // 输出true
        System.out.println(a > b);   // 输出true
        System.out.println(a < b);   // 输出false
        System.out.println(a >= b);  // 输出true
        System.out.println(a <= b);  // 输出false
    }
}

逻辑运算符

&&：逻辑与，||：逻辑或，!：逻辑非。

public class LogicalOperators {
    public static void main(String[] args) {
        boolean a = true;
        boolean b = false;

        System.out.println(a && b);  // 输出false
        System.out.println(a || b);  // 输出true
        System.out.println(!a);      // 输出false
    }
}

控制结构

条件语句

Java中的条件语句主要有if、if-else和if-else if-else。

if语句

public class IfStatement {
    public static void main(String[] args) {
        int a = 10;
        if (a > 0) {
            System.out.println("a is positive");  // 输出a is positive
        }
    }
}

if-else语句

public class IfElseStatement {
    public static void main(String[] args) {
        int a = 10;
        if (a > 0) {
            System.out.println("a is positive");  // 输出a is positive
        } else {
            System.out.println("a is not positive");
        }
    }
}

if-else if-else语句

public class IfElseIfElseStatement {
    public static void main(String[] args) {
        int a = 0;
        if (a > 0) {
            System.out.println("a is positive");
        } else if (a == 0) {
            System.out.println("a is zero");  // 输出a is zero
        } else {
            System.out.println("a is negative");
        }
    }
}

循环语句

Java中的循环语句主要有for、while和do-while。

for循环

public class ForLoop {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            System.out.println(i);  // 输出0, 1, 2, 3, 4
        }
    }
}

while循环

public class WhileLoop {
    public static void main(String[] args) {
        int i = 0;
        while (i < 5) {
            System.out.println(i);  // 输出0, 1, 2, 3, 4
            i++;
        }
    }
}

do-while循环

public class DoWhileLoop {
    public static void main(String[] args) {
        int i = 0;
        do {
            System.out.println(i);  // 输出0, 1, 2, 3, 4
            i++;
        } while (i < 5);
    }
}

数组与字符串

数组的定义和使用

数组是一组相同类型的元素的集合。Java中的数组可以是基本类型数组（如int[]）或对象数组（如String[]）。

定义和初始化数组

public class Arrays {
    public static void main(String[] args) {
        int[] numbers = new int[5];  // 定义一个长度为5的int数组
        numbers[0] = 1;
        numbers[1] = 2;
        numbers[2] = 3;
        numbers[3] = 4;
        numbers[4] = 5;

        for (int i = 0; i < 5; i++) {
            System.out.println(numbers[i]);  // 输出1, 2, 3, 4, 5
        }
    }
}

动态初始化数组

public class DynamicArray {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5};

        for (int i = 0; i < numbers.length; i++) {
            System.out.println(numbers[i]);  // 输出1, 2, 3, 4, 5
        }
    }
}

字符串操作

字符串在Java中是通过String类来表示的。字符串可以进行各种操作，如拼接、分割等。

字符串拼接

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

        String result = str1 + " " + str2;  // 拼接字符串
        System.out.println(result);  // 输出Hello World
    }
}

字符串分割

public class StringSplit {
    public static void main(String[] args) {
        String str = "Hello,World,Java";

        String[] splitResult = str.split(",");  // 使用逗号分割字符串

        for (String s : splitResult) {
            System.out.println(s);  // 输出Hello, World, Java
        }
    }
}

方法与类

定义方法

在Java中，方法是代码的逻辑单元，用于执行特定的任务。方法可以返回值，也可以不返回值。

没有返回值的方法

public class MethodExample {
    public static void printHello() {
        System.out.println("Hello, World!");
    }

    public static void main(String[] args) {
        printHello();  // 输出Hello, World!
    }
}

返回值的方法

public class MethodExample {
    public static int add(int a, int b) {
        return a + b;
    }

    public static void main(String[] args) {
        int result = add(10, 20);
        System.out.println(result);  // 输出30
    }
}

创建类和对象

在Java中，类是对象的模板，对象是类的实例。类中可以包含成员变量和方法。

定义类

public class MyClass {
    int myVariable;

    public void myMethod() {
        System.out.println("Hello from myMethod!");
    }
}

创建对象

public class Main {
    public static void main(String[] args) {
        MyClass obj = new MyClass();
        obj.myVariable = 10;
        obj.myMethod();  // 输出Hello from myMethod!
    }
}

类的成员变量与方法

类可以包含成员变量和方法。成员变量是类的状态，方法是类的行为。

成员变量

成员变量是类的属性，用于存储类的状态信息。

public class Person {
    String name;
    int age;

    public void introduce() {
        System.out.println("My name is " + name + ", age " + age);
    }
}

成员方法

成员方法是类的行为，用于执行特定的任务。

public class Person {
    String name;
    int age;

    public void introduce() {
        System.out.println("My name is " + name + ", age " + age);
    }

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

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

使用成员变量和方法

public class Main {
    public static void main(String[] args) {
        Person person = new Person();
        person.setName("John");
        person.setAge(30);
        person.introduce();  // 输出My name is John, age 30
    }
}

面向对象编程

封装

封装是将数据和操作数据的方法绑定在一起的一种机制，目的是保护数据，避免数据被外部随意修改。

封装示例

public class Person {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    public void introduce() {
        System.out.println("My name is " + name + ", age " + age);
    }
}

使用封装

public class Main {
    public static void main(String[] args) {
        Person person = new Person();
        person.setName("John");
        person.setAge(30);
        person.introduce();  // 输出My name is John, age 30
    }
}

继承

继承允许一个类继承另一个类的属性和方法。继承的核心机制是“is-a”关系，例如猫是动物的一种。

继承示例

public class Animal {
    public void eat() {
        System.out.println("Animal is eating");
    }
}

public class Cat extends Animal {
    public void meow() {
        System.out.println("Cat is meowing");
    }
}

使用继承

public class Main {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.eat();  // 输出Animal is eating
        cat.meow();  // 输出Cat is meowing
    }
}

多态

多态是指一个对象可以有多种形态。在Java中，多态主要通过方法重写（覆盖）和方法重载（过载）来实现。

方法重写（覆盖）

public class Animal {
    public void eat() {
        System.out.println("Animal is eating");
    }
}

public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("Cat is eating");
    }
}

使用方法重写

public class Main {
    public static void main(String[] args) {
        Animal animal = new Cat();
        animal.eat();  // 输出Cat is eating
    }
}

方法重载（过载）

public class MathUtil {
    public int add(int a, int b) {
        return a + b;
    }

    public double add(double a, double b) {
        return a + b;
    }
}

使用方法重载


public class Main {
    public static void main(String[] args) {
        MathUtil util = new MathUtil();
        int result1 = util.add(10, 20);  // 输出30
        double result2 = util.add(10.5, 20.5);  // 输出31.0
    }
}
``

以上就是Java编程入门教程的全部内容。通过本教程，你已经掌握了Java的基本语法、控制结构、数组与字符串操作、方法与类的定义以及面向对象编程的基本概念。希望这些知识能够帮助你开始你的Java编程之旅。如果你想要进一步学习和实践，可以访问[慕课网](https://www.imooc.com/)，那里提供了丰富的Java编程课程和项目。