首页手记 Java主流技术入门教程

Java主流技术入门教程

标签：

Java SSM

概述

本文详细介绍了Java开发环境搭建、基础语法、面向对象编程、常用数据结构与算法、异常处理与多线程以及Java主流技术入门等知识点，帮助初学者快速掌握Java编程的核心技能。从开发工具的选择、JDK的安装与配置到编写第一个Java程序，文章提供了丰富的指导与示例代码。此外，还涵盖了Spring框架和MyBatis的基础使用方法，使得读者能够进一步了解Java企业级应用开发。

Java开发环境搭建

Java开发工具选择

在开发Java应用程序时，选择合适的开发工具是非常重要的。常见的Java开发工具包括Eclipse、IntelliJ IDEA、NetBeans等。对于初学者而言，Eclipse和IntelliJ IDEA是比较推荐的选择，它们都提供了丰富的功能，如智能代码补全、调试工具等，能够帮助开发者提高开发效率。

Eclipse: Eclipse是开源且免费的开发环境，适合各种规模的项目。它提供了一个丰富的插件生态系统，可以扩展其功能以适应不同的需求。
IntelliJ IDEA: IntelliJ IDEA有两种版本，Community版本是免费的，Ultimate版本是付费的，但提供了更多的高级功能。它特别擅长于Java开发，并且也有强大的代码分析和重构工具。

JDK安装与配置

Java开发工具包（JDK，Java Development Kit）是Java开发所必需的。JDK中包含了Java编译器（javac）、Java运行时环境（JRE，Java Runtime Environment）和其他开发工具，如JavaDoc、Java Platform Debugger Architecture等。以下是安装JDK的步骤：

访问Oracle官网或开源中国的JDK下载页面，选择适合的操作系统版本进行下载。
下载后，运行安装程序，按照提示完成安装。默认的安装路径通常是C:\Program Files\Java\jdk-<版本号>。
为了确保JDK能够被系统识别，你需要配置环境变量。右键点击“此电脑”或“计算机”，选择“属性”，然后点击“高级系统设置”。在“系统属性”窗口中，点击“环境变量”。
在“系统变量”中，找到名为Path的变量，并编辑它的值。将JDK的安装路径添加到变量值中。例如，C:\Program Files\Java\jdk-11\bin。
验证JDK是否安装成功。打开命令行窗口，输入java -version和javac -version命令，如果输出版本信息，说明安装成功。

编写第一个Java程序

下面是一个简单的Java程序，它打印“Hello, World!”。

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

创建一个新文件，命名为HelloWorld.java。
将上述代码复制到文件中。
打开命令行窗口，进入包含HelloWorld.java文件的目录。
使用Java编译器编译程序。执行命令：
```
javac HelloWorld.java
```
编译成功后，会在相同目录下生成一个名为HelloWorld.class的字节码文件。
运行编译后的程序。执行命令：
```
java HelloWorld
```
运行结果将显示“Hello, World!”。

Java基础语法

数据类型与变量

在Java中，数据类型分为两大类：基本数据类型（Primitive Types）和引用数据类型（Reference Types）。基本数据类型包括整型、浮点型、字符型和布尔型，而引用数据类型则包括数组、类和接口等。

整型：
- byte: 8位有符号整数，取值范围为-128到127。
- short: 16位有符号整数，取值范围为-32768到32767。
- int: 32位有符号整数，取值范围为-2147483648到2147483647。
- long: 64位有符号整数，取值范围为-9223372036854775808到9223372036854775807。
浮点型：
- float: 32位单精度浮点数。
- double: 64位双精度浮点数。
字符型：
- char: 单个字符，存储在16位中，使用Unicode编码。
布尔型：
- boolean: 表示真或假，取值为true或false。

示例代码：

