Java编程 Javase13

最新推荐文章于 2023-08-22 08:58:53 发布
最新推荐文章于 2023-08-22 08:58:53 发布
阅读量402 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： JavaSE 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kkh01421/article/details/115916057
本文深入探讨了Java中的多线程概念，包括并发与并行、进程与线程的区别、线程调度、主线程的执行流程。详细讲解了如何创建多线程程序，包括继承Thread类和实现Runnable接口的方式，并介绍了线程安全问题和解决方案，如线程同步、锁机制。此外，还讨论了线程池的使用以及Lambda表达式在简化多线程代码中的应用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

一、多线程

（一）并发与并行

（二）进程概念

  • 进程指一个内存中的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个程序从创建、运行到消亡的过程。

（三）线程概念

  • 线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以被称之为多线程程序。
  • 总之：一个程序运行后至少有一个进程，一个进程中可以包含多个线程。

（四）线程的调度

1、分时调度

  • 所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间

2、抢占式调度

  • 优先让优先级高的线程使用CPU，如果线程的优先级相同，那么就会随机选择一个（线程随机性），Java使用的为抢占式调度。

（五）主线程

  • 执行（main）方法的线程
  • 单线程程序：Java程序中只有一个线程，执行从main方法开始，从上到下依次执行。
  • JVM执行main方法，main方法会进入到栈内存。JVM会找操作系统开辟一条main方法通向CPU的执行路径。cpu就可以通过这个路径（主线程）来执行main方法。

（六）创建多线程程序第一种方式

  • 创建Thread类的子类
  • java.lang.Thread类：是描述线程的类，如果想要实现多线程程序，就必须继承Thread类

1、实现步骤

  • 创建一个Thread类的子类
  • 在Thread类的子类中重写Thread类中的run方法，设置线程任务
  • 创建Thread类的子类对象
  • 调用Thread类中的方法start方法，开启新的线程，执行run方法
void start() 使该线程开始执行；Java虚拟机调用该线程的run方法。
    结果是两个线程并发地运行；当前线程(main线程)和另一个线程(创建的新线程，执行其run方法)。
    多次启动一个线城是非法的。特别是当线程已经结束执行后不能再重新启动。

2、测试代码

public class test1 extends Thread {

    @Override
    public void run() {
        for (int i = 1; i <=10; i++) {
            System.out.println("run"+i);
        }
    }
}

public class test01 {
    public static void main(String[] args) {
        test1 t1 = new test1();
        t1.start();
        for (int i = 1; i <=10 ; i++) {
            System.out.println("main"+i);
        }

    }
}
run1
run2
main1
run3
main2
run4
main3
run5
main4
run6
main5
run7
main6
run8
main7
run9
main8
run10
main9
main10

二、线程

（一）多线程原理

1、随机打印结果

2、多线程内存图解

（二）Thread类

1、获取线程的名称

  • 使用Thread类中的方法getName
String getName()    返回该线程的名称
  • 可以先获取到当前正在执行的线程，使用线程中的方法getName获取线程的名称
static Thread currentTHread()    返回对当前正在执行的线程对象的引用
  • 测试代码
public class test2 extends Thread{

    @Override
    public void run() {
        //直接获取线程名称
        String name = getName();
        System.out.println(name);
        //线程运行中获取
       Thread name1 = currentThread();
        System.out.println(name1);
        //链式编程获取线程名
        System.out.println(Thread.currentThread().getName());
    }
}

public class test02 {
    public static void main(String[] args) {
        test2 t2 = new test2();
        t2.start();
        //输出主线程名
        System.out.println(Thread.currentThread().getName());
    }
}

Thread-0
main
Thread[Thread-0,5,main]
Thread-0

2、设置线程的名程（了解）

（1）使用Thread类中的方法setName（名字）

        void setName(String name) 改变线程名称，使之与参数name相同。

