首頁手記 Java入門：從零開始學習Java編程語言

Java入門：從零開始學習Java編程語言

標簽：

Java

本文全面介绍了Java编程语言的基础知识，从Java入门到环境搭建、基础语法和面向对象编程，内容详尽丰富。文章还涵盖了Java的高级编程技术，如异常处理、文件操作和输入输出流等，旨在帮助读者快速掌握Java的核心概念和技术。通过详细示例和代码讲解，读者可以轻松上手并深入理解Java入门的相关知识。

Java简介

Java是一种广泛使用的编程语言，由Sun Microsystems公司（现已被Oracle收购）在1995年开发。Java语言具有简单性、面向对象、平台无关性、安全性等优点，广泛应用于各种领域。以下是Java的历史与发展、特点与优势以及应用领域。

Java的历史与发展

Java语言的发展始于1991年，当时由James Gosling、Patrick Naughton、Chris Warth和Mike Sheridan等人在一个名为“绿色团队”的小组中开发。Java最初被设计用于嵌入在各种电器中的小型控制器中，例如电视机顶盒、烤面包机等。随着互联网的兴起，Java逐渐转向了Web应用开发领域，并在1995年正式发布。

Java第一个版本是Java 1.0，随后版本不断更新。每个版本都带来了新的功能和改进。2006年，Java 6发布，引入了泛型和注解等特性。2009年，Java 7发布，增加了switch语句支持字符串、try-with-resources语法等。2011年，Java 8发布，引入了lambda表达式、函数式接口、Stream API等特性。最新的版本是Java 17，于2021年发布，它是一个长期支持版本，提供了更好的性能和安全性。

Java的特点与优势

Java语言具有多个显著的特点和优势，这些特点使其成为许多开发人员的首选语言之一：

简单性：Java语言的设计旨在简单、清晰和易于学习。它去掉了C++中一些复杂的特性，例如指针和内存管理，使得初学者更容易上手。
面向对象：Java是一门面向对象的语言，支持封装、继承和多态等面向对象的特性，这使得代码的复用性和可维护性更强。
跨平台性：Java的一个重要特点就是“一次编写，到处运行”。Java程序在任何支持Java虚拟机（JVM）的操作系统上都能运行，这使得Java程序具有很好的可移植性。
安全性：Java虚拟机（JVM）提供了强大的安全性功能，包括字节码验证、安全的内存管理以及沙箱模式等，这使得Java程序在安全性上得到了很好的保障。
丰富的库：Java提供了一个庞大的标准库，包括网络编程、数据库访问、图形界面开发、多线程等。这些库为开发人员提供了丰富的资源。

Java的应用领域

Java语言的应用领域非常广泛，包括但不限于：

Web应用：Java可以用来开发Web应用程序，包括服务器端的Java Servlet、Java Server Pages（JSP）、Spring等框架。
企业应用：Java在企业级应用开发中有着广泛的应用，包括企业资源计划（ERP）系统、客户关系管理（CRM）系统、供应链管理系统等。
移动应用：Java可以开发移动应用，虽然Java ME和Java ME等移动平台已经逐渐被淘汰，但Java在Android开发中仍然占据重要地位。
游戏开发：Java可以用来开发桌面游戏、手机游戏和网络游戏。例如，Minecraft游戏就是用Java编写的。
大数据处理：Java在大数据处理领域也有应用，如Apache Hadoop、Apache Spark等大数据处理框架都是使用Java开发的。
云计算：Java在云计算领域也有广泛应用，包括Amazon Web Services（AWS）、Google Cloud等云平台都支持Java应用的开发。

Java环境搭建

在开始编写Java程序之前，需要首先搭建好Java开发环境。这包括安装Java开发工具包（JDK）、配置环境变量以及编写第一个Java程序。

安装Java开发工具包（JDK）

Java开发工具包（JDK）包含了Java编译器、Java文档工具、Java运行环境等开发所需的工具。以下是安装JDK的步骤：

下载JDK：访问Oracle官方网站或OpenJDK的官方网站，下载对应版本的JDK安装包。通常建议下载最新的长期支持（LTS）版本。
安装JDK：
- 打开下载的安装包，按照提示完成安装。安装过程中可以根据需要选择安装路径。
- 安装完成后，需要设置环境变量。

配置环境变量

在安装好JDK后，需要配置环境变量，使系统能够识别Java的命令，例如javac和java。以下是配置环境变量的步骤：

