Java多线程

最新推荐文章于 2024-08-30 16:02:13 发布
原创 最新推荐文章于 2024-08-30 16:02:13 发布 · 327 阅读 · 1 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

1、实现线程的两种方式

       在Java中主要提供两种方式实现线程，分别为继承java.lang.Thread类与实现java.lang.Runnable接口。

（1）继承Thread类

       Thread类是java.lang包中的一一个类，从这个类中实例化的对象代表线程，程序员启动一个新线程需要建立Thread实例。Thread 类中常用的两个构造方法如下:

  • public Thread()：创建一个新的线程对象。
  • public Thread(String threadName)：创建一个 名称为threadName的线程对象。

继承Thread类创建一个新的线程的语法如下:

public class ThreadTest extends Thread{
}

       完成线程真正功能的代码放在类的run()方法中，当一个类继承Thread类后，就可以在该类中覆盖run()方法，将实现该线程功能的代码写入run()方法中，然后同时调用Thread类中的start0方法执行线程，也就是调用run()方法。

       Thread对象需要一个任务来执行，任务是指线程在启动时执行的工作，该工作的功能代码被写在run()方法中。run()方法必须使用以下语法格式：

public void run(){
}

       注：如果start()方法调用一个已经启动的线程，系统将抛出llelalThreadStateException异常。

       当执行一个线程程序时，就自动产生一个线程，主方法正是在这个线程上运行的。当不再启动其他线程时，该程序就为单线程程序。主方法线程启动由Java虚拟机负责，程序员负责启动自己的线程。代码如下:

public static void main(String[] args) {
    new ThreadTest).start();
}

例：

public class ThreadTest extends Thread { // 指定类继承Thread类
	private int count = 10;
	
	public void run() { // 重写run()方法
		while (true) {
			System.out.print(count+" "); // 打印count变量
			if (--count == 0) { // 使count变量自减，当自减为0时，退出循环
				return;
			}
		}
	}
	
	public static void main(String[] args) {
		new ThreadTest().start();
	}
}

输出：

       在main方法中，使线程执行需要调用Thread类中的start()方法，start()方法调用被覆盖的run()方法，如果不调用start(方法，线程永远都不会启动，在主方法没有调用start()方法之前，Thread 对象只是一个实例，而不是一个真正的线程。

 

（2）实现Runnable接口

       到目前为止，线程都是通过扩展Thread类来创建的，如果程序员需要继承其他类(非Thread类)，而且还要使当前类实现多线程，那么可以通过Runnable接口来实现。例如，一个扩展JFrame类的GUI程序不可能再继承Thread类，因为Java语言中不支持多继承，这时该类就需要实现Runnable接口使其具有使用线程的功能。实现Runnable接口的语法如下:

public class Thread extends Object implements Runnable

注：实质上Thread类实现了Runnable接口，其中的rum()方法正是对Runnable接口中的run()方法的具体实现。

       实现Runnable接口的程序会创建一个Thread对象,并将Runnable对象与Thread对象相关联。Thread类中有以下两个构造方法:

  • public Thread(Runnable target)。
  • public Thread(Runnable target,String name)。

这两个构造方法的参数中都存在Runnable 实例，使用以上构造方法就可以将Runnable 实例与Thread实例相关联。

使用Runnable接口启动新的线程的步骤如下:

  • 建立Runnable对象。
  • 使用参数为Runnable对象的构造方法创建Thread实例。
  • 调用start()方法启动线程。

例：

import java.awt.*;
import java.net.*;
import javax.swing.*;

public class SwingAndThread extends JFrame{
	private JLabel jl = new JLabel();
	private static Thread t;
	private int count = 0;
	private Container container = getContentPane();	//声明容器
	
	public SwingAndThread() {
		setBounds(300, 200, 250, 100); // 绝对定位窗体大小与位置
		container.setLayout(null); // 使窗体不使用任何布局管理器
		URL url = SwingAndThread.class.getResource("/1.gif"); // 获取图片的URL
		Icon icon = new ImageIcon(url); // 实例化一个Icon
		jl.setIcon(icon); // 将图标放置在标签中
		 // 设置图片在标签的最左方
		jl.setHorizontalAlignment(SwingConstants.LEFT);
		jl.setBounds(10, 10, 200, 50); // 设置标签的位置与大小
		jl.setOpaque(true);
		t = new Thread(new Runnable() {
			public void run() {
				while (count <= 200) {
					jl.setBounds(count, 10, 200, 50);
					try {
						Thread.sleep(1000);
					} catch (Exception e) {
						e.printStackTrace();
					}
					count += 4;
					if (count == 200) {
						count = 10;
					}
				}				
			}
		});
		t.start();		   // 启动线程
		container.add(jl); // 将标签添加到容器中
		setVisible(true);  // 使窗体可视		
		setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);// 设置窗体的关闭方式
	}
	
	public static void main(String[] args) {
		new SwingAndThread();
	}
	
}

