首页手记 JAVA编程入门教程：从零开始学习

JAVA编程入门教程：从零开始学习

标签：

Java

概述

Java是一种广泛使用的计算机编程语言，具有跨平台运行的特点，应用领域涵盖桌面应用、Web应用、移动应用（如Android）和企业级应用。本文详细介绍了如何安装和配置Java环境，以及编写和运行第一个Java程序的方法。此外，文章还涵盖了Java的基本语法、面向对象编程和集合框架等内容。

JAVA简介与环境搭建

什么是Java

Java是由James Gosling等人在Sun Microsystems（现为Oracle Corporation）公司开发的一种广泛使用的计算机编程语言。Java是一种面向对象的语言，具有跨平台（Write Once, Run Anywhere）的特点，这意味着编写好的Java程序可以在不同的操作系统（如Windows、Linux、macOS）上运行，无需重新编译。Java不仅具有丰富的类库和工具，还有强大的社区支持，这使得学习和开发Java变得相对容易。

Java应用广泛，包括桌面应用、Web应用、移动应用和企业级应用等。Java的历史可以追溯到1990年代，它的发展历程和诸多特性使其在众多编程语言中独树一帜。Java分为多个版本，目前的最新长期支持版本为Java 17（LTS），以及最新的非长期支持版本Java 19。版本差别主要体现在新特性的添加和优化，但旧版本的Java代码可以在新的版本中继续运行。

安装JDK

Java Development Kit (JDK) 是Java开发的必要工具，它包括了Java运行环境（Java Runtime Environment, JRE）和开发工具（Java Development Kit, JDK）。
以下是安装JDK的步骤：

访问Oracle官网下载页面（https://www.oracle.com/java/technologies/javase-jdk17-downloads.html）下载对应的JDK安装包。
根据操作系统选择相应的安装包，例如Windows系统下载Windows x86或Windows x64版本。
双击下载好的安装包，按照向导提示进行安装，安装过程中可以选择安装路径，默认安装路径为C:\Program Files\Java\jdk-17。
安装完成后，通常会有一个额外的安装选项，可以安装JavaFX，这取决于你的需求，选择是否安装。
安装完成后，可以检查安装是否成功。打开命令行工具，输入java -version，如果显示版本信息，则安装成功。

配置环境变量

为了在命令行界面或任何其他程序中使用Java，需要配置环境变量。不同操作系统中配置环境变量的方式有所不同，以下是Windows系统的具体步骤：

打开系统属性中的“环境变量”设置项。
在“系统变量”区域，找到并选择变量名为Path的环境变量，点击编辑。
在编辑环境变量对话框中，点击“新建”，输入JDK安装目录下的bin文件夹路径，例如C:\Program Files\Java\jdk-17\bin，点击确定。
关闭环境变量设置窗口。

编写第一个Java程序

编写第一个Java程序需要遵循以下步骤：

使用任何文本编辑器（如Notepad++或Visual Studio Code）创建一个新的文件，命名为HelloWorld.java。
在文件中编写以下代码：

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

保存文件，确保文件扩展名为.java。
打开命令行窗口，导航到保存HelloWorld.java文件的目录。
编译Java程序，输入命令javac HelloWorld.java。如果编译成功，将会生成一个.class文件。
运行程序，输入命令java HelloWorld。输出结果为Hello, World!。

Java基础语法

关键字与标识符

关键字

Java语言中的关键字是预定义的词汇，具有特定用途，不能用作标识符。以下是Java中的关键字列表：

abstract assert boolean break byte case catch char class const continue default do double else enum extends final finally float for if implements import instanceof int interface long native new package private protected public return short static strictfp super switch synchronized this throw throws transient try void volatile while

标识符

标识符是在程序中命名各种元素的名称，如变量名、方法名、类名等。标识符命名规则如下：

