首页手记 Java开发入门：初学者必备指南

Java开发入门：初学者必备指南

标签：

Java

概述

本文详细介绍了Java开发入门所需的基础知识，包括开发环境搭建、基础语法、面向对象编程、常用数据结构与算法以及异常处理和文件操作。通过本文，读者可以掌握从安装JDK、配置环境变量到使用集成开发环境（IDE）的全过程。此外，还涵盖了Java中的基本数据类型、控制流程语句、类和对象的概念、继承和多态等核心概念。

Java开发环境搭建

安装Java开发工具包（JDK）

Java开发工具包（Java Development Kit，简称JDK）包含了Java开发所需的编译器、API文档、Java虚拟机（JVM）以及调试工具等。首先，你需要前往Oracle官网下载JDK，或者通过其他官方授权的下载渠道获取最新版本的JDK。下载完成后，按照安装向导的提示进行安装。安装过程中可以选择自定义安装路径或使用默认安装路径。

配置环境变量

安装完成后，为了能够在任意路径下运行Java命令，需要配置系统环境变量。以下是配置环境变量的具体步骤：

Windows系统

打开“此电脑”，点击右键，选择“属性”。
点击“高级系统设置”。
在“系统属性”窗口中，点击“环境变量”按钮。
在“系统变量”区域，找到并选择“Path”，点击“编辑”。
在“编辑环境变量”窗口中，点击“新建”，添加JDK的bin目录路径，例如：C:\Program Files\Java\jdk-11.0.1\bin。
确认所有设置后，点击“确定”以保存更改。
验证配置是否成功，打开命令提示符，输入java -version命令，如果显示Java版本信息，则说明环境变量配置成功。

macOS和Linux系统

打开终端。
编辑.bash_profile或.zshrc文件。使用文本编辑器，例如vi或nano，编辑主目录下的.bash_profile或.zshrc文件。

在文件末尾添加以下内容：

export JAVA_HOME=/usr/lib/jvm/java-11-openjdk
export PATH=$JAVA_HOME/bin:$PATH

保存并关闭文件后，运行source .bash_profile或source .zshrc命令使环境变量生效。
验证配置是否成功，输入java -version命令，如果显示Java版本信息，则说明环境变量配置成功。

使用集成开发环境（IDE）

集成开发环境（Integrated Development Environment，简称IDE）是开发Java程序常用的工具，常见的IDE包括Eclipse、IntelliJ IDEA、NetBeans等。这里以Eclipse为例进行介绍。

安装Eclipse
- 访问Eclipse官网下载页面，选择适合的操作系统版本进行下载。
- 安装完成后，运行Eclipse应用程序，会自动配置开发环境。
创建Java项目
- 打开Eclipse，点击“File”菜单，选择“New” -> “Java Project”，在弹出的对话框中输入项目名称，例如HelloWorld。
- 点击“Finish”按钮完成项目创建。
编写并运行第一个程序
- 在项目中创建一个新的类，点击“File”菜单，选择“New” -> “Class”，输入类名，例如HelloWorld。
- 在新创建的类中，输入以下代码：
```
public class HelloWorld {
 public static void main(String[] args) {
     System.out.println("Hello, World!");
 }
}
```
- 右键点击HelloWorld类，选择“Run As” -> “Java Application”。
- 程序执行后，控制台会显示“Hello, World!”输出信息。

通过这样的步骤，你已经成功搭建了Java开发环境，并使用Eclipse开发了第一个Java程序。

Java基础语法

创建第一个Java程序

Java程序的基本单位是类（Class），每个Java程序都至少包含一个主类（Main Class），主类中包含一个main方法。main方法是由Java虚拟机（JVM）调用的入口点。创建一个简单的Java程序，使用下面的代码：

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

数据类型及变量

Java是一种强类型语言，所有变量必须在声明时指定数据类型。Java的数据类型分为两种：基本数据类型和引用数据类型。基本数据类型包括整型、浮点型、字符型和布尔型。引用数据类型包括类、接口、数组等。

以下是基本数据类型的示例：

