JAVASE16

最新推荐文章于 2023-09-27 10:09:20 发布
最新推荐文章于 2023-09-27 10:09:20 发布
阅读量537 收藏
点赞数
分类专栏： java 后端 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cnjss/article/details/115678183
版权

JAVASE16

一、线程状态

我们在现实生活中，思考问题、发现问题、处理问题，这是一个完成一件事或者处理一个问题经历的中间过程。在程序世界也一样，要完成一件事情线程从出生到消亡会经历一个流程，中间会有不同状态的转换。

我们把线程状态分为五种

  1. 新生状态（新建状态）：使用 new 关键字和 Thread 类或其子类建立一个线程对象后，该线程对象就处于新建状态。它保持这个状态直到程序 start() 这个线程。
  2. 就绪状态：当线程对象调用了start()方法之后，该线程就进入就绪状态。就绪状态的线程处于就绪队列中，要等待JVM里线程调度器的调度。
  3. 运行状态：如果就绪状态的线程获取 CPU 资源，就可以执行run()，此时线程便处于运行状态。处于运行状态的线程最为复杂，它可以变为阻塞状态、就绪状态和死亡状态。
  4. 阻塞状态：如果一个线程执行了sleep（睡眠）suspend（挂起）等方法，失去所占用资源之后，该线程就从运行状态进入阻塞状态。,但是线程并没有结束
  5. 终止状态：一个运行状态的线程完成任务或者其他终止条件发生时，该线程就切换到终止状态。
注意：一个线程一旦进入终止状态,是不可逆转的，是无法恢复

如果一个线程阻塞状态解除之后,无法直接恢复运行,而是会直接进入到就绪状态，等待cpu的调动。

这里，我们需要知道让一个线程进入到就绪状态的几种方法：

​ 第一种：调用start()方法

​ 第二种：阻塞结束，恢复就绪状态

​ 第三种：调用yield()方法，礼让线程

​ 第四种：cpu的调用切换

我们还需要知道让一个线程进入阻塞状态的几种方法：

​ 第一种：调用sleep()方法

​ 第二种：调用Join()方法

​ 第三种：调用wait()方法

​ 第四种：IO操作

进入终止状态的几种方法：

​ 第一种：等待线程的自然执行完毕

​ 第二种：添加标识判断（这也是比较推荐的一种）

​ 第三种：调用stop方法（极度不推荐）

①几种阻塞方法

Thread.sleep(ms) 线程睡眠,阻塞指定ms时间值
一个线程执行sleep方法,进入休眠,释放cpu的资源
抱着资源睡觉–>对象的资源|锁

//这里我们做一个倒计时的代码，使用Thread.sleep(ms)
public class LianXi implements Runnable{
    public static void main(String[] args) {
        new Thread(new LianXi()).start();
    }
    @Override
    public void run() {
        for(int i=10;i>=0;i--){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("倒计时"+i);
        }
    }
}

yield 方法
礼让线程
给了其他线程更多的执行机会,但是不能决定是否其他线程一定执行,要看cpu的调度

public class YieldTest implements Runnable{
    public static void main(String[] args) {
        YieldTest  yd = new YieldTest();
        new Thread(yd,"A").start();
        new Thread(yd,"B").start();
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"开始执行");
        Thread.yield(); //礼让
        System.out.println(Thread.currentThread().getName()+"结束执行");
    }
}

join 插队线程
join() 等待插队线程执行完毕 ,当前线程才能继续执行
join(ms) 最多只等待多少ms时间

public class LianXi10 {
    public static void main(String[] args) {
        Thread th =new Thread(()->{
            for(int i=0;i<=20;i++){

                System.out.println(Thread.currentThread().getState()+"运行状态");
            }
        });
        System.out.println(th.getState());
        th.start();
        System.out.println(th.getState());
        while(true){

        }
    }

}
class Fu implements Runnable {

    @Override
    public void run() {
        System.out.println("爹想抽烟了");
        System.out.println("给阿耶买烟去，小兔崽子");
        Thread th = new Thread(new Zi());
        th.start();//注意start方法要写在join方法上面
        try {
            th.join();//在这里插队，这里是插到Zi执行完毕，也可以设置插的时间
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("烟雾缭绕,不错，爹舒服了");
    }
}
class Zi implements Runnable{