标识符由字母、数字、下划线（_）或美元符号（$）组成，但不得以数字开头。
标识符不能是Java中的关键字。
标识符区分大小写，例如myVariable和MyVariable被认为是两个不同的标识符。
标识符不能以数字开头，例如1myVariable是非法的。
推荐使用camelCase或snake_case命名方式，以提高代码的可读性。例如myVariable或my_variable。

以下是一个使用camelCase命名方式的例子：

public class MyClass {
    public static void main(String[] args) {
        int myVariable = 10;
        System.out.println(myVariable);
    }
}

数据类型与变量

Java中的数据类型可以分为两类：基本数据类型和引用数据类型。基本数据类型包括整型、浮点型、字符型和布尔型，而引用数据类型则包括类、接口及数组类型。

基本数据类型

整型
- byte: 8位，范围从-128到127
- short: 16位，范围从-32,768到32,767
- int: 32位，范围从-2^31到2^31-1
- long: 64位，范围从-2^63到2^63-1
浮点型
- float: 单精度浮点数，32位
- double: 双精度浮点数，64位
字符型
- char: 16位Unicode字符，取值范围从'\u0000'到'\uffff'
布尔型
- boolean: 取值为true或false

以下是一个使用基本数据类型变量的例子：

public class DataTypesExample {
    public static void main(String[] args) {
        byte b = 127;
        short s = 32767;
        int i = 2147483647;
        long l = 9223372036854775807L;
        float f = 1.234f;
        double d = 1.234;
        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中，声明变量必须指定变量的数据类型，并可以初始化变量。以下是一些示例：

// 声明一个整型变量并初始化
int age = 18;

// 声明一个字符变量并初始化
char grade = 'A';

// 声明一个布尔变量并初始化
boolean flag = true;

// 声明一个浮点型变量并初始化
float price = 9.99f;

// 声明一个字符串变量并初始化
String name = "Tom";

运算符

Java支持多种运算符，包括算术运算符、关系运算符、逻辑运算符、位运算符、赋值运算符和三目运算符。

常见算术运算符

+ 加法
- 减法
* 乘法
/ 除法
% 取模（余数）

示例代码：

int a = 10;
int b = 3;

int add = a + b;
int subtract = a - b;
int multiply = a * b;
int divide = a / b;
int remainder = a % b;

System.out.println("Addition: " + add);
System.out.println("Subtraction: " + subtract);
System.out.println("Multiplication: " + multiply);
System.out.println("Division: " + divide);
System.out.println("Remainder: " + remainder);

关系运算符

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

示例代码：

int c = 5;
int d = 10;

boolean isEqual = c == d;
boolean isNotEqual = c != d;
boolean isGreaterThan = c > d;
boolean isLessThan = c < d;
boolean isGreaterThanOrEqual = c >= d;
boolean isLessThanOrEqual = c <= d;

System.out.println("Is Equal: " + isEqual);
System.out.println("Is Not Equal: " + isNotEqual);
System.out.println("Is Greater Than: " + isGreaterThan);
System.out.println("Is Less Than: " + isLessThan);
System.out.println("Is Greater Than or Equal: " + isGreaterThanOrEqual);
System.out.println("Is Less Than or Equal: " + isLessThanOrEqual);

逻辑运算符

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

示例代码：

boolean e = true;
boolean f = false;

boolean logicalAnd = e && f;
boolean logicalOr = e || f;
boolean logicalNot = !e;

System.out.println("Logical And: " + logicalAnd);
System.out.println("Logical Or: " + logicalOr);
System.out.println("Logical Not: " + logicalNot);

控制语句

Java中的控制语句分为条件语句和循环语句，用于控制程序的流程。

条件语句

if
else
if-else 语句
if-else if-else 语句
switch 语句

示例代码：

int num = 10;

if (num > 0) {
    System.out.println("Number is positive.");
} else if (num < 0) {
    System.out.println("Number is negative.");
} else {
    System.out.println("Number is zero.");
}

switch (num) {
    case 0:
        System.out.println("Number is zero.");
        break;
    case 1:
        System.out.println("Number is one.");
        break;
    default:
        System.out.println("Number is other.");
}

循环语句

for 循环
while 循环
do-while 循环

示例代码：

// for 循环
for (int i = 0; i < 5; i++) {
    System.out.println("Current loop index: " + i);
}

// while 循环
int j = 0;
while (j < 5) {
    System.out.println("Current loop index: " + j);
    j++;
}

// do-while 循环
int k = 0;
do {
    System.out.println("Current loop index: " + k);
    k++;
} while (k < 5);

类与对象

面向对象基础

面向对象编程（Object-Oriented Programming，OOP）的核心概念包括：

封装：将数据和操作数据的方法绑定在一起。
继承：子类继承父类的属性和方法。
多态：对象的多种形态，即通过子类可以实现不同的功能。

在Java中，通过类实现封装，类是对象的蓝图，描述了对象的属性和行为。对象是类的实例化，通过new关键字创建。

封装

封装是将数据（属性）和操作数据的方法封装到一个类中，并通过访问修饰符控制数据的访问权限。封装有助于隐藏内部实现细节，同时提供公共接口来操作数据。以下是一个封装的例子：

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

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

    // getter
    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    // setter
    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("John", 25);

        System.out.println(person.getName()); // 输出John
        System.out.println(person.getAge()); // 输出25

        person.setName("Jack");
        person.setAge(30);

        System.out.println(person.getName()); // 输出Jack
        System.out.println(person.getAge()); // 输出30
    }
}

