首页手记 Java零基础教程：一步一步学Java编程

Java零基础教程：一步一步学Java编程

标签：

Java

概述

Java零基础教程介绍了Java编程的基础知识，包括安装配置环境、基本语法、控制流程语句、数组与字符串操作，以及面向对象编程等核心概念。文章还详细讲解了异常处理和文件操作，帮助初学者全面掌握Java编程技能。

Java简介与安装配置

什么是Java

Java是一种面向对象的编程语言，由Sun Microsystems（现已被Oracle收购）在1995年首次发布。Java的设计初衷是为了开发一次编写，多次编译的程序，使得程序可以在任何平台（如Windows、Linux、Mac OS等）上运行，而无需重新编译。Java语言因其简单、可靠、可移植性、可扩展性等特性，被广泛用于开发Web应用、桌面应用、移动应用等。

Java的特点和优势

Java有许多显著的特点和优势，包括但不限于：

跨平台性：Java程序可以在任何支持Java虚拟机（Java Virtual Machine，简称JVM）的平台上运行。这种特性使得Java程序具有很好的可移植性。
简单：Java语法相对简单，易于学习，与C/C++等语言相比，它去除了某些复杂的特性。
面向对象：Java语言的设计完全遵循面向对象的原则，包括封装、继承和多态。
安全：Java提供了多种安全机制，特别是对于网络应用，Java的沙盒（sandbox）安全模型可以防止恶意代码。
垃圾回收：Java有一个自动垃圾回收机制，可以自动释放不再使用的内存，避免了内存泄漏问题。
丰富的类库：Java自带大量的类库，使得开发人员可以方便地使用各种工具和组件。

Java开发环境搭建

要开始学习Java编程，首先需要搭建一个Java开发环境。这通常包括安装JDK（Java Development Kit）、编写并运行Java程序等步骤。

安装Java开发工具包（JDK）

JDK是Java开发工具包，包括Java编译器、Java运行环境、Java调试工具等。以下是安装JDK的步骤：

访问Oracle官方网站的JDK下载页面（https://www.oracle.com/java/technologies/javase-downloads.html），选择合适的JDK版本。
下载适合您操作系统的Java开发工具包（JDK）。
安装下载的JDK。根据安装向导的提示，选择合适的安装路径，并完成安装。

配置环境变量

为了使系统能够识别Java命令，需要配置环境变量，具体步骤如下：

设置JAVA_HOME：将JDK安装目录的路径设置为环境变量JAVA_HOME。
设置PATH：将JAVA_HOME下的bin目录路径添加到PATH环境变量中。

在Windows操作系统中，可以通过控制面板的环境变量设置来完成上述操作。以下是具体步骤：

打开“控制面板” > “系统和安全” > “系统” > “高级系统设置” > “环境变量”。
在“系统变量”区域，点击“新建”，输入变量名JAVA_HOME，变量值填写JDK的安装路径，例如C:\Program Files\Java\jdk1.8.0_261。
在“系统变量”区域，找到并选择变量Path，点击“编辑”，在“变量值”中添加%JAVA_HOME%\bin。
点击“确定”完成环境变量设置。

配置完成后，打开命令行窗口，输入java -version和javac -version命令检验是否配置成功。如果输出信息显示Java版本信息，说明环境配置成功。

Java基本语法入门

第一个Java程序HelloWorld

HelloWorld程序是Java编程中最基础的程序之一，它用于输出"Hello, World!"文本。以下是一个简单的HelloWorld程序：

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

Java基本语法结构

Java程序的基本结构包括包声明（可选）、导入语句（可选）、类定义和主函数（main方法）。主函数是程序的入口点，所有Java应用程序的执行都从main方法开始。主函数的语法如下：

public class ClassName {
    public static void main(String[] args) {
        // 程序代码
    }
}

注释的使用

Java语言支持三种类型的注释：单行注释、多行注释和文档注释。

单行注释：使用//开始，注释内容到行尾结束。
多行注释：使用/*开始，*/结束。
文档注释：使用/** ... */，常用于生成文档。

示例代码：

public class CommentTest {
    public static void main(String[] args) {
        // 这是一行单行注释
        int a = 10; // 另一个单行注释
        /*
         * 这是多行注释，可以跨越
         * 多行
         */
        System.out.println("Hello, World!");
        /**
         * 这是文档注释
         * 可用于生成文档
         */
    }
}