输出：

       注：启动一个新的线程，不是直接调用Thread子类对象的run()方法,而是调用Thread子类的start()方法，Thread类的start()方法产生一个新的线程，该线程运行Thread子类的run()方法。

 

2、线程的生命周期

       线程具有生命周期，其中包含7种状态，分别为出生状态、就绪状态、运行状态、等待状态、休眠状态、阻塞状态和死亡状态。出生状态就是线程被创建时处于的状态，在用户使用该线程实例调用start()方法之前线程都处于出生状态:当用户调用start()方法后， 线程处于就绪状态(又被称为可执行状态);当线程得到系统资源后就进入运行状态。

       一旦线程进入可执行状态，它会在就绪与运行状态下转换，同时也有可能进入等待、休眠、阻塞或死亡状态。当处于运行状态下的线程调用Thread类中的wait()方法时，该线程便进入等待状态，进入等待状态的线程必须调用Thread类中的notify()方法才能被唤醒，而notifyAll()方法是将所有处于等待状态下的线程唤醒;当线程调用Thread类中的sleep()方法时，则会进入休眠状态。如果一个线程在运行状态下发出输入/输出请求,该线程将进入阻塞状态，在其等待输入/输出结束时线程进入就绪状态，对于阻塞的线程来说，即使系统资源空闲，线程依然不能回到运行状态。当线程的run()方法执行完毕时，线程进入死亡状态。

线程生命周期中的各种状态如下：

       虽然多线程看起来像同时执行，但事实上在同一时间点上只有一个线程被执行，只是线程之间切换较快，所以才会使人产生线程是同时进行的假象。在Windows操作系统中，系统会为每个线程分配一小段CPU时间片，一旦CPU时间片结束就会将当前线程换为下一个线程，即使该线程没有结束。

根据上图所示，可以总结出使线程处于就绪状态有以下几种方法：

  • 调用sleep()方法。
  • 调用wait()方法。
  • 等待输入/输出完成。

当线程处于就绪状态后，可以用以下几种方法使线程再次进入运行状态：

  • 线程调用notify()方法。
  • 线程调用notifyAll()方法。
  • 线程调用interrupt()方法。.
  • 线程的休眠时间结束。
  • 输入/输出结束。

 

3、操作线程的方法

（1）线程的休眠

sleep()方法的语法如下:

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

       注：上述代码会使线程在2秒（该单位为毫秒。）之内不会进入就绪状态。由于sleep()方法的执行有可能抛出InterruptedException异常，所以将sleep()方法的调用放在try-catch块中。虽然使用了sleep()方法的线程在一段时间内 会醒来，但是并不能保证它醒来后进入运行状态，只能保证它进入就绪状态。

例：

import java.awt.*;
import java.util.*;
import javax.swing.*;

public class SleepMethodTest extends JFrame {
	private static final long serialVersionUID = 1L;
	private Thread t;
	// 定义颜色数组
	private static Color[] color = { Color.BLACK, Color.BLUE, Color.CYAN,
			Color.GREEN, Color.ORANGE, Color.YELLOW, Color.RED,
			Color.PINK, Color.LIGHT_GRAY };
	private static final Random rand = new Random();// 创建随机对象
	
	private static Color getC() {// 获取随机颜色值的方法
		return color[rand.nextInt(color.length)];
	}
	
	public SleepMethodTest() {
		t = new Thread(new Runnable() {// 创建匿名线程对象
			int x = 30;// 定义初始坐标
			int y = 50;
			
			public void run() {// 覆盖线程接口方法
				while (true) {// 无限循环
					try {
						Thread.sleep(100);// 线程休眠0.1秒
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					// 获取组件绘图上下文对象
					Graphics graphics = getGraphics();
					graphics.setColor(getC());// 设置绘图颜色
					// 绘制直线并递增垂直坐标
					graphics.drawLine(x, y, 100, y++);
					if (y >= 80) {
						y = 50;
					}
				}
			}
		});
		t.start();// 启动线程
	}
	
	public static void main(String[] args) {
		init(new SleepMethodTest(), 100, 100);
	}
	// 初始化程序界面的方法
	public static void init(JFrame frame, int width, int height) {
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		frame.setSize(width, height);
		frame.setVisible(true);
	}
}

输出：

（2）线程的加入