public class DataTypesExample {
    public static void main(String[] args) {
        byte byteValue = 100;
        short shortValue = 1000;
        int intValue = 10000;
        long longValue = 100000L;
        float floatValue = 123.45f;
        double doubleValue = 123.456789;
        char charValue = 'A';
        boolean booleanValue = true;

        System.out.println("byte: " + byteValue);
        System.out.println("short: " + shortValue);
        System.out.println("int: " + intValue);
        System.out.println("long: " + longValue);
        System.out.println("float: " + floatValue);
        System.out.println("double: " + doubleValue);
        System.out.println("char: " + charValue);
        System.out.println("boolean: " + booleanValue);
    }
}

运算符

Java 中的运算符包括算术运算符、关系运算符、逻辑运算符、位运算符等。

算术运算符：+、-、*、/、%
关系运算符：==、!=、>、<、>=、<=
逻辑运算符：&&、||、!
位运算符：&、|、^、~、<<、>>

示例代码：

public class OperatorsExample {
    public static void main(String[] args) {
        int a = 10, b = 20;

        System.out.println("a + b: " + (a + b));
        System.out.println("a - b: " + (a - b));
        System.out.println("a * b: " + (a * b));
        System.out.println("a / b: " + (a / b));
        System.out.println("a % b: " + (a % b));

        System.out.println("a == b: " + (a == b));
        System.out.println("a != b: " + (a != b));
        System.out.println("a > b: " + (a > b));
        System.out.println("a < b: " + (a < b));
        System.out.println("a >= b: " + (a >= b));
        System.out.println("a <= b: " + (a <= b));

        boolean x = true, y = false;

        System.out.println("x && y: " + (x && y));
        System.out.println("x || y: " + (x || y));
        System.out.println("!x: " + (!x));

        int c = 3, d = 4;

        System.out.println("c & d: " + (c & d));
        System.out.println("c | d: " + (c | d));
        System.out.println("c ^ d: " + (c ^ d));
        System.out.println("~c: " + (~c));
        System.out.println("c << 1: " + (c << 1));
        System.out.println("c >> 1: " + (c >> 1));
    }
}

流程控制语句

Java 中的流程控制语句主要有条件语句（if-else）、循环语句（for、while、do-while）和跳转语句（break、continue、return）。

条件语句：
- if：根据条件判断执行代码块。
- else：如果条件不成立，则执行else后的代码块。
- else if：用于多个条件判断。
循环语句：
- for：用于已知循环次数的循环。
- while：用于不确定循环次数的循环。
- do-while：先执行一次循环代码块，再判断循环条件，用于保证至少执行一次循环。
跳转语句：
- break：跳出循环或switch语句。
- continue：跳过当前循环的剩余语句，继续进行下一次循环。
- return：返回方法的结果，结束方法的执行。

示例代码：

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

        if (number > 5) {
            System.out.println("Number is greater than 5");
        } else {
            System.out.println("Number is not greater than 5");
        }

        int counter = 0;
        while (counter < 5) {
            System.out.println("Counter: " + counter);
            counter++;
        }

        for (int i = 0; i < 5; i++) {
            System.out.println("For loop: " + i);
        }

        int loopCount = 0;
        do {
            System.out.println("Do-while loop: " + loopCount);
            loopCount++;
        } while (loopCount < 3);

        for (int j = 0; j < 5; j++) {
            if (j == 3) {
                break;
            }
            System.out.println("Break example: " + j);
        }

        for (int k = 0; k < 5; k++) {
            if (k == 3) {
                continue;
            }
            System.out.println("Continue example: " + k);
        }

        String result = "Done";
        returnResult(result);
    }

    public static void returnResult(String result) {
        System.out.println("Return example: " + result);
    }
}

面向对象编程

类与对象

面向对象编程（Object-Oriented Programming，OOP）是Java编程的核心特性。在面向对象编程中，一切皆对象，对象是类的实例。类是用来定义对象结构和行为的模板，它包含了数据（成员变量）和方法（成员方法）。

类定义：
- 使用class关键字来定义一个类。
- 在类中可以定义成员变量（字段）和成员方法（函数）。
对象实例化：
- 使用new关键字来创建一个对象实例。