标识符命名规则

Java中的标识符包括类名、变量名、方法名等。标识符命名遵循如下规则：

标识符由字母、数字、下划线“_”、美元符号“$”组成，但不能以数字开头。
标识符不可以是Java的关键字或保留字。
标识符区分大小写，例如test和Test是两个不同的标识符。
建议使用有意义的标识符名称，如userAge、MaxNumber等。

常量与变量

常量和变量是程序中存储数据的两种基本形式。常量的值不能改变，而变量的值可以在程序执行过程中被修改。

常量

常量使用关键字final定义，一旦赋值就不能再改变。

final int MAX_VALUE = 100;

变量

变量用于存储数据，具有一个类型和一个名字。可以使用int、float、boolean等基本数据类型，也可以使用类或接口等引用类型。

int age = 18;
String name = "John Doe";
boolean isAdult = true;

数据类型

Java的数据类型分为基本类型（Primitive Types）和引用类型（Reference Types）。

基本类型

基本类型主要包括：

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

示例代码：

byte age = 100;
short height = 1000;
int score = 90;
long population = 1000000000L;
float price = 10.5f;
double weight = 75.5;
char grade = 'A';
boolean isPass = true;

引用类型

引用类型主要包括类、接口和数组。

示例代码：

String message = "Hello, World!";
ArrayList<Integer> list = new ArrayList<>();
Array<String> array = new Array<>();

基本运算符

Java提供了多种基本运算符，包括算术运算符、关系运算符、逻辑运算符、位运算符、赋值运算符等。

算术运算符

算术运算符包括加法+、减法-、乘法*、除法/、取模%等。

示例代码：

int a = 10, b = 5;
int sum = a + b;    // 15
int diff = a - b;   // 5
int prod = a * b;   // 50
int quot = a / b;   // 2
int rem = a % b;    // 0

关系运算符

关系运算符用于比较两个操作数，结果为true或false。主要包括==、!=、>、<、>=、<=。

示例代码：

int a = 10, b = 5;
boolean isEqual = a == b;  // false
boolean isNotEqual = a != b;  // true
boolean isGreater = a > b;    // true
boolean isLess = a < b;       // false
boolean isGreaterEqual = a >= b;  // true
boolean isLessEqual = a <= b;     // false

逻辑运算符

逻辑运算符&&、||和!用于组合或反转布尔值。

示例代码：

boolean a = true, b = false;
boolean andResult = a && b;    // false
boolean orResult = a || b;     // true
boolean notResult = !a;        // false

位运算符

位运算符包括位与&、位或|、位异或^、位非~、左移<<、右移>>和无符号右移>>>。

示例代码：

int a = 60; // 二进制形式：00111100
int b = 13; // 二进制形式：00001101

int andResult = a & b;    // 12，即00001100
int orResult = a | b;     // 61，即00111101
int xorResult = a ^ b;    // 49，即00110001
int notResult = ~a;       // -61，即11000011（补码形式）
int leftShift = a << 2;   // 240，即11110000
int rightShift = a >> 2;  // 15，即00001111
int unsignedRightShift = a >>> 2; // 15，即00001111

赋值运算符

赋值运算符包括基本的赋值=、复合赋值+=、-=、*=、/=、%=等。

示例代码：

int a = 10;
int b = 5;
a += b;    // a现在是15
a -= b;    // a现在是10
a *= b;    // a现在是50
a /= b;    // a现在是10
a %= b;    // a现在是0

Java控制流程语句

条件语句：if, if-else, switch

条件语句是根据条件的真假来决定程序的执行流程。Java中的条件语句主要包括if、if-else、if-else if-else和switch语句。

if语句

if语句用于判断一个条件，如果条件为真，则执行相应的代码块。

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

if-else语句

if-else语句用于判断一个条件，如果条件为真，则执行一个代码块，如果条件为假，则执行另一个代码块。

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

if-else if-else语句

if-else if-else语句用于判断多个条件，可以根据条件的顺序依次判断，直到找到一个为真的条件。

int score = 85;
if (score >= 90) {
    System.out.println("优秀");
} else if (score >= 80) {
    System.out.println("良好");
} else if (score >= 60) {
    System.out.println("及格");
} else {
    System.out.println("不及格");
}

