Java教程
JAVA主流技术学习：从入门到提升
本文主要是介绍JAVA主流技术学习：从入门到提升，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！
概述
JAVA主流技术学习涵盖了从基础回顾到面向对象编程、集合框架、异常处理、IO操作与多线程等核心领域，旨在全面掌握JAVA编程的精髓与实践。
JAVA基础回顾
JAVA简介
JAVA 是一种面向对象的、跨平台的编程语言，由 Sun Microsystems 开发并于 1995 年发布。它旨在简化编写、部署和维护代码的过程，使得开发者能在不同操作系统上运行和维护应用程序。JAVA 的核心特点是其强大的类库、面向对象编程原则以及垃圾回收机制。
JDK、JVM理解
JAVA 开发工具包（JDK）包含了编写、编译和运行 JAVA 应用程序所需的所有组件。JVM（Java Virtual Machine）是 JAVA 应用程序运行的基础，它允许在不同操作系统上运行 JAVA 代码，实现了平台无关性。
数据类型、变量、运算符
JAVA 的数据类型分为基本类型和引用类型。基本类型包括：byte、short、int、long、float、double、char 和 boolean。引用类型则包含类、接口、数组等。变量需要在声明时指定类型，并赋予初始值。
public class BasicTypes {
public static void main(String[] args) {
int age = 25; // 整数类型
float salary = 5000.99f; // 浮点类型
char grade = 'A'; // 字符类型
boolean isValid = true; // 布尔类型
System.out.println("Age: " + age);
System.out.println("Salary: " + salary);
System.out.println("Grade: " + grade);
System.out.println("IsValid: " + isValid);
}
}
JAVA 的运算符包括算术运算符、赋值运算符、比较运算符、逻辑运算符等。这些运算符用于执行基本的数学操作和数据比较。
控制结构：条件语句、循环语句
JAVA 提供了 if、else、switch、for、while 和 do-while 等控制结构，用于实现流程控制。
public class ControlStructures {
public static void main(String[] args) {
int x = 10;
if (x > 0) {
System.out.println("x 是正数");
} else {
System.out.println("x 不是正数");
}
for (int i = 1; i <= 5; i++) {
System.out.println("循环次数: " + i);
}
int count = 0;
do {
System.out.println("循环执行次数: " + count);
count++;
} while (count < 3);
}
}
面向对象编程
类与对象的创建
类是对象的蓝图，包含了对象的属性和方法。创建对象时，会根据类的定义实例化一个对象。
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 am " + age + " years old.");
}
}
public class Main {
public static void main(String[] args) {
Person person = new Person("Tom", 20);
person.introduce();
}
}
封装、继承、多态
封装是隐藏对象的内部实现细节，只通过公共接口暴露外部可以操作的对象。继承允许创建一个类来继承另一个类的属性和方法。多态使得不同类的对象可以以相同的方式处理，增加了代码的灵活性和复用性。
public class Animal {
public void eat() {
System.out.println("Animal eats.");
}
}
public class Dog extends Animal {
@Override
public void eat() {
System.out.println("Dog eats bone.");
}
}
public class Main {
public static void main(String[] args) {
Animal animal = new Dog();
animal.eat();
}
}
接口与抽象类
接口定义了一系列方法和常量，类实现了接口后必须实现接口中的所有方法。抽象类可以包含抽象方法，子类必须实现这些方法。
public interface Flyable {
void fly();
}
public abstract class Bird implements Flyable {
public void eat() {
System.out.println("Bird eats seeds.");
}
@Override
public void fly() {
System.out.println("Bird flies.");
}
}
public class Sparrow extends Bird {
@Override
public void fly() {
System.out.println("Sparrow flies fast.");
}
}
public class Main {
public static void main(String[] args) {
Bird bird = new Sparrow();
bird.eat();
bird.fly();
}
}
静态成员与实例成员
静态成员属于类，而不是实例，可以被类直接访问。实例成员属于对象，每个对象都有各自的副本。
public class MyClass {
private String privateField;
public static int staticField;
public MyClass(String field) {
privateField = field;
}
public static void staticMethod() {
staticField = 100;
}
public void instanceMethod() {
System.out.println("Instance field: " + privateField);
}
}
public class Main {
public static void main(String[] args) {
MyClass.staticMethod();
MyClass instance = new MyClass("Hello");
instance.instanceMethod();
}
}
集合框架
ArrayList、LinkedList、Vector区别
这些类都是 java.util 包下的集合类，用于存储对象集合。
public class ArrayListVsLinkedList {
public static void main(String[] args) {
ArrayList<String> list1 = new ArrayList<>();
LinkedList<String> list2 = new LinkedList<>();
list1.add("A");
list1.add("B");
list1.add("C");
list2.add("A");
list2.add("B");
list2.add("C");
System.out.println("ArrayList size: " + list1.size());
System.out.println("LinkedList size: " + list2.size());
}
}
HashMap、HashSet、TreeMap应用
这些类分别用于存储键值对、无重复元素的集合和有序集合。
public class CollectionUsage {
public static void main(String[] args) {
HashMap<String, Integer> map = new HashMap<>();
map.put("Apple", 1);
map.put("Banana", 2);
map.put("Cherry", 3);
map.put("Date", 4);
map.remove("Banana");
System.out.println("HashMap: " + map);
HashSet<String> set = new HashSet<>();
set.add("Apple");
set.add("Banana");
set.add("Cherry");
set.add("Date");
System.out.println("HashSet: " + set);
TreeMap<String, Integer> sortedMap = new TreeMap<>(map);
System.out.println("TreeMap (sorted): " + sortedMap);
}
}
集合的迭代与遍历
使用 for-each 循环或者 Iterator 接口进行遍历。
public class CollectionIteration {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("A");
list.add("B");
list.add("C");
// 使用 for-each 循环
for (String element : list) {
System.out.println(element);
}
// 使用 Iterator
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
}
}
}
异常处理
错误与异常的区别
错误用于描述程序无法修复的运行时问题，异常则用于描述可以被程序捕获和处理的问题。
try、catch、finally块
public class ExceptionHandling {
public static void main(String[] args) {
try {
int[] array = {1, 2};
System.out.println(array[3]);
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("Caught an ArrayIndexOutOfBoundsException: " + e.getMessage());
} finally {
System.out.println("Finally block executed.");
}
}
}
自定义异常和异常链
自定义异常继承自 Exception 类，异常链使用 throws 关键字。
public class CustomException {
public static void process(int value) throws MyException {
if (value < 0) {
throw new MyException("Value is negative.");
}
}
public static void main(String[] args) {
try {
process(-10);
} catch (MyException e) {
System.out.println("Caught MyException: " + e.getMessage());
}
}
}
class MyException extends Exception {
public MyException(String message) {
super(message);
}
}
IO操作
文件读写操作
利用 FileReader, FileWriter, BufferedReader, BufferedWriter 等类实现文件操作。
import java.io.*;
public class FileIO {
public static void main(String[] args) {
try (BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"))) {
writer.write("Hello, World!");
} catch (IOException e) {
System.out.println("An error occurred: " + e.getMessage());
}
}
}
字符串输入输出
使用 BufferedReader 和 BufferedWriter 进行字符串的读取和写入。
import java.io.*;
public class StringIO {
public static void main(String[] args) {
try (BufferedReader reader = new BufferedReader(new FileReader("input.txt"));
BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"))) {
String line;
while ((line = reader.readLine()) != null) {
System.out.println("Read: " + line);
writer.write(line);
writer.newLine();
}
} catch (IOException e) {
System.out.println("An error occurred: " + e.getMessage());
}
}
}
文件路径操作
使用 File 类来处理文件路径。
import java.io.File;
public class PathOperations {
public static void main(String[] args) {
File file = new File("example.txt");
System.out.println("File path: " + file.getAbsolutePath());
System.out.println("File exists: " + file.exists());
System.out.println("Directory exists: " + file.isDirectory());
System.out.println("File is a file: " + file.isFile());
}
}
多线程
线程创建与启动
创建线程有两种方式：继承 Thread 类或实现 Runnable 接口。
public class ThreadCreation {
public static void main(String[] args) {
Thread thread = new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 5; i++) {
System.out.println("Thread running: " + i);
}
}
});
thread.start();
}
}
线程同步与等待通知
使用 synchronized 关键字保证线程安全，并配合 wait() 和 notify() 方法实现同步。
public class ThreadSynchronization {
private static Object lock = new Object();
public static class ThreadA extends Thread {
@Override
public void run() {
synchronized (lock) {
for (int i = 0; i < 5; i++) {
System.out.println("Thread A: " + i);
lock.notify();
lock.wait();
}
}
}
}
public static class ThreadB extends Thread {
@Override
public void run() {
synchronized (lock) {
lock.wait();
lock.notify();
for (int i = 0; i < 5; i++) {
System.out.println("Thread B: " + i);
}
}
}
}
public static void main(String[] args) {
ThreadA threadA = new ThreadA();
ThreadB threadB = new ThreadB();
threadA.start();
threadB.start();
}
}
自定义线程池
使用 ExecutorService 和 ThreadPoolExecutor 来创建和管理线程池。
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class CustomThreadPool {
public static void main(String[] args) {
ExecutorService executor = Executors.newFixedThreadPool(5);
for (int i = 0; i < 10; i++) {
executor.submit(() -> {
System.out.println("Thread ID: " + Thread.currentThread().getId());
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
});
}
executor.shutdown();
}
}
并发集合和原子类使用
并发集合如 ConcurrentHashMap，原子类如 AtomicInteger 用于提高性能和简化多线程编程。
public class ConcurrentUsage {
public static void main(String[] args) {
ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
map.put("A", 1);
map.put("B", 2);
AtomicInteger count = new AtomicInteger(0);
count.incrementAndGet(); // 原子操作
Thread thread1 = new Thread(() -> {
map.put("C", 3);
});
Thread thread2 = new Thread(() -> {
count.incrementAndGet();
});
thread1.start();
thread2.start();
try {
thread1.join();
thread2.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Map: " + map);
System.out.println("Count: " + count.get());
}
}
通过这些示例代码，学习者可以逐步理解并实践 JAVA 的各种基础和高级特性，为后续更深入的学习打下坚实的基础。
这篇关于JAVA主流技术学习：从入门到提升的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！
您可能喜欢
-
基于Java+Springboot+Vue开发的体育用品商城管理系统09-16
-
基于Java+Springboot+Vue开发的口腔牙科诊所预约管理系统09-16
-
如何基于Java解析国密数字证书09-16
-
Spring Boot项目开发教程：快速入门与实战指南09-15
-
单点登录实战：入门级指南与实操详解09-15
-
登录校验实战：从零构建安全登录系统09-15
-
Java知识库系统学习：从零开始的编程之旅09-15
-
JAVA知识库系统学习：从零基础到入门的全面指南09-15
-
Java主流技术学习：从入门到进阶的实用指南09-15
-
Java主流技术学习：从入门到上手的实践指南09-15
-
实战编程技巧：从基础概念到实际应用09-15
-
掌握JAVA主流框架学习：从入门到实践09-15
-
Java主流框架学习：从基础到实战09-15
-
Nginx发布实战：入门级部署与优化攻略09-15
-
Spring Boot项目实战：从零开始构建高效RESTful服务09-15
栏目导航
