JAVAOOP-19线程

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

JAVAOOP-19线程

一. 线程相关类Runtime,Timer使用

Runtime类是一个单例类

  • 每个 Java 应用程序都有一个 Runtime 类实例，使应用程序能够与其运行的环境相连接。通过 getRuntime 方法获取当前运行时。

  • 案例:自动关机

    package com.yunhe.thread;

import java.io.IOException;

public class RunTimeDemo {
    public static void main(String[] args) throws IOException {
        Runtime r=Runtime.getRuntime();
        r.exec("shutdown -s -t 300");//300秒后关机
        r.exec("shutdown -a");//取消关机
    }
}

Timer：

​ 一种工具，用于在后台线程中执行的任务。

​ 可安排任务执行一次，

​ 或者定期重复执行。

​ 定时器在子线程中执行

普通方法说明
public void schedule(TimerTask task, long delay)安排在指定延迟后执行指定的任务。
public void schedule(TimerTask task, long delay, long period)安排指定的任务从指定的延迟后开始进行重复的固定延迟执行。
public void schedule(TimerTask task, Date firstTime, long period)安排指定的任务在指定的时间开始进行重复的固定延迟执行。

TimerTask：

由 Timer 安排为一次执行或重复执行的任务。

普通方法说明
abstract void run()此计时器任务要执行的操作。
boolean cancel()取消此计时器任务。

​

​

import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

public class Demo11 {

    public static void main(String[] args){
        test3();
    }

    // 1 秒后执行任务
    public static void test1(){
        Timer timer  = new Timer();
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("执行任务");
            }
        },1000);
    }

    // 3 秒后执行任务，每隔 2 秒执行一次
    public static void test2(){
        Timer timer = new Timer();
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("测试2.."+ new Date());
            }
        },3000,2000);
    }

    public static void test3(){
        Timer timer = new Timer();
        timer.schedule(new TimerTask() {
            int count  = 5;
            @Override
            public void run() {
                System.out.println("任务A: " + count + "..." + Thread.currentThread());
                count--;
                if(count==0){
                    timer.cancel();
                }
            }
        },1000,2000);
    }

}

二. 线程之间通讯wait,notify

Object类的方法：

普通方法说明
void notify()唤醒在此对象监视器上等待的单个线程。
void notifyAll()唤醒在此对象监视器上等待的所有线程。
void wait()在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待。
void wait(long timeout)在其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者超过指定的时间量前，导致当前线程等待。
//解决死锁的方法：线程间的通信  wait() notify() 等待，唤醒 他们和synchorized搭配使用
public class TestTX {

	public static void main(String[] args) throws InterruptedException {
		new ThreadE().start(); Thread.sleep(10);
		new ThreadF().start();

	}

}
class Suo {
	public static final Object o=new Object();
}

class ThreadE extends Thread{
	public void run(){
		synchronized (Suo.o) {
			System.out.println("1");
			System.out.println("2");
			//输出12之后，让他等待，他在等待时，会把当前锁给释放了
			try {
				Suo.o.wait();
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println("3");
			System.out.println("4");
		}
		
	}
}

class ThreadF extends Thread{
	public void run(){
		synchronized (Suo.o) {
			System.out.println("a");
			System.out.println("b");
			System.out.println("c");
			System.out.println("d");
			Suo.o.notify();
			//通知对方线程，你需要的条件满足了，不用等了
		}
	}
}

三. 线程池

1. 线程池的作用
线程池作用就是限制系统中执行线程的数量。
根据系统的环境情况，可以自动或手动设置线程数量，达到运行的最佳效果。
少了浪费了系统资源，多了造成系统拥挤效率不高。
用线程池控制线程数量，其他线程排 队等候。
一个任务执行完毕，再从队列的中取最前面的任务开始执行。
若队列中没有等待进程，线程池的这一资源处于等待。
当一个新任务需要运行时，如果线程池 中有等待的工作线程，就可以开始运行了；否则进入等待队列。
2. 为什么要用线程池?
1.减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。
2.可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机)。
Java里面线程池的顶级接口是Executor，但是严格意义上讲Executor并不是一个线程池，而只是一个执行线程的工具。真正的线程池接口是ExecutorService。