（2）创建一个带参数的构造方法，参数传递线程的名称；调用父类的带参数构造方法，把线程的名称传递给父类，让父类（Thread）给子线程起一个名字Thread（String name）分配给新的Thread对象。

public class test3 extends Thread{
    //获取线程名称
    public void run(){
        System.out.println(Thread.currentThread().getName());
    }
    //获取线程名称
    public test3(){}
    public test3(String name){
        super(name);
    }

}

public class test03 {
    public static void main(String[] args) {
        test3 t1=new test3();
        t1.setName("zhangsan");
        t1.start();

        new test3("lisi").start();

    }

}

3、Thread类常用方法:Sleep

public static void sleep (long millis):使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）

毫秒数结束后，线程继续执行。

public class test4 {
    public static void main(String[] args) {
        //模拟秒表
        for (int i = 1; i <60 ; i++) {
            System.out.println(i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

（三）Runable接口

1、实现Runable接口

（1）Runable接口应该由那些打算通过某一线程执行其实例的类实现。类必须定义为一个称为run的无参数方法。

（2）构造方法

Thread(Runable target):分配新的Thread对象
Thread(Runable target,String name):分配新的Thread对象

实现步骤

1、创建一个Runable接口的实现类

2、在实现类中重写Runable接口的run方法，设置线程任务

3、创建一个Runable接口的实现类对象

4、创建Thread类对象，构造方法中传递Runable接口的是实现类对象

5、调用Thread类中的start方法，开启新的线程执行run方法。

public  class test5 implements Runnable{
    public void run(){
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+"-->"+i);
        }
    }
}

public class test05 {
    public static void main(String[] args) {
        test5 t1 = new test5();
        Thread t = new Thread(t1);
        t.start();
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "-->" + i);
        }
    }
}

2、Thread和Runnable的区别

如果一个类继承Thread，则不适合资源共享，如果实现了Runable接口，则很容易实现资源共享。

实现Runable接口创建多线程程序好处

1、避免了单线程局限性

一个类只能继承一个类，实现Runable接口还可以继承其他类实现其他接口

2、增强了程序的扩展性，降低了程序的耦合性（解耦）

实现Runable接口的方式，把设置线程任务和开启新线程进行了分离（解耦）

实现类中，重写了run方法：用来设置线程任务

创建Thread类对象，调用start方法：用来开启新线程

（四）匿名内部类方式实现线程的创建

匿名：没有名字

内部类：写在其他类内部的类

作用：简化代码。把子类继承父类，重写父类的方法，创建子类对象合一步完成。把实现类实现类接口，重写接口中的方法，创建实现类对象合一步完成。

产物：子类/实现类对象，而这个类没有名字。

格式：

new 父类/接口 (){
    重复父类/接口中方法
};

测试代码：

public class test6 {
    public static void main(String[] args) {
        //类
       new Thread(){
           @Override
           public void run() {
               for (int i = 0; i < 10; i++) {
                   System.out.println(Thread.currentThread().getName()+"-->"+i);
               }
           }
       }.start();
       //接口
        Runnable r =new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println(Thread.currentThread().getName()+"-->"+i);
                }
            }
        };
        new Thread(r).start();
        //接口简化
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println(Thread.currentThread().getName()+"-->"+i);
                }
            }
        }).start();
    }
}

二、线程安全