继承

继承允许定义一个新的类（子类）来扩展现有类（父类）的功能，子类可以访问父类的属性和方法。子类可以重写父类的方法，以提供更具体的实现。以下是一个继承的例子：

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

public class Dog extends Animal {
    public void bark() {
        System.out.println("Dog barks");
    }

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

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

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

多态

多态允许在运行时使用子类对象来调用基类中的方法，但该方法在基类中被重写。这意味着，可以将子类对象赋值给基类变量，从而实现更灵活的代码设计。以下是一个多态的例子：

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

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

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

public class Main {
    public static void main(String[] args) {
        Mammal mammal = new Mammal();
        mammal.eat(); // 输出Mammal is eating

        mammal = new Dog();
        mammal.eat(); // 输出Dog is eating

        mammal = new Cat();
        mammal.eat(); // 输出Cat is eating
    }
}

类的定义与对象的创建

类的定义包含类名、属性和方法。以下是一个简单的类定义示例：

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

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

    // 方法
    public void introduce() {
        System.out.println("My name is " + name + " and I am " + age + " years old.");
    }
}

创建对象并调用方法：

public class Main {
    public static void main(String[] args) {
        // 创建对象
        Person person = new Person("John", 25);

        // 调用方法
        person.introduce();
    }
}

构造方法

构造方法是用于初始化对象的特殊方法，其名称与类名相同。构造方法没有返回类型，甚至不能返回void。当创建对象时，构造方法会被自动调用。

public class Car {
    String brand;
    int year;

    // 构造方法
    public Car(String brand, int year) {
        this.brand = brand;
        this.year = year;
    }
}

创建对象：

public static void main(String[] args) {
    Car car = new Car("Toyota", 2020);
}

方法重载与方法重写

方法重载

方法重载允许一个类拥多个同名方法，但每个方法的参数列表不同，从而实现不同的功能。以下是一个方法重载的例子：