       如果当前某程序为多线程程序，假如存在-一个线程A，现在需要插入线程B，并要求线程B先执行完毕，然后再继续执行线程A,此时可以使用Thread类中的join()方法来完成。

例：

import java.awt.*;
import javax.swing.*;

public class JoinTest extends JFrame{
	private Thread threadA;
	private Thread threadB;
	
	final JProgressBar progressBar = new JProgressBar();
	final JProgressBar progressBar2 = new JProgressBar();
	int count = 0;
	public JoinTest() {
		super();	// 超类，次数值JFrame	
		getContentPane().add(progressBar, BorderLayout.NORTH);// 将进度条设置在窗体最北面		
		getContentPane().add(progressBar2, BorderLayout.SOUTH);// 将进度条设置在窗体最南面
		progressBar.setStringPainted(true); 				 // 设置进度条显示数字字符
		progressBar2.setStringPainted(true);
		
		threadA = new Thread(new Runnable() {
			int count = 0;
			public void run() {
				while (true) {
					progressBar.setValue(++count);
					try {
						Thread.sleep(100);	// 使线程A休眠100毫秒
						threadB.join();		// 使线程B调用join()方法
					} catch (Exception e) {
						e.printStackTrace();
					}
				}	
			}
		});
		threadA.start();	// 启动线程A
		
		threadB = new Thread(new Runnable() {
			int count = 0;
			@Override
			public void run() {
				while (true) {
					progressBar2.setValue(++count);
					try {
						Thread.sleep(100);
					} catch (Exception e) {
						e.printStackTrace();
					}
					if (count == 100) {
						break;
					}
				}			
			}
		});
		threadB.start(); // 启动线程B
	}
	
	// 设置窗体各种属性方法
	public static void init(JFrame frame, int width, int height) {
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		frame.setSize(width, height);
		frame.setVisible(true);
	}
	
	public static void main(String[] args) {
		init(new JoinTest(), 100, 100);
	}
	
}

输出：

（3）线程中断

       以往有的时候会使用stop0方法停止线程，但当前版本的JDK早已废除了stop0方法，不建议使用stop()方法来停止一个线程的运行。现在提倡在run()方法中使用无限循环的形式，然后使用一个布尔型标记控制循环的停止。

public class IterruptedTest implements Runnable {
    private boolean isContinue = false;	//设置一个标记变量，默认值为false
    public void run() {		//重写run()方法
    while (true) {
        //...
        if (isContinue){		//当isContinue变为true时，停止线程
            break;
        }
    }
    public void setContinue() {	//定义设量f isContinue变最为true的方法
        this.isContinue = true;
    }
}

       如果线程是因为使用了sleep()或 wai()方法进入了就绪状态，可以使用Thread类中interrupt()方法使线程离开run()方法，同时结束线程，但程序会抛出InterruptedException 异常，用户可以在处理该异常时完成线程的中断业务处理，如终止while循环。

（4）线程的礼让

       Thread类中提供了一种礼让方法，使用yield()方法表示，它只是给当前正处于运行状态的线程一个提醒，告知它可以将资源礼让给其他线程，但这仅是一种暗示，没有任何-一种机制保证当前线程会将资源礼让。

       yield()方法使具有同样优先级的线程有进入可执行状态的机会,当当前线程放弃执行权时会再度回到就绪状态。对于支持多任务的操作系统来说，不需要调用yield()方法，因为操作系统会为线程自动分配CPU时间片来执行。

 

4、线程的优先级

       Thread类中包含的成员变量代表了线程的某些优先级，如Thread.MIN_ PRIORITY (常数1)、Thread.MAX_ PRIORITY (常数10)、Thread.NORM_ PRIORITY (常数5)。其中每个线程的优先级都在Thread.MIN_ PRIORITY~Thread.MAX_ PRIORITY 之间，在默认情况下其优先级都是Thread.NORM_PRIORITY。每个新产生的线程都继承了父线程的优先级。

例：

import java.awt.*;
import javax.swing.*;

public class PriorityTest extends JFrame{
	private Thread threadA;
	private Thread threadB;
	private Thread threadC;
	private Thread threadD;
	