示例代码：

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 static void main(String[] args) {
        Person person = new Person("Alice", 25);
        person.introduce();
    }
}

继承与多态

继承是面向对象编程中的一个关键特性，它允许一个类（称为子类或派生类）继承另一个类（称为父类或基类）的属性和方法。多态则是指同一个方法在不同的对象中有不同的表现形式。

继承：
- 使用extends关键字来实现继承。
- 子类可以覆盖父类的成员方法，并且可以访问父类的成员变量和方法。
多态：
- 支持方法重载（Overloading）和方法重写（Overriding）。
- 方法重写指的是子类重写父类的方法，实现不同的功能。
- 方法重载指的是在一个类中重载同一个方法名，但形参不同。

示例代码：

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

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

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

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

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

        Animal cat = new Cat();
        cat.sound();  // 输出 "Cat meows"

        voice(animal);
        voice(dog);
        voice(cat);
    }

    public static void voice(Animal animal) {
        animal.sound();
    }
}

封装与抽象

封装是面向对象编程中的核心概念之一，通过封装，可以将数据和操作数据的方法封装在一起，隐藏内部实现细节，只暴露必要的接口。抽象则是封装的一个高级形式，用于定义类或接口的通用行为。

封装：
- 通过访问修饰符（public、private、protected）控制成员变量的访问。
- 使用getter和setter方法来访问和修改成员变量。
抽象：
- 使用abstract关键字定义抽象类或抽象方法。
- 抽象类只能被继承，不能实例化。
- 抽象方法只提供方法签名，具体实现由子类提供。

示例代码：

public class EncapsulatedData {
    private int data;

    public int getData() {
        return data;
    }

    public void setData(int data) {
        this.data = data;
    }
}

