首页手记 Java主流技术学习：从入门到初级应用指南

Java主流技术学习：从入门到初级应用指南

标签：

Java SpringBoot Spring

概述

本文介绍了Java主流技术学习的入门指南，涵盖了环境搭建、基础语法、面向对象编程以及常用库和框架等内容。文章详细讲解了如何安装Java开发环境，并提供了示例代码帮助理解变量、数据类型、流程控制语句等基础知识。此外，还介绍了类与对象的概念、常见设计模式以及Java集合框架的使用方法。

Java主流技术学习：从入门到初级应用指南

Java简介与环境搭建

Java语言简介

Java是一种广泛使用的面向对象的编程语言，由Sun Microsystems公司（现已被Oracle收购）开发。Java语言最初设计时的目标是“编写一次，到处运行”（Write Once, Run Anywhere），这使它成为了跨平台开发的理想选择。Java虚拟机（JVM）确保了Java程序能够在任何支持JVM的平台上运行，这大大提高了开发效率和代码的可移植性。

Java语言的特点包括：

简单易学：Java语言语法简洁，学习成本相对较低。
面向对象：支持封装、继承、多态等面向对象的基本特性。
平台无关性：Java程序能在任何安装了Java虚拟机的平台上运行。
自动内存管理：Java自动进行内存分配和垃圾回收，降低了编程错误的可能性。
丰富的库：Java提供了大量的标准库，包括网络、数据库、图形界面等，方便开发人员使用。

开发环境安装与配置

安装Java开发环境需要以下几个步骤：

下载Java开发工具包（JDK）：访问JDK官方网站下载适用于你的操作系统的JDK。
安装JDK：根据下载文件的安装向导进行安装。
配置环境变量：安装完成后，需要配置环境变量，确保系统的PATH环境变量中包含JDK的bin目录。
验证安装：打开命令行工具，输入java -version，如果能正确显示Java版本信息，说明安装成功。

# Bash脚本示例
# 下载JDK
wget https://example.com/jdk-17_linux-x64_bin.tar.gz
# 解压JDK
tar -xzf jdk-17_linux-x64_bin.tar.gz
# 设置环境变量
export JAVA_HOME=/path/to/jdk
export PATH=$JAVA_HOME/bin:$PATH

第一个Java程序示例

下面是一个简单的Java程序示例，它将输出“Hello, World!”：

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

创建一个名为HelloWorld.java的文件，并将上面的代码写入文件。
使用Java编译器编译程序：打开命令行工具，执行javac HelloWorld.java，生成一个名为HelloWorld.class的文件。
运行程序：在命令行工具中，输入java HelloWorld，可以看到输出结果为Hello, World!。

Java基础语法

变量与数据类型

在Java中，变量用于存储数据。变量必须先声明其类型，然后才能使用。Java的数据类型分为两类：基本类型（Primitive Types）和引用类型（Reference Types）。

基本类型

基本类型包括整型、浮点型、字符型和布尔型。下面是几种常见的基本类型及其对应的包装类：

int：整型，范围从-2147483648到2147483647。
float：单精度浮点型。
double：双精度浮点型。
char：字符型，用于存储单个字符。
boolean：布尔型，取值为true或false。

示例代码：

public class DataTypes {
    public static void main(String[] args) {
        int number = 10;
        float floatNumber = 10.5f;
        double doubleNumber = 10.5;
        char character = 'A';
        boolean flag = true;

        System.out.println(number);
        System.out.println(floatNumber);
        System.out.println(doubleNumber);
        System.out.println(character);
        System.out.println(flag);
    }
}

引用类型

引用类型包括类、接口、数组等。引用类型的变量存储的是对象的引用（地址），而不是对象本身。引用类型的变量可以指向null。

示例代码：

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

        int[] array = new int[5];
        array[0] = 1;
        array[1] = 2;
        array[2] = 3;
        array[3] = 4;
        array[4] = 5;
        System.out.println(array[0]);
        System.out.println(array[1]);
        System.out.println(array[2]);
        System.out.println(array[3]);
        System.out.println(array[4]);
    }
}

流程控制语句

Java中提供了多种流程控制语句，包括条件语句（如if和switch）、循环语句（如for和while）以及跳转语句（如break和continue）。

条件语句

条件语句用于根据指定的条件执行不同的代码块。if语句是最基本的条件语句，而switch语句则用于基于不同选项执行不同的代码块。

示例代码：