	public PriorityTest() {
		getContentPane().setLayout(new GridLayout(4, 1));
		final JProgressBar progressBar = new JProgressBar();
		final JProgressBar progressBar2 = new JProgressBar();
		final JProgressBar progressBar3 = new JProgressBar();
		final JProgressBar progressBar4 = new JProgressBar();
		getContentPane().add(progressBar);
		getContentPane().add(progressBar2);
		getContentPane().add(progressBar3);
		getContentPane().add(progressBar4);
		progressBar.setStringPainted(true);
		progressBar2.setStringPainted(true);
		progressBar3.setStringPainted(true);
		progressBar4.setStringPainted(true);
		threadA = new Thread(new MyThread(progressBar));
		threadB = new Thread(new MyThread(progressBar2));
		threadC = new Thread(new MyThread(progressBar3));
		threadD = new Thread(new MyThread(progressBar4));
		setPriority("threadA", 5, threadA);
		setPriority("threadB", 5, threadB);
		setPriority("threadC", 4, threadC);
		setPriority("threadD", 3, threadD);
	}
	
	// 定义设置线程的名称、优先级的方法
	public static void setPriority(String threadName, int priority,Thread t) {
		t.setPriority(priority);
		t.setName(threadName);
		t.start();
	}
	
	private final class MyThread implements Runnable{
		private final JProgressBar bar;
		int count = 0;
		
		private MyThread(JProgressBar bar) {
			this.bar = bar;
		}
		
		public void run() {
			while (true) {
				bar.setValue(count += 10);
				try {
					Thread.sleep(1000);
				} catch (Exception e) {
					System.out.println("当前线程被中断");
				}
			}			
		}
	}
	
	public static void init(JFrame frame, int width, int height) {
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		frame.setSize(width, height);
		frame.setVisible(true);
	}
	
	public static void main(String[] args) {
		init(new PriorityTest(), 100, 100);
	}
	
}

输出：

 

5、线程同步

（1）同步块

在Java中提供了同步机制，可以有效地防止资源冲突。同步机制使用synchronized 关键字。语法如下：

synchronized(Object){
}

       通常将共享资源的操作放置在synchronized 定义的区域内，这样当其他线程也获取到这个锁时，必须等待锁被释放时才能进入该区域。Object 为任意-一个对象， 每个对象都存在一个标志位，并具有两个值，分别为0和1。一个线程运行到同步块时首先检查该对象的标志位，如果为0状态，表明此同步块中存在其他线程在运行。这时该线程处于就绪状态，直到处于同步块中的线程执行完同步块中的代码为止。这时该对象的标志位被设置为1,该线程才能执行同步块中的代码，并将Object对象的标志位设置为0,防止其他线程执行同步块中的代码。

例：

public class ThreadSafeTest implements Runnable{
	int num = 10;
	public void run() {
		while (true) {
			synchronized("") {
				if (num > 0) {
					try {
						Thread.sleep(1000);
					} catch (Exception e) {
						e.printStackTrace();
					}
					System.out.println("tickets" + --num);
				}
			}
		}
	}
	
	public static void main(String[] args) {
		ThreadSafeTest t = new ThreadSafeTest();
		Thread tA = new Thread(t);
		Thread tB = new Thread(t);
		Thread tC = new Thread(t);
		Thread tD = new Thread(t);
		tA.start();
		tB.start();
		tC.start();
		tD.start();
	}
}

输出：

（2）同步方法

同步方法就是在方法前面修饰synchronized关键字的方法，其语法如下:

synchronized void f(){
}

        当某个对象调用了同步方法时，该对象上的其他同步方法必须等待该同步方法执行完毕后才能被执行。必须将每个能访问共享资源的方法修饰为synchronized,否则就会出错。

例如将以上部分程序改为：

public synchronized void doit() {
		while(true) {
			if(num > 0) {
				try {
					Thread.sleep(10);
				} catch (Exception e) {
					e.printStackTrace();
				}
				System.out.println("tickets" + --num);
			}
		}		
	}
	