int num = 10;                // int 整型
float pi = 3.14f;            // float 浮点型
double largeNum = 3.14159;   // double 浮点型
char letter = 'A';           // char 字符型
boolean flag = true;         // boolean 布尔型

变量名应该遵循一定的命名规范：变量名以字母、下划线或美元符号开头，后续可以是字母、数字、下划线或美元符号的任意组合。变量名区分大小写。

控制流程语句

Java中的控制流程语句包括条件语句（如if和switch）和循环语句（如for和while）。这些语句允许程序根据某些条件执行不同的代码块，或者在满足特定条件时重复执行代码块。

条件语句

if语句

int age = 18;
if (age >= 18) {
   System.out.println("You are an adult.");
}

if-else语句

int age = 17;
if (age >= 18) {
   System.out.println("You are an adult.");
} else {
   System.out.println("You are not an adult.");
}

if-else if-else语句

int grade = 85;
if (grade >= 90) {
   System.out.println("Grade: A");
} else if (grade >= 80) {
   System.out.println("Grade: B");
} else if (grade >= 70) {
   System.out.println("Grade: C");
} else {
   System.out.println("Grade: F");
}

循环语句

for循环

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

while循环

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

do-while循环

int i = 0;
do {
   System.out.println("Iteration " + i);
   i++;
} while (i < 5);

通过这些基本的语法和控制流程语句，你可以操控程序的执行流程，使其更加灵活和高效。

对象与类

类的定义

类（Class）是面向对象编程的基本构造，它定义了一组相关的属性（字段）和行为（方法）。属性描述了对象的状态，方法描述了对象的行为。类的定义通常包括以下几个部分：

类声明：使用class关键字声明一个类。
成员变量（属性）：定义类的内部变量。
构造函数：初始化对象时调用的特殊方法。
方法：描述对象的行为。

下面是一个简单的类定义示例：

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 int getYear() {
        return year;
    }

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

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

    public void displayInfo() {
        System.out.println("Car brand: " + brand + ", Year: " + year);
    }
}

对象的创建与使用

对象是类的实例化。使用new关键字可以创建一个新的对象。以下是如何创建和使用上述Car类的实例：

public class CarDemo {
    public static void main(String[] args) {
        // 创建一个Car对象
        Car myCar = new Car("Toyota", 2020);

        // 调用对象的方法
        myCar.displayInfo();

        // 修改对象的属性
        myCar.setBrand("Honda");
        myCar.setYear(2021);

        // 再次调用对象的方法
        myCar.displayInfo();
    }
}

运行上述代码，你会看到以下输出：

Car brand: Toyota, Year: 2020
Car brand: Honda, Year: 2021

方法与构造函数

方法

方法是类中定义的函数。方法可以接收参数并返回结果。方法用于封装特定的行为，使得代码更易于维护和重用。

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

    public int subtract(int a, int b) {
        return a - b;
    }
}

public class CalculatorDemo {
    public static void main(String[] args) {
        Calculator calc = new Calculator();
        System.out.println(calc.add(10, 5));  // 输出 15
        System.out.println(calc.subtract(10, 5));  // 输出 5
    }
}

构造函数

构造函数用于初始化对象的状态。构造函数的名称与类名相同，并且没有返回值类型（包括void）。构造函数可以有默认参数或自定义参数。

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

    // 默认构造函数
    public Student() {
        name = "Unknown";
        age = 0;
    }

    // 带参数的构造函数
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

public class StudentDemo {
    public static void main(String[] args) {
        Student student1 = new Student();
        System.out.println(student1.getName());  // 输出 Unknown
        System.out.println(student1.getAge());  // 输出 0

        Student student2 = new Student("Alice", 20);
        System.out.println(student2.getName());  // 输出 Alice
        System.out.println(student2.getAge());  // 输出 20
    }
}

通过构造函数，你可以确保对象在创建时具有正确的初始状态。构造函数在对象创建时自动调用，而不需要显式调用。

面向对象编程