3. 比较重要的几个类

java.util.concurrent 包

类描述
ExecutorService真正的线程池接口。
ScheduledExecutorService能和Timer/TimerTask类似，解决那些需要任务重复执行的问题。
ThreadPoolExecutorExecutorService的默认实现。
ScheduledThreadPoolExecutor继承ThreadPoolExecutor的ScheduledExecutorService接口实现，周期性任务调度的类实现。

4. 四种线程池

Java通过Executors提供四种线程池，分别为：

1,newCachedThreadPool
创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。

2,newFixedThreadPool
创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。

3,newScheduledThreadPool
创建一个定长线程池，支持定时及周期性任务执行。

4,newSingleThreadExecutor
创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
​

Executors:

方法说明
static ExecutorService newCachedThreadPool()创建一个可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们。
static ExecutorService newFixedThreadPool(int nThreads)创建一个可重用固定线程数的线程池，以共享的无界队列方式来运行这些线程。
static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。
static ExecutorService newSingleThreadExecutor()创建一个使用单个 worker 线程的 Executor，以无界队列方式来运行该线程。

ExecutorService:
​

方法说明
void execute(Runnable command)在未来某个时间执行给定的命令。

示例：

newCachedThreadPool

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

/**
 * 描述: 创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程，那么就会回收部分空闲（60秒不执行任务）的线程，当任务数增加时，此线程池又可以智能的添加新线程来处理任务。
 * 此线程池不会对线程池大小做限制，线程池大小完全依赖于操作系统（或者说JVM）能够创建的最大线程大小。
 *
 **/