	public void run() {
		doit();
}

 

java多线程进度条
02-10
java多线程进度条
eclipse中添加图片URL，提示空指针
luo137479400的博客
01-31 2065
以下是学习过程中，书上的实例代码，博主对着敲了一遍却无法运行。 import java.awt.*; import java.net.URL; import javax.swing.*; public class SwingAndThread extends JFrame { /** * */ private static final long serialVersionUID
java进度条_Java实现进度条开发过程
weixin_35738304的博客
02-12 2191
首先说流程:1.访问启动任务servlet2.启动任务servlet开启任务,并跳转掉进度条展示页面3.页面就绪就调用(进度参数获取servlet),此后进度条展示页面定时调用,直到传递过来为100%.4.获取参数servlet从session中取出任务,并获取任务中的进度参数.返回进度参数给进度展示页面.一下是各个文件代码，工程为web工程。1.进度条schedule.css文件:body{m...
JAVA SWING 实现模拟进度条效果
homeskating的博客
07-30 975
package zikao.swing; import javax.swing.*; import java.awt.*; public class JProgressBarTest { /* JProgressBar使用的步骤: 1,创建JProgressBar的对象 public JProgressBar(int orient,int min,int max): orient: 方向 min: 最小值 max: 最大值 2,设置属性 .
Java多线程详解（一）Java多线程入门
刘成
11-27 2443
最近听很多面试的小伙伴说，网上往往是一篇一篇的Java多线程的文章，除了书籍没有什么学习多线程的一系列文章。但是仅仅凭借一两篇文章很难对多线程有系统的学习，而且面试的时候多线程这方面的知识往往也是考察的重点，所以考虑之下决定写一系列关于Java多线程的文章。文章参考了高老师的《Java多线程编程核心技术》。力争使用最短的篇幅把Java多线程的知识作以系统的讲述。 本节思维导图： 思维导图...
JAVA之多线程
maxu0808的博客
03-18 1万+
一、什么是多线程 1. 线程与进程、并行与并发 进程：每个进程拥有自己的一整套变量。一个进程可以包含多个线程。 线程：线程属于进程，多个线程会存在共享数据的情况发生，也就是多个线程会共享同一块内存区域。 一个例子：打开word是一个进程，打开qq音乐又是另外一个进程，两进程之间不会互相影响（都有自己的一块内存区域）。但比如在qq音乐里一遍听歌，一遍又浏览排行榜，那就是在qq音乐这个进程里又有两个线程，它们之间会存在共享内存的情况。 并发：多线程就是并发的例子，一块CPU调度时会分为好多个时间片，每
Java技术——Java多线程学习
关于Android开发的一些技术点总结 ╮(￣▽￣”)╭
09-01 1万+
0.前言 转载请标明出处：http://blog.csdn.net/seu_calvin/article/details/52400927 学习多线程之前需要先了解以下几个概念。 进程：一般指一个程序运行时的实例，每个进程有自己独立的地址空间。一个进程无法直接访问另一个进程的数据。 线程：是CPU调度的最小单元，一个进程可以有很多线程，每条线程可以并行执行不同的任务。并且每个线程有独立的运...
【Java多线程】Java多线程技能
热门推荐
一定要站在自己热爱的生活里闪闪发光
10-02 4万+
到 1. 进程和多线程的概念及线程的优点 提到多线程这个技术就不得不提及“进程”这个概念，在“百度百科”中对进程的解释如下： 进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。在早期面向进程设计的计算机结构中，进程是程序的基本执行实体；在当代面向线程设计的计算机结构中，进程是线程的容器。程序是指令、数据及其组织形式的描述，进程是程序的实体。 进程是受操作系统管理的基本运行单元。 那什么是线程呢？ 线程可以理解成是在
Java 多线程详解
最新发布
goTsHgo的博客
08-30 1845
多线程（Multithreading）是指在一个程序中同时执行多个线程的能力。线程是进程中的一个执行路径，多线程允许程序在同一时间内执行多个操作。Java 中的多线程可以通过并发处理来提高程序的性能和响应速度，尤其在处理复杂计算、大量 I/O 操作或并发任务时非常有用。多线程使得程序可以同时执行多个任务，充分利用CPU资源，提升程序性能，增强响应性，并简化程序的复杂度。尽管多线程编程带来了一些挑战，如线程安全和死锁问题，但合理设计和使用多线程可以显著改善程序的整体表现。
java 多线程机制_java多线程机制
weixin_31614753的博客
02-20 173
多线程使用场景1、同时需要做两件以上事情时需要开多个线程(例如：上传功能附带进度条显示，一边做上传，一边更新进度条状态。)2、大量同类型数据需要进行处理(导入导出大量数据)3、office文档转换pdf比较慢4、一个任务的执行进度，比如我们常看到的进度条，实现方式可以是在任务中加入一个整型属性变量(这样不同方法可以共享)，任务执行一定程度就给变量值加1，另外开一个线程按时间间隔不断去访问这个变量，...
线程的优先级
weixin_30485799的博客
04-03 127
public class PriorityTest extends JFrame{ private static final long seriaVersionUID = 1L; private Thread threadA; private Thread threadB; private Thread threadC; private T...
Java枚举类型与泛型
king_weng的博客
02-23 4148
一、枚举类型 1、使用枚举类型设置常量 以往设置常量，通常将常量放置在接口中，这样在程序中就可以直接使用，并且该常量不能被修改，因为在接口中定义常量时，该常量的修饰符为final与static。常规定义常量的代码如下所示。 例：在接口中定义常量的常规方式 public interface Constants{ public static final int Constan...
Ubuntu18.04安装JDK14
king_weng的博客
06-02 1913
1、下载 https://www.oracle.com/java/technologies/javase-downloads.html 比如此处我下载的是jdk-14.0.1_linux-x64_bin.tar.gz 2、解压 可在/usr中使用mkdir java创建一个文件夹，然后将上面下载的文件解压到该文件夹： tar -zxvf jdk-14.0.1_linux-x64_bin.tar.gz 我解压出来的文件下图所示： 3、配置环境变量 修改/e...
Swing程序设计
king_weng的博客
01-09 1172
一、Swing 1、Swing概述 Swing是一个用于开发Java应用程序用户界面的开发工具包。以抽象窗口工具包（AWT）为基础使跨平台应用程序可以使用任何可插拔的外观风格。原来的AWT组件来自java.awt 包，当含有AWT组件的Java应用程序在不同的平台上执行时，每个平台的GUI组件的显示会有所不同，但是在不同平台，上运行使用Swing开发的应用程序时，就可以统一GUI...
Java之数据库操作
king_weng的博客
03-15 1162
一、JDBC概述 JDBC是一种可用于执行SQL语句的Java API (Application Programming Interface,应用程序设计接口)，是连接数据库和Java应用程序的纽带。 1、JDBC-ODBC桥 JDBC-0DBC桥是一个JDBC驱动程序，完成了从JDBC操作到0DBC操作之间的转换工作，允许JDBC驱动程序被用作ODBC的驱动程序...
Java之maven中pom.xml字段详解
king_weng的博客
03-11 999
<modules>：子模块项目<properties>：属性，包括系统属性、自定义属性 <dependencies>：依赖 <groupId>,<artifactId>, <version>：描述了依赖的项目唯一标志。 <groupId> ：创建项目的组织或团体的唯一 Id。 <artifactId>：项目唯一id，可视为项目名。 <version...
Java反射机制
king_weng的博客
01-18 760
一、Class类与Java反射 通过Java反射机制，可在程序中访问已经转载到JVM中的Java对象的描述，实现访问、检测和修改描述Java对象本身信息的功能。Java反射机制的功能十分强大，在java.lang.reflect包中提供了对该功能的支持。 众所周知，所有Java 类均继承了Object 类，在Object类中定义了一个getClass()方法，该方法...
Java快速入门
king_weng的博客
12-18 652
1、JDK和JRE （1）JDK 是 Java 语言的软件开发工具包，主要用于移动设备、嵌入式设备上的java应用程序。JDK是整个java开发的核心，它包含了JAVA的运行环境（JVM+Java系统类库）和JAVA工具。 （2）JRE Java Runtime Environment缩写，指Java运行环境，是Sun的产品。运行JAVA程序所必须的环境的集合，...
Java数字处理类
king_weng的博客
12-22 595
一、数字格式化 在Java中没有格式化的数据遵循以下原则: 如果数据绝对值大于0.001并且小于1000000, Java 将以常规小数形式表示。 如果数据绝对值小于0.001或者大于0000000，使用科学记数法表示。 DecimalFormat是NumberFormat的一个子类，用于格式化十进制数字。它可以将一些数字格式化为整数、浮点数、百分数等。通过使用该类...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值