switch语句

switch语句用于根据选择器表达式的值来选择要执行的代码块。switch语句通常用于等值比较。

int num = 2;
switch (num) {
    case 1:
        System.out.println("One");
        break;
    case 2:
        System.out.println("Two");
        break;
    case 3:
        System.out.println("Three");
        break;
    default:
        System.out.println("Other");
}

循环语句：for, while, do-while

循环语句用于重复执行一段代码，直到满足特定条件。Java中的循环语句主要有for、while和do-while循环。

for循环

for循环通常用于已知循环次数的情况。语法结构如下：

for (初始化; 循环条件; 更新) {
    // 循环体
}

示例代码：

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

while循环

while循环用于在循环条件为真时执行特定代码块。语法结构如下：

while (循环条件) {
    // 循环体
}

示例代码：

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

do-while循环

do-while循环是另一种循环结构，它先执行循环体，然后检查条件。这保证至少执行一次循环体。

do {
    // 循环体
} while (循环条件);

示例代码：

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

break与continue语句

break和continue语句用于改变循环的执行流程。

break语句

break语句用于立即退出循环，不再检查循环条件。

示例代码：

for (int i = 0; i < 10; i++) {
    if (i == 5) {
        break;  // 在i等于5时退出循环
    }
    System.out.println(i);
}

continue语句

continue语句用于跳过当前循环的剩余部分，直接进入下一次循环。

示例代码：

for (int i = 0; i < 10; i++) {
    if (i % 2 == 0) {
        continue;  // 遇到偶数时跳过输出
    }
    System.out.println(i);
}

代码块与作用域

代码块是一组代码，通常用大括号{}括起来。代码块可以定义局部变量，这些变量的作用范围限于代码块内部。

示例代码：

public class ScopeTest {
    public static void main(String[] args) {
        {
            int x = 10;
            System.out.println(x);  // 输出10
        }
        // System.out.println(x);  // 编译错误：x未被定义
    }
}

标签语句

标签语句可以为一个语句块指定一个标签，标签后面必须跟随一个冒号。标签语句通常用于嵌套循环中跳出外层循环。

示例代码：

outerLoop:
for (int i = 0; i < 3; i++) {
    innerLoop:
    for (int j = 0; j < 3; j++) {
        if (i == 1 && j == 1) {
            break outerLoop;  // 跳出外层循环
        }
        System.out.println("i = " + i + ", j = " + j);
    }
}

数组与字符串操作

数组的定义与使用

数组是一组相同类型的元素的集合。数组可以通过指定元素的数量和类型来定义，然后通过索引访问各个元素。

定义数组

int[] numbers = new int[5];  // 定义一个包含5个整数的数组
double[] scores = {90.5, 80.0, 75.5};  // 定义一个已初始化的数组

访问数组元素

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

修改数组元素

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

遍历数组

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

多维数组

int[][] matrix = new int[3][3];
matrix[0][0] = 1;
matrix[0][1] = 2;
matrix[0][2] = 3;
matrix[1][0] = 4;
matrix[1][1] = 5;
matrix[1][2] = 6;
matrix[2][0] = 7;
matrix[2][1] = 8;
matrix[2][2] = 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中最常用的对象之一，提供了大量的方法来操作字符串。

创建字符串

String str1 = "Hello, World!";
String str2 = new String("Hello, World!");

字符串连接

String str1 = "Hello, ";
String str2 = "World!";
String result = str1 + str2;
System.out.println(result);  // 输出Hello, World!

字符串长度

String str = "Hello, World!";
int length = str.length();
System.out.println(length);  // 输出13

字符串索引

String str = "Hello, World!";
char ch = str.charAt(5);
System.out.println(ch);  // 输出W

字符串查找与替换

String str = "Hello, World!";
int index = str.indexOf("World");
System.out.println(index);  // 输出7
str = str.replace("World", "Java");
System.out.println(str);  // 输出Hello, Java!

字符串分割

String str = "Hello,World,Java";
String[] parts = str.split(",");
for (String part : parts) {
    System.out.println(part);
}

字符串的其他操作

String str = "   Hello, World!   ";
str = str.trim();  // 去除空白字符
System.out.println(str);  // 输出Hello, World!

str = str.toLowerCase();
System.out.println(str);  // 输出hello, world!