public abstract class AbstractExample {
    public abstract void abstractMethod();

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

public class ConcreteClass extends AbstractExample {
    @Override
    public void abstractMethod() {
        System.out.println("Abstract method implemented");
    }
}

public class Main {
    public static void main(String[] args) {
        EncapsulatedData data = new EncapsulatedData();
        data.setData(10);
        System.out.println(data.getData());

        ConcreteClass concrete = new ConcreteClass();
        concrete.nonAbstractMethod();
        concrete.abstractMethod();
    }
}

常用数据结构与算法

数组与集合

Java提供了多种数据结构，如数组、ArrayList、LinkedList等，来存储和操作数据。其中，数组和集合是较为常用的数据结构。

数组：
- 固定长度，通过索引访问元素。
- 具有较快的随机访问速度。
- 声明和初始化如下：
```
int[] numbers = new int[5];
numbers[0] = 1;
numbers[1] = 2;
// 或者
int[] numbers = {1, 2, 3, 4, 5};
```
集合：
- 集合是动态数组，可以自动调整大小。
- 常用的集合类包括ArrayList、LinkedList、HashSet、HashMap等。
- 示例代码：
```
List<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
list.add("Cherry");
```
Set<String> set = new HashSet<>();
set.add("Dog");
set.add("Cat");
set.add("Mouse");

Map<String, String> map = new HashMap<>();
map.put("Key1", "Value1");
map.put("Key2", "Value2");

常见排序算法

常见的排序算法包括冒泡排序、选择排序、插入排序、快速排序等。

冒泡排序：

通过不断交换相邻元素位置，使较小的元素逐渐上升到数组前端。

示例代码：

public static void bubbleSort(int[] arr) {
int n = arr.length;
for (int i = 0; i < n-1; i++) {
    for (int j = 0; j < n-i-1; j++) {
        if (arr[j] > arr[j+1]) {
            int temp = arr[j];
            arr[j] = arr[j+1];
            arr[j+1] = temp;
        }
    }
}
}

选择排序：

从数组中找到最小（或最大）的元素，将其放到数组的最前面。

示例代码：

public static void selectionSort(int[] arr) {
int n = arr.length;
for (int i = 0; i < n-1; i++) {
    int minIndex = i;
    for (int j = i+1; j < n; j++) {
        if (arr[j] < arr[minIndex]) {
            minIndex = j;
        }
    }
    int temp = arr[i];
    arr[i] = arr[minIndex];
    arr[minIndex] = temp;
}
}

基本查找算法

常见的查找算法包括顺序查找、二分查找等。

顺序查找：

从数组开始位置逐一比较，直到找到目标元素或遍历结束。

示例代码：

public static int sequentialSearch(int[] arr, int target) {
for (int i = 0; i < arr.length; i++) {
    if (arr[i] == target) {
        return i;
    }
}
return -1;
}

二分查找：

适用于有序数组，通过不断缩小查找范围，逐步逼近目标元素。

示例代码：

public static int binarySearch(int[] arr, int target) {
int left = 0;
int right = arr.length - 1;
while (left <= right) {
    int mid = left + (right - left) / 2;
    if (arr[mid] == target) {
        return mid;
    } else if (arr[mid] < target) {
        left = mid + 1;
    } else {
        right = mid - 1;
    }
}
return -1;
}

异常处理与多线程

异常处理机制

异常处理机制是Java中用于处理程序运行时错误的重要机制。Java使用try-catch语句来捕获和处理异常。同时，使用finally和throw语句来控制异常的传递和处理。

try-catch：

将可能抛出异常的代码放在try块中，捕获异常的代码放在catch块中。

示例代码：

try {
int result = 10 / 0;
} catch (ArithmeticException e) {
System.out.println("Arithmetic exception caught: " + e.getMessage());
}

finally：

无论是否发生异常，都会执行finally块中的代码。

示例代码：

public static void main(String[] args) {
try {
    int result = 10 / 0;
} catch (ArithmeticException e) {
    System.out.println("Arithmetic exception caught: " + e.getMessage());
} finally {
    System.out.println("Finally block executed.");
}
}

throw：

用于手动抛出异常。

示例代码：

public static void main(String[] args) {
throw new RuntimeException("Something went wrong.");
}

多线程基础

Java中的多线程是通过Thread类或Runnable接口来实现的。多线程可以提高程序的执行效率和响应速度。

Thread类：

继承Thread类，重写run方法，并调用start方法启动线程。

示例代码：

public class MyThread extends Thread {
@Override
public void run() {
    System.out.println("Thread is running.");
}

public static void main(String[] args) {
    MyThread thread = new MyThread();
    thread.start();
}
}

Runnable接口：

实现Runnable接口，重写run方法，创建Thread对象并调用start方法启动线程。

示例代码：

public class MyRunnable implements Runnable {
@Override
public void run() {
    System.out.println("Runnable is running.");
}

public static void main(String[] args) {
    MyRunnable runnable = new MyRunnable();
    Thread thread = new Thread(runnable);
    thread.start();
}
}

线程同步与死锁

线程同步是指多个线程之间需要协作执行任务，而死锁则是当多个线程互相等待对方释放资源时发生的情况。

线程同步：

使用synchronized关键字来实现线程同步。

示例代码：

public class SynchronizedExample {
synchronized void printA() {
    System.out.println("Print A");
}

synchronized void printB() {
    System.out.println("Print B");
}

public static void main(String[] args) {
    SynchronizedExample example = new SynchronizedExample();
    Thread threadA = new Thread(() -> example.printA());
    Thread threadB = new Thread(() -> example.printB());
    threadA.start();
    threadB.start();
}
}

死锁：

死锁通常发生在多个线程互相等待对方释放资源时。

示例代码：

public class DeadlockExample {
static class Friend {
    private final String name;
    public Friend(String name) {
        this.name = name;
    }

    public String getName() {
        return this.name;
    }

    public synchronized Friend getFriend(Friend friend) {
        System.out.println(name + " is asking " + friend.getName() + " for a pen.");
        friend.borrowPen(this);
        return friend;
    }

    public synchronized void borrowPen(Friend friend) {
        System.out.println(name + " is borrowing a pen from " + friend.getName());
    }