public class Calculator {
    // 方法重载
    public int add(int a, int b) {
        return a + b;
    }

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

调用重载方法：

public static void main(String[] args) {
    Calculator calculator = new Calculator();
    System.out.println(calculator.add(1, 2)); // 输出3
    System.out.println(calculator.add(1.5, 2.5)); // 输出4.0
}

方法重写

方法重写允许子类覆盖继承自父类的方法，以提供新的实现。以下是一个方法重写的例子：

public class Animal {
    public void sound() {
        System.out.println("Animal makes sound");
    }
}

public class Dog extends Animal {
    @Override
    public void sound() {
        System.out.println("Dog barks");
    }
}

调用重写方法：

public static void main(String[] args) {
    Animal animal = new Animal();
    animal.sound(); // 输出Animal makes sound

    Dog dog = new Dog();
    dog.sound(); // 输出Dog barks
}

抽象类与接口

抽象类

抽象类是一种不能实例化的类，它只能被继承。抽象类可以包含抽象方法和非抽象方法。以下是一个抽象类的例子：

public abstract class Shape {
    public abstract void draw();
    public void rotate() {
        System.out.println("Shape is rotating");
    }
}

public class Circle extends Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a circle");
    }
}

public class Main {
    public static void main(String[] args) {
        Circle circle = new Circle();
        circle.draw(); // 输出Drawing a circle
        circle.rotate(); // 输出Shape is rotating
    }
}

接口

接口是一种引用类型，它定义了一组方法签名，但不提供方法实现。接口不仅可以包含方法，还可以包含常量。以下是一个接口的例子：

public interface Drawable {
    void draw();
}

public class Square implements Drawable {
    @Override
    public void draw() {
        System.out.println("Drawing a square");
    }
}

public class Main {
    public static void main(String[] args) {
        Square square = new Square();
        square.draw(); // 输出Drawing a square
    }
}

集合框架

常用集合类介绍

Java集合框架是一组接口和实现，用于存储和操作对象集合。常用的集合接口包括Collection（扩展为List和Set）和Map，每个接口都有多个实现类。

List接口

List是一种可重复元素的有序集合，允许元素重复。常见的实现类有ArrayList和LinkedList。

ArrayList: 基于数组实现，支持随机访问。
LinkedList: 基于链表实现，支持双向访问。

示例代码：

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

public class ListExample {
    public static void main(String[] args) {
        List<String> list1 = new ArrayList<>();
        List<String> list2 = new LinkedList<>();

        list1.add("Apple");
        list1.add("Banana");
        list1.add("Cherry");

        list2.add("Apple");
        list2.add("Banana");
        list2.add("Cherry");

        System.out.println("ArrayList: " + list1);
        System.out.println("LinkedList: " + list2);
    }
}

Set接口

Set是一个不重复元素的无序集合。常见的实现类有HashSet和TreeSet。

HashSet: 基于哈希表实现，不保证元素顺序。
TreeSet: 基于红黑树实现，自动排序元素。

示例代码：

import java.util.HashSet;
import java.util.Set;
import java.util.TreeSet;

public class SetExample {
    public static void main(String[] args) {
        Set<String> set1 = new HashSet<>();
        Set<String> set2 = new TreeSet<>();

        set1.add("Apple");
        set1.add("Banana");
        set1.add("Cherry");

        set2.add("Apple");
        set2.add("Banana");
        set2.add("Cherry");

        System.out.println("HashSet: " + set1);
        System.out.println("TreeSet: " + set2);
    }
}

Map接口

Map是一种键值对的集合，键是唯一的。常见的实现类有HashMap和TreeMap。

HashMap: 基于哈希表实现，不保证元素顺序。
TreeMap: 基于红黑树实现，自动排序键值对。

示例代码：

import java.util.HashMap;
import java.util.Map;
import java.util.TreeMap;

public class MapExample {
    public static void main(String[] args) {
        Map<String, Integer> map1 = new HashMap<>();
        Map<String, Integer> map2 = new TreeMap<>();

        map1.put("Apple", 10);
        map1.put("Banana", 20);
        map1.put("Cherry", 30);

        map2.put("Apple", 10);
        map2.put("Banana", 20);
        map2.put("Cherry", 30);

        System.out.println("HashMap: " + map1);
        System.out.println("TreeMap: " + map2);
    }
}

List、Set与Map的区别与使用