打开环境变量设置：
- 在Windows系统中，可以右键点击此电脑/我的电脑，选择属性，然后点击“高级系统设置”，在“系统属性”窗口的“高级”标签下点击“环境变量”。
- 在Linux或Mac系统中，可以通过终端编辑环境变量文件，如~/.bashrc或~/.bash_profile。
设置JAVA_HOME变量：
- 在Windows系统中，在“系统变量”中新建变量名为JAVA_HOME，变量值为JDK的安装目录。
- 在Linux或Mac系统中，添加如下内容到环境变量文件中：
```
export JAVA_HOME=/path/to/jdk
```
设置PATH变量：
- 在Windows系统中，在“系统变量”中找到名为Path的变量，点击编辑，在变量值末尾追加;%JAVA_HOME%\bin。
- 在Linux或Mac系统中，同样编辑环境变量文件，添加如下内容：
```
export PATH=$JAVA_HOME/bin:$PATH
```
验证环境变量配置：
- 打开命令行或终端，输入java -version或javac -version命令，检查是否能够正确显示Java版本信息。

第一个Java程序：Hello World

完成环境搭建后，可以编写第一个Java程序。下面是一个简单的“Hello World”程序，用于输出“Hello, World!”。

创建Java源文件：
- 使用文本编辑器（如Notepad++、VSCode等）创建一个文件，命名为HelloWorld.java。

编写Hello World程序：

在文件中输入下面的代码：

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

编译Java程序：
- 打开命令行或终端，切换到包含HelloWorld.java文件的目录。
- 输入javac HelloWorld.java命令，编译Java源文件。如果成功，会在当前目录生成一个名为HelloWorld.class的字节码文件。
运行Java程序：
- 输入java HelloWorld命令运行程序。
- 在命令行或终端中，你将看到输出“Hello, World!”。

Java基础语法

Java编程语言有许多基础语法，包括数据类型与变量、语句与表达式、数组与字符串操作等。这些语法构成了Java程序的基础，是学习Java编程的重要内容。

数据类型与变量

在Java中，数据类型决定了变量能够存储的数据类型和范围。Java的数据类型分为基本类型（Primitive Types）和引用类型（Reference Types）两种。基本类型包括整型、浮点型、字符型和布尔型，而引用类型包括数组、对象和接口等。

基本类型

Java的基本类型如下表所示：

类型	描述	默认值 (默认值)	占用空间 (字节)	范围
`byte`	8位有符号整型，范围-128到127。	0	1	-128 to 127
`short`	16位有符号整型，范围-32,768到32,767。	0	2	-32,768 to 32,767
`int`	32位有符号整型，范围-2,147,483,648到2,147,483,647	0	4	-2,147,483,648 to 2,147,483,647
`long`	64位有符号整型，范围-9,223,372,036,854,775,808到9,223,372,036,854,775,807	0	8	-9,223,372,036,854,775,808 to 9,223,372,036,854,775,807
`float`	32位浮点型，精度为7位左右，遵循IEEE 754标准。	0.0f	4	1.4E-45 to 3.4028235E38
`double`	64位浮点型，精度为15位左右，遵循IEEE 754标准。	0.0d	8	4.9E-324 to 1.7976931348623157E308
`char`	16位Unicode字符，范围\u0000到\uffff。	'\u0000'	2	\u0000 to \uffff
`boolean`	布尔型，表示真或假。	false	1	true或false

变量声明

变量是存储数据的容器，其声明格式如下：

type variableName = value;

示例：

int age = 25;
float price = 19.99f;
char letter = 'A';
boolean isTrue = true;

数据类型转换

数据类型转换分为两种方式：隐式转换和显式转换。

隐式转换：当从一种较小的数据类型转换为较大的数据类型时，JVM会自动进行转换。
```
int number = 25;
long lNumber = number; // 隐式转换，从int到long
```
显式转换：从较大的数据类型转换为较小的数据类型时，需要使用类型转换关键字（如int、byte、float等）进行显式转换。
```
double dNumber = 25.1;
int iNumber = (int) dNumber; // 显式转换，从double到int
```

语句和表达式

语句是Java程序执行的基本单位，表达式是计算操作的结果。Java中常见的语句和表达式包括赋值语句、条件语句、循环语句等。

赋值语句

赋值语句用于将一个值赋给一个变量。语法格式如下：

variable = expression;

示例：

int x = 10;
x = 20; // 将20赋值给x

条件语句

条件语句用于根据条件执行不同的代码。Java中常见的条件语句有if语句和switch语句。

if语句：

if (condition) {
  // 如果条件为真，则执行这里的代码
} else {
  // 如果条件为假，则执行这里的代码
}

示例：

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

switch语句：