面向对象编程（Object-Oriented Programming，简称OOP）是一种编程范式，它强调对象的使用。在OOP中，对象是类的实例，并可以包含数据（属性）和行为（方法）。OOP的三大特性是封装、继承和多态。

封装

封装是将数据和操作数据的方法组合在一起，并通过访问控制符限制对外界的数据访问。封装有助于隐藏对象的内部状态，使类的使用者只能通过公共接口与对象交互，从而提高系统的安全性和灵活性。

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

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

    // 获取name
    public String getName() {
        return name;
    }

    // 获取age
    public int getAge() {
        return age;
    }

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

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

public class PersonDemo {
    public static void main(String[] args) {
        Person person = new Person("Alice", 20);
        System.out.println(person.getName());  // 输出 Alice
        System.out.println(person.getAge());  // 输出 20

        person.setAge(25);
        System.out.println(person.getAge());  // 输出 25
    }
}

在上述代码中，Person类封装了name和age属性，外部代码只能通过公共方法访问这些属性。这有助于保护对象内部的状态，防止外部代码直接修改属性，从而保证了程序的稳定性和安全。

继承

继承是面向对象编程的基本特性之一，用于表示“is-a”关系。子类可以继承父类的所有属性和方法，从而可以重用和扩展父类的功能。

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 class AnimalDemo {
    public static void main(String[] args) {
        Dog myDog = new Dog();
        myDog.eat();  // 输出 Animal is eating.
        myDog.bark();  // 输出 Dog is barking.
    }
}

在上述代码中，Dog类继承了Animal类。Dog类可以调用Animal类中的eat方法，也可以定义自己的bark方法。通过继承，代码可以实现重用和扩展，从而提高开发效率和代码的可维护性。

多态

多态是指在运行时可以根据对象实际类型来调用相应的方法。多态使得相同的接口可以有多种实现方式，增强了代码的灵活性和扩展性。

public class Shape {
    public void draw() {
        System.out.println("Shape is being drawn.");
    }
}

public class Circle extends Shape {
    @Override
    public void draw() {
        System.out.println("Circle is being drawn.");
    }
}

public class Triangle extends Shape {
    @Override
    public void draw() {
        System.out.println("Triangle is being drawn.");
    }
}

public class ShapeDemo {
    public static void main(String[] args) {
        Shape shape1 = new Circle();
        Shape shape2 = new Triangle();

        shape1.draw();  // 输出 Circle is being drawn.
        shape2.draw();  // 输出 Triangle is being drawn.
    }
}

在上述代码中，Circle和Triangle类继承了Shape类，都重写了draw方法。在ShapeDemo类中，我们定义了两个Shape类型的变量，分别引用了Circle和Triangle的实例。通过调用draw方法，可以看到多态的效果。

通过继承和多态，Java程序可以实现更灵活和高效的设计。

常用数据结构与算法

数组与列表

数组是一种基本的数据结构，用于存储一组相同类型的元素。Java中提供了多种数组类型，包括一维数组、多维数组和泛型数组。数组的长度在声明时固定，不能改变。

public class ArrayDemo {
    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]);
        }

        // 二维数组
        int[][] matrix = {
                {1, 2, 3},
                {4, 5, 6},
                {7, 8, 9}
        };
        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还提供了ArrayList等数据结构，这些数据结构在使用上更加灵活。ArrayList是一个动态数组，允许添加和删除元素。

import java.util.ArrayList;
import java.util.List;

public class ArrayListDemo {
    public static void main(String[] args) {
        // 创建ArrayList
        List<String> fruits = new ArrayList<>();
        fruits.add("Apple");
        fruits.add("Banana");
        fruits.add("Cherry");

        // 遍历ArrayList
        for (String fruit : fruits) {
            System.out.println(fruit);
        }

        // 删除元素
        fruits.remove("Banana");
        System.out.println(fruits);  // 输出 [Apple, Cherry]
    }
}

常用算法（排序、查找）

排序算法

排序是计算机科学中的基本算法之一，用于将一组数据按照特定顺序排列。常用的排序算法包括冒泡排序、插入排序、选择排序、归并排序、快速排序等。