String subStr = str.substring(7, 12);
System.out.println(subStr);  // 输出world

String str1 = "Hello";
String str2 = "hello";
System.out.println(str1.equals(str2));  // 输出false
System.out.println(str1.equalsIgnoreCase(str2));  // 输出true

String与StringBuffer的区别

字符串String和字符串缓冲区StringBuffer都是用于存储和操作字符串的类，但它们在实现上有很大区别。

String：字符串对象是不可变的，每次操作都会生成新的字符串对象，因此不适合频繁修改字符串的情况。
StringBuffer：字符串缓冲区对象是可变的，可以在不创建新对象的情况下修改字符串内容，因此更适合频繁修改字符串的情况。

示例代码：

String str1 = "Hello";
String str2 = str1.concat(" World");
System.out.println(str1);  // 输出Hello
System.out.println(str2);  // 输出Hello World

StringBuffer sb = new StringBuffer("Hello");
sb.append(" World");
System.out.println(sb);  // 输出Hello World

字符串的常用方法

字符串类String提供了许多常用的方法来操作字符串。以下是一些常用方法：

trim：去除字符串两端的空白字符。
toLowerCase 和 toUpperCase：将字符串转换为小写或大写。
substring：返回指定索引的子字符串。
equals 和 equalsIgnoreCase：比较两个字符串是否相等，后者忽略大小写。

示例代码：

String str = "   Hello, World!   ";
str = str.trim();  // 去除空白字符
System.out.println(str);  // 输出Hello, World!
str = str.toLowerCase();
System.out.println(str);  // 输出hello, world!

String subStr = str.substring(7, 12);
System.out.println(subStr);  // 输出world

String str1 = "Hello";
String str2 = "hello";
System.out.println(str1.equals(str2));  // 输出false
System.out.println(str1.equalsIgnoreCase(str2));  // 输出true

面向对象编程基础

类与对象

面向对象编程（Object-Oriented Programming，OOP）是通过类和对象的方式来描述现实世界中的事物。对象是类的实例，类是对具有相同属性和方法的对象的抽象描述。

定义类

public class Person {
    String name;
    int age;

    public void introduce() {
        System.out.println("Hello, my name is " + name + " and I am " + age + " years old.");
    }
}

创建对象

Person person = new Person();
person.name = "John Doe";
person.age = 30;
person.introduce();  // 输出Hello, my name is John Doe and I am 30 years old.

构造方法

构造方法用于创建对象并初始化对象的属性。构造方法的名字必须与类名相同，没有返回类型，可以有多个重载版本。

public class Person {
    String name;
    int age;

    // 默认构造方法
    public Person() {
        name = "Default";
        age = 18;
    }

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

    public void introduce() {
        System.out.println("Hello, my name is " + name + " and I am " + age + " years old.");
    }
}

成员变量与成员方法

成员变量是在类中定义的变量，用来存储对象的状态。成员方法是在类中定义的方法，用来描述对象的行为。

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) {
        this.age = age;
    }

    public void introduce() {
        System.out.println("Hello, my name is " + name + " and I am " + age + " years old.");
    }
}

封装、继承与多态

封装、继承和多态是面向对象编程的三大特性。

封装

封装是将数据和操作数据的方法捆绑在一起，对外界隐藏内部实现细节，防止外部代码直接访问数据，从而实现数据的保护。

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) {
        this.age = age;
    }

    public void introduce() {
        System.out.println("Hello, my name is " + name + " and I am " + age + " years old.");
    }
}

继承

继承是面向对象编程的核心特性之一，允许一个类继承另一个类的属性和方法。子类可以重写父类的方法，以便提供特定于子类的实现。

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.");
    }

    @Override
    public void eat() {
        System.out.println("Dog is eating.");
    }
}

多态

多态允许子类可以替换掉父类的方法，从而在运行时根据实际对象类型调用适当的方法。

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.");
    }

    @Override
    public void eat() {
        System.out.println("Dog is eating.");
    }
}

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

        Animal dog = new Dog();
        dog.eat();  // 输出Dog is eating.
        dog.bark();  // 输出Dog is barking.
    }
}

抽象类与接口

抽象类和接口都是用来实现抽象的概念，抽象类可以包含抽象方法和具体方法，而接口中只能包含抽象方法。

抽象类

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

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

接口

public interface Movable {
    void move();
}