switch (expression) {
  case value1:
      // 当expression等于value1时执行这里的代码
      break;
  case value2:
      // 当expression等于value2时执行这里的代码
      break;
  default:
      // 当expression不等于任何case值时执行这里的代码
}

示例：

int dayOfWeek = 3;
switch (dayOfWeek) {
  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 (initialization; condition; increment) {
  // 循环体
}

示例：

for (int i = 1; i <= 10; i++) {
  System.out.println("数字：" + i);
}

while循环：

while (condition) {
  // 循环体
}

示例：

int i = 1;
while (i <= 10) {
  System.out.println("数字：" + i);
  i++;
}

do-while循环：

do {
  // 循环体
} while (condition);

示例：

int i = 1;
do {
  System.out.println("数字：" + i);
  i++;
} while (i <= 10);

数组与字符串操作

数组是一种容器，用来存储多个相同类型的值。字符串是用于表示文本数据的特殊类型，也是不可变的对象。

数组

声明和初始化数组：

int[] numbers = new int[5]; // 声明一个数组，长度为5

数组初始化：

int[] numbers = {1, 2, 3, 4, 5}; // 初始化数组

访问数组元素：

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

遍历数组：

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

字符串

字符串是Java中最常用的类型之一，它是不可变的，意味着一旦创建了一个字符串对象，其内容就不能改变。

声明和初始化字符串：
```
String str = "Hello, World!";
```

字符串操作：

String str = "Hello, World!";
System.out.println(str.length()); // 输出字符串长度
System.out.println(str.charAt(0)); // 输出第一个字符
System.out.println(str.substring(7)); // 输出从第7个字符开始的子字符串
System.out.println(str.toLowerCase()); // 转换为小写
System.out.println(str.toUpperCase()); // 转换为大写

字符串拼接：

String firstName = "John";
String lastName = "Doe";
String fullName = firstName + " " + lastName;
System.out.println(fullName); // 输出 "John Doe"

字符串比较：

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

Java面向对象编程

面向对象编程（OOP）是一种编程范式，Java语言是一种典型的面向对象语言，支持封装、继承和多态等特性。面向对象编程使得程序设计更加模块化、可复用和易于维护。本节将详细介绍Java中面向对象编程的基本概念，包括类与对象的概念、构造函数与方法以及继承与多态性。

类与对象的概念

面向对象编程的基本单位是类（Class）和对象（Object）。类是一种抽象的数据类型，定义了一组属性（即成员变量）和行为（即成员方法）。对象是类的实例，它具体化了类的属性和行为。

类的定义：类是创建对象的模板，它包含了属性（成员变量）和方法（成员函数）。

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 this.name;
  }

  public int getAge() {
      return this.age;
  }

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

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

  public void introduce() {
      System.out.println("我的名字是：" + this.name + "，我今年" + this.age + "岁。");
  }
}

对象的创建：对象是类的实例，可以通过new关键字创建。

Person person1 = new Person("张三", 25);
person1.introduce(); // 输出 "我的名字是：张三，我今年25岁。"

构造函数与方法

构造函数是一种特殊的方法，用于初始化对象的成员变量。构造函数的名称必须与类名相同，没有返回类型，并且不能有返回值（不包括void）。

构造函数的定义：

public class Car {
  private String brand;
  private String model;
  private int year;

  // 构造函数
  public Car(String brand, String model, int year) {
      this.brand = brand;
      this.model = model;
      this.year = year;
  }
}

方法的定义：方法是类的行为，用于执行特定的操作。

public class Rectangle {
  private int width;
  private int height;

  // 构造函数
  public Rectangle(int width, int height) {
      this.width = width;
      this.height = height;
  }

  // 方法
  public int getArea() {
      return this.width * this.height;
  }

  public void setWidth(int width) {
      this.width = width;
  }

  public void setHeight(int height) {
      this.height = height;
  }
}

继承与多态性

继承是面向对象编程的重要特性之一，它允许一个类（子类）继承另一个类（父类）的属性和行为。多态性允许对象以不同的形式表现，即父类引用可以指向子类对象。

继承的定义：

public class Animal {
  public void eat() {
      System.out.println("动物在进食。");
  }
}

public class Dog extends Animal {
  public void bark() {
      System.out.println("狗在吠叫。");
  }
}

多态性的使用：

Animal animal = new Dog();
animal.eat(); // 输出 "动物在进食。"
((Dog) animal).bark(); // 输出 "狗在吠叫。"

多态性的具体例子：

public class Mammal extends Animal {
  public void breathe() {
      System.out.println("哺乳动物在呼吸。");
  }

  public void bark() {
      System.out.println("哺乳动物没有声音。");
  }
}

