JavaSE进阶（day11，复习自用）

最新推荐文章于 2026-01-01 15:39:09 发布
原创 最新推荐文章于 2026-01-01 15:39:09 发布 · 390 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #jvm #开发语言

本文详细介绍了Java中多线程的创建方式，包括继承Thread类、实现Runnable接口和Callable接口，并探讨了线程安全和同步机制，如同步代码块、同步方法和Lock锁。此外，还讨论了线程池的概念、API以及Executors工具类的使用，以及定时器Timer和ScheduledExecutorService的实现。最后，补充了并发、并行的基本概念和线程的生命周期知识。

多线程

多线程的创建

Java是通过java.lang.Thread 类来代表线程的。
按照面向对象的思想，Thread类应该提供了实现多线程的方式。

方式一：继承Thread类

在这里插入图片描述

/**
 * 目标：多线程的创建方式一：继承Thread类实现。
 */
public class ThreadDemo1 {
    public static void main(String[] args) {
        //3.new一个新线程对象
        Thread t = new MyThread();
        //4.调用start方法启动线程（执行的还是run方法）
        t.start();

        for (int i = 0; i < 5; i++) {
            System.out.println("主线程执行输出：" + i);
        }


    }
}

/**
 * 1.定义一个线程类继承Thread类
 */
class MyThread extends Thread{
    /**
     * 2.重写run方法，里面是定义线程以后要干啥
     */
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println("子线程执行输出：" + i);
        }
    }
}

1、为什么不直接调用了run方法，而是调用start启动线程。
直接调用run方法会当成普通方法执行，此时相当于还是单线程执行。
只有调用start方法才是启动一个新的线程执行。

2、把主线程任务放在子线程之前了。
这样主线程一直是先跑完的，相当于是一个单线程的效果了。

方式二：实现Runnable接口

在这里插入图片描述
优点：线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强。
缺点：编程多一层对象包装，如果线程有执行结果是不可以直接返回的。

/**
 * 目标：学会线程的创建方式二，理解它的优缺点
 */
public class ThreadDemo2 {
    public static void main(String[] args) {
        //3.创建一个任务对象
        Runnable target = new MyRunnable();
        //4.把任务对象交给Thread处理
        Thread t = new Thread(target);
//        Thread t = new Thread(target,"1号");
        //5.启动线程
        t.start();

        for (int i = 0; i < 100; i++) {
            System.out.println("主线程执行输出：" + i);
        }



    }
}
/**
 * 1.定义一个线程任务类 实现Runnable接口
 */
class MyRunnable implements Runnable{
    /**
     * 2.重写run方法，定义线程的执行任务
     */
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("子线程执行输出：" + i);
        }
    }
}

在这里插入图片描述

/**
 * 目标：学会线程的创建方式二(匿名内部类方式实现，语法形式)
 */
public class ThreadDemo2_Other {
    public static void main(String[] args) {
        //3.创建一个任务对象
        Runnable target = new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    System.out.println("子线程1执行输出：" + i);
                }
            }
        };
        //4.把任务对象交给Thread处理
        Thread t = new Thread(target);
        //5.启动线程
        t.start();


      //简化写法
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    System.out.println("子线程2执行输出：" + i);
                }
            }
        }).start();


        //进一步简化写法
        new Thread(()-> {
                for (int i = 0; i < 100; i++) {
                    System.out.println("子线程3执行输出：" + i);
                }
            }
        ).start();



        for (int i = 0; i < 100; i++) {
            System.out.println("主线程执行输出：" + i);
        }



    }
}

方式三：JDK 5.0新增：实现Callable接口

1、前2种线程创建方式都存在一个问题：
他们重写的run方法均不能直接返回结果。
不适合需要返回线程执行结果的业务场景。

2、怎么解决这个问题呢？
JDK 5.0提供了Callable和FutureTask来实现。
这种方式的优点是：可以得到线程执行的结果。
在这里插入图片描述
在这里插入图片描述

/**
 * 目标：学会线程的创建方式三：实现Callable接口，结合FutureTask完成。
 */
