Java笔记_基础_线程

最新推荐文章于 2024-04-15 20:13:30 发布
最新推荐文章于 2024-04-15 20:13:30 发布
阅读量69 收藏
点赞数
分类专栏： java笔记 文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/YWXKSJHX/article/details/115800030
版权

文章目录

创建线程方法① 继承Thread

继承Thread 重写run()方法
调用启动: 创建对象.start:();

方法返回值说明
(static)sleep(int i)void睡眠 i 毫秒
(static)currentThread()void返回当前正在执行的线程,可直接 getName
getPriority()int获取优先值 返回int
getName()String获取对象名
setName(String str)void给当前线程对象起名
setPriority(int i)voidi:1~10 优先级值 越高表示CPU优先执行概率越高(概率!)
setDeomon()void将对象线程标记为附属线程,当没有非附属线程运行时,附属线程将自动结束
public class Demo {
    public static void main(String[] args) throws Exception {
        Demo1 d = new Demo1();
        d.start(); //开启新线程
        for (int i = 0; i < 3; i++) {
            System.out.println("主线程执行了");
            try {
                Thread.sleep(2000);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

class Demo1 extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("新线程执行了");
            try {
                Thread.sleep(1000);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

运行结果:

主线程执行了
新线程执行了
新线程执行了
主线程执行了
新线程执行了
新线程执行了
主线程执行了
新线程执行了

创建线程方法② 实现Runnable接口

实现Runnable接口 重写run()方法
调用启动: Thread对象有参构造 创建对象.start:();

public class Demo {
    public static void main(String[] args) throws Exception {
        Demo1 d = new Demo1();
        Thread t = new Thread(d);
        t.start(); //开启新线程
        for (int i = 0; i < 3; i++) {
            System.out.println("主线程执行了");
            try {
                Thread.sleep(2000);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

class Demo1 implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("新线程执行了");
            try {
                Thread.sleep(1000);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

Lambda表达式 与上方代码完全相同

public class Demo {
    public static void main(String[] args) throws Exception {
        Thread t = new Thread(() -> { //使用Lambda表达式匿名内部类 实现Runnable接口 重写run();
            for (int i = 0; i < 5; i++) {
                System.out.println("新线程执行了");
                try {
                    Thread.sleep(1000);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
        t.start(); //开启新线程
        for (int i = 0; i < 3; i++) {
            System.out.println("主线程执行了");
            try {
                Thread.sleep(2000);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

运行结果:

主线程执行了
新线程执行了
新线程执行了
主线程执行了
新线程执行了
新线程执行了
主线程执行了
新线程执行了

创建线程方法③ 实现Callable接口

可以获取线程返回值
实现Callable<返回值类型>接口 重写call()方法
调用启动: FutureTask<返回值类型>有参构造创建对象 Thread对象有参构造创建对象.start:();
FutureTask<返回值类型>对象.get(): 等待线程运行结束,返回运行结果

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

public class Demo {
    public static void main(String[] args) throws Exception {
        Demo1 d = new Demo1();
        FutureTask<String> f = new FutureTask<>(d); //泛型与参数的返回值类型一致
        Thread t = new Thread(f);
        t.start(); //开启新线程
        for (int i = 0; i < 3; i++) {
            System.out.println("主线程执行了");
            try {
                Thread.sleep(2000);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        String s = f.get();
        System.out.println("主线程: 新线程的返回值为" + s);
    }
}

class Demo1 implements Callable<String> {

    @Override
    public String call() throws Exception { //此处返回值为 Callable 的泛型
        for (int i = 0; i < 5; i++) {
            System.out.println("新线程执行了");
            try {
                Thread.sleep(1000);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return "Demo1";
    }
}

运行结果:

主线程执行了
新线程执行了
新线程执行了
主线程执行了
新线程执行了
新线程执行了
主线程执行了
新线程执行了
主线程: 新线程的返回值为Demo1

线程池

Executors

尽量避免使用此方法创建线程池

方法返回值说明
(static)newCachedThreadPool()构造方法创建一个默认线程池
(static)newFixedThreadPool(int i)构造方法创建一个有上限的线程池
submit(Runnable r)void开启线程,当线程池中有空线程将不再新建,使用空线程
shutdown()void关闭线程池
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Demo {
    public static void main(String[] args) throws Exception {
        ExecutorService es = Executors.newCachedThreadPool();
        System.out.println("主线程执行了");

        es.submit(() -> {
            System.out.println(Thread.currentThread().getName());
            
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        });
        es.submit(() -> System.out.println(Thread.currentThread().getName()));
        Thread.sleep(1000);
        es.submit(() -> System.out.println(Thread.currentThread().getName()));

        es.shutdown();
        System.out.println("主线程结束了");
    }
}

构造方法:

主线程执行了
pool-1-thread-1
pool-1-thread-2
pool-1-thread-2
主线程结束了

ThreadPoolExecutor

可以指定规则的线程池
用法同Executors

构造方法: ThreadPoolExecutor(核心线程数, 最大线程数, 空闲线程存活时间, 时间单位, 阻塞队列, 线程工厂, 拒绝策略)

参数类型说明
核心线程数int大于0
最大线程数int大于核心线程数
空闲线程存活时间int大于0
时间单位TimeUnitTimeUnit.SECONDS:秒 / DAYS天 / HOURS小时 / MINUTES分钟 / MILLISECONDS毫秒
阻塞队列ArrayBlockingQueuenew ArrayBlockingQueue<>(int i): 当核心线程满了将存至队列,当队列满了将创建新线程,当线程达到最大值时,将启动拒绝策略
线程工厂ExecutorsExecutors.defaultThreadFactory(): 创建默认线程
拒绝策略ThreadPoolExecutornew ThreadPoolExecutor.AbortPolicy(): 丢弃任务并抛出异常 / DiscardPolicy(): 丢弃任务(不推荐) / DiscardOldestPolicy(): 丢弃队列中等待最久的任务 / CallerRunsPolicy(): 绕过线程直接执行
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class Demo {
    public static void main(String[] args) throws Exception {
        ThreadPoolExecutor es = new ThreadPoolExecutor(2, 3, 1, TimeUnit.SECONDS, new ArrayBlockingQueue<>(2), Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());
        System.out.println("主线程执行了");

        es.submit(() -> {
            System.out.println(Thread.currentThread().getName());

            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        });
        es.submit(() -> System.out.println(Thread.currentThread().getName()));
        Thread.sleep(1000);
        es.submit(() -> System.out.println(Thread.currentThread().getName()));

        es.shutdown();
        System.out.println("主线程结束了");
    }
}

运行结果:

主线程执行了
pool-1-thread-1
pool-1-thread-2
pool-1-thread-2
主线程结束了

线程操作

CountDownLatch

控制一个线程等待其他线程各自执行完毕后再执行

方法返回值说明
CountDownLatch(int i)构造方法原理为计数器,初始为 i ,每当一个线程执行完毕计数器 -1 ,当计数器为 0 时,唤醒所有等待中的线程
await()void使当前线程等待,当计数器为0时唤醒
countDown()void表示线程执行完毕
import java.util.concurrent.CountDownLatch;

public class Demo {

    private static CountDownLatch c = new CountDownLatch(2);

    public static void main(String[] args) throws Exception {

        Thread t1 = new Thread(() -> { //新线程 1
            try {
                Thread.sleep(2000); //等待2秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("新线程 1: 执行了");
            c.countDown();
        });

        Thread t2 = new Thread(() -> { //新线程 2
            System.out.println("新线程 2: 执行了");
            try {
                Thread.sleep(2000); //等待2秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            c.countDown();
        });

        t1.start(); //开启新线程 1
        t2.start(); //开启新线程 2
        System.out.println("主线程: 执行了");
        c.await();
        System.out.println("主线程: 两条新线程执行完毕");
    }
}

运行结果:

主线程: 执行了
新线程 2: 执行了
新线程 1: 执行了
主线程: 两条新线程执行完毕

Semaphore

控制同时执行的线程数量

Semaphore(int i) | | 原理为计数器,初始为 i ,允许同时执行的线程数量, i 为 0 则不允许获取执行权限
acquire() | | 获取执行权限 i-1
release() | | 归还执行权限 i+1

import java.util.concurrent.Semaphore;

public class Demo {

    private static Semaphore s = new Semaphore(3);

    public static void main(String[] args) throws Exception {

        Thread t1 = new Thread(() -> { //新线程 1
            try {
                s.acquire();
                System.out.println("新线程 1: 执行了");
                Thread.sleep(2000); //等待2秒
                System.out.println("新线程 1: 执行完毕");
                s.release();
            } catch (Exception e) {
                e.printStackTrace();
            }
        });

        Thread t2 = new Thread(() -> { //新线程 2
            try {
                s.acquire();
                System.out.println("新线程 2: 执行了");
                Thread.sleep(2000); //等待2秒
                System.out.println("新线程 2: 执行完毕");
                s.release();
            } catch (Exception e) {
                e.printStackTrace();
            }
        });

        Thread t3 = new Thread(() -> { //新线程 3
            try {
                s.acquire();
                System.out.println("新线程 3: 执行了");
                Thread.sleep(2000); //等待2秒
                System.out.println("新线程 3: 执行完毕");
                s.release();
            } catch (Exception e) {
                e.printStackTrace();
            }
        });

        Thread t4 = new Thread(() -> { //新线程 4
            try {
                s.acquire();
                System.out.println("新线程 4: 执行了");
                Thread.sleep(2000); //等待2秒
                System.out.println("新线程 4: 执行完毕");
                s.release();
            } catch (Exception e) {
                e.printStackTrace();
            }
        });

        Thread t5 = new Thread(() -> { //新线程 5
            try {
                s.acquire();
                System.out.println("新线程 5: 执行了");
                Thread.sleep(2000); //等待2秒
                System.out.println("新线程 5: 执行完毕");
                s.release();
            } catch (Exception e) {
                e.printStackTrace();
            }
        });
        t1.start();
        t2.start();
        t3.start();
        t4.start();
        t5.start();
        System.out.println("主线程: 执行了");
    }
}

运行结果:

主线程: 执行了
新线程 3: 执行了
新线程 1: 执行了
新线程 2: 执行了
新线程 3: 执行完毕
新线程 2: 执行完毕
新线程 1: 执行完毕
新线程 4: 执行了
新线程 5: 执行了
新线程 4: 执行完毕
新线程 5: 执行完毕

可以看到最多同时执行 3 条线程,即使中间等待了 2秒 ,其他线程也无法执行

安全问题

在不同线程同时操作一个数据,可能会出现线程安全问题

抢票案例:

public class Demo {

    public static int tickets = 10; //一共10张票

    public static void main(String[] args) throws Exception {
        new Demo1().start();
        new Demo1().start();
        new Demo1().start();
        new Demo1().start();
        new Demo1().start(); //开启5个抢票线程
        Thread.sleep(5000);
    }
}

class Demo1 extends Thread {
    @Override
    public void run() {
        while (true) {
            if (Demo.tickets > 0) {
                System.out.println("线程" + Thread.currentThread().getName() + ": 抢票");
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                Demo.tickets = Demo.tickets - 1;
                System.out.println("线程" + Thread.currentThread().getName() + ": 抢到了,还有" + Demo.tickets + "张");
            } else {
                System.out.println("线程" + Thread.currentThread().getName() + ": 没票了");
                break;
            }
        }
    }
}

运行结果:

线程Thread-4: 抢票
线程Thread-3: 抢票
线程Thread-2: 抢票
线程Thread-1: 抢票
线程Thread-0: 抢票
线程Thread-2: 抢到了,还有6张
线程Thread-1: 抢到了,还有6张
线程Thread-3: 抢到了,还有6张
线程Thread-0: 抢到了,还有6张
线程Thread-0: 抢票
线程Thread-4: 抢到了,还有6张
线程Thread-4: 抢票
线程Thread-3: 抢票
线程Thread-1: 抢票
线程Thread-2: 抢票
线程Thread-1: 抢到了,还有3张
线程Thread-1: 抢票
线程Thread-0: 抢到了,还有1张
线程Thread-0: 抢票
线程Thread-3: 抢到了,还有2张
线程Thread-3: 抢票
线程Thread-2: 抢到了,还有3张
线程Thread-2: 抢票
线程Thread-4: 抢到了,还有2张
线程Thread-4: 抢票
线程Thread-4: 抢到了,还有-1张
线程Thread-4: 没票了
线程Thread-2: 抢到了,还有-2张
线程Thread-2: 没票了
线程Thread-0: 抢到了,还有-2张
线程Thread-0: 没票了
线程Thread-1: 抢到了,还有-3张
线程Thread-1: 没票了
线程Thread-3: 抢到了,还有-2张
线程Thread-3: 没票了

很明显不可能还剩-2张票

线程锁

synchronized(任意对象){ 共享数据操作代码块 }

将代码块锁上,参数对象相当于钥匙,只有一把钥匙,即被相同锁锁上的代码同一时间只能有一份在执行

public class Demo {

    public static int tickets = 10; //一共10张票

    public static String s = "一个字符串";

    public static void main(String[] args) throws Exception {
        new Demo1().start();
        new Demo1().start();
        new Demo1().start();
        new Demo1().start();
        new Demo1().start(); //开启5个抢票线程
        Thread.sleep(5000);
    }
}

class Demo1 extends Thread {
    @Override
    public void run() {
        while (true) {
            synchronized (Demo.s) { //使用一个字符串对象当锁
                if (Demo.tickets > 0) {
                    System.out.println("线程" + Thread.currentThread().getName() + ": 抢票");
                    try {
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    Demo.tickets = Demo.tickets - 1;
                    System.out.println("线程" + Thread.currentThread().getName() + ": 抢到了,还有" + Demo.tickets + "张");
                } else {
                    System.out.println("线程" + Thread.currentThread().getName() + ": 没票了");
                    break;
                }
            }
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

运行结果:

线程Thread-0: 抢票
线程Thread-0: 抢到了,还有9张
线程Thread-4: 抢票
线程Thread-4: 抢到了,还有8张
线程Thread-3: 抢票
线程Thread-3: 抢到了,还有7张
线程Thread-2: 抢票
线程Thread-2: 抢到了,还有6张
线程Thread-1: 抢票
线程Thread-1: 抢到了,还有5张
线程Thread-2: 抢票
线程Thread-2: 抢到了,还有4张
线程Thread-3: 抢票
线程Thread-3: 抢到了,还有3张
线程Thread-4: 抢票
线程Thread-4: 抢到了,还有2张
线程Thread-0: 抢票
线程Thread-0: 抢到了,还有1张
线程Thread-4: 抢票
线程Thread-4: 抢到了,还有0张
线程Thread-3: 没票了
线程Thread-2: 没票了
线程Thread-1: 没票了
线程Thread-0: 没票了
线程Thread-4: 没票了

ReentrantLock

方法返回值说明
Lock()void获得锁
tryLock()void尝试获得锁
unLock()void释放锁

虚拟机中线程的六种状态:

NEW ( 新建 ) -> 创建线程对象
RUNNABLE ( 就绪 ) -> start();
BLOCKED ( 阻塞 ) -> 无法进入被锁对象
WAITING ( 等待 ) -> wait();
TIME_WAITING ( 计时 ) -> sleep();
TERMINATED ( 结束 ) -> 运行完毕

原子性

原子性操作有: ①除long和double之外的原始类型的赋值 ②java.concurrent.Atomic.*类的操作

AtomicInteger

以原子方式操作int

方法返回值说明
AtomicInteger()构造方法初始化默认值为0
AtomicInteger(int i)构造方法初始化为 i
get()int获取值
getAndIncrement()int以原子方式自增1 返回自增前
incrementAndGet()int以原子方式自增1 返回自增后
addAndGet(int i)int以原子方式增加i 返回结果
getAndSet(int i)int以原子方式改为i 返回旧

Hashtable: 用法同HashMap 底层synchronized加HashMap(效率较低)
ConcurrentHashMap: 用法同HashMap(效率较高)

BlockingQueue

阻塞队列

方法返回值说明
ArrayBlockingQueue构造方法底层数组,有界
LinkedBlockingQueue构造方法底层链表.无界
put(T t)void存入元素 /类似集合,但若存入时队列满了则等待队列有空余再存入
take()T取出元素 /类似集合,但若取出时队列为空则等待队列有内容时再取出
杨望星空世纪航行
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java笔记 - 线程基础知识
yansha的专栏
04-05 4455
进程是一个执行中程序的实例，是操作系统进行资源分配和调度的一个独立单元。线程是进程中一个单一的程序控制流，是 CPU 调度和分派的基本单元。进程在执行时拥有独立的内存空间，进程中的线程可以共享进程的内存空间。在 Java 的世界中，进程可以拥有多个并发执行的线程，多线程是实现并发任务的方式。
Java笔记-基础
Kei's Blog
05-25 700
Java 基础语法 一个Java程序可以认为是一系列对象的集合，而这些对象通过调用彼此的方法来协同工作。下面简要介绍下类、对象、方法和实例变量的概念。 对象：对象是类的一个实例，有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。类：类是一个模板，它描述一类对象的行为和状态。方法：方法就是行为，一个类可以有很多方法。逻辑运算、数据修改以及所有动
尚硅谷_java多线程_学习笔记
qq_17079255的博客
10-08 918
文章标题
java 线程基础超详细笔记
最新发布
weixin_70139631的博客
04-15 2212
线程是进程创建的，是进程的一个实体一个进程可以拥有多个线程线程：程序中不同的运行路线,在Java中将程序的不同运行路线的数据封装成一个线程对象多个线程都占用了对方的锁资源，但不肯相让，导致了死锁。
Java多线程笔记
weixin_44159128的博客
04-15 1413
Java基础中的多线程基本实现方法
Java基础笔记_Java基础笔记_Java笔记_worthnwg_
10-02
这份"Java基础笔记"涵盖了初学者需要掌握的关键知识点，旨在帮助快速入门Java编程。以下是对这些笔记内容的详细解读： 1. **Java简介**：Java是由Sun Microsystems（现已被Oracle公司收购）于1995年发布的面向对象...
java笔记_Java笔记_
10-03
这份"java笔记"是专为初学者设计的，旨在帮助那些对编程没有基础的人快速掌握Java核心技术。笔记采用Ediplus编辑器编写，这是一款轻量级且功能强大的文本编辑工具，非常适合程序员进行代码编写和学习。 首先，Java...
Java Studty.rar_Java笔记_java基础学习
09-24
在这个压缩包中，我们可以期待找到一些关键的学习资源，如代码示例和笔记，这些都是理解并掌握Java基础知识的重要工具。 1. **Java简介**：Java是一种面向对象的、跨平台的编程语言，由Sun Microsystems（现为...
达内Java_笔记整理.rar_Java 达内笔记_Java笔记_java 笔记_笔记_达内
09-23
达内是一家知名的教育机构，其整理的Java笔记通常会覆盖从基础到进阶的各种主题，以系统化的方式帮助学员掌握这门广泛使用的编程语言。 首先，Java的基础知识是必不可少的，这些笔记可能包括变量、数据类型、运算符...
多线程笔记_java/多线程_
10-03
在Java编程语言中，多线程是程序设计中的一个重要概念，尤其在开发高效能和响应迅速的应用时。本文档将全面解析多线程的基础知识，从简单到复杂，帮助开发者深入理解并掌握这一核心技术。 一、多线程基础 1.1 线程...
Java笔记_根据MySQL表生成Java实体类
YWXKSJHX的博客
01-25 2580
根据MySQL表生成Java实体类
Java笔记_基础_配置文件
YWXKSJHX的博客
04-24 1802
文章目录XMLdtdschemapropertiesJSON XML XML文件是由很多标签组成的,而标签名是可以自定义的 <?xml version="1.0" encoding="UTF-8" standalone="yes"?> <!-- 必须写在第一行第一列 /version="1.0" 这句话必须写 /encoding="UTF-8" 表示该XML文件应该用此编码打开(可不写) /standalone="yes" 是否依赖其他的xml文件yes/no(可不写) --> &l
idea的一些设置
YWXKSJHX的博客
03-20 308
文章目录字体设置背景设置颜色图片控制台背景设置编码设置忽略大小写更新设置启动设置导包设置Maven配置启动过慢解决办法实用插件 截图时idea版本为2019.3.5 字体设置 Settings > Editor > Font Font: 字体样式 Size: 字体大小 Line spacing: 行间距 背景设置 颜色 Settings > Editor > Color Scheme > General Text > Default text
Java笔记_基础语法
YWXKSJHX的博客
03-21 164
喜闻乐见的"Hello World" public class HelloWorld { //定义一个名叫"HelloWorld"的类 public static void main(String[] args){ //main方法: java程序的入口 System.out.println("Hello World"); //打印至控制台 } } public class 类名{ 访问修饰符 权限修饰符 返回值数据类型 方法名(数据类型 数据){ 方法(值); } } 源文件：源.
Java笔记_基础_常用类
YWXKSJHX的博客
04-12 157
文章目录String String
Java笔记_基础_集合
YWXKSJHX的博客
04-17 128
文章目录集合 集合
Java笔记_配置环境变量
YWXKSJHX的博客
03-22 128
目录JDK JDK JDK是 Java 语言的软件开发工具包，是整个java开发的核心，它包含了JAVA的运行环境（JVM+Java系统类库）和JAVA工具。 JDK有很多版本，但我们一般使用JDK8 JDK8官网下载: https://www.oracle.com/java/technologies/javase/javase-jdk8-downloads.html 但是Java官网在国外，国内下载慢不说，下载10次能失败9次 然后我发现腾讯软件中心也可以下载,直接搜索 JDK 就可以了 ..
Java笔记_框架_MyBatis
YWXKSJHX的博客
04-24 101
文章目录配置驱动 配置驱动 sql语句: CREATE DATABASE Demo; USE Demo; CREATE TABLE Demo( id int PRIMARY KEY, test1 varchar(10), test2 int ); INSERT INTO Demo(id, test1, test2) VALUES (1, "第一个数据", 123); INSERT INTO Demo(id, test1, test2) VALUES (2, "第二个数据", 234); INSERT I
Java笔记_基础_Web
YWXKSJHX的博客
04-23 101
文章目录httpservletHttpServlet配置文件驱动注解驱动@WebServlet("/访问路径") http 网络超文本数据传输协议 不支持中文,传输中文时将字符分割为十六进制的字节以百分号分割而进行传输 URL编码: URLEncoder.encode(String, "编码"); 以指定编码将字符串转换成URL编码 URL解码: URLDecoder.decode(String, "编码"); 将URL编码以指定编码转换成字符串 浏览器 -> 服务器 : 请求 服务器 -> 浏
毕向东Java_SE核心笔记：从基础到实战
Java_SE毕向东笔记涵盖了全面的Java编程基础知识和进阶主题，共分为16章。以下是各章节的主要知识点概述： 1. **编程基础** (第3章)：介绍了Java的主要特性，如简单性、面向对象、可移植性（write once, run ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值