public class ConditionalStatements {
    public static void main(String[] args) {
        int number = 10;

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

        String day = "Monday";
        switch (day) {
            case "Monday":
                System.out.println("It's Monday.");
                break;
            case "Tuesday":
                System.out.println("It's Tuesday.");
                break;
            default:
                System.out.println("It's some other day.");
        }
    }
}

循环语句

循环语句允许代码块重复执行直到满足一定的条件。Java支持for、while和do-while循环。

示例代码：

public class LoopStatements {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            System.out.println("Iteration " + i);
        }

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

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

数组与字符串操作

数组

数组是一种数据结构，用于存储相同类型的多个值。Java中的数组可以是基本类型或对象类型的数组。

示例代码：

public class Arrays {
    public static void main(String[] args) {
        // 基本类型数组
        int[] intArray = new int[5];
        intArray[0] = 1;
        intArray[1] = 2;
        intArray[2] = 3;
        intArray[3] = 4;
        intArray[4] = 5;

        for (int i = 0; i < intArray.length; i++) {
            System.out.println(intArray[i]);
        }

        // 对象类型数组
        String[] stringArray = new String[4];
        stringArray[0] = "Apple";
        stringArray[1] = "Banana";
        stringArray[2] = "Cherry";
        stringArray[3] = "Date";

        for (String str : stringArray) {
            System.out.println(str);
        }
    }
}

字符串操作

字符串在Java中使用String类表示。String类提供了许多方法来操作字符串，如拼接、分割、替换等。

示例代码：

public class StringOperations {
    public static void main(String[] args) {
        String str = "Hello, World!";

        // 拼接字符串
        String newStr = str + " Welcome!";
        System.out.println(newStr);

        // 分割字符串
        String[] result = newStr.split(",");
        for (String s : result) {
            System.out.println(s);
        }

        // 替换字符串
        String replacedStr = newStr.replace("!", "?");
        System.out.println(replacedStr);

        // 获取子串
        String subStr = newStr.substring(12);
        System.out.println(subStr);
    }
}

类与对象

类的定义与使用

类是面向对象编程的基础，它定义了一组相关的属性和方法。类的定义包括字段（变量）和方法（函数）。

示例代码：

public class Student {
    // 类的字段
    String name;
    int age;

    // 类的方法
    public void displayInfo() {
        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
    }
}

对象的创建与方法调用

对象是类的一个实例。创建对象时需要指定类名以及构造函数。

示例代码：

public class ObjectCreation {
    public static void main(String[] args) {
        // 创建Student对象
        Student student = new Student();
        student.name = "John Doe";
        student.age = 20;

        // 调用对象的方法
        student.displayInfo();
    }
}

封装、继承与多态

封装

封装是指将数据（属性）和操作数据的函数（方法）结合在一起，对外界隐藏内部实现细节。通过定义公共接口，提供对数据的操作方法，从而保护数据的安全性。

示例代码：

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

    // Getter方法
    public String getName() {
        return name;
    }

    // Setter方法
    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age > 0) {
            this.age = age;
        } else {
            System.out.println("Age cannot be negative.");
        }
    }
}

继承

继承允许一个类继承另一个类的属性和方法。被继承的类称为基类或父类，继承的类称为派生类或子类。

示例代码：

public class BaseClass {
    public void baseMethod() {
        System.out.println("Base method is called.");
    }
}

public class DerivedClass extends BaseClass {
    public void derivedMethod() {
        System.out.println("Derived method is called.");
    }
}

多态

多态是指允许将对象作为其父类类型来使用。多态性通过方法重写和方法重载实现。

示例代码：

public class Polymorphism {
    public static void main(String[] args) {
        BaseClass base = new BaseClass();
        DerivedClass derived = new DerivedClass();

        // 方法重写：同名方法在子类中重新定义
        base.baseMethod(); // 输出：Base method is called.
        derived.baseMethod(); // 输出：Base method is called.
        derived.derivedMethod(); // 输出：Derived method is called.

        // 方法重载：同一类中同名不同参数的方法
        staticMethod(10); // 调用 int 类型的静态方法
        staticMethod("Hello"); // 调用 String 类型的静态方法
    }

    public static void staticMethod(int num) {
        System.out.println("Method with int parameter: " + num);
    }

    public static void staticMethod(String str) {
        System.out.println("Method with String parameter: " + str);
    }
}

面向对象编程进阶

抽象类与接口

抽象类

抽象类是一种不能被实例化的类，它主要用于被其他类继承。抽象类可以包含抽象方法（没有实现的方法）和非抽象方法（有实现的方法）。