冒泡排序是一种简单的排序算法，通过重复遍历待排序的序列，比较相邻元素的大小并进行交换。

public class BubbleSort {
    public static void sort(int[] arr) {
        int n = arr.length;
        for (int i = 0; i < n - 1; i++) {
            for (int j = 0; j < n - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        int[] numbers = {64, 34, 25, 12, 22, 11, 90};
        sort(numbers);
        for (int num : numbers) {
            System.out.print(num + " ");
        }
    }
}

查找算法

查找算法用于在一组数据中查找特定元素的位置。常见的查找算法包括顺序查找和二分查找。

顺序查找是最简单的查找算法，从头到尾遍历数组，逐个比较元素。

public class SequentialSearch {
    public static int search(int[] arr, int target) {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == target) {
                return i;
            }
        }
        return -1;
    }

    public static void main(String[] args) {
        int[] numbers = {12, 22, 34, 25, 64, 11, 90};
        int index = search(numbers, 25);
        System.out.println(index == -1 ? "Element not found" : "Element found at index " + index);
    }
}

二分查找要求数组必须是已排序的。通过不断缩小查找范围，以对数时间复杂度完成查找。

public class BinarySearch {
    public static int search(int[] arr, int target) {
        int left = 0;
        int right = arr.length - 1;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (arr[mid] == target) {
                return mid;
            } else if (arr[mid] < target) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        return -1;
    }

    public static void main(String[] args) {
        int[] numbers = {12, 22, 25, 34, 64, 90};
        int index = search(numbers, 25);
        System.out.println(index == -1 ? "Element not found" : "Element found at index " + index);
    }
}

这些基本的数据结构和算法是编程中常用的基础工具，掌握它们有助于提高编程的能力和效率。

异常处理与文件操作

异常处理机制

异常处理是编程中处理错误和异常情况的重要机制。Java使用try-catch语句来捕获并处理异常。try块中包含可能抛出异常的代码，catch块用于处理捕获到的异常。

public class ExceptionHandlingDemo {
    public static void main(String[] args) {
        try {
            int result = 10 / 0;
            System.out.println("This will not be printed.");
        } catch (ArithmeticException e) {
            System.out.println("Caught an ArithmeticException: " + e.getMessage());
        }

        try {
            String str = null;
            System.out.println(str.length());
        } catch (NullPointerException e) {
            System.out.println("Caught a NullPointerException: " + e.getMessage());
        }
    }
}

在上述代码中，try块中包含可能抛出异常的代码。如果try块中的代码抛出了异常，程序会跳转到相应的catch块，执行异常处理逻辑。这样可以确保程序在出现错误时不会崩溃，而可以优雅地处理异常情况。

文件读写操作

Java提供了FileInputStream和FileOutputStream等类来进行文件的读写操作。这些类提供了基本的文件读写功能，包括读取文件内容、写入文件内容等。

读取文件内容

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

public class FileReadDemo {
    public static void main(String[] args) {
        File file = new File("example.txt");
        try (FileInputStream fis = new FileInputStream(file)) {
            int content;
            while ((content = fis.read()) != -1) {
                System.out.print((char) content);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在上述代码中，FileInputStream用于读取文件内容。通过read方法逐个字节读取文件内容，并输出到控制台。

写入文件内容

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileWriteDemo {
    public static void main(String[] args) {
        File file = new File("example.txt");
        try (FileOutputStream fos = new FileOutputStream(file)) {
            String content = "Hello, World!";
            byte[] contentBytes = content.getBytes();
            fos.write(contentBytes);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在上述代码中，FileOutputStream用于写入文件内容。通过write方法将字符串转换为字节并写入文件。

文件操作是编程中常见的任务之一，通过上述示例代码，你可以了解如何在Java中进行基本的文件读写操作。

点击查看更多内容

为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

FFIVE

手记
篇

粉丝

70

获赞与收藏

459

关注作者，订阅最新文章

阅读免费教程

Java并发工具

23个小节 19285 315

Java 并发原理入门教程

26个小节 39045 568

Java 入门教程

50个小节 342126 3165

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空