public class TestNewCachedThreadPool {
    public static void main(String[] args) {
        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
        for (int i = 1; i <= 10; i++) {
            final int index = i;
            try {
                Thread.sleep(index * 1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            cachedThreadPool.execute(new Runnable() {

                @Override
                public void run() {
                    String threadName = Thread.currentThread().getName();
                    System.out.println("执行：" + index + "，线程名称：" + threadName);
                }
            });
        }
    }
}

响应：
执行：1，线程名称：pool-1-thread-1
执行：2，线程名称：pool-1-thread-1
执行：3，线程名称：pool-1-thread-1
执行：4，线程名称：pool-1-thread-1
执行：5，线程名称：pool-1-thread-1
执行：6，线程名称：pool-1-thread-1
执行：7，线程名称：pool-1-thread-1
执行：8，线程名称：pool-1-thread-1
执行：9，线程名称：pool-1-thread-1
执行：10，线程名称：pool-1-thread-1

newFixedThreadPool

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

/**
 * 描述:创建固定大小的线程池。每次提交一个任务就创建一个线程，直到线程达到线程池的最大大小。
 * 线程池的大小一旦达到最大值就会保持不变，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程。
 *
 **/
public class TestNewFixedThreadPool {

    public static void main(String[] args) {

        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);

        for (int i = 1; i <= 10; i++) {
            final int index = i;
            fixedThreadPool.execute(new Runnable() {

                @Override
                public void run() {
                    try {
                        String threadName = Thread.currentThread().getName();
                        System.out.println("执行：" + index + "，线程名称：" + threadName);
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {

                        e.printStackTrace();
                    }
                }
            });
        }

    }
}

因为线程池大小为3，每个任务输出index后sleep 2秒，所以每两秒打印3个数字，和线程名称。
响应：
执行：2，线程名称：pool-1-thread-2
执行：3，线程名称：pool-1-thread-3
执行：1，线程名称：pool-1-thread-1

执行：4，线程名称：pool-1-thread-1
执行：6，线程名称：pool-1-thread-2
执行：5，线程名称：pool-1-thread-3

执行：7，线程名称：pool-1-thread-1
执行：9，线程名称：pool-1-thread-3
执行：8，线程名称：pool-1-thread-2

执行：10，线程名称：pool-1-thread-1

newFixedThreadPool

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

/**
 * 描述:创建固定大小的线程池。每次提交一个任务就创建一个线程，直到线程达到线程池的最大大小。
 * 线程池的大小一旦达到最大值就会保持不变，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程。
 *
 **/
public class TestNewFixedThreadPool {

    public static void main(String[] args) {

        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);

        for (int i = 1; i <= 10; i++) {
            final int index = i;
            fixedThreadPool.execute(new Runnable() {

                @Override
                public void run() {
                    try {
                        String threadName = Thread.currentThread().getName();
                        System.out.println("执行：" + index + "，线程名称：" + threadName);
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {

                        e.printStackTrace();
                    }
                }
            });
        }

    }
}

因为线程池大小为3，每个任务输出index后sleep 2秒，所以每两秒打印3个数字，和线程名称。
响应：
执行：2，线程名称：pool-1-thread-2
执行：3，线程名称：pool-1-thread-3
执行：1，线程名称：pool-1-thread-1

执行：4，线程名称：pool-1-thread-1
执行：6，线程名称：pool-1-thread-2
执行：5，线程名称：pool-1-thread-3

执行：7，线程名称：pool-1-thread-1
执行：9，线程名称：pool-1-thread-3
执行：8，线程名称：pool-1-thread-2

执行：10，线程名称：pool-1-thread-1

newScheduledThreadPool

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
 * 描述:创建一个定长线程池，支持定时及周期性任务执行。延迟执行
 *
 **/
public class TestNewScheduledThreadPool {

    public static void main(String[] args) {

        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);

        scheduledThreadPool.schedule(new Runnable() {

            @Override
            public void run() {
                System.out.println("表示延迟3秒执行。");
            }
        }, 3, TimeUnit.SECONDS);


        scheduledThreadPool.scheduleAtFixedRate(new Runnable() {

            @Override
            public void run() {
                System.out.println("表示延迟1秒后每3秒执行一次。");
            }
        }, 1, 3, TimeUnit.SECONDS);
    }

}

表示延迟1秒后每3秒执行一次。
表示延迟3秒执行。
表示延迟1秒后每3秒执行一次。
表示延迟1秒后每3秒执行一次。
表示延迟1秒后每3秒执行一次。
表示延迟1秒后每3秒执行一次。

newSingleThreadExecutor

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

/**
 * 描述:创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
 *
 **/
public class TestNewSingleThreadExecutor {

