Java 简介：从入门到实践的完整教程

雨鸣静声

 关注

阅读 72

08-04 18:00

Java 是当今最流行的编程语言之一，广泛应用于企业级应用、Android开发、大数据处理等领域。本文将系统介绍 Java 的核心概念、基础语法和实际编程技巧，帮助初学者快速入门。

一、Java 简介与特性

1.1 Java 是什么

Java 是 Sun Microsystems（现属 Oracle）于 1995 年发布的面向对象编程语言，设计目标是"一次编写，到处运行"（Write Once, Run Anywhere）。

1.2 Java 核心特性

  • 面向对象：一切皆对象，支持封装、继承和多态
  • 跨平台性：通过 JVM 实现跨平台运行
  • 自动内存管理：垃圾回收机制（GC）
  • 健壮性：强类型检查、异常处理机制
  • 安全性：字节码验证、安全管理器
  • 多线程支持：内置多线程编程模型

二、Java 开发环境搭建

2.1 JDK 安装

  1. 下载 JDK（建议 JDK 11 或 LTS 版本）
  2. 配置环境变量：
  • JAVA_HOME：指向 JDK 安装目录
  • PATH：添加 %JAVA_HOME%\bin

2.2 第一个 Java 程序

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

编译运行：

javac HelloWorld.java  // 编译
 java HelloWorld       // 运行

三、Java 基础语法

3.1 数据类型与变量

javapublic class DataTypes {
     public static void main(String[] args) {
         // 基本数据类型
         byte b = 100;        // 8位
         short s = 1000;      // 16位
         int i = 100000;      // 32位
         long l = 10000000000L; // 64位
         
         float f = 3.14f;     // 32位浮点数
         double d = 3.1415926535; // 64位浮点数
         
         char c = 'A';        // 16位Unicode字符
         boolean bool = true;  // 布尔值
         
         // 引用类型
         String str = "Java Programming";
         
         System.out.println("Byte range: " + Byte.MIN_VALUE + " to " + Byte.MAX_VALUE);
     }
 }

3.2 运算符

javapublic class Operators {
     public static void main(String[] args) {
         int a = 10, b = 3;
         
         // 算术运算符
         System.out.println("a + b = " + (a + b)); // 13
         System.out.println("a / b = " + (a / b)); // 3 (整数除法)
         System.out.println("a % b = " + (a % b)); // 1
         
         // 比较运算符
         System.out.println("a == b: " + (a == b)); // false
         System.out.println("a != b: " + (a != b)); // true
         
         // 逻辑运算符
         boolean x = true, y = false;
         System.out.println("x && y: " + (x && y)); // false
         System.out.println("x || y: " + (x || y)); // true
         
         // 位运算符
         System.out.println("a & b: " + (a & b)); // 2 (二进制 1010 & 0011 = 0010)
     }
 }

3.3 控制结构

javapublic class ControlFlow {
     public static void main(String[] args) {
         // if-else 语句
         int score = 85;
         if (score >= 90) {
             System.out.println("A");
         } else if (score >= 80) {
             System.out.println("B");
         } else {
             System.out.println("C");
         }
         
         // switch 语句 (Java 12+ 增强版)
         int day = 3;
         String dayName = switch (day) {
             case 1 -> "Monday";
             case 2 -> "Tuesday";
             case 3 -> "Wednesday";
             default -> "Invalid day";
         };
         System.out.println(dayName); // Wednesday
         
         // for 循环
         for (int i = 1; i <= 5; i++) {
             System.out.print(i + " "); // 1 2 3 4 5
         }
         System.out.println();
         
         // while 循环
         int j = 0;
         while (j < 5) {
             System.out.print((j * 2) + " "); // 0 2 4 6 8
             j++;
         }
         System.out.println();
         
         // do-while 循环
         int k = 5;
         do {
             System.out.println("This will run at least once");
             k--;
         } while (k > 0);
     }
 }

四、面向对象编程基础

4.1 类与对象