(一）线程安全概述

1、单线程程序不会出现线程安全问题

2、多线程程序没有访问共享数据不会产生问题

3、多线程程序访问了共享数据会产生数据安全问题

（二）线程同步

1、同步代码块

格式：

synchronized(锁对象){
    代码
}

注意：

        通过代码块中的锁对象可以使用任意对象。但是必须保证多个线程使用的锁对象是同一个。

锁对象作用：

        把同步代码块锁住，只让一个线程在同步代码块执行

public class test7 implements Runnable{
    private int number=100;
    //创建锁对象
    Object obj=new Object();
    @Override
    public void run() {
        while(number>0){
            synchronized (obj){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if(number>0){
                    System.out.println("现在到第"+number+"号");
                }
                number--;
            }
        }
    }
}


public class test07 {
    public static void main(String[] args) {
       test7 t=new test7();
        Thread t1=new Thread(t);
        Thread t2=new Thread(t);
        Thread t3=new Thread(t);
        t1.start();
        t2.start();
        t3.start();
    }
}

2、同步技术原理

使用一个锁对象，这个锁对象叫同步锁也叫对象锁，也叫对象监视器。

同步中的线程没有执行完毕不会释放锁，同步外的线程没有锁进不去同步。

同步保证了只有一个线程在同步在中执行共享数据，保证安全。程序频繁的判断锁，获取锁，释放锁，程序的效率会降低。

3、同步方法

（1）把访问共享数据代码抽取出来，放到一个方法中

（2）在方法上 添加synchronized修饰符

格式：定义方法的格式

修饰符 synchronized 返回值类型 方法名（参数列表）{
    代码
}
public class test7 implements Runnable{
    private int number=100;
    @Override
    public void run() {
        syn();
    }
    //创建同步方法
    private synchronized void syn() {
        while(number>0){
            synchronized (this){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if(number>0){
                    System.out.println("现在到第"+number+"号");
                }
                number--;
            }
        }
    }
}

4、静态同步方法

public class test7 implements Runnable{
    private static int number=100;
    @Override
    public void run() {
        syn();
    }

    private static synchronized void syn() {
        while(number>0){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if(number>0){
                    System.out.println("现在到第"+number+"号");
                }
                number--;
            }
        }
    }

静态同步方法的锁对象是本类的class文件

5、Lock锁

Lock接口中的方法：

void Lock():获取锁
void unLock():释放锁

使用步骤

1、在成员位置创建一个ReentrantLock对象

2、在可能出现安全问题代码前调用Lock接口中方法获取Lock获取锁

3、在可能出现安全问题代码后调用Lock接口中方法释放unLock获取锁

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class test7 implements Runnable {
    private static int number = 100;
    Lock l =new ReentrantLock();
    @Override
    public void run() {
        while (true) {
            l.lock();
            if (number > 0) {
                System.out.println("现在到第" + number + "号");
            }
            number--;
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            l.unlock();
        }
    }
}

三、线程状态

(一）线程状态概述

 (二）等待唤醒

线程间通信

1、通信的线程必须死用同步代码块包裹起来，保证等待和唤醒自由一个人在执行

2、同步使用的锁对象必须保证唯一

3、只有锁对象才能调用wait和notify方法

Object类中方法
void wait()
    在其他线程调用此对象的notify方法或者ontifyALL方法前，导致当前线程等待
void notify(）
    唤醒在此对象监视器上等待的单个线程，会继续执行wait方法之后的代码
public class test8 {
    public static void main(String[] args) {
        Object obj = new Object();
        //创建一个顾客线程
        new Thread(){
            @Override

            public void run() {
                synchronized (obj) {
                    System.out.println("告知老板要的包子种类和数量。");
                    try {
                        obj.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("开吃！");
                }
            }
        }.start();
        //创建一个老板线程
        new Thread(){
            @Override
            public void run() {
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (obj){
                    System.out.println("老板三秒后做好包子");
                    obj.notify();
                }

            }
        }.start();
    }
}

（三）Object类中的wait带参方法和notifyALL方法

进入到TimeWaiting（计时等待）有两种方式

1、使用sleep（long m）方法，在毫秒值结束后，线程睡醒进入到Runable/Bolcked状态

2、使用wait（long m)方法，wait方法如果在毫秒值结束后，还没有notify唤醒，就会自动醒来，线程睡醒进入到Runable/Blocked状态

唤醒的方法：

void notify():唤醒在此对象监视器上等待的单个线程
void notifyALL():唤醒在此对象监视器上等待的所有线程

public class test8 {
    public static void main(String[] args) {
        Object obj = new Object();
        //创建一个顾客线程
        new Thread(){
            @Override

            public void run() {
                synchronized (obj) {
                    System.out.println("告知老板要的包子种类和数量。");
                    try {
                        obj.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("顾客张三开吃！");
                }
            }
        }.start();
        new Thread(){
            @Override

            public void run() {
                synchronized (obj) {
                    System.out.println("告知老板要的包子种类和数量。");
                    try {
                        obj.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("顾客李四开吃！");
                }
            }
        }.start();
        //创建一个老板线程
        new Thread(){
            @Override
            public void run() {
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized (obj){
                    System.out.println("老板三秒后做好包子");
                    obj.notifyAll();
                }

            }
        }.start();
    }
}

四、等待唤醒机制

（一）线程间通信

1、概念：多个线程在处理同一个资源，但是处理的动作（线程的任务）却不相同。

2、作用：当我们需要多个线程来共同完成一个任务时，并且我们希望他们有规律的执行，那么多线程之间需要一些协调通信，以此来帮我们达到多线程共同操作一份数据。

（二）等待唤醒机制

等待唤醒机制：线程之间的通信。

重点：有效利用资源。

    1、等待唤醒中的方法

wait：线程不再活动，不再参与调度，进入wait set中，因此不会浪费CPU资源，也不会去竞争锁了，这时的线程状态即是WAITTING。它还要等着别的线程执行一个特别的动作，也就是通知（notify）在这个对象上等待的线程从wait set中释放出来，重新进入到调度队列（ready queue）中。

notify：选取所通知wait set中的一个线程释放。

notifyAll：释放所通知对象的wait set上的全部线程。

2、调用wait和notify需要注意的细节

（1）wait方法与notify方法必须要由同一个锁对象调用。因为：对应的锁对象可以通过notify唤醒使用同一个锁对象调用的wait方法后的线程。

（2）wait方法与notify方法是属于Object类的方法的。因为：锁对象可以是任意对象，而任意对象的所属类都是继承了Object类的。

（3）wait方法与notify方法必须要在同步代码块或者是同步函数中使用。因为：必须要通过锁对象调用这2个方法。

3、等待唤醒机制需求分析

4、代码实现

public class baozi {
    String pi;
    String xian;
    boolean zhuangtai = false;
}


public class baozipu extends Thread {
    private baozi bz;

    public baozipu(baozi bz) {
        this.bz = bz;
    }

    @Override
    public void run() {
        int count = 0;
        while (true) {
            synchronized (bz) {
                if (bz.zhuangtai == true) {
                    try {
                        bz.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                if (count % 2 == 0) {
                    bz.pi = "薄皮";
                    bz.xian = "猪肉大葱";
                } else {
                    bz.pi = "冰皮";
                    bz.xian = "香辣茄子";
                }
                count++;
                System.out.println("包子铺的" + bz.pi + bz.xian + "包子马上出锅了");
                try {
                    Thread.sleep(3000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                bz.zhuangtai = true;
                bz.notify();
                System.out.println("包子出锅，可以开吃啦！");

            }
        }
    }
}


public class eat extends Thread{
    private baozi bz;

    public eat(baozi bz) {
        this.bz = bz;
    }

    @Override
    public void run() {
        while(true){
            synchronized (bz){
                if(bz.zhuangtai==false){
                    try {
                        bz.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("顾客正在吃"+bz.pi+bz.xian+"包子");
                bz.zhuangtai=false;
                bz.notify();
                System.out.println("顾客已经吃完了。");
                System.out.println("-------------------------------");
            }
        }
    }
}


public class test09 {
    public static void main(String[] args) {
        baozi baozi=new baozi();
        new baozipu(baozi).start();
        new eat(baozi).start();
    }
}

五、线程池

（一）线程池的概念和原理

   1、概念

线程池其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源。

2、原理

 （二）线程池使用

1、使用步骤

（1）使用线程池的工厂类Executors里边提供的静态方法newFixedThreadPool生产一个指定线程数量的线程池

（2）创建一个类实现Runnable接口，重写run方法，设置线程任务

（3）调用ExecutorsService中的方法submit，传递线程任务（实现类），开启线程执行run方法

（4）线程池会一直开启，使用完了线程，会自动把线程归还给线程池，线程可以继续使用。调用ExecutorsService中的方法shutdow销毁线程池（不建议执行）

2、代码实现

public class rmpl implements Runnable{
    public void run(){
            System.out.println(Thread.currentThread().getName());
    }
}


import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class test {
    public static void main(String[] args) {
        ExecutorService es = Executors.newFixedThreadPool(3);
        es.submit(new rmpl());
        es.submit(new rmpl());
        es.submit(new rmpl());
        es.submit(new rmpl());
        es.shutdown();
        es.submit(new rmpl());//执行后出现异常
    }
}

六、Lambda表达式

（一）函数式编程思想概述

1、面向对象思想：

做一件事情，找一个能解决这个事情的对象，调用对象的方法完成事情

2、函数式编程思想：

纸要能获取到结果，谁去做的，怎么做的都不重要，重要的是结果而不是过程。

（二）冗余的Runnable代码

1、传统写法

public class test6 {
    public static void main(String[] args) {
        //类
       new Thread(){
           @Override
           public void run() {
               for (int i = 0; i < 10; i++) {
                   System.out.println(Thread.currentThread().getName()+"-->"+i);
               }
           }
       }.start();
       //接口
        Runnable r =new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println(Thread.currentThread().getName()+"-->"+i);
                }
            }
        };
        new Thread(r).start();
        //接口简化
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println(Thread.currentThread().getName()+"-->"+i);
                }
            }
        }).start();
    }
}

（1）为了指定run方法，不得不需要Runnable接口的实现类

（2）为了指定run的方法体，不得不需要Runnable接口的实现类

（3）为了省去定义一个实现类的麻烦，不得不使用匿名内部类

（4）必须覆盖重写抽象run方法，所以方法名称，方法参数，方法返回值不得不再写一遍且不能写错

（三）函数式编程思想

public class test01 {
    public static void main(String[] args) {
        //使用匿名内部类实现多线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                 {
                    System.out.println(Thread.currentThread().getName());
                }
            }
        }).start();

        //使用lambda表达式实现多线程
       new Thread(()->{
           System.out.println(Thread.currentThread().getName());
       }).start();
    }
}

（四）Lambda标准格式

Lambda表达式的标准格式由三部分组成

1、一些参数

2、一个箭头

3、一段代码

格式：（参数列表）->（一些重写方法的代码）

解释说明格式：

（）：接口中抽象方法的参数列表，没有参数，就空着；有参数就写出参数，多个参数使用逗号分隔

->：传递的意思，把参数传递给方法体{ }

{ }：重写接口的抽象方法

1、无参数无返回

public interface cook {
    public abstract void makefood();
}


public class test {
    public static void main(String[] args) {
        invokecook(()->{
            System.out.println("做饭了！");
        });
    }

    public static void invokecook(cook c){
        c.makefood();
    }
}

2、有参数和返回值

案例一：

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

    public person() {
    }

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

    @Override
    public String toString() {
        return "person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

public class test {
    public static void main(String[] args) {
        person[] arr= {
                new person("zhangsan",18),
                new person("lisi",28),
                new person("wangwu",16),
        };
      Arrays.sort(arr,(person o1,person o2)->{
          return o1.getAge()-o2.getAge();
      });
        for (person p:
             arr) {
            System.out.println(p);
        }
    }
}

 案例二：


public interface CAL {
    public abstract int cal(int a,int b);
}

public class test01 {
    public static void main(String[] args) {
        invokcal(120,130,(int a,int b)->{
            return a+b;
        });
    }

    private static void invokcal(int a, int b, CAL c) {
        int sum=c.cal(a,b);
        System.out.println(sum);
    }
}

（五）Lambda表达式省略

Lambda表达式是可推导可省略

凡是根据上下文推导出来的内容，都可以省略书写

可以省略的内容：

1（参数列表）：括号中参数列表的数据类型可以省略不写

2（参数列表）：括号中的参数只有一个，那么类型和（）都可以省略

3   {一些代码}：如果{ }中的代码只有一行，无论是否有返回值，都可以省略（{ }，return ，分号）

注意：要省略{ }，return，分号必须一起省略

（六）Lambda的使用前提

1、使用Lambda必须具有接口且要求接口中只有一个抽象方法。

2、使用Lambda必须具有上下文推断。

JavaSE13
cystart的博客
02-03 475
子类对象实例化的全过程： ①从结果上来看：(继承性) 子类对象继承父类以后，就获取了父类中声明的属性或方法。 创建子类的对象，在堆空间中，就会加载所有父类中声明的属性。 ②从过程上来看： 当我们通过子类的构造器创建子类对象时，我们一定会直接或间接的调用其父类的构造器，进而调用父类的父类的构造器，直到调用了java.lang.Object类中空参的构造器为止。正因为加载过所有的父类的结构，所以才可以看到内存中父类的结构，子类对象才可以考虑进行调用。 虽然·创建子类对象时，调用了父类的构造器，但是自始自终就创建
19年全套java教程javase零基础到高级视频idea小白自学编程jdk8
06-16
总结，"19年全套java教程javase零基础到高级视频idea小白自学编程jdk8"这个资源涵盖了Java编程语言从入门到精通的全过程，包括了JDK8的新特性、JavaSE的基础与进阶知识，以及使用IDEA进行开发的实践指导。...
Java SE Development Kit 13.0.2 x64.zip
02-10
官网下载太慢了，适合win10使用的 JAVA SE 13.0.2 没下EE 主要下的太慢了，挂了一晚上才下载好
Java SE 13 新增特性
Practitioner
08-20 265
因此，在 Java 13 中引入了新的实现方式，使用了新的实现 NioSocketImpl 来代替老旧的 PlainSocketImpl 实现。java.net.Socket 和 java.net.ServerSocket 类早在 Java 1.0 时就已经引入了，它们的实现的 Java 代码和 C 语言代码的混合，维护和调试都十分不易；ZGC 是 Java SE 11 中引入的一个实验性垃圾收集器，它承诺在10毫秒或更短的时间内实现 stop-the-world。默认情况下，这个值是300秒。
JavaSE 13(面向对象）
weixin_45333967的博客
08-02 902
前言： 今天准备整理一下JavaSE第二阶段（面向对象）的知识点以及重点，便于自己的复习与巩固，因为这一块内容的概念较多较杂所以需要整理清楚。 1.类和对象： 1 1.什么是对象： 对象（object) 代表现实世界中可以明确标识的一个实体。例如：一个学生、一张桌子、一个圆、一个按钮甚至一笔贷款都可以看作是一个对象。 每个对象都有自己独特的标识、状态和行为。 一个对象的狀态（state，也称为特征...
【JavaSE】13-集合
Sihang_Xie的博客
05-16 440
十三、 集合 13.1 Java集合框架概述 1.集合是什么 集合是数据的容器，是数组的延申，简称 Java 容器。 说明：此时的存储主要指的是内存层面的存储，不涉及到持久化的硬盘存储。 2.数组的特点 在介绍集合之前，先回顾一下数组的特点： ① 首先，数组一旦初始化以后，其长度就确定了。 ② 数组一旦定义好，其元素的类型也就确定了。如String[] 、int[]。 3.数组的缺点 ① 一旦初始化以后，其长度就不可修改了。 ② 数组中提纲的方法非常有限，对于添加、删除、插入数据等操作需要自己手写实现方法
基于JavaSE的日常Java编程设计源码
10-02
本文档主要介绍的是基于JavaSE的日常Java编程设计源码。该项目是一系列日常编程设计的源代码集合，其开发过程主要依赖于JavaSE环境。JavaSE作为Java标准版，是开发Java应用程序的基础，适用于各种平台，包括Windows...
基于JavaSE的Java编程案例设计源码
最新发布
10-03
在当前的计算机编程教学和实践领域，Java语言凭借其强大的跨平台能力、丰富的类库支持以及优秀的...通过学习和实践这些案例，Java编程的学习者可以系统地掌握JavaSE编程的核心技能，并将理论知识转化为实际的编程能力。
java控制台javaSE 初级java家教管理系统控制台命令行程序项目源代码 Java源代码 家教管理系统程序代码
07-01
本系统是使用java语言结合mysql数据库开发的初级java家教管理系统，使用命令行控制台界面进行系统的操作。 1. 录入家教信息 2. 查看个人信息 3. 查看家教记录 4. 修改个人信息（修改账号、密码、手机号、性别...
Java虚拟机规范 JavaSE7
04-29
Java虚拟机（JVM）是Java程序运行的基础，它负责执行Java字节码，提供了一个与平台无关的执行环境。JVM规范定义了JVM的结构、指令集和运行时数据区，以及如何执行指令和处理异常。自1999年以来，JVM规范经历了多次...
JavaSE（13）——Java集合总结
phg739436146的博客
08-07 199
java集合总结 1. 概述 java容器可分为两大类 Collection List ArrayList LinkedList Vector (了解即可，已过时) Set TreeSet HashSet LinkedHashSet Map HashMap LinkedHashMap TreeMap ConcurrentHashMap HashTable (了解即可，已过时) 2. ArrayList和Vector的区别 共同点 这两个类都实现了List接口 都是
JavaSE进阶13：网络编程入门、UDP通信程序、TCP通信程序、日志logback、枚举
XXXZhy丶Blog
04-26 1642
1.线程池 1.1 线程状态介绍 当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。线程对象在不同的时期有不同的状态。那么Java中的线程存在哪几种状态呢？Java中的线程 状态被定义在了java.lang.Thread.State枚举类中，State枚举类的源码如下： public class Thread { public enum State { /* 新建 */ NEW , /* 可运行状态
JavaSE学习13（IO流 File,字节流）
weixin_44643735的博客
11-06 159
IO流 1.File 1.1 File类概述和构造方法 file:它是文件和目录路径名的抽象表示 文件和目录是可以通过File封装成对象的 对于File而言，其封装的并不是真正存在的文件，仅仅是一个路径名而已。可以存在，也可以不存在。 将来要通过具体的操作把这个路径的内容转换为具体存在的 构造方法 File(String pathname) 通过给定的路径名字符...
JavaSE 13 集合与泛型
loetca
04-14 531
JavaSE 13 集合与泛型
JAVA SE 13快速安装
hdk996的博客
10-10 2319
1.JAVA SE 13下载链接地址：https://www.oracle.com/technetwork/java/javase/downloads/jdk13-downloads-5672538.html 2.默认安装路径 3.配置环境变量中的系统变量 首先找到Java安装的地址（默认C:\Program Files\Java\jdk-13），复制 在电脑属性-高级系统设置-环境变量-系统变...
JavaSE(十三)-String类
专业的计算机毕业设计指南
08-22 110
类代表不可变的字符序列。“abc”、”ddd”等字符串为String类的一个对象。String表示的是字符串，String在Java中是一个类，不属于8个基本数据类型之一。String是一个final修饰的类，那么String类是最终类，不能被继承！
JavaSE_13_系统常用类（一）
weixin_42788897的博客
06-14 125
重点字符串常用方法；正则表达式；String、StringBuilder、StringBuffer三者区别；包装类的使用及与字符串的互转。难点正则表达式；String、StringBuilder、StringBuffer三者区别。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值