示例代码：

public abstract class AbstractClass {
    public void nonAbstractMethod() {
        System.out.println("Non-abstract method.");
    }

    public abstract void abstractMethod();
}

接口

接口是一种完全抽象的类，它只能包含抽象方法。接口提供了一种实现多继承的方式，一个类可以实现多个接口。

示例代码：

public interface InterfaceExample {
    void interfaceMethod();
}

public class InterfaceImplementation implements InterfaceExample {
    public void interfaceMethod() {
        System.out.println("Interface method is called.");
    }
}

构造器与静态成员

构造器

构造器是用于初始化新对象的方法。构造器的名称必须和类名相同，没有返回值类型，可以有参数。

示例代码：

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

    public ConstructorExample(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void displayInfo() {
        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
    }

    public static void main(String[] args) {
        ConstructorExample example = new ConstructorExample("John Doe", 20);
        example.displayInfo();
    }
}

静态成员

静态成员属于类，而不属于任何特定的对象实例。静态成员包括静态变量和静态方法。

示例代码：

public class StaticMembers {
    static int staticVar = 10;

    public static void staticMethod() {
        System.out.println("Static method is called.");
    }

    public void nonStaticMethod() {
        System.out.println("Static variable: " + staticVar);
    }

    public static void main(String[] args) {
        StaticMembers.staticMethod(); // 调用静态方法
        StaticMembers nonStatic = new StaticMembers();
        nonStatic.nonStaticMethod(); // 调用非静态方法
    }
}

常见设计模式简介

单例模式

单例模式确保一个类只有一个实例，并提供一个全局访问点。单例模式可以用于需要全局访问的资源管理器或配置类。

示例代码：

public class Singleton {
    private static Singleton instance;

    private Singleton() {}

    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }

    public void singletonMethod() {
        System.out.println("Singleton method is called.");
    }

    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();
        singleton.singletonMethod();
    }
}

工厂模式

工厂模式用于创建对象时提供一个创建对象的接口，但允许子类决定实例化哪一个类。工厂模式分为简单工厂模式和工厂方法模式。

示例代码：

public interface Shape {
    void draw();
}

public class Circle implements Shape {
    public void draw() {
        System.out.println("Drawing a Circle.");
    }
}

public class Square implements Shape {
    public void draw() {
        System.out.println("Drawing a Square.");
    }
}

public class ShapeFactory {
    public static Shape getShape(String shapeType) {
        if (shapeType == null) {
            return null;
        }
        if (shapeType.equalsIgnoreCase("CIRCLE")) {
            return new Circle();
        } else if (shapeType.equalsIgnoreCase("SQUARE")) {
            return new Square();
        }
        return null;
    }
}

public class FactoryPattern {
    public static void main(String[] args) {
        Shape circle = ShapeFactory.getShape("CIRCLE");
        circle.draw();

        Shape square = ShapeFactory.getShape("SQUARE");
        square.draw();
    }
}

观察者模式

观察者模式定义了对象之间的依赖关系，当一个对象状态改变时，所有依赖于它的对象都会得到通知并被自动更新。

示例代码：

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

public interface Observer {
    void update(int state);
}

public class Subject {
    private List<Observer> observers;
    private int state;

    public Subject() {
        this.observers = new ArrayList<>();
    }

    public void registerObserver(Observer observer) {
        this.observers.add(observer);
    }

    public void removeObserver(Observer observer) {
        this.observers.remove(observer);
    }

    public void notifyObservers() {
        for (Observer observer : this.observers) {
            observer.update(this.state);
        }
    }

    public int getState() {
        return state;
    }

    public void setState(int state) {
        this.state = state;
        notifyObservers();
    }
}

public class ConcreteObserver1 implements Observer {
    public void update(int state) {
        System.out.println("Observer 1 received state: " + state);
    }
}

public class ConcreteObserver2 implements Observer {
    public void update(int state) {
        System.out.println("Observer 2 received state: " + state);
    }
}

public class ObserverPattern {
    public static void main(String[] args) {
        Subject subject = new Subject();
        ConcreteObserver1 observer1 = new ConcreteObserver1();
        ConcreteObserver2 observer2 = new ConcreteObserver2();

        subject.registerObserver(observer1);
        subject.registerObserver(observer2);

        subject.setState(10);
        subject.setState(20);
    }
}

常用Java库与框架入门

Java集合框架

Java集合框架提供了许多接口（如List、Set、Map）和实现类（如ArrayList、HashMap）来处理一组对象。集合框架简化了常见的操作（如添加、删除、遍历等）。