public class Car implements Movable {
    @Override
    public void move() {
        System.out.println("Car is moving.");
    }
}

包的使用

包是Java中组织类的机制，用于避免类名冲突。包的名称通常采用反向域名的形式，以确保唯一性。

定义包

package com.example;

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

使用包

import com.example.Test;

public class Main {
    public static void main(String[] args) {
        Test.main(args);
    }
}

异常处理与文件操作

什么是异常

异常是指程序在运行过程中发生的非正常情况，例如非法输入、资源不可用等。异常分为可检查异常（checked exceptions）和不可检查异常（unchecked exceptions）。

异常处理机制（try, catch, finally）

Java使用try-catch-finally语句来处理异常。try块用于包含可能抛出异常的代码，catch块用于捕获并处理异常，finally块用于包含需要在任何情况下都执行的清理代码。

public class ExceptionTest {
    public static void main(String[] args) {
        try {
            int a = 10;
            int b = 0;
            int result = a / b;
            System.out.println(result);
        } catch (ArithmeticException e) {
            System.out.println("除数不能为0");
        } finally {
            System.out.println("finally块执行");
        }
    }
}

常见异常类型

Java中有许多预定义的异常类型，包括ArithmeticException、NullPointerException、IOException等。

文件输入输出操作

Java提供了丰富的类库用于操作文件，包括FileInputStream、FileOutputStream、BufferedReader、BufferedWriter等。

使用BufferedReader和BufferedWriter

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class FileIOExample {
    public static void main(String[] args) {
        String filePath = "test.txt";
        try (BufferedReader reader = new BufferedReader(new FileReader(filePath));
             BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"))) {
            String line = null;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
                writer.write(line);
                writer.newLine();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

文件的读写操作示例

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

public class FileReadWriteExample {
    public static void main(String[] args) {
        String filePath = "test.txt";
        try {
            File file = new File(filePath);
            FileWriter writer = new FileWriter(file);
            writer.write("Hello, World!");
            writer.close();

            // 读取文件
            File file2 = new File(filePath);
            String content = new String(java.nio.file.Files.readAllBytes(file2.toPath()));
            System.out.println(content);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

点击查看更多内容

为 TA 点赞

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

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

ITMISS

手记
篇

粉丝

51

获赞与收藏

244

关注作者，订阅最新文章

相关文章推荐

【Java学习路线升级版】，新手该如何一步步的学习 Java

三步教你掌握Java编程思想[图]

Java零基础入门实力担当课程，限时一元！

零基础小白java学习之路

零基础入门转行学习java，如何才能成为Java软件工程师！

阅读免费教程

Java并发工具

23个小节 19133 310

Java 并发原理入门教程

26个小节 38736 565

Java 入门教程

50个小节 339379 3141

推荐

评论

收藏

共同学习，写下你的评论



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

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

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

支付方式

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

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

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

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

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

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

作者：

免费赠送

兑换码：1111222211 复制

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

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

热搜

最近搜索清空

Java零基础教程：一步一步学Java编程

什么是Java

Java的特点和优势

Java开发环境搭建

安装Java开发工具包（JDK）

配置环境变量

第一个Java程序HelloWorld

Java基本语法结构

注释的使用

标识符命名规则

常量与变量

常量

变量

数据类型

基本类型

引用类型

基本运算符

算术运算符

关系运算符

逻辑运算符

位运算符

赋值运算符

条件语句：if, if-else, switch

if语句

if-else语句

if-else if-else语句

switch语句

循环语句：for, while, do-while

for循环

while循环

do-while循环

break与continue语句

break语句

continue语句

代码块与作用域

标签语句

数组的定义与使用

定义数组

访问数组元素

修改数组元素

遍历数组

多维数组

字符串的基本操作

创建字符串

字符串连接

字符串长度

字符串索引

字符串查找与替换

字符串分割

字符串的其他操作

String与StringBuffer的区别

字符串的常用方法

类与对象

定义类

创建对象

构造方法

成员变量与成员方法

封装、继承与多态

封装

继承

多态

抽象类与接口

抽象类

接口

包的使用

定义包

使用包

什么是异常

异常处理机制（try, catch, finally）

常见异常类型

文件输入输出操作

使用BufferedReader和BufferedWriter

文件的读写操作示例

相关文章推荐

阅读免费教程