public class ThreadDemo3 {
    public static void main(String[] args) {
        //3.创建Callable任务对象
        Callable call = new MyCallable(100);
        //4.把Callable任务对象 交给 FutureTask对象
        //FutureTask对象的作用1：是Runnable的对象（实现了Runnable接口）可以交给Thread了
        //FutureTask对象的作用2：可以在线程执行完毕之后调用其get方法得到线程执行完成的结果
        FutureTask<String> f1 = new FutureTask<>(call);
        //5.交给线程处理
        Thread t1 = new Thread(f1);
        t1.start();


        Callable call2 = new MyCallable(200);
        FutureTask<String> f2 = new FutureTask<>(call2);
        Thread t2 = new Thread(f2);
        t2.start();

        try {
            //如果f1任务没有执行完毕，这里的代码会等待，直到线程1跑完才提取结果
            String rs1 = f1.get();
            System.out.println("第一个结果：" + rs1);
        }  catch (Exception e) {
            e.printStackTrace();
        }

        try {
            //如果f2任务没有执行完毕，这里的代码会等待，直到线程2跑完才提取结果
            String rs2 = f2.get();
            System.out.println("第二个结果：" + rs2);
        }  catch (Exception e) {
            e.printStackTrace();
        }


    }
}
/**
 * 1.定义一个任务类：实现Callable接口 应该声明线程任务执行完毕后的结果的数据类型
 */

class MyCallable implements Callable<String>{
    private int n;

    public MyCallable(int n) {
        this.n = n;
    }

    /**
     * 2.重写call方法（任务方法）
     */
    @Override
    public String call() throws Exception {
        int sum = 0;
        for (int i = 0; i <=n; i++) {
            sum+=i;
        }
        return "子线程执行的结果是："+sum;
    }
}

Thread的常用方法

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

public class MyThread extends Thread{
    public MyThread() {
    }

    public MyThread(String name) {
        //为当前线程对象设置名称，送给父类的有参数构造器初始化名称
        super(name);
    }

    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
//            System.out.println(this.getName()+"输出："+i);//也可以
            System.out.println(Thread.currentThread().getName()+"输出:" + i);
        }
    }
}

/**
 * 目标：线程的API
 */
public class ThreadDemo01 {
    //main方法是由主线程负责调度的
    public static void main(String[] args) {
        Thread t1 = new MyThread("1号");
        //t1.setName("1号");
        t1.start();
        System.out.println(t1.getName());


        Thread t2 = new MyThread("2号");
        //t2.setName("2号");
        t2.start();
        System.out.println(t2.getName());

        //哪个线程执行它，它就得到哪个线程对象（当前线程对象）
        //主线程的名称就叫main
        Thread m = Thread.currentThread();
        System.out.println(m.getName());
        m.setName("最牛的线程：");

        for (int i = 0; i < 5; i++) {
            System.out.println(m.getName()+"线程输出:" + i);
        }

    }
}

/**
 * 目标：线程的API
 */
public class ThreadDemo02 {
    //main方法是由主线程负责调度的
    public static void main(String[] args) throws Exception {
        for (int i = 0; i <= 5; i++) {
            System.out.println("输出：" + i);
            if(i==3){
                //让线程进入休眠状态
                //段子：项目经理让我加上这行代码，如果用户愿意交钱，我就注释掉。
                Thread.sleep(3000);
            }
        }
    }
}

线程安全

在这里插入图片描述
在这里插入图片描述

public class Account {
    private String cardId;
    private double money;//账户的余额

    public Account() {
    }

    public Account(String cardId, double money) {
        this.cardId = cardId;
        this.money = money;
    }

    public String getCardId() {
        return cardId;
    }

    public void setCardId(String cardId) {
        this.cardId = cardId;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }

    /**
     * 小明 小红
     * @param money
     */
    public void drawMoney(double money) {
        //0.先获取是谁来取钱，线程的名字就是人名
        String name = Thread.currentThread().getName();
        //1.判断账户是否够钱
        if(this.money>=money){
            //2.取钱
            System.out.println(name + "来取钱成功，吐出：" + money);
            //3.更新余额
            this.money -= money;
            System.out.println(name + "取钱后剩余：" + this.money);
        }else{
            //4.余额不足
            System.out.println(name + "来取钱，余额不足!");
        }
    }
}


/**
 * 取钱的线程类
 */
public class DrawThread extends Thread{
    //接收处理的账户对象
    private Account acc;
    public DrawThread(Account acc,String name){
        super(name);
        this.acc = acc;
    }