常用接口与实现类

List：有序集合，允许元素重复，可以通过索引访问。
Set：不允许元素重复的集合。
Map：键值对映射，键唯一。

示例代码：

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.HashMap;
import java.util.Set;

public class CollectionFramework {
    public static void main(String[] args) {
        // 使用 ArrayList
        List<String> list = new ArrayList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Cherry");
        list.add("Date");

        for (String fruit : list) {
            System.out.println(fruit);
        }

        // 使用 HashSet
        Set<String> set = new HashSet<>();
        set.add("Apple");
        set.add("Banana");
        set.add("Cherry");
        set.add("Date");

        for (String fruit : set) {
            System.out.println(fruit);
        }

        // 使用 HashMap
        Map<String, String> map = new HashMap<>();
        map.put("Apple", "Red");
        map.put("Banana", "Yellow");
        map.put("Cherry", "Red");
        map.put("Date", "Brown");

        for (Map.Entry<String, String> entry : map.entrySet()) {
            System.out.println(entry.getKey() + " : " + entry.getValue());
        }
    }
}

IO流与文件操作

Java IO提供了一套用于处理输入输出流的API，包括文件读写、网络通信等。常用的IO类包括FileInputStream、FileOutputStream、BufferedReader、BufferedWriter等。

示例代码：

import java.io.*;

public class FileOperations {
    public static void main(String[] args) {
        // 写入文件
        try {
            FileOutputStream fos = new FileOutputStream("output.txt");
            String content = "Hello, World!";
            fos.write(content.getBytes());
            fos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 读取文件
        try {
            FileInputStream fis = new FileInputStream("output.txt");
            int content;
            while ((content = fis.read()) != -1) {
                System.out.print((char) content);
            }
            fis.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 使用 BufferedReader 和 BufferedWriter
        try {
            BufferedReader reader = new BufferedReader(new FileReader("output.txt"));
            BufferedWriter writer = new BufferedWriter(new FileWriter("output2.txt"));

            String line;
            while ((line = reader.readLine()) != null) {
                writer.write(line);
                writer.newLine();
            }

            reader.close();
            writer.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

简单网络编程

Java提供了Socket和ServerSocket类来实现基本的网络通信。客户端和服务器之间通过Socket连接进行数据传输。

示例代码：

import java.io.*;
import java.net.*;

public class SimpleNetworking {
    public static void main(String[] args) {
        // 启动服务器端
        new Thread(() -> {
            try {
                ServerSocket serverSocket = new ServerSocket(9999);
                Socket socket = serverSocket.accept();
                BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                String input = in.readLine();
                System.out.println("Received: " + input);
                in.close();
                socket.close();
                serverSocket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }).start();

        // 启动客户端
        try {
            Socket socket = new Socket("localhost", 9999);
            OutputStream out = socket.getOutputStream();
            PrintWriter writer = new PrintWriter(out, true);
            writer.println("Hello, Server!");
            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

通过以上内容的学习，你已经掌握了Java编程的基础知识和一些常见的设计模式。熟悉这些基本概念和技巧后，你可以继续深入学习更高级的Java编程技术和框架，如Spring框架、Hibernate等，进一步提升自己的编程能力。如果你需要更多练习和进一步的学习资源，可以考虑访问慕课网（https://www.imooc.com/），那里有许多优质的教程和课程。

点击查看更多内容

为 TA 点赞

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

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

动漫人物

手记
篇

粉丝

18

获赞与收藏

71

关注作者，订阅最新文章

阅读免费教程

Java并发工具

23个小节 19367 315

Java 并发原理入门教程

26个小节 39106 568

Java 入门教程

50个小节 342495 3164

推荐

评论

收藏

共同学习，写下你的评论



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

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

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

支付方式

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

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

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

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

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

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

作者：

免费赠送

兑换码：1111222211 复制

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

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

热搜

最近搜索清空

Java主流技术学习：从入门到初级应用指南

Java语言简介

开发环境安装与配置

第一个Java程序示例

变量与数据类型

基本类型

引用类型

流程控制语句

条件语句

循环语句

数组与字符串操作

数组

字符串操作

类的定义与使用

对象的创建与方法调用

封装、继承与多态

封装

继承

多态

抽象类与接口

抽象类

接口

构造器与静态成员

构造器

静态成员

单例模式

工厂模式

观察者模式

Java集合框架

常用接口与实现类

IO流与文件操作

简单网络编程

阅读免费教程