java// Person.java
 public class Person {
     // 字段
     private String name;
     private int age;
     
     // 构造方法
     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'm " + age + " years old.");
     }
     
     // Getter 和 Setter
     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;
     }
 }
  
 // Main.java
 public class Main {
     public static void main(String[] args) {
         // 创建对象
         Person person1 = new Person("Alice", 25);
         person1.introduce(); // Hello, my name is Alice and I'm 25 years old.
         
         // 访问字段通过方法
         person1.setAge(26);
         System.out.println(person1.getName() + " is now " + person1.getAge());
     }
 }

4.2 继承与多态

java// Animal.java (父类)
 public class Animal {
     private String name;
     
     public Animal(String name) {
         this.name = name;
     }
     
     public void makeSound() {
         System.out.println("Some generic animal sound");
     }
     
     public String getName() {
         return name;
     }
 }
  
 // Dog.java (子类)
 public class Dog extends Animal {
     public Dog(String name) {
         super(name); // 调用父类构造方法
     }
     
     @Override
     public void makeSound() {
         System.out.println("Woof! Woof!");
     }
     
     // 子类特有方法
     public void wagTail() {
         System.out.println(getName() + " is wagging its tail");
     }
 }
  
 // Main.java
 public class Main {
     public static void main(String[] args) {
         Animal myAnimal = new Animal("Generic Animal");
         Dog myDog = new Dog("Buddy");
         
         // 多态示例
         Animal animalRef;
         animalRef = myAnimal;
         animalRef.makeSound(); // Some generic animal sound
         
         animalRef = myDog;
         animalRef.makeSound(); // Woof! Woof! (运行时多态)
         
         // 向下转型 (需要类型检查)
         if (animalRef instanceof Dog) {
             Dog dogRef = (Dog) animalRef;
             dogRef.wagTail(); // Buddy is wagging its tail
         }
     }
 }

4.3 抽象类与接口

java// Shape.java (抽象类)
 public abstract class Shape {
     public abstract double area(); // 抽象方法
     
     public void display() { // 具体方法
         System.out.println("This is a shape");
     }
 }
  
 // Drawable.java (接口)
 public interface Drawable {
     void draw(); // 接口方法默认是public abstract
     default void showInfo() { // Java 8+ 默认方法
         System.out.println("This object can be drawn");
     }
 }
  
 // Circle.java
 public class Circle extends Shape implements Drawable {
     private double radius;
     
     public Circle(double radius) {
         this.radius = radius;
     }
     
     @Override
     public double area() {
         return Math.PI * radius * radius;
     }
     
     @Override
     public void draw() {
         System.out.println("Drawing a circle with radius " + radius);
     }
 }
  
 // Main.java
 public class Main {
     public static void main(String[] args) {
         Circle circle = new Circle(5.0);
         
         circle.display(); // 来自抽象类 Shape
         circle.draw();    // 来自接口 Drawable
         circle.showInfo(); // 来自接口的默认方法
         
         System.out.println("Circle area: " + circle.area());
     }
 }

五、异常处理

javaimport java.util.Scanner;
  
 public class ExceptionHandling {
     public static void main(String[] args) {
         Scanner scanner = new Scanner(System.in);
         
         try {
             System.out.print("Enter numerator: ");
             int numerator = scanner.nextInt();
             
             System.out.print("Enter denominator: ");
             int denominator = scanner.nextInt();
             
             int result = divide(numerator, denominator);
             System.out.println("Result: " + result);
             
         } catch (ArithmeticException e) {
             System.out.println("Error: " + e.getMessage()); // / by zero
         } catch (NumberFormatException e) {
             System.out.println("Error: Please enter valid integers");
         } catch (Exception e) {
             System.out.println("An unexpected error occurred: " + e.getMessage());
         } finally {
             scanner.close();
             System.out.println("Resource cleanup completed");
         }
     }
     
     public static int divide(int a, int b) throws ArithmeticException {
         if (b == 0) {
             throw new ArithmeticException("Division by zero is not allowed");
         }
         return a / b;
     }
 }

六、集合框架

6.1 List 接口