public class Dog2 extends Mammal {
  public void bark() {
      System.out.println("狗在吠叫。");
  }
}

public class TestPolymorphism {
  public static void main(String[] args) {
      Animal animal = new Mammal();
      animal.bark(); // 输出 "哺乳动物没有声音。"
      animal = new Dog2();
      animal.bark(); // 输出 "狗在吠叫。"
  }
}

在继承关系中，子类可以覆盖（重写）父类的方法，实现更具体的行为。此外，还可以使用抽象类和接口来实现更复杂的继承关系和多态性。

Java常用编程技术

Java提供多种编程技术和工具，包括异常处理、文件操作、输入输出流等，这些技术可以大大提高程序的健壮性和效率。本节将详细介绍这些技术及其应用场景。

异常处理

异常处理是Java中处理程序错误和异常情况的重要机制。它允许程序在发生错误时优雅地处理异常，而不是直接终止程序。Java中的异常处理基于try-catch-finally语句块和throw关键字。

try-catch-finally语句块

try-catch-finally语句块用于捕获和处理异常。try块包含可能抛出异常的代码，catch块捕获并处理异常，finally块在try和catch块执行后总是执行，常用于清理资源。

基本语法：

try {
  // 可能发生异常的代码
} catch (ExceptionType1 e1) {
  // 处理ExceptionType1异常
} catch (ExceptionType2 e2) {
  // 处理ExceptionType2异常
} finally {
  // 总是执行的代码
}

示例：

public class ExceptionExample {
  public static void main(String[] args) {
      try {
          int result = 10 / 0; // 可能抛出ArithmeticException
      } catch (ArithmeticException e) {
          System.out.println("发生除以零错误。");
      } finally {
          System.out.println("代码执行完成。");
      }
  }
}

自定义异常

除了系统提供的异常类型外，还可以根据需要自定义异常类型。自定义异常通常继承自Exception类或其子类。

自定义异常类：

public class MyException extends Exception {
  public MyException(String message) {
      super(message);
  }
}

抛出自定义异常：

public class CustomExceptionExample {
  public static void checkAge(int age) throws MyException {
      if (age < 0) {
          throw new MyException("年龄不能是负数。");
      }
  }

  public static void main(String[] args) {
      try {
          checkAge(-1);
      } catch (MyException e) {
          System.out.println(e.getMessage());
      }
  }
}

文件操作

文件操作是Java中常见的任务之一，包括读写文件、文件的复制和删除等。Java提供了java.io包中的类来实现文件操作。

文件读取

可以使用FileReader和BufferedReader类读取文本文件。

示例：

import java.io.*;

public class FileReadExample {
  public static void main(String[] args) throws IOException {
      FileReader fileReader = new FileReader("example.txt");
      BufferedReader bufferedReader = new BufferedReader(fileReader);

      String line;
      while ((line = bufferedReader.readLine()) != null) {
          System.out.println(line);
      }

      bufferedReader.close();
      fileReader.close();
  }
}

文件写入

可以使用FileWriter和BufferedWriter类写入文本文件。

示例：

import java.io.*;

public class FileWriteExample {
  public static void main(String[] args) throws IOException {
      FileWriter fileWriter = new FileWriter("example.txt", true);
      BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);

      bufferedWriter.write("新行");
      bufferedWriter.newLine();
      bufferedWriter.write("新的内容");

      bufferedWriter.close();
      fileWriter.close();
  }
}

输入输出流

输入输出流（I/O Stream）是Java中用于处理输入输出操作的重要工具。Java中的输入输出流分为字节流和字符流，字节流处理字节数据，字符流处理字符数据。

字节流

InputStream和OutputStream是字节流的抽象基类，位于java.io包中。

读取文件示例：

import java.io.*;

public class ByteStreamReadExample {
  public static void main(String[] args) throws IOException {
      FileInputStream fileInputStream = new FileInputStream("example.bin");
      byte[] buffer = new byte[1024];
      int length;
      while ((length = fileInputStream.read(buffer)) != -1) {
          System.out.write(buffer, 0, length);
      }
      fileInputStream.close();
  }
}

写入文件示例：

import java.io.*;

public class ByteStreamWriteExample {
  public static void main(String[] args) throws IOException {
      FileOutputStream fileOutputStream = new FileOutputStream("example.bin");
      String data = "Hello, World!";
      byte[] buffer = data.getBytes();
      fileOutputStream.write(buffer);
      fileOutputStream.close();
  }
}

字符流

Reader和Writer是字符流的抽象基类，位于java.io包中。

读取文件示例：

import java.io.*;