List：适用于需要有序、允许重复元素的场景。如存储学生的成绩列表。
Set：适用于需要无序、不重复元素的场景。如存储用户ID列表。
Map：适用于需要键值对形式存储数据的场景。如存储用户ID与用户名的映射。

ArrayList与LinkedList的对比

ArrayList：
- 基于数组实现，支持随机访问。
- 插入和删除操作较慢，因为需要移动元素。
- 查找操作较快，因为支持随机访问。
LinkedList：
- 基于链表实现，支持双向访问。
- 插入和删除操作较快，因为不需要移动元素。
- 查找操作较慢，因为需要遍历链表。

示例代码：

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

public class ListComparison {
    public static void main(String[] args) {
        List<String> list1 = new ArrayList<>();
        List<String> list2 = new LinkedList<>();

        long startTime1 = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
            list1.add("Item " + i);
        }
        long endTime1 = System.currentTimeMillis();
        System.out.println("ArrayList time: " + (endTime1 - startTime1) + " ms");

        long startTime2 = System.currentTimeMillis();
        for (int i = 0; i < 10000; i++) {
            list2.add("Item " + i);
        }
        long endTime2 = System.currentTimeMillis();
        System.out.println("LinkedList time: " + (endTime2 - startTime2) + " ms");
    }
}

异常处理与文件操作

异常处理机制

Java中的异常处理机制主要包括三个关键字：try、catch和finally。try块包含了可能抛出异常的代码，catch块用于捕获和处理异常，finally块用于执行清理操作，无论是否发生异常都会执行。

示例代码：

public class ExceptionHandling {
    public static void main(String[] args) {
        try {
            int result = 10 / 0; // 引发异常
            System.out.println("Result: " + result);
        } catch (ArithmeticException e) {
            System.out.println("ArithmeticException: " + e.getMessage());
        } finally {
            System.out.println("Finally block executed");
        }
    }
}

文件读写操作

Java提供了FileInputStream和FileOutputStream类用于文件的读写操作。以下是一个简单的文件读写示例：

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class FileIOExample {
    public static void main(String[] args) {
        // 写入文件
        try (FileOutputStream fos = new FileOutputStream("output.txt")) {
            String data = "Hello, World!";
            fos.write(data.getBytes());
        } catch (IOException e) {
            System.out.println("Error writing to file: " + e.getMessage());
        }

        // 读取文件
        try (FileInputStream fis = new FileInputStream("output.txt")) {
            int data;
            while ((data = fis.read()) != -1) {
                System.out.print((char) data);
            }
        } catch (IOException e) {
            System.out.println("Error reading file: " + e.getMessage());
        }
    }
}

以上代码演示了如何创建一个文件并写入数据，然后读取该文件的内容。注意使用try-with-resources语句自动管理文件流的关闭。

点击查看更多内容

为 TA 点赞

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

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

幕布斯6054654

手记
篇

粉丝

219

获赞与收藏

1011

关注作者，订阅最新文章

阅读免费教程

Java并发工具

23个小节 19244 315

Java 并发原理入门教程

26个小节 38983 568

Java 入门教程

50个小节 341700 3163

推荐

评论

收藏

共同学习，写下你的评论



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

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

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

支付方式

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

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

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

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

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

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

作者：

免费赠送

兑换码：1111222211 复制

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

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

热搜

最近搜索清空

JAVA编程入门教程：从零开始学习

什么是Java

安装JDK

配置环境变量

编写第一个Java程序

关键字与标识符

关键字

标识符

数据类型与变量

基本数据类型

变量的声明与初始化

运算符

常见算术运算符

关系运算符

逻辑运算符

控制语句

条件语句

循环语句

面向对象基础

封装

继承

多态

类的定义与对象的创建

构造方法

方法重载与方法重写

方法重载

方法重写

抽象类与接口

抽象类

接口

常用集合类介绍

List接口

Set接口

Map接口

List、Set与Map的区别与使用

ArrayList与LinkedList的对比

异常处理机制

文件读写操作

阅读免费教程