javaimport java.util.ArrayList;
 import java.util.LinkedList;
 import java.util.List;
  
 public class ListExample {
     public static void main(String[] args) {
         // ArrayList (基于动态数组)
         List<String> arrayList = new ArrayList<>();
         arrayList.add("Apple");
         arrayList.add("Banana");
         arrayList.add(1, "Orange"); // 在索引1处插入
         
         System.out.println("ArrayList: " + arrayList);
         System.out.println("Second element: " + arrayList.get(1));
         
         // LinkedList (基于双向链表)
         List<Integer> linkedList = new LinkedList<>();
         linkedList.add(10);
         linkedList.add(20);
         linkedList.addFirst(5); // 在开头添加
         
         System.out.println("LinkedList: " + linkedList);
         System.out.println("First element: " + linkedList.getFirst());
     }
 }

6.2 Set 接口

javaimport java.util.HashSet;
 import java.util.LinkedHashSet;
 import java.util.Set;
 import java.util.TreeSet;
  
 public class SetExample {
     public static void main(String[] args) {
         // HashSet (无序，唯一)
         Set<String> hashSet = new HashSet<>();
         hashSet.add("Apple");
         hashSet.add("Banana");
         hashSet.add("Apple"); // 不会重复添加
         
         System.out.println("HashSet: " + hashSet);
         
         // LinkedHashSet (保持插入顺序)
         Set<Integer> linkedHashSet = new LinkedHashSet<>();
         linkedHashSet.add(3);
         linkedHashSet.add(1);
         linkedHashSet.add(2);
         
         System.out.println("LinkedHashSet: " + linkedHashSet);
         
         // TreeSet (自然排序)
         Set<String> treeSet = new TreeSet<>();
         treeSet.add("Orange");
         treeSet.add("Apple");
         treeSet.add("Banana");
         
         System.out.println("TreeSet: " + treeSet); // [Apple, Banana, Orange]
     }
 }

6.3 Map 接口

javaimport java.util.HashMap;
 import java.util.LinkedHashMap;
 import java.util.Map;
 import java.util.TreeMap;
  
 public class MapExample {
     public static void main(String[] args) {
         // HashMap (键唯一，无序)
         Map<String, Integer> hashMap = new HashMap<>();
         hashMap.put("Alice", 25);
         hashMap.put("Bob", 30);
         hashMap.put("Alice", 26); // 更新值
         
         System.out.println("HashMap: " + hashMap);
         System.out.println("Alice's age: " + hashMap.get("Alice"));
         
         // LinkedHashMap (保持插入顺序)
         Map<Integer, String> linkedHashMap = new LinkedHashMap<>();
         linkedHashMap.put(3, "Three");
         linkedHashMap.put(1, "One");
         linkedHashMap.put(2, "Two");
         
         System.out.println("LinkedHashMap: " + linkedHashMap);
         
         // TreeMap (键自然排序)
         Map<String, Integer> treeMap = new TreeMap<>();
         treeMap.put("Orange", 3);
         treeMap.put("Apple", 5);
         treeMap.put("Banana", 2);
         
         System.out.println("TreeMap: " + treeMap); // {Apple=5, Banana=2, Orange=3}
         
         // 遍历Map
         for (Map.Entry<String, Integer> entry : treeMap.entrySet()) {
             System.out.println(entry.getKey() + ": " + entry.getValue());
         }
     }
 }

七、多线程编程

7.1 创建线程

java// 方式1: 继承Thread类
 class MyThread extends Thread {
     @Override
     public void run() {
         for (int i = 0; i < 5; i++) {
             System.out.println(getName() + " is running: " + i);
             try {
                 Thread.sleep(500); // 暂停500毫秒
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }


相关推荐

Java Web从入门到实践

静守幸福 186 0 0

SQL 入门教程：从基础到实践

扒皮狼 32 0 0

JavaWeb从入门到实践

开源GIS定制化开发方案 71 0 0

Helm 从入门到实践

花明 78 0 0

爬虫从入门到应用简介

天悦哥 29 0 0

《Docker 从入门到实践》笔记

杰克逊爱学习 62 0 0

详解 Dockerfile：从入门到实践

玩物励志老乐 34 0 0

webpack 从入门到工程实践

思考的鸿毛 73 0 0

初探Electron，从入门到实践

Android开发指南 127 0 0

Oracle从入门到项目实践

Greatiga 37 0 0

精彩评论（0）

0 0 举报