public class CharStreamReadExample {
  public static void main(String[] args) throws IOException {
      FileReader fileReader = new FileReader("example.txt");
      char[] buffer = new char[1024];
      int length;
      while ((length = fileReader.read(buffer)) != -1) {
          System.out.write(buffer, 0, length);
      }
      fileReader.close();
  }
}

写入文件示例：

import java.io.*;

public class CharStreamWriteExample {
  public static void main(String[] args) throws IOException {
      FileWriter fileWriter = new FileWriter("example.txt", true);
      String data = "新内容";
      char[] buffer = data.toCharArray();
      fileWriter.write(buffer);
      fileWriter.close();
  }
}

常用集合框架

Java集合框架提供了一系列接口和实现类，用于存储和操作不同类型的对象集合。集合框架主要包含Collection接口、List接口、Set接口和Map接口等。

List接口

List接口表示一种有序的集合，允许元素重复。常用实现类有ArrayList和LinkedList。

ArrayList示例：

import java.util.*;

public class ArrayListExample {
  public static void main(String[] args) {
      List<String> list = new ArrayList<>();
      list.add("元素1");
      list.add("元素2");
      list.add("元素3");

      System.out.println("列表中的元素：" + list);
  }
}

LinkedList示例：

import java.util.*;

public class LinkedListExample {
  public static void main(String[] args) {
      List<String> list = new LinkedList<>();
      list.add("元素1");
      list.add("元素2");
      list.add("元素3");

      System.out.println("列表中的元素：" + list);
  }
}

Set接口

Set接口表示一种不包含重复元素的集合。常用实现类有HashSet和TreeSet。

HashSet示例：

import java.util.*;

public class HashSetExample {
  public static void main(String[] args) {
      Set<String> set = new HashSet<>();
      set.add("元素1");
      set.add("元素2");
      set.add("元素3");
      set.add("元素1"); // 重复元素将被忽略

      System.out.println("集合中的元素：" + set);
  }
}

TreeSet示例：

import java.util.*;

public class TreeSetExample {
  public static void main(String[] args) {
      Set<String> set = new TreeSet<>();
      set.add("元素1");
      set.add("元素2");
      set.add("元素3");

      System.out.println("集合中的元素：" + set);
  }
}

Map接口

Map接口表示一种键值对的集合，键是唯一的。常用实现类有HashMap和TreeMap。

HashMap示例：

import java.util.*;

public class HashMapExample {
  public static void main(String[] args) {
      Map<String, Integer> map = new HashMap<>();
      map.put("元素1", 1);
      map.put("元素2", 2);
      map.put("元素3", 3);

      System.out.println("键值对：" + map);
  }
}

TreeMap示例：

import java.util.*;

public class TreeMapExample {
  public static void main(String[] args) {
      Map<String, Integer> map = new TreeMap<>();
      map.put("元素1", 1);
      map.put("元素2", 2);
      map.put("元素3", 3);

      System.out.println("键值对：" + map);
  }
}

通过这些示例，可以看到Java集合框架的强大功能，能够满足各种存储和操作对象的需求。

點擊查看更多內容

為 TA 點贊

若覺得本文不錯，就分享一下吧！

評論

評論

共同學習，寫下你的評論

評論加載中...

展開查看更多評論

作者其他優質文章

正在加載中

臨摹微笑

手記
篇

粉絲

32

獲贊與收藏

170

關注作者，訂閱最新文章

閱讀免費教程

Java并發工具

23個小節 19844 321

Java 并發原理入門教程

26個小節 40021 580

Java 入門教程

50個小節 351802 3256

推薦

評論

收藏

共同學習，寫下你的評論



感謝您的支持，我會繼續努力的～

掃碼打賞，你說多少就多少

贊賞金額會直接到老師賬戶

支付方式

打開微信掃一掃，即可進行掃碼打賞哦

今天注冊有機會得

100積分直接送

付費專欄免費學

大額優惠券免費領

立即參與放棄機會

點擊
抽獎

慕課手記新用戶專享福利

恭喜你，你的運氣太好了，居然抽中了 100個積分！

恭喜你，抽中了價值元的專欄！

太棒了，直接落到你賬戶里！

積分商城里的羅技鼠標、機械鍵盤、
Kindle 閱讀器、小米平衡車
Apple iPad （10.2英寸）、大額優惠券
在等著你去兌換了噢

作者：

免費贈送

兌換碼：1111222211 復制

優惠券可用于購買實戰課、體系課
無門檻使用

先去看看，有什么好東西馬上兌換我愛學習，選課去


亚洲在线久爱草,狠狠天天香蕉网,天天搞日日干久草,伊人亚洲日本欧美

熱搜

最近搜索清空