    @Override
    public void run() {
        //小明 小红 取钱的
        acc.drawMoney(100000);
    }
}

/**
 * 需求：模拟取钱案例
 */
public class ThreadDemo {
    public static void main(String[] args) {
        //1.定义线程类，加载一个共享的账户对象
        Account acc = new Account("ICDC-111",100000);

        //2.创建2个线程对象，代表小明和小红同时进来了
        new DrawThread(acc,"小明").start();
        new DrawThread(acc,"小红").start();

    }
}

线程同步

同步思想概述

1、取钱案例出现问题的原因？
多个线程同时执行，发现账户都是够钱的。

2、如何才能保证线程安全呢？
让多个线程实现先后依次访问共享资源，这样就解决了安全问题
线程同步的核心思想
加锁，把共享资源进行上锁，每次只能一个线程进入访问完毕以后解锁，然后其他线程才能进来。

方式一：同步代码块

在这里插入图片描述
锁对象用任意唯一的对象好不好呢?
不好，会影响其他无关线程的执行。
锁对象的规范要求
规范上：建议使用共享资源作为锁对象。
对于实例方法建议使用this作为锁对象。
对于静态方法建议使用字节码（类名.class）对象作为锁对象。

/**
     * 小明 小红
     * @param money
     */
    public void drawMoney(double money) {
        //0.先获取是谁来取钱，线程的名字就是人名
        String name = Thread.currentThread().getName();
        //同步代码块
        //小明 小红
        //this ===acc 共享账户
        synchronized (this) {
            //1.判断账户是否够钱
            if(this.money>=money){
                //2.取钱
                System.out.println(name + "来取钱成功，吐出：" + money);
                //3.更新余额
                this.money -= money;
                System.out.println(name + "取钱后剩余：" + this.money);
            }else{
                //4.余额不足
                System.out.println(name + "来取钱，余额不足!");
            }
        }

    }

    //100个线程人
    public static void run(){
        synchronized(Account.class){

        }
    }

方式二：同步方法

在这里插入图片描述
同步方法底层原理：
同步方法其实底层也是有隐式锁对象的，只是锁的范围是整个方法代码。
如果方法是实例方法：同步方法默认用this作为的锁对象。但是代码要高度面向对象！
如果方法是静态方法：同步方法默认用类名.class作为的锁对象。
1、是同步代码块好还是同步方法好一点？
同步代码块锁的范围更小，同步方法锁的范围更大。

/**
     * 小明 小红
     * @param money
     */
    public synchronized void drawMoney(double money) {
        //0.先获取是谁来取钱，线程的名字就是人名
        String name = Thread.currentThread().getName();
        //1.判断账户是否够钱
        if(this.money>=money){
            //2.取钱
            System.out.println(name + "来取钱成功，吐出：" + money);
            //3.更新余额
            this.money -= money;
            System.out.println(name + "取钱后剩余：" + this.money);
        }else{
            //4.余额不足
            System.out.println(name + "来取钱，余额不足!");
        }
    }

方式三：Lock锁

在这里插入图片描述

/**
     * 小明 小红
     * @param money
     */
    public synchronized void drawMoney(double money) {
        //0.先获取是谁来取钱，线程的名字就是人名
        String name = Thread.currentThread().getName();
        //1.判断账户是否够钱
        if(this.money>=money){
            //2.取钱
            System.out.println(name + "来取钱成功，吐出：" + money);
            //3.更新余额
            this.money -= money;
            System.out.println(name + "取钱后剩余：" + this.money);
        }else{
            //4.余额不足
            System.out.println(name + "来取钱，余额不足!");
        }
    }

线程通信

在这里插入图片描述
在这里插入图片描述

public class Account {
    private String cardId;
    private double money;//账户的余额

    public Account() {
    }

    public Account(String cardId, double money) {
        this.cardId = cardId;
        this.money = money;
    }

    public String getCardId() {
        return cardId;
    }

    public void setCardId(String cardId) {
        this.cardId = cardId;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }

    /**
     * 小红 小明：取钱
     */
    public synchronized void drawMoney(double money) {
        try {
            String name = Thread.currentThread().getName();
            if(this.money>=money){
                //钱够：可取
                this.money -= money;
                System.out.println(name + "来取钱" + money + "成功！余额是："+this.money);
                //没钱了
                this.notifyAll();//唤醒所有线程
                this.wait();//锁对象，让当前线程进入等待！

            }else{
                //钱不够：不可取
                //唤醒别人 等待自己
                this.notifyAll();//唤醒所有线程
                this.wait();//锁对象，让当前线程进入等待！
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     *  亲爹 干爹 岳父 存钱
     */
    public synchronized void deposit(double money) {
        try {
            String name = Thread.currentThread().getName();
            if(this.money == 0){
                //没钱了:存钱呗
                this.money += money;
                System.out.println(name + "存钱" + money + "成功！存钱后余额是：" + this.money);
                //有钱了：唤醒别人，等待自己
                this.notifyAll();//唤醒所有线程
                this.wait();//锁对象，让当前线程进入等待!
            }else{
                //有钱，不存钱
                this.notifyAll();//唤醒所有线程
                this.wait();//锁对象，让当前线程进入等待!
            }
        } catch (Exception e) {
            e.printStackTrace();
        }


    }
}


/**
 * 取钱的线程类
 */
public class DepositThread extends Thread{
    //接收处理的账户对象
    private Account acc;
    public DepositThread(Account acc, String name){
        super(name);
        this.acc = acc;
    }

    @Override
    public void run() {
        //亲爹 干爹 岳父
        while (true) {

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

/**
 * 取钱的线程类
 */
public class DrawThread extends Thread{
    //接收处理的账户对象
    private Account acc;
    public DrawThread(Account acc, String name){
        super(name);
        this.acc = acc;
    }

    @Override
    public void run() {
        //小明 小红取钱的
        while (true) {

            acc.drawMoney(100000);
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}


public class ThreadDemo {
    public static void main(String[] args) {
        //目标：了解线程通信的流程
        //使用3个爸爸存钱(生产者) 2个孩子取钱(消费者) 模拟线程通信思想（一存10万 一取10万）
        //1.创建账户对象，代表5个人共同操作的账户
        Account acc = new Account("ICBC-112",0);
        //2.创建2个取钱线程代表小明和小红
        new DrawThread(acc,"小明").start();
        new DrawThread(acc,"小红").start();

        //3.创建3个存钱线程代表：亲爹 干爹 岳父
        new DepositThread(acc,"亲爹").start();
        new DepositThread(acc,"干爹").start();
        new DepositThread(acc,"岳父").start();

    }
}

线程池

线程池概述

线程池就是一个可以复用线程的技术。

不使用线程池的问题
如果用户每发起一个请求，后台就创建一个新线程来处理，下次新任务来了又要创建新线程，而创建新线程的开销是很大的，这样会严重影响系统的性能。

线程池实现的API、参数说明

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

/*
目标：自定义一个线程池对象，并测试其特性
 */
public class ThreadPoolDemo1 {
    public static void main(String[] args) {
        //1.创建线程池对象
        /*
          int corePoolSize,
          int maximumPoolSize,
          long keepAliveTime,
          TimeUnit unit,
          BlockingQueue<Runnable> workQueue,
          ThreadFactory threadFactory,
          RejectedExecutionHandler handler

         */

        ExecutorService pool = new ThreadPoolExecutor(3,5,6, TimeUnit.SECONDS,new ArrayBlockingQueue<>(5),
                Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());

        //2.给任务线程池处理
        Runnable target = new MyRunnable();
        pool.execute(target);
        pool.execute(target);
        pool.execute(target);

        pool.execute(target);
        pool.execute(target);
        pool.execute(target);
        pool.execute(target);
        pool.execute(target);

        //创建临时线程
        pool.execute(target);
        pool.execute(target);

//        //不创建，拒绝策略被触发!!!
//        pool.execute(target);

        //关闭线程池（开发中一般不会使用）
        //pool.shutdownNow();//立即关闭，即使任务还没有完成，会丢失任务的！
        pool.shutdown();//会等待全部任务执行完毕之后再关闭(建议使用的)


    }
}

线程池处理Runnable任务

在这里插入图片描述
在这里插入图片描述

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName() + "输出了：HelloWorld ==>" + i);
        }
        try {
            System.out.println(Thread.currentThread().getName() + "本任务与线程绑定了,线程进入休眠了~~~");
            Thread.sleep(10000000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}


/*
目标：自定义一个线程池对象，并测试其特性
 */
public class ThreadPoolDemo2 {
    public static void main(String[] args) throws Exception {
        //1.创建线程池对象
        /*
          int corePoolSize,
          int maximumPoolSize,
          long keepAliveTime,
          TimeUnit unit,
          BlockingQueue<Runnable> workQueue,
          ThreadFactory threadFactory,
          RejectedExecutionHandler handler

         */

        ExecutorService pool = new ThreadPoolExecutor(3,5,6, TimeUnit.SECONDS,new ArrayBlockingQueue<>(5),
                Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());

        //2.给任务线程池处理
        Future<String> f1 = pool.submit(new MyCallable(100));
        Future<String> f2 = pool.submit(new MyCallable(200));
        Future<String> f3 = pool.submit(new MyCallable(300));
        Future<String> f4 = pool.submit(new MyCallable(400));
        Future<String> f5 = pool.submit(new MyCallable(500));

//        String rs = f1.get();
//        System.out.println(rs);

        System.out.println(f1.get());
        System.out.println(f2.get());
        System.out.println(f3.get());
        System.out.println(f4.get());
        System.out.println(f5.get());

    }
}

线程池处理Callable任务

在这里插入图片描述

/**
 * 1.定义一个任务类：实现Callable接口 应该声明线程任务执行完毕后的结果的数据类型
 */

public class MyCallable implements Callable<String>{
    private int n;

    public MyCallable(int n) {
        this.n = n;
    }

    /**
     * 2.重写call方法（任务方法）
     */
    @Override
    public String call() throws Exception {
        int sum = 0;
        for (int i = 0; i <=n; i++) {
            sum+=i;
        }
        return Thread.currentThread().getName()+ "执行的"+"1-"+n+"的和的结果是："+sum;
    }
}


/*
目标：使用Executors的工具方法直接得到一个线程池对象。
 */
public class ThreadPoolDemo3 {
    public static void main(String[] args) throws Exception {
        //1.创建固定线程数据的线程池
        ExecutorService pool = Executors.newFixedThreadPool(3);

        pool.execute(new MyRunnable());
        pool.execute(new MyRunnable());
        pool.execute(new MyRunnable());
        pool.execute(new MyRunnable());//已经没有多余线程了



    }
}

Executors工具类实现线程池

在这里插入图片描述
在这里插入图片描述在这里插入图片描述

补充知识：定时器

定时器是一种控制任务延时调用，或者周期调用的技术。
作用：闹钟、定时邮件发送。

方式一：Timer

/*
目标：Timer定时器的使用和了解
 */
public class TimerDemo1 {
    public static void main(String[] args) {
        //1.创建Timer定时器
        Timer timer = new Timer();//定时器本身就是一个单线程。
        //2.调用方法，处理定时任务
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "执行AAA~~~"+new Date());
//                try {
//                    Thread.sleep(5000);
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
            }
        },0,2000);

        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "执行BBB~~~"+new Date());
//                System.out.println(10 / 0);
            }
        },0,2000);

        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "执行CCC~~~"+new Date());
            }
        },0,3000);


    }

}