    public static void main(String[] args) {
        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();
        for (int i = 1; i <= 10; i++) {
            final int index = i;
            singleThreadExecutor.execute(new Runnable() {

                @Override
                public void run() {
                    try {
                        String threadName = Thread.currentThread().getName();
                        System.out.println("执行：" + index + "，线程名称：" + threadName);
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }
}

结果依次输出，相当于顺序执行各个任务。
响应：
执行：1，线程名称：pool-1-thread-1
执行：2，线程名称：pool-1-thread-1
执行：3，线程名称：pool-1-thread-1
执行：4，线程名称：pool-1-thread-1
执行：5，线程名称：pool-1-thread-1
执行：6，线程名称：pool-1-thread-1
执行：7，线程名称：pool-1-thread-1
执行：8，线程名称：pool-1-thread-1
执行：9，线程名称：pool-1-thread-1
执行：10，线程名称：pool-1-thread-1

四.线程生命周期

当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态。在线程的生命周期中，它要经过新建(New)、就绪（Runnable）、运行（Running）、阻塞(Blocked)和死亡(Dead)5种状态。尤其是当线程启动以后，它不可能一直"霸占"着CPU独自运行，所以CPU需要在多条线程之间切换，于是线程状态也会多次在运行、阻塞之间切换

\1. 新建状态，当程序使用new关键字创建了一个线程之后，该线程就处于新建状态，此时仅由JVM为其分配内存，并初始化其成员变量的值

\2. 就绪状态，当线程对象调用了start()方法之后，该线程处于就绪状态。Java虚拟机会为其创建方法调用栈和程序计数器，等待调度运行

\3. 运行状态，如果处于就绪状态的线程获得了CPU，开始执行run()方法的线程执行体，则该线程处于运行状态

\4. 阻塞状态，当处于运行状态的线程失去所占用资源之后，便进入阻塞状态

\5. 在线程的生命周期当中，线程的各种状态的转换过程

在这里插入图片描述

五.单例模式

单例模式：

单例模式是一种对象创建模式，用于生产一个对象的实例，它可以确保系统中一个类只产生一个实例，这样做有两个好处：

1.对于频繁使用的对象，可以省略创建对象所花费的时间，这对于那些重量级对象而言，是非常可观的一笔系统开销。

2.由于new操作的次数减少，所以系统内存的使用评率也会降低，这将减少GC压力，缩短GC停顿时间。

由于以上两点可知单例模式的使用对于系统的关键组件和频繁使用的对象来说是可以有效的改善系统的性能的。

单例模式分为饿汉模式和懒汉模式：

1.饿汉模式：
 public final class EagerSingleton {
        
        private static EagerSingleton singObj = new EagerSingleton();

        private EagerSingleton() {
        }

        public static EagerSingleton getSingleInstance() {
            return singObj;
        }
  }

这种写法就是所谓的饥饿模式，每个对象在没有使用之前就已经初始化了。这就可能带来潜在的性能问题：如果这个对象很大呢？没有使用这个对象之前，就把它加载到了内存中去是一种巨大的浪费。

针对这种情况，我们可以对以上的代码进行改进，使用一种新的设计思想——延迟加载（Lazy-load Singleton）。

2. 懒汉模式：
  public final class LazySingleton {

        private static LazySingleton singObj = null;

        private LazySingleton() {
        }

        public static LazySingleton getSingleInstance() {
            if (null == singObj ) {
                singObj = new LazySingleton();
            }
            return singObj;
        }
    }

这种写法就是所谓的懒汉模式。它使用了延迟加载来保证对象在没有使用之前，是不会进行初始化的。但是：这种写法线程安全吗？回答必然是：不安全

这是因为在多个线程可能同时运行到“if (null == singObj )”，判断singObj为null，于是同时进行了初始化。所以，这是面临的问题是如何使得这个代码线程安全？很简单，在那个方法前面加一个Synchronized就OK了。

public final class ThreadSafeSingleton {
        
        private static ThreadSafeSingleton singObj = null;

        private ThreadSafeSingleton() {
        }

        public static Synchronized ThreadSafeSingleton getSingleInstance() {
            if (null == singObj ) {
                singObj = new ThreadSafeSingleton();
            }
            return singObj;
        }
    }
温故。
关注
专栏目录
线程——一个计数器计数到100，在每个数字之间暂停1秒，每隔10个数字输出一个字符串
晓晓仙儿的博客
11-15 3674
【16】一个计数器计数到100，在每个数字之间暂停1秒，每隔10个数字输出一个字符串。 public class MyThread extends Thread{ public void run() { for(int i=0;i&lt;100;i++) { if(i%10==0) { System.out.println("------"+i); } ...
java面试题26-107(答案)_JAVA面试题26-107(答案)
weixin_35028513的博客
02-28 497
26.用socket通讯写出客户端和服务器端的通讯，要求客户发送数据后能够回显相同的数据。.java:源代码java.*;importjava.io.*;Server{publicServer(){BufferedReaderbr=null;PrintWriterpw=null;try{ServerSocketserver=newServerSocket(8888);//建...
Java-线程篇-多线程并发下的锁
const_wu的博客
08-18 939
在计算机体系结构中，多线程是中央处理器 (CPU)（或多核处理器中的单核）在操作系统支持下并发提供多个执行线程的能力。这种方法不同于多处理。在多线程应用程序中，线程共享单个或多个内核的资源，包括计算单元、CPU 缓存和转换后备缓冲区 (TLB)。Java程序是需要运行在Java虚拟机上面的，Java内存模型（Java Memory Model ,JMM）就是一种符合内存模型规范的，屏蔽了各种硬件和操作系统的访问差异的，保证了Java程序在各种平台下对内存的访问都能保证效果一致的机制及规范。
OOP19-Java多线程
理论联系实际
03-07 444
多线程-线程间的同步 Java多线程ATM转账 在没有同步时数据错误 账户有转账等功能, 文件Account.java public class Account { protected String id; protected long balance; public Account(String id, long balance) { this...
Java学习-多线程
qq_51586702的博客
09-26 389
java多线程学习笔记，学习平台：https://space.bilibili.com/95256449/channel/seriesdetail?sid=393820&ctype=0
Java虚拟机（二）对象的创建与OOP-Klass模型
GarfieldEr007的专栏
11-10 630
相关文章  Java虚拟机系列 前言 在前一篇文章中我们学习了Java虚拟机的结构原理与运行时数据区域，那么我们大概知道了Java虚拟机的内存的概况，那么内存中的数据是如何创建和访问的呢？这篇文章会给你答案。 1.对象的创建 对象的创建通常是通过new一个对象而已，当虚拟机接收到一个new指令时，它会做如下的操作。  （1）判断对象对应的类是否加载、链接、初始化  虚拟机接收到一条new指令时...
B站【狂神说Java笔记】-多线程
最新发布
2401_86402522的博客
09-06 738
synchronized 方法 控制对 “ 对象”的访问，每个对象对应一把锁，每个synchronized 方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行。处理多线程问题时，多个线程访问同一个对象（并发），并且某些线程还想修改这个对象，这个时候我们就需要线程同步，线程同步就是一种机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程再使用。
S2_javaoop_第五章3-19笔记
qq_40603568的博客
03-19 212
第一节：异常概念一、概念1、异常：有异于常态，和正常情况不一样，有错误出现，阻止当前方法或作用域。2、异常处理：将出现的异常提示给编程人员与用户，使原本将要中断的程序继续运行或者退出。并且能够保存数据和释放资源。二、异常体系结构1、所有异常都继承于Throwable类，其下有两大子类：（1）Error类：错误，一般编程人员不太接触，如虚拟机错误、线程死锁。硬伤：使程序崩溃（2）Exception类...
JAVA多线程基础篇-关键字synchronized
qq_33479841的博客
06-27 612
syncronized是JAVA多线程开发中一个重要的知识点，涉及到多线程开发，多多少少都使用过。那么syncronized底层是如何实现的？为什么加了它就能实现资源串行访问？本文将基于上述问题，探索syncronized的用法及原理。由于本节知识涉及到JMM相关知识，具体可查看上一篇文章JAVA多线程基础篇-关键字volatile。由上表可知，synchronized的具体功能包括：锁方法、锁对象和锁代码块。1.概念 一个线程可以多次执行synchronized，重复获取同一把锁。 2.案例 运行结果如下
Java-Development-2021
03-31
19. **Java 11及以后版本**：不断更新的语言特性，如文本块（Text Blocks）、Optional改进等，开发者应保持关注并适时学习。 20. **持续集成/持续部署（CI/CD）**：Jenkins、GitLab CI/CD等工具在Java开发中的应用...
JAVA语言-学习指南.pdf
09-30
18. **OOP概念**：面向对象编程（OOP）将数据和方法封装进一个类，创建对象实例来使用这些数据和行为。 19. **循环语句**：`for`、`while`和`do-while`是循环语句，而`switch`语句用于条件分支，不能构成循环。 20...
Java-多线程-狂神笔记
weixin_42605958的博客
07-08 196
线程简介 process与Thread 一个软件（exe)是一个进程，软件中的声音图像是多线程 程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。 进程是执行程序的一次执行过程，是一个动态的概念。是系统分配资源的基本单位 真正执行的是线程，线程是CPU调度和执行的单位 注意：很多多线程是模拟出来的，真正的多线程是指有多个CPU，即多核，如服务器。如果是模拟出来的多线程，即在一个cpu下，在同一时间点，cpu只能执行一个代码，因为切换的很快，所以就有同时执行的错局。 本章核心
这108道 JavaOOP 面试题 你是不是都会了？
uuqaz的博客
07-22 974
1、什么是B/S架构？什么是C/S架构1.B/S(Browser/Server)，浏览器/服务器程序2. C/S(Client/Server)，客户端/服务端，桌面应用程序2、Java都有那些开发平台？1.JAVA SE：主要用在客户端开发2. JAVA EE：主要用在web应用程序开发3. JAVA ME：主要用在嵌入式应用程序开发3、什么是JDK？什么是JRE?1.JDK：java development kit：java开发工具包，是开发人员所需要安装的环境2. JRE：java runtime en
15_JAVA OOP
温故。的博客
04-12 1357
15_JAVAOOP 一、课程目标 1. 【理解】什么是泛型 2. 【掌握】泛型的基本使用 3. 【理解】什么是Collections工具类 4. 【理解】什么是File类 5. 【掌握】File类的常用功能 6. 【理解】什么是递归 7. 【理解】递归的执行原理 8. 【掌握】递归的案例 9. 【掌握】打印多级目录案例 10. 【掌握】文件搜索案例 二、泛型 2.1 泛型概述 ​ 在前面学习集合时，我们都知道集合中是可以存放任意对象的，只要把对象存储集合后，那么这时他们都会被提升成Object类型。当
11_JAVA OPP
温故。的博客
04-08 1166
11-JAVAOOP 一、课程目标 1. 【理解】StringBuffer类 2. 【掌握】StringBuffer的使用 3. 【理解】Math类的使用 4. 【理解】Arrays类的使用 5. 【掌握】包装类的使用 6. 【理解】BigInteger类和BigDecimal类的使用 7. 【掌握】Date类的使用 8. 【掌握】SimpleDateFormat类的使用 9. 【理解】Calendr类的使用 二、StringBuffer类|StringBuilder 2.1 StringBuffer类概
01_java基础
温故。的博客
03-13 1062
day01_Java基础 一、课程目标 1. 【了解】Java语言发展史 2. 【理解】Java语言平台版本 3. 【理解】Java语言特点 4. 【理解】JRE与JDK 5. 【掌握】Java开发环境搭建 6. 【掌握】第一个Java程序 7. 【掌握】注释 8. 【理解】关键字/标识符 二、Java语言概述 2.1 Java语言发展史 Java之父：詹姆斯·高斯林（James Gosling） 1977年获得了加拿大卡尔加里大学计算机科学学士学位
JAVAOOP-21 反射
温故。的博客
04-20 758
JAVAOOP-21 反射 XML 什么是XML XML是一种可扩展的标记语言，标准通用标记语言的子集 ，从 HTML —> XHTML —> XML 发展而来。 使用的时候是以文件的形式存在，扩展名为xml。 XML文件的用途 数据交换：作为与编程语言、操作系统无关的数据格式，通过网络进行数据的交换。 数据存储：通常作为超小型数据库来看待，可以存储数据。 配置文件：配置文件本质上就是数据存储的一种应用，主要用于应用程序的配置存储。 文件格式：office文件也是使用xml技术进行了数据的存
12_JAVA OOP
温故。的博客
04-09 666
12_JAVAOOP 一、课程目标 1. 【理解】什么是异常 2. 【理解】异常的体系结构 3. 【掌握】处理异常的方式 4. 【理解】自定义异常 5. 【理解】Log4J的作用 二、异常概述 2.1 什么是异常 ​ 异常，就是不正常的意思。在生活中:医生说,你的身体某个部位有异常,该部位和正常相比有点不同,该部位的功能将受影响.在程序中的意思就是： 异常 ：指的是程序在执行过程中，出现的非正常的情况，最终会导致JVM的非正常停止。 在Java等面向对象的编程语言中，异常本身是一个类，产生异常就是创建
Java编程基础：OOP概念与实践
1. 面向对象编程（OOP）是Java的核心概念，它包括类、对象、封装、继承和多态五个主要特性。类是对象的蓝图，封装是隐藏内部实现细节，只对外提供接口。继承允许子类继承父类的属性和方法，多态则是同一个方法在不同...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值