    public static void main(String[] args) throws InterruptedException {
        Friend john = new Friend("John");
        Friend jack = new Friend("Jack");

        Thread thread1 = new Thread(() -> john.getFriend(jack));
        Thread thread2 = new Thread(() -> jack.getFriend(john));

        thread1.start();
        thread2.start();

        thread1.join();
        thread2.join();
    }
}
}

Java常用框架入门

Spring框架简介

Spring是一个非常流行的Java企业级应用开发框架，它的主要优势在于提供了一整套完整的解决方案，使开发者能够更轻松地构建企业级应用。它主要分为几个模块，包括核心容器、数据访问、MVC框架等。

核心容器：提供了依赖注入（DI）和控制反转（IoC）功能，简化了组件间的耦合。
数据访问：提供了JDBC、JPA等模块，用于简化数据库操作。
MVC框架：提供了一个Web框架，实现了MVC架构模式，使Web应用开发更加简洁。

示例代码：

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringExample {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
        HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
        obj.getMessage();
    }
}

Spring Boot快速上手

Spring Boot旨在简化Spring框架的配置，使开发者能够更快地开发、测试和部署应用。它通过约定优于配置（Conventions over Configuration）的理念，大大减少了配置文件的编写工作。

创建Spring Boot项目：
- 可以使用Spring Initializr或Spring Boot CLI工具来快速创建Spring Boot项目。
依赖管理：
- Spring Boot会自动管理所有依赖，只需在pom.xml或build.gradle文件中声明需要的依赖即可。
启动类：
- 使用@SpringBootApplication注解的类是Spring Boot应用的入口点，该注解将@Configuration、@EnableAutoConfiguration和@ComponentScan三个注解组合在一起。
配置文件：
- 使用application.properties或application.yml文件来配置应用的相关参数。

示例代码：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

MyBatis基础使用

MyBatis是一个持久层框架，用于简化数据库操作。它通过简单的XML或注解来配置映射，使开发者能够专注于SQL语句的编写，而不是复杂的数据库操作。

配置文件：
- MyBatis通过mybatis-config.xml或application.properties文件来配置数据库连接信息。
映射文件：
- 使用XML或注解来编写SQL映射，映射文件中定义了数据库表和Java对象之间的关系。

示例代码：

public class User {
    private int id;
    private String name;
    private String password;

    // Getters and Setters
}

public interface UserMapper {
    @Select("SELECT * FROM user WHERE id = #{id}")
    User getUserById(Integer id);
}

<!-- mybatis-config.xml -->
<configuration>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC" />
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver" />
                <property name="url" value="jdbc:mysql://localhost:3306/mydatabase" />
                <property name="username" value="root" />
                <property name="password" value="password" />
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="UserMapper.xml" />
    </mappers>
</configuration>

<!-- UserMapper.xml -->
<mapper namespace="com.example.mapper.UserMapper">
    <select id="getUserById" resultType="com.example.model.User">
        SELECT * FROM user WHERE id = #{id}
    </select>
</mapper>

通过这些示例代码，你可以快速上手Spring Boot和MyBatis的基本使用方法，并开始构建你的Java企业级应用。

点击查看更多内容

为 TA 点赞

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

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

守着一只汪

手记
篇

粉丝

11

获赞与收藏

37

关注作者，订阅最新文章

阅读免费教程

Java并发工具

23个小节 19367 315

Java 并发原理入门教程

26个小节 39106 568

Java 入门教程

50个小节 342495 3164

推荐

评论

收藏

共同学习，写下你的评论



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

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

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

支付方式

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

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

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

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

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

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

作者：

免费赠送

兑换码：1111222211 复制

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

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

热搜

最近搜索清空

Java主流技术入门教程

Java开发工具选择

JDK安装与配置

编写第一个Java程序

数据类型与变量

运算符

流程控制语句

类与对象

继承与多态

封装与抽象

数组与集合

常见排序算法

基本查找算法

异常处理机制

多线程基础

线程同步与死锁

Spring框架简介

Spring Boot快速上手

MyBatis基础使用

阅读免费教程