在这里插入图片描述

方式二： ScheduledExecutorService

在这里插入图片描述

/*
目标：Timer定时器的使用和了解
 */
public class TimerDemo2 {
    public static void main(String[] args) {

        //1.创建ScheduleExecutorService线程池，做定时器
        ScheduledExecutorService pool = Executors.newScheduledThreadPool(3);

        //2.开启定时任务
        pool.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "执行输出：AAA ==> "+new Date());
                try {
                    Thread.sleep(10000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        },0,2, TimeUnit.SECONDS);

        pool.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "执行输出：BBB ==> "+new Date());
                System.out.println(10 / 0);
            }
        },0,2, TimeUnit.SECONDS);

        pool.scheduleAtFixedRate(new TimerTask() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + "执行输出：CCC ==> "+new Date());
            }
        },0,2, TimeUnit.SECONDS);

    }

}

补充知识：并发、并行

简单说说并发和并行的含义
并发：CPU分时轮询的执行线程。
并行：同一个时刻同时在执行。
在这里插入图片描述
在这里插入图片描述

补充知识：线程的生命周期

在这里插入图片描述
在这里插入图片描述

JavaSE进阶 面向对象多态
11-12
JavaSE 进阶 面向对象多态 在 JavaSE 中，面向对象多态是指同一个对象可以具有多种形态，例如一个人可以是老师、丈夫、父亲等。这种多态性是通过方法的重写和重载来实现的。 多态的形式有很多，例如： 1. 方法...
JavaSE进阶 面向对象继承
11-12
JavaSE进阶面向对象继承 继承是Java语言中的一种机制，允许一个类继承另一个类的特征和行为。继承的优点是可以提高代码的可重用性，减少代码冗余，提高开发效率。 1. 继承的定义：继承是指一个类继承另一个类的...
JavaSE进阶（day03，复习自用）
Singularity_233的博客
05-11 235
什么是多态？指对象可以有多种形态。public String name = "父类动物";public String name = "子类狗";System . out . println("狗跑得贼溜~~");} /*** 独有功能System . out . println("狗在看门!!!");} }public String name = "子类乌龟";System . out . println("乌龟跑得非常慢！");} /*** 独有功能。
JavaSE进阶（day04，复习自用）
Singularity_233的博客
05-12 228
1、包装类是什么，作用是什么？基本数据类型对应的引用类型，实现了一切皆对象。后期集合和泛型不支持基本类型，只能使用包装类。2、包装类有哪些特殊功能？可以把基本类型的数据转换成字符串类型(用处不大)可以把字符串类型的数值转换成真实的数据类型（真的很有用）/*** 目标：明白包装类的概念，并使用。int a = 10;//自动装箱 System . out . println(a);//自动拆箱 System . out . println(it1);
JavaSE进阶（day10，复习自用）
Singularity_233的博客
05-23 195
缓冲流也称为高效流、或者高级流。之前学习的字节流可以称为原始流。缓冲流自带缓冲区、可以提高原始字节流、字符流读写数据的性能字节缓冲输入流自带了8KB缓冲池，以后我们直接从缓冲池读取数据，所以性能较好。字节缓冲输出流自带了8KB缓冲池，数据就直接写入到缓冲池中去，写数据性能极高了。缓冲流的作用？缓冲流自带缓冲区、可以提高原始字节流、字符流读写数据的性能缓冲流有几种？字节缓冲流字节缓冲输入流： BufferedInputStream字节缓冲输出流：BufferedOutputStream。
JavaSE进阶（day05，复习自用）
Singularity_233的博客
05-14 204
}// 1.：定义一个电影类，定义一个集合存储电影对象。// 2.：创建3个电影对象，封装相关数据，把3个对象存入到集合中去。movies . add(new Movie("《肖生克的救赎》" , 9.7 , "罗宾斯"));movies . add(new Movie("《霸王别姬》" , 9.6 , "张国荣、张丰毅"));movies . add(new Movie("《阿甘正传》" , 9.5 , "汤姆.汉克斯"));
JavaSE进阶（day01,复习自用）
Singularity_233的博客
05-09 284
静态成员方法（有static修饰，归属于类），建议用类名访问，也可以用对象访问。实例成员方法（无static修饰，归属于对象），只能用对象触发访问。1.成员方法的分类和访问分别是什么样的？静态成员方法（有static修饰，属于类和对象共享）访问格式：类名.静态成员方法。对象.静态成员方法。（不推荐）实例成员方法（无static修饰，属于对象）的访问格式：对象.实例成员方法。2.每种成员方法的使用场景是怎么样的？
JavaSE进阶（day02，复习自用）
Singularity_233的博客
05-10 338
*** 声明了一个接口:体现一种规范，规范一定是公开的。//目标：接口中的成分特点：JDK 8之前接口中只能有抽象方法和常量。//1.常量 //注意：由于接口体现规范思想，规范默认都是公开的，所以代码层面，public static final可以省略不写。String SCHOOL_NAME = "黑马程序员";//public static final String SCHOOL_NAME = "黑马程序员";
JavaSE进阶（day07，复习自用）
Singularity_233的博客
05-18 520
/初步体验Stream流的方便与快捷 public class StreamTest {Collections . addAll(names , "张三丰" , "张无忌" , "周芷若" , "赵敏" , "张强");// //1.从集合中找出姓张的放到新集合 // List<String> zhangList = new ArrayList<>();
JavaSE进阶（day09，复习自用）
Singularity_233的博客
05-22 210
字符集（Character Set）是多个字符的集合，字符集种类较多，每个字符集包含的字符个数不同，常见字符集有：ASCII字符集GBK字符集Unicode（UTF-8）字符集等。常见字符集底层字符的编码是什么样的？英文和数字等在任何国家的字符集中都占1个字节GBK字符中一个中文字符占2个字节UTF-8编码中一个中文1般占3个字节编码前的字符集和解码时的字符集有什么要求？必须一致，否则会出现字符乱码英文和数字不会乱码每次读取一个字节存在什么问题？性能较慢。
JavaSE进阶（day14，复习自用）
Singularity_233的博客
05-29 635
XML是什么?XML的全称为（EXtensible Markup Language），是一种可扩展的标记语言。它是是一种数据表示格式，可以用于自定义数据格式。XML的作用是什么?用于进行存储数据和传输数据作为软件的配置文件使用程序读取XML中的数据两种解析方式SAX解析DOM解析。
JavaSE进阶每日复习与笔记.zip
11-03
**JavaSE进阶知识点概述** JavaSE（Java Standard Edition）是Java编程语言的基础部分，它提供了用于开发桌面应用程序和服务器端应用的核心库。本压缩包包含的笔记涵盖了JavaSE的一些重要进阶主题，包括抽象类与...
JAVASE进阶.xmind
07-31
JAVASE进阶.xmind
02-javase进阶课件.rarr
01-18
02-javase进阶课件.rarr
Spring Boot AOP （六）架构落地与最佳实践
Java、Python、AI、前沿技术等领域的技术总结和经验分享。
12-29 2902
摘要： 本文详细介绍了Spring Boot AOP在企业级项目中的架构落地与最佳实践。通过分析切面分层设计、顺序控制和性能优化等关键点，文章展示了如何构建统一治理横切关注点的核心架构。重点内容包括方法调用链的完整流程（日志、事务、限流、异常处理、性能监控）、切面组合策略（@Order控制执行顺序）以及高级实战示例。文章强调切面单一职责、异常安全和可组合性等设计原则，为企业级AOP应用提供了清晰的技术路线图。
【java入门到放弃】网络
WZDBXHNL的博客
12-28 1225
防火墙既可以是硬件，也可以是软件，本质上是一种，而不是只能对应某一种形态。
【线程池 + Socket 服务器】
最新发布
2401_86718044的博客
01-01 571
通过线程池 + Socket 的组合，我们可以轻松构建高并发、可扩展的网络服务器。Flush 机制看似小细节，却直接影响数据是否及时、正确到达客户端。掌握自动与手动两种方式，就能应对从简单聊天到文件上传的各种场景。这两个示例代码都已经过完整测试，直接复制运行即可。欢迎在评论区分享你的实践经验，或者提出想看的进阶话题（如 NIO、非阻塞、HTTP 协议解析）
点赞系统问题
amdkk的博客
12-26 1219
​​：Spring Pulsar 提供的接口，允许通过customize方法深度定制消费者行为。批量接收策略配置。：控制批量消息接收策略maxNumMessages：单次批量拉取多少条信息timeout：超时后触发批量处理。NACK重试策略当消费者调用时触发重试。：消息重投递的退避策略接口。.minDelayMs(1000) // 初始延迟 1 秒 .maxDelayMs(60000) // 最大延迟 60 秒 .multiplier(2) // 指数退避倍数。
抽象类和接口的区别
tryxr的博客
12-27 1196
本文对比了Java中接口（Interface）与抽象类（AbstractClass）的8个核心区别。主要差异包括：抽象类使用abstract class定义，支持单继承，可包含实例字段和构造器，体现"is-a"关系；接口使用interface定义，允许多实现，仅包含常量，体现"can-do"能力。抽象类适合共享代码和状态，接口适合定义跨类能力。建议优先使用接口定义能力，仅在需要共享状态或实现模板方法时使用抽象类，并考虑组合优于继承。二者可结合使用，如Shape抽象类实
JavaSE进阶：常用类深度解析
"动力节点的JavaSE进阶课程涵盖了Java编程中的常用类，包括String、StringBuffer、基础类型包装类、日期相关类、数字相关类、Random类和Enum。这些知识点对于深入理解和应用Java语言至关重要。" 在Java编程中，...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值