    @Override
    public void run() {
        for(int i=1;i<=10;i++) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("小马阿小二郎，拿着钱袋买烟啷"+"走了"+i+"秒");
        }
    }
}
②getState()

Thread类中提供了一个属性: getState() 获取一个线程当前的状态
返回Thread.State枚举类型

public class StateTest {
    public static void main(String[] args) {
        Thread th1 = new Thread(()->{
            for(int i=1;i<=20;i++){
                if(i==10){
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(Thread.currentThread().getName()+"--->"+i);
            }
        });
        System.out.println(th1.getState());  //NEW

        th1.start();

        System.out.println(th1.getState());  //RUNNABLE

        //不停的打印th1线程的状态
        while(true){
            System.out.println(th1.getState());
            try {
                Thread.sleep(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            //当th1执行完毕进入终止状态结束打印
            if(th1.getState().equals(Thread.State.TERMINATED)){
                System.out.println(th1.getState());
                break;
            }
        }
    }
}
③线程的优先级

Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程。线程调度器按照 线程的优先级 决定应调度哪个线程来执行。线程的优先级用数字表示，范围从 1 到 10

每一个线程都存在优先级 : 优先执行的可能性
默认么一个线程优先级别为5
级别: 1~10 1最小 10最大

​ static int MAX_PRIORITY 线程可以拥有的最大优先级。
​ static int MIN_PRIORITY 线程可以拥有的最低优先级。
​ static int NORM_PRIORITY 分配给线程的默认优先级。

Thread 提供getPriority() 获取一个线程的优先级以及setPriority() 设置一个线程的优先级

注意: 优先级只能放大执行的机会,不代表一定先执行或者后执行优先级低只是意味着获得调度的概率低。并不是绝对先调用优先级高后调用优先级低的线程。

public class PriorityTest {
    public static void main(String[] args) {
        Thread th1 = new Thread(()->{
            System.out.println("th1线程");
        });

        Thread th2 = new Thread(()->{
            System.out.println("th2线程");
        });

        Thread th3 = new Thread(()->{
            System.out.println("th3线程");
        });

        //设置优先级
        th1.setPriority(Thread.MAX_PRIORITY);
        th2.setPriority(1);
        th3.setPriority(5);

        //获取优先级
        System.out.println(th1.getPriority());
        System.out.println(th2.getPriority());
        System.out.println(th3.getPriority());

        th1.start();
        th2.start();
        th3.start();
    }
}

二、守护线程与用户线程

守护线程与用户线程区别:
守护线程,就是用来守护用户线程的,当用户线程执行完毕,守护线程会直接结束
创建的线程默认用户线程
垃圾回收器就是一个典型的守护线程
如何设置一个线程为守护线程: void setDaemon(boolean on) 将此线程标记为 daemon线程或用户线程。 true->守护线程 false->用户线程
先设置守护线程,然后再start()

public class OtherDemo06 {
    public static void main(String[] args) {
        Thread th = new Thread(()->{
            int i = 1;
            while(true){
                System.out.println("我是守护线程"+i++);
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        //设置守护线程
        th.setDaemon(true);

        //开启线程
        th.start();

        //主线程默认用户线程
        for(int i=1;i<=20;i++){
            System.out.println("main用户线程"+i);
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}

三、中断标识

void interrupt() 为一个线程添加一个中断标识
static boolean interrupted() interrupted方法判断当前线程已经被添加过中断标识(是否当前线程调用过interrupt()方法).同时复位中断标识
boolean isInterrupted() 判断线程是否添加过中断标识,但是不会清楚这个标识

以上三个方法都不能实现线程的终止,只是添加|判断标识,配合break,return…一起使用

如果一个线程执行完毕,会自动复位|清除终止标识

public class InterruptTest {
    public static void main(String[] args) {
        Thread th = new Thread(()->{
            int i = 1;
            while(true){
                System.out.println("我是th线程"+i++);
                if(Thread.interrupted()==true){
                    System.out.println("结束");
                    System.out.println("结束之前最后判断状态"+Thread.currentThread().isInterrupted());
                    break;
                }
            }
        });
        th.start();

        System.out.println(th.isInterrupted());

        //为th线程添加一个中断标识
        th.interrupt();

        //isInterrupted() 判断th线程是否存在中断标识
       for(int i=1;i<=10;i++){
           System.out.println(th.isInterrupted());
           try {
               Thread.sleep(10);
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }


    }
}

四、线程安全

线程安全:
在一般情况下，创建一个线程是不能提高程序的执行效率的，所以要创建多个线程。但是多个线程同时运行的时候可能调用线程函数，在多个线程同时对同一个内存地址进行写入，由于CPU时间调度上的问题，写入数据会被多次的覆盖，所以就有可能造成数据的不准确。

加锁方式控制安全
同步锁 synchronized -> 我们也称悲观锁

​ synchronized :
​ 同步方法 : 方法上synchronized修饰
​ 同步块 : synchronized(this|类|资源){排队执行的代码}
​ 类.class : 相当于同步的整个类,class对象是唯一的
​ this : 同步了这个类型的某一个对象,锁住了这个对象的所有资源
​ 资源 : 当只想要锁住一个对象的某一个资源,可以只锁资源

​ 同步的范围代码太小容易锁不住,范围大效率低

同步方法
同步的资源–>指代调用成员方法的对象
成员是属于对象的
静态的属于类的

​ 简单,但是范围大效率低,而且有可能逻辑出现问题(案例中在死循环的外面)

①同步方法
public class Web12306_01 implements Runnable {
    int tickets = 100; //票

    /*
        买票过程
     */
    @Override
    public synchronized void run() {
        while(true){
            //A B C
            if(tickets<=0){
                break;
            }
            //A B C
            System.out.println(Thread.currentThread().getName()+"正在购买第"+tickets--+"张票");

            //模拟网络延迟
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        Web12306_01 web = new Web12306_01();
        //创建3个线程
        new Thread(web,"zhangsan").start();
        new Thread(web,"lisi").start();
        new Thread(web,"wangwu").start();
    }
}
②同步块(类)

同步块
synchronized(this|类.class|资源){}

​ 类.class : 类的class对象,每一个类,在加载到内存的时候,都会存在一个属于当前这个类的class对象,唯一的,不变的
​ 简单,但是一个类型的class对象是唯一的

public class Web12306_02 implements Runnable {
    int tickets = 10000; //票

    /*
        买票过程
     */
    @Override
    public void run() {
       while(true){
           //A B C
           synchronized (Web12306_02.class){//同步类
               if(tickets<=0){
                   break;
               }
               //A B C
               System.out.println(Thread.currentThread().getName()+"正在购买第"+tickets--+"张票");

               //模拟网络延迟
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
       }
    }

    public static void main(String[] args) {
        Web12306_02 web = new Web12306_02();
        Web12306_02 web2 = new Web12306_02();
        //创建3个线程
        new Thread(web,"zhangsan").start();
        new Thread(web,"lisi").start();
        new Thread(web2,"wangwu").start();
    }
}
③同步块(this)

synchronized(this|类.class|资源){}

this-> 成员方法中默认指代当前调用成员方法的对象

public class Web12306_03 implements Runnable {
    int tickets = 50; //票

    /*
        买票过程
     */
    @Override
    public void run() {
       while(true){
           //A B C
           synchronized (this){
               if(tickets<=0){
                   break;
               }
               //A B C
               System.out.println(Thread.currentThread().getName()+"正在购买第"+tickets--+"张票");

               //模拟网络延迟
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
       }
    }

    public static void main(String[] args) {
        Web12306_03 web = new Web12306_03();
        Web12306_03 web2 = new Web12306_03();
        //创建3个线程
        new Thread(web,"zhangsan").start();
        new Thread(web2,"lisi").start();
        new Thread(web2,"wangwu").start();
    }
}
④同步块(资源)

资源
自定义引用数据类型的对象–>new的对象的地址,不变的

​ 锁要锁不变的内容,会变的锁不住

public class Web12306_04 implements Runnable {
    Ticket tickets = new Ticket(); //票
    /*
        买票过程
     */
    @Override
    public void run() {
       while(true){
           //A B C
           synchronized (tickets){
               if(tickets.num<=0){
                   break;
               }
               //A B C
 		    System.out.println(Thread.currentThread().getName()+"正在购买第"+tickets.num--+"张票");

               //模拟网络延迟
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
       }
    }

    public static void main(String[] args) {
        Web12306_04 web = new Web12306_04();
        Web12306_04 web2 = new Web12306_04();
        //创建3个线程
        new Thread(web2,"zhangsan").start();
        new Thread(web2,"lisi").start();
        new Thread(web2,"wangwu").start();
    }
}

class Ticket{
    int num = 50;
}
⑤提高线程效率

双重检查 double check
尽量缩小同步块的代码范围,提高效率

public class Web12306_05 implements Runnable {
    int tickets = 10000; //票
    /*
        买票过程
     */
    @Override
    public void run() {
       while(true){
           //A B C
           if(tickets<=0){
               break;
           }
//但我们要执行这些代码，我们完全没必要放入同步块中
           System.out.println("------------------------->");
           System.out.println("------------------------->");
           System.out.println("------------------------->");
           System.out.println("------------------------->");
           System.out.println("------------------------->");
           System.out.println("------------------------->");

               //A B C
           synchronized (this) {
               if(tickets<=0){//我们完全可以在这里再添加一个判断语句，来提高效率
                   break;
               }
               System.out.println(Thread.currentThread().getName() + "正在购买第" + tickets-- + "张票");

               //模拟网络延迟
               try {
                   Thread.sleep(100);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
       }
    }

    public static void main(String[] args) {
        Web12306_05 web = new Web12306_05();
        Web12306_05 web2 = new Web12306_05();
        //创建3个线程
        new Thread(web,"zhangsan").start();
        new Thread(web,"lisi").start();
        new Thread(web,"wangwu").start();
    }
}

五、线程通信

线程通信
Object 类中提供的wait() 与 notify() notifyAll()方法
前提需要使用在同步环境下

​ wait() 等待,会对应进入到某一个对象的等待池中进行等待,阻塞状态,等待被唤醒
​ 释放cpu的资源,也会释放对象的锁
​ notify() 唤醒,唤醒某一个对象等待池中正在等待的线程,唤醒某一个
​ 不会释放对象锁
​ notifyAll() 唤醒全部

这里我们来做个练习：

模拟街道的红绿灯 ,人车公用街道
街道Street 红绿灯boolean flag ns南北 -> 车 we东西 -> 人
人 we东西 true
公用资源 街道
车 ns南北 false

生产者消费者模式–> 信号灯法

public class Demo06 {
    public static void main(String[] args) {
        Street s = new Street();
        new Thread(new Person(s)).start();
        new Thread(new Car(s)).start();
    }
}

//人
class Person implements Runnable{
    private Street street ;

    public Person(Street street) {
        this.street = street;
    }

    @Override
    public void run() {
       while(true){
           street.we();
       }
    }
}

//车
class Car implements Runnable{
    private Street street ;

    public Car(Street street) {
        this.street = street;
    }

    @Override
    public void run() {
        while(true){
            street.ns();
        }
    }
}

//街道
class Street{
    boolean flag = false; //红绿灯

    //南北
    public synchronized void ns(){
        //车 ns南北    false
        if(flag==false){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("车走");

            //变灯
            flag = true;
            //唤醒this对象等待池中的线程
            this.notify();
            //进入到this对象的等待池中等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
    //东西
    public synchronized void we(){
        //we东西    true
        if(flag==true){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("人走");

            //变灯
            flag = false;
            //唤醒this对象等待池中的线程
            this.notify();
            //进入到this对象的等待池中等待
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}
cnjss
关注
专栏目录
《JavaSE系列教程》
緑水長流*z
08-10 7万+
本专栏内容是为零基础正在学习Java的学习者量身定制的学习路线及方案，本教程字数超20w+，插图超过400+，知识体系极其全面，案例极其丰富。本配备有专门的学习群及学习视频，读者可加学习群与正在学习该阶段的人一同学习，有任何不懂的也可以观看于此教程配套的学习视频。
JAVA-16 API的使用
m0_59214979的博客
11-15 956
本节 :1. 掌握JAVA API文档的查阅方式 2. 常用类API的使用 java的API，其实就是应用程序的接口。 网站api一般是指一个网站提供的接口，比如登录验证、信息查询、通知、支付等等。 windows api是指windows操作系统提供的api。 我们要学会各种方法各种文档的查看和使用。 API文档地址链接：Java API 平台 1. 掌握JAVA API文档的查阅方式 构造函数： 该构造函数需要传入一个 字符串 ，构造出来的 字符串是 该原...
JavaSE 16
cystart的博客
02-05 469
异常处理： 异常概述与异常体系： 异常：在Java语言中，将程序执行中发生的不正常情况称为“异常”。 (开发过程中的语法错误和逻辑错误不是异常) Java程序在执行过程中所发生的异常事件可分为两类： Error：Java虚拟机无法解决的严重问题。如：JVM系统内部错误、资源耗尽等严重情况。比如：StackOverflowError和OOM。一般不编写针对性的代码进行处理。 Exception: 其它因编程错误或偶然的外在因素导致的一般性问题，可以使用针对性的代码进行处理。 1.运行时异常： 是指编译器不要求
Java javase16
kkh01421的博客
09-04 231
一、Stream流 （一）流式思想概述 当需要对多个元素进行操作（多步操作）时，考虑到性能及便利性，我们应该拼好一个模型再按照方案去执行它。（拼接流式模型） Stream流是一个来自数据源的元素队列。 元素是特定类型的对象，形成一个队列。Java中的Stream并不会存储元素而是按需计算。 数据源流的来源，可以是集合，数组等。 Stream操作有两个基础特征 PIpelinling：中间操作都会返回流本身。这样多个操作可以串联成一个管道，如同流式风格。 内部迭代：Stream提供了内部迭代方式，流可以
JavaSE 16(StringBuffer与StringBuild的区别）
weixin_45333967的博客
08-06 319
前言： StringBuffer和StringBuilder都继承自抽象类AbstractStringBuilder。 StringBuffer和StringBuilder是系统的类,两者和字符串的区别都是可变的字符序列. 但是不同的是StringBuffer是线程安全的,比较消耗资源的类,StringBuilder是线程不安全,节省资源的类 ，下面就来整理一下两者的详细区别。 两者的优势及缺陷：...
javase_16(其它流)
-为兴趣而生,是值得的
09-03 1009
IO包中的其他流:   1.打印流 a)PrintWriter(写-->print打印) 与PrintStream  (字符流) PrintWriter用法一:其实它是对一个Writer进行了封装 package com.javami.kudyTest; import java.io.FileNotFoundException; import java.io.PrintWri
javase 16 网络编程
皮皮亮的博客
11-07 1153
16 网络编程 ​ 学了这个我想你应该就能理解java的兼容性了，java不需要了解通信的规则，原理就能在其功能面操作，通过封装方法，得到数据传输的能力，只需要了解通信所需要的的然后给他信息就能进行通信连接。 计算机网络的概念 网络即将不同区域的电脑连接到一起， 组成局域网、城域网或广域网。把分布在不同地理区域的计算机与专门的外部设备用通信线路互连成一个规模大、功能强的网络系统，从而使众多的计算机可以方便地互相传递信息，共享硬件、软件、数据信息等资源。 主要功能实现： 资源共享 信息传输与集中处理 均衡负
非常详细javaSE学习笔记.rar
10-21
这份“非常详细JavaSE学习笔记.rar”压缩包显然是一份全面的Java SE学习资源，包含了从基础知识到高级特性的全方位讲解。下面，我们将详细探讨这份笔记可能涵盖的关键知识点。 1. **Java起源与环境搭建**：笔记可能...
JavaSE基础面试题.docx
06-11
JavaSE基础面试题涵盖了许多核心概念，以下是这些知识点的详细说明： 1. **面向对象的特征**：包括封装、继承和多态。封装是隐藏对象的属性和实现细节，仅对外提供公共访问方式；继承是子类继承父类的属性和方法，...
3、JavaSE：流程控制-16.pdf
06-12
Java SE中的流程控制是编程中不可或缺的部分，它允许程序员决定程序执行的顺序和逻辑。在本节中，我们将深入探讨Java中的用户交互以及如何使用`Scanner`类来获取用户输入。 `Scanner`类是Java标准库`java.util`包的...
JAVA SE (16)
zzyssg的博客
04-05 980
Java 反射 反射：在运行状态中，对于任意一个类，能够知道这个类的所有属性和方法；对于任意一个对象，能够调用它的任意方法和属性；并且能够改变它的属性。 反射机制允许程序在运行时取得一个已知名称的class的内部信息，即修饰符、属性、方法，并且可在运行时改变属性或者调用方法。 **缺点：**反射使用不当会造成很高的资源浪费。使用反射会打破封装性，导致对象的属性不安全。 一个JVM中只有一个Clas...
JavaSE16——抽象类（Abstract Class）
最新发布
tonyshi1989的博客
09-27 1011
使用abstract关键字修饰方法，该方法就成了抽象方法，抽象方法只包含一个方法名，而没有方法体。修饰符 abstract 返回值类型 方法名 (参数列表);抽象类用关键字"abstract"进行声明：在Java中，通过使用关键字"abstract"来声明一个抽象类。抽象类不能被直接实例化，只能作为父类被继承。抽象方法和非抽象方法：抽象类可以包含抽象方法和非抽象方法。抽象方法：没有具体实现的方法，只有方法声明，没有方法体。抽象方法必须使用关键字"abstract"进行声明。
JavaSE-16 集合框架
weixin_30316097的博客
01-09 120
学习要点 Java集合框架内容 ArrayList和LinkedList HashMap Iterator 泛型集合 Java的集合框架 1 概述 数据结构是以某种形式将数据组织在一起的集合，它不仅存储数据，还支持访问和处理数据的操作。 数据结构对程序设计有着深远的影响，在面向过程的C语言中，数据库结构用struct来描述，而在面向对象的编程中，数据结构是用类来...
JavaSE_16_集合框架（二）
weixin_42788897的博客
06-14 73
重点Map集合的特点及使用；栈与队列的概念及使用。难点Map集合结构及遍历方式。
JAVASE-16 SPI
Sheng_Q的博客
03-07 510
JAVASE-16 SPI 最近写业务代码的时候，遇到了SPI的概念，是个遗漏的知识点，总结一下 1.SPI概念 SPI 是英文Service Provider Interface的缩写, 即服务提供商接口。 以jdbc为例，在jdk中提供了jdbc的接口类，不同厂商分别提供对应的实现类，如：mysql-jdbc,oralce-jdbc,sqlserver-jdbc等。 JDBC的接口类是java的基础类库，是由引导类加载器加载进jvm的；实现类是在运行时从厂家的jar包中加载得到的，因此至少是通过系统类加
【JavaSE】16-网络编程
Sihang_Xie的博客
05-16 1139
十六、 网络编程 16.1 网络编程概述 网络编程的目的： 直接或间接地通过网络协议与其它计算机实现数据交换，进行通讯。 网络编程中有两个主要的问题： 如何准确地定位网络上一台或多台主机；定位主机上的特定的应用。 找到主机后如何可靠高效地进行数据传输。 16.2 网络通信要素概述 网络编程中的两个主要问题，分别对应以下两个要素： 要素一：IP和端口号 IP ：相当于每台主机的身份证号码，是网络当中唯一定位的一台主机。 端口号：区分一台主机上不同的应用程序，哪一个应用程序来进行通信。 要
JavaSE16-面向对象-接口
Joyechen1的博客
03-01 290
面向对象-接口
Java SE 16新版本特性（中文注释说明）
weixin_45576146的博客
03-18 1775
目录合并发行说明JDK 16 发行说明Introduction/介绍IANA 数据 2020dJDK 16 的新功能和增强功能已删除的功能和选项甲骨文 JDK 与甲骨文开放 JDK 的区别 合并发行说明 本页包含 JDK 16 一般可用性 （GA） 版本的所有发布说明 JDK 16GA JDK 16 发行说明 Introduction/介绍 这些说明描述了重要的更改、增强功能、删除的 ABI 和功能、废弃的 ABI 和功能，以及有关 JDK 16 和 Java SE 16 的其他信息。在某些情况下，这些
Java SE（16） 变量数据类型2
wqh101121的博客
12-24 507
变量的数据类型
JavaSE核心技术：StringBuffer详解
"StringBuffer类-JavaSE核心编程" 在Java SE编程中，`StringBuffer` 类是一个重要的类，主要用于处理可变的字符串。与不可变的 `String` 类不同，`StringBuffer` 提供了在字符串操作中高效且安全的修改能力。当需要...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值