|
五、黑马程序员—异常处理和常用类
第五篇
1、异常
异常：就是不正常，是指程序在运行时出现的不正常情况。其实就是程序中出现的问题。
这个问题按照面向对象思想进行描述，并封装成了对象。因为问题的产生有产生的原因、有
问题的名称、有问题的描述等多个属性信息存在。当出现多属性信息最方便的方式就是将这
些信息进行封装。异常就是 java 按照面向对象的思想将问题进行对象封装。这样就方便于
操作问题以及处理问题。
出现的问题有很多种，比如角标越界，空指针等都是。就对这些问题进行分类。而且这
些问题都有共性内容比如：每一个问题都有名称，同时还有问题描述的信息，问题出现的位
置，所以可以不断的向上抽取。形成了异常体系。
异常的体系 Throwable
Error
通常指 JVM 出现重大问题如：运行的类不存在或者内存溢出等。
不需要编写针对代码对其处理，程序无法处理。
Exception
在运行时运行出现的一些情况，可以通过 try,catch,finally 处理
异常处理两种方式：
1、捕获异常：try catch 直接处理可能出现的异常！
2、声明异常：throws 声明告诉调用者可能的异常，暴露问题，调用者自己
处理！
我的总结：
Exception 和 Error 的子类名大都是以父类名作为后缀。
Java 异常其实是对不正常情况的一种描述,并将其封装成对象;
Java 在 设计异常体系时，将容易出现的异常情况都封装成了对象。
2、异常处理格式
异常处理的 5 个关键字
try ,catch,
finally
throw, throws
我的总结：
捕获异常：先捕获小异常再捕获大异常。
程序是调出来的，不是写出来的；多测试是程序员的必修课。
异常处理后，程序不会因为出现异常而退出!
异常处理格式
try{
//可能出异常的代码
} catch(异常类 对象){
//处理该异常类型的语句
}
[finally] {
//一定会执行的代码
//catch 块使用 System.exit(1);除外
}
备注：当 try 语句块出现异常，程序会自动跳到 catch 语句块去找匹配的异常类型，并执行
异常处理语句，finally 语句块是异常的统一出口。
3、多异常处理
声明异常时尽可能声明具体异常类型,方便更好的处理;
方法声明几个异常就对应有几个 catch 块;
若多个 catch 块中的异常出现继承关系,父类异常 catch 块放在最后;
在 catch 语句块使用 Exception 类作为异常类型时：
所有子类实例都可以使用父类接收(向上转型)，即所有的异常对象都可以使用 Exception 接
收;
注：在 java 处理多异常时捕获小范围的异常必须放在大范围异常之前。
java7 - 同时捕获多个异常类型
Java7 之前：
try {
int a = Integer.parseInt("1");
int b = Integer.parseInt("0");
int c = a / b;
System.out.println(c);
} catch (NumberFormatException e)
{
e.printStackTrace();
} catch(ArithmeticException e)
{
e.printStackTrace();
}
Java7：将多个异常写到了同一个 catch 代码块
try {
Integer a = Integer.parseInt("1");
Integer b = Integer.parseInt("0");
Integer c = a / b;
System.out.println(c);
} catch (NumberFormatException
| ArithmeticException e ) {
e.printStackTrace();
}
4、异常的分类
异常分类:
编译时被检查异常; ---> Checked 异常
在程序中必须使用 try...catch 处理；
编译时不被检测的异常; ---> Runtime 异常
可以不使用 try...catch 处理，但一旦出现异常就将由 JVM 处理。
异常的分类之 Runtime 异常
RuntimeException(运行时异常)是指因设计或实现方式不当而导致的问题.
说白了,就是程序员造成的,程序员小心谨慎是完全可以避免的异常.比如,事先判断对象是否
为 null 就 可 以 避 免 NullPointerException 异 常 , 事 先 检 查 除 数 不 为 0 就 可 以 避 免
ArithmeticException 异常;
特点:
这种异常Java编译器不会检查它,也就说程序中出现这类异常的时候,即使不处理也没有
问题,但是一旦出现异常,程序将异常终止,若采用异常处理,则会被相应的程序执行处理.
异常的分类之 Checked 异常
除了 RuntimeException 以及子类,其他的 Exception 及其子类都是受检查异常,我们也可
以称为非 RuntimeException 异常.
特点:
Java 编译器会检查它,也就说程序中一旦出现这类异常,要么是没有 try-catch 语句捕获,
或 throws 语句没有声明抛出它,编译就不会通过,也就说这种异常,程序要求必须处理.
5、声明异常（throws）
在可能出现异常的方法上声明抛出可能出现异常的类型：
声明的时候尽可能声明具体的异常,方便更好的处理.
当前方法不知道如何处理这种异常，可将该异常交给上一级调用者来处理(非
RuntimeException 类型的异常)。
方法一旦使用 throws 声明抛出方法内可能出现的异常类型， 该方法就可以不再过问该
异常了；
一个方法调用另一个使用 throws 声明抛出的方法，自己要么 try...catch , 要么也 throws;
格式：
public 返回值类型 方法名(参数列表...)
throws 异常类 A,异常类 B... {
}
6、throw
自行抛出一个异常对象，抛出异常类的对象；
若 throw 抛出的是 Runtime 异常：
程序可以显示使用 try...catch 来捕获并处理，也可以不管，直接交给方法调用者处理；
若 throw 抛出 Checked 异常：
要么放在 try 里自己处理，要么放在一个 throws 声明的方法里面，交给调用者处理。
Eg：
public static void main(String[] args) {
try {
fn1(1);
} catch (Exception e) { e.printStackTrace(); }
fn2(2);
}
public static void fn1(int a) throws Exception{
if(a >0) { throw new Exception("fn1 -- a 值不合法"); }
}
public static void fn2(int a) {
if(a >0) { throw new RuntimeException("a 值不合法"); }
}
throws & throw
throws 用于在方法上声明该方法不需要处理的异常类型。
throw 用于抛出具体异常类的对象。
throws 与 throw 的区别：
thorws 用在方法上，后面跟异常类名,可以是多个异常类。
throw 用在方法内，后面跟异常对象,只能是一个。
7、finally
异常的统一出口：
不管 try 块程序是否异常，也不管哪个 catch 执行，finally 块总会执行。
try 语句块或会执行的 catch 语句块使用了 JVM 系统退出语句例外;//System.exit(1);
try 块必须和 catch 块或和 finally 同在，不能单独存在，二者必须出现一个。
不要在 finally 中使用 return 或 throw 语句，否则将会导致 try、catch 中的 return 或 throw 失
效。
我的总结：finally 代码块只在一种情况下不执行：System.exit(0)；
Eg：
package reviewDemo;
public class Demo19 {
public static void main(String[] args) {
try{
System.out.println(17/0);
}catch(Exception e){
//e.printStackTrace();
System.out.println("程序错误，请修正！");
}finally{
System.out.println("这是finally代码块！");
}
}
}
输出：
程序错误，请修正！
这是finally代码块！
8、throw 和 catch 同时使用
当异常出现在当前方法中,程序只对异常进行部分处理,还有一些处理需要在方法的调用
者中才能处理完成,此时还应该再次抛出异常,这样就可以让方法的调用者也能捕获到异常;
Eg：
public static void buy(String price) throws Exception {
try {
if(price != null)
Double.parseDouble(price);
} catch (Exception e) {
e.printStackTrace();
throw new Exception("价格不能只能是数字组成");
}
}
public static void main(String[] args) {
try {
buy(null);
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
9、常用类
String
String 表示字符串,所谓字符串,就是一连串的字符;
String 是不可变类，一旦 String 对象被创建，包含在对象中的字符序列(内容)是不可变的，
直到对象被销毁；
常量池:JVM 中一块独立的区域存放字符串常量和基本类型常量（public static final）。
String 使用 private final char value[]来实现字符串的存储,也就是说 String 对象创建之后,
就不能再修改此对象中存储的字符串内容,就是因为如此,才说 String 类型是不可变的.
String 对象比较:
单独使用""引号创建的字符串都是常量,编译期就已经确定存储到常量池中；
使用 new String("")创建的对象会存储到堆内存中,是运行期新创建的；
使用只包含常量的字符串连接符如"aa" + "bb"创建的也是常量,编译期就能确定,已经确
定存储到常量池中；
使用包含变量的字符串连接符如"aa" + s1 创建的对象是运行期才创建的,存储在堆中；
Eg：
package string;
public class StringDemo {
public static void main(String[] args) {
/*
* "" 其实表示的是 String 的匿名对象
*/
String s = "";
/**
* String() 初始化一个新创建的 String 对象，使其表示一个空字符序列。
* "",不是表示 null
* String(String original)
* String s = new String("asd");// s 的值就是 asd
*/
s = new String();//""
String s1 = new String("11");
String s2 = new String("11");
System.out.println(s1 == s2);//false
String s3 = "22";
String s4 = "22";
System.out.println(s3 == s4);//true
System.out.println(s3 == s2);//false
String s5 = "2" + "2";//这句话其实在编译器编译后的 class 文件中 已经变成 "22"
//s5 创建了几个对象?//回答：最多一个，如果常量池里面没有就是创建一个，如果
常量池里本来就有就是创建零个！下面的 str 一样的道理。
String str = "A" +"B"+ "C" +"D" +"E";//String str = "ABCDE";
System.out.println(s3 == s5);//true
/**
* String 特点: 不可变的, 一个 String 对象的内容不能变,一旦内容变量该对象
就变成一个新的 String 对象了
* String str = "AAA";
* str = str+"12";
*/
String str1 = "ABCDE";
System.out.println(str == str1);//true
String str2 = "ABC" + "DE";
System.out.println(str == str2);//true
String ss = "AB";
String str3 = ss + "CDE";//这里的 str3 在运行期才能确定内容值
System.out.println(str3 == str2);//false
String str4 = getStr() +"CDE";//在运行期才能确定 str4 的值
System.out.println(str == str4);//false
System.out.println(str3 == str4);//false
/*
* String s = "cd"; //一个 String 对象
s = s + "itcast"; //itcast 也是 String 对象, 最后的 s 的值 cditcast,也是一个
String 对象
System.out.print(s);
* */
}
public static String getStr(){
return "AB";
}
}
Eg:
package reviewDemo;
public class Demo20 {
public static void main(String[] args) {
//s1,s2只新建了一个对象
String s1 = "你好";
String s2 = "你好";
//s3,s4新建了两个对象
String s3 = "你好";
String s4 = "你好";
}
}
10、String 方法
String():初始化一个新的 String 对象，使其表示一个空字符序列，并不是返回空(不等于
null)。
String(StringBuffer buffer):根据 StringBuffer 对象来创建 String 对象；
String(StringBuilder builder):同上
char charAt(int index):取字符串中指定位置的字符，index 从 0 开始计算。
String concat(String str):连接字符串，等同于 “+”；
boolean contentEquals(StringBuffer buffer):若二者包含的字符序列相同时就返回 true;
boolean equals(Object obj):将该字符串与指定对象比较，若二者包含的字符序列相等返回
true；
boolean equalsIgnoreCase(String anotherString) 将此 String 与另一个 String 比较，不考虑大
小写;
byte[] getBytes():将该字符串转换成 byte 数组；
int indexOf(String str):找出 str 字符串在该字符串中第一次出现的位置；
int indexOf(String str, int fromIndex) 返回指定子字符串在此字符串中第一次出现处的索引，
从指定的索引开始;
int lastIndexOf(String str) 返回指定子字符串在此字符串中最后一次出现处的索引;
int length():返回当前字符串长度；
String replace(char oldChar, char newChar) :返回一个新的字符串，它是通过用 newChar 替换
此字符串中出现的所有 oldChar 得到的。
String replaceAll(String regex, String replacement) 使用给定的 字符串 replacement 替换此字
符串所有的 regex 字符串;
boolean startsWith(String prefix) 测试此字符串是否以指定的前缀开始.
String[] split(String regex)： 把字符串按指定的字符串分隔开。
String substring(int beginIndex) 返回一个新的字符串，从 beginIndex 开始截取，它是此字符
串的一个子字符串;
String substring(int beginIndex, int endIndex) 返回一个新字符串，它是此字符串的一个子字符
串;[begin,end)
char[] toCharArray() 将此字符串转换为一个新的字符数组。
String toLowerCase() 将此 String 中的所有字符都转换为小写;
String toUpperCase()转成大写;
static String valueOf(基本类型 obj):把基本类型值转成字符串;
String trim() ：忽略字符串前导空白和尾部空白。
String 小练习
判断字符串是否由数字组成：
package reviewDemo;
public class Demo20 {
public static void main(String[] args) {
String s1 = "123456789";
String s2 = "12345 6789";
System.out.print(isnum(s1));
System.out.print(isnum(s2));
}
public static boolean isnum(String s){
char []ch = s.toCharArray();
for (char c : ch) {
if(!(c > '0' && c <= '9')){
return false;
}
}
return true;
}
}
输出：
true
false
判断字符串是否为空：
分析：
字符串的空有两种情况：1、null；2、"";
package reviewDemo;
public class Demo21 {
public static void main(String[] args) {
String s1 = "";
System.out.println(isimpty(s1));
}
public static String isimpty(String s){
if(s != null & !"".equals(s)){
return "不为空";
}
return "为空！";
}
}
11、StringBuffer 与 StringBuilder
String 是不可变类，一旦 String 对象被创建，包含在对象中的字符序列是不可变的，直到对
象被销毁；
StringBuffer 与 StringBuilder 对象则是可变的！
举例说明这两个的好处：（不用每次新建对象，效率高！）
package reviewDemo;
public class Demo22 {
public static void main(String[] args) {
String s = "";
long begintime = System.currentTimeMillis();
for(int i = 1;i <= 100000;i++){
s += i;
}
long endtime = System.currentTimeMillis();
long time = endtime - begintime;
System.out.println("运行时间为："+time);
StringBuffer s1 = new StringBuffer();
s = "";
begintime = System.currentTimeMillis();
for(int i = 1;i <= 100000;i++){
s = ""+i;
s1 = new StringBuffer(s);
}
endtime = System.currentTimeMillis();
time = endtime - begintime;
System.out.println("运行时间为："+time);
}
}
输出：
运行时间为：82922
运行时间为：15
可以看得出：StringBuffer 这两个效率相当高！
StringBuffer： 是线程安全的；
StringBuilder： 是线程不安全的，性能高点，推荐使 StringBuilder；(jdk1.5 出现)
StringBuffer 的字符序列是可变的(通过 append 等方法操作)
StringBuffer 和 String 之间的转换；
String toString() 返回此序列中数据的字符串表示形式。
StringBuffer(String str):以指定的字符串创建 StringBuffer 对象。
StringBuffer 方法
public StringBuilder()构造一个不带任何字符的 StringBuilder 对象。
StringBuffer(String str) ：构造一个字符串缓冲区，并将其内容初始化为指定的字符串内容。
StringBuffer append(Object o) ：将指定的任意类型对象追加到此 StringBuffer 对象。
StringBuffer insert(int offset, Object o) :将任意类型参数的字符串表示形式插入此序列中。
StringBuffer delete(int start, int end) :移除此序列的子字符串中的字符。
StringBuffer deleteCharAt(int index): 移除此序列指定位置的 char。
Eg：
package reviewDemo;
/**
* 用StringBuilder 或StringBuffer:
把字符串“ABCDE”;
转变成字符串“A,B,C,D”
*/
public class Demo23 {
public static void main(String[] args) {
//第一种方法：往里面插入；
StringBuilder sb = new StringBuilder("ABCDE");
sb.deleteCharAt(sb.length()-1);
System.out.println(sb);
for (int i = 0; i < sb.length(); i+=2) {
sb.insert(i, ",");
}
sb.deleteCharAt(0);
System.out.println(sb);
//第二种方法：往里面追加，要追加必须遍历，必须换为数组！
sb = new StringBuilder("ABCDE");
sb.deleteCharAt(sb.length()-1);
System.out.println(sb);
char []cs = sb.toString().toCharArray();
StringBuilder sb1 = new StringBuilder();
for (char c : cs) {
sb1.append(c).append(",");
}
sb1.deleteCharAt(sb1.length()-1);
System.out.println(sb1);
}
}
编写一个程序，这个程序把一个整数数组中的每个元素用逗号连接成一个字符串，例如，
根据内容为{1，2，3}的数组形成内容为"1,2,3"的字符串。
package reviewDemo;
/**
* 编写一个程序，
* 这个程序把一个整数数组中的每个元素用逗号连接成一个字符串，
* 例如，根据内容为{1，2，3}的数组形成内容为"1,2,3"的字符串。
*/
public class Demo24 {
public static void main(String[] args) {
int []i = {1,2,3,4,5};
StringBuilder sb = new StringBuilder();
for (int j : i) {
sb.append(j).append(",");
}
sb.deleteCharAt(sb.length()-1);
System.out.println(sb);
}
}
12、Math 和 Random 和 UUID
Math 类
public final class Math extends Object
以下 X 表示 double,float,int, long
abs(X x):求绝对值
max(X x1,X x2):求最大值
min(X x1,X x2)：求最小值
public static double random()：返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。
和使用 new java.util.Random 一样
Math.PI;
Random 类
负责生成伪随机数；
Random() 创建一个新的随机数生成器。
int nextInt() 返回下一个伪随机数，它是此随机数生成器的序列中均匀分布的 int 值。
int nextInt(int n) 返回一个伪随机数，它是取自此随机数生成器序列的、在 0（包括）
和指定值 n（不包括）之间均匀分布的 int 值。
package reviewDemo;
public class Demo26 {
public static void main(String[] args) {
System.out.println(Math.E);//2.718281828459045
int a = 12;
int b = 25;
System.out.println(Math.max(a,b));//这里可以使用静态导入（导入
Math类中的方法，这样的话前面就不用写上Math.）
System.out.println(Math.min(a,b));
}
}
package reviewDemo;
import java.util.UUID;
public class Demo27 {
public static void main(String[] args) {
UUID u = UUID.randomUUID();
String s = u.toString();
System.out.println(s);//此时是随机生成的，肯定每次都不一样，全网唯
一！
u = new UUID(1222222222, 12);//根据构造方法来
s = u.toString();
System.out.println(s);//这一个的UUID是固定的。
}
}
我的总结：UUID（用来标示文件名等（免得文件上传因为名字可能一样而被覆盖），可以
保证全网唯一！）
UUID 类:用唯一标识符 (UUID) 的类。 UUID 表示一个 128 位的值。
UUID(Universally Unique Identifier)全局唯一标识符,是指在一台机器上生成的数字，它保证
对在同一时空中的所有机器都是唯一的。按照开放软件基金会(OSF)制定的标准计算，用到
了以太网卡地址、纳秒级时间、芯片 ID 码和许多可能的数字。由以下几部分的组合：当前
日期和时间(UUID 的第一个部分与时间有关，如果你在生成一个 UUID 之后，过几秒又生
成一个 UUID，则第一个部分不同，其余相同)，时钟序列，全局唯一的 IEEE 机器识别号（如
果有网卡，从网卡获得，没有网卡以其他方式获得），UUID 的唯一缺陷在于生成的结果串
会比较长。
标准的 UUID 格式为：xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxx (8-4-4-4-12),其中每个 x 是 0-9
或 a-f 范围内的一个十六进制的数字;
UUID uuid = UUID.randomUUID();
String uid = uuid.toString();
13、Date 和 Calendar
处理日期，时间；
大部分的方法已过时，不推荐使用，但是你使用过时的方法也不会报错。
Date() 分配 Date 对象并初始化此对象，以表示分配它的时间（精确到毫秒）。
Date(long date) 分配 Date 对象并初始化此对象，以表示自从标准基准时间（称为“历元
（epoch）”，即 1970 年 1 月 1 日 00:00:00 GMT）以来的指定毫秒数。
SimpleDateFormat
java.text.SimpleDateFormat
SimpleDateFormat 是一个与语言环境有关的方式来格式化和解析日期的具体类。它允许进
行格式化（日期 -> 文本）、解析（文本 -> 日期）和规范化。
SimpleDateFormat(String pattern) 用给定的模式和默认语言环境的日期格式符号构造
SimpleDateFormat。
public final String format(Date date)将一个 Date 格式化为日期/时间字符串。
public Date parse(String source) throws ParseException：把字符串 source 表示的时间按 source
的格式转成 Date 对象。
练习：String 与 Date 的相互转化
按某种时间格式来输出指定的 String 类型时间
date2String
format
把某种时间格式的 String 时间转成 Date 类型时间
string2Date
parse
package reviewDemo;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Demo28 {
public static void main(String[] args) throws Exception {
Date d = new Date();
System.out.println(d);//获取当前时间
//格式化
SimpleDateFormat sd = new SimpleDateFormat("yyyy-M-d
HH:mm:ss E");
String s = sd.format(d);//这个方法继承于SimpleDateFormat的父类
DateFormat类！
System.out.println(s);
//反格式化
d = sd.parse(s);
System.out.println(d);
}
}
Calendar
推荐使用处理日期和时间的类 Calendar;
是抽象类，不能实例化，通过
static Calendar getInstance() 获得一个 Calendar 对象。
int get(int field):返回指定日历字段值
静态常量：
YEAR 表示年的字段数字。
MONTH 表示月份字段数字,月份范围是[0,11]。
DATE 表示一个月中的某天。
DAY_OF_MONTH 表示一个月中的某天。
DAY_OF_WEEK 表示一个星期中的某天。
HOUR_OF_DAY / HOUR 表示第几小时
MINUTE 表示第几分钟
SECOND 表示第几秒
Date getTime() 返回一个表示此 Calendar 时间值的 Date 对象。
void set(int year, int month, int date, int hour, int minute, int second) 设置字段 YEAR、
MONTH、DAY_OF_MONTH、HOUR、MINUTE 和 SECOND 的值。
abstract void add(int field, int amount) 根据日历的规则，为给定的日历字段添加或减去指定的
时间量。
若 amount 为负数，则减去一天，
若 amount 为正数 ，则加上一天
例子
package reviewDemo;
import java.util.Calendar;
import java.util.Date;
public class Demo29 {
public static void main(String[] args) {
Calendar c = Calendar.getInstance();
System.out.println(c);
Date d = c.getTime();
System.out.println(d);
/**
* void set(int year, int month, int date, int hour, int minute,
int second)
* 设置字段 YEAR、MONTH、DAY_OF_MONTH、HOUR、MINUTE 和 SECOND 的
值。
*/
c.set(2015, 07, 15, 12, 24, 55);
d = c.getTime();
System.out.println(d);
c.add(Calendar.DAY_OF_MONTH, 3);
d = c.getTime();
System.out.println(d);
}
}
我的总结：注意常查看 api！
Eg：“查询距今最近三天内的记录”，这里的‘三天内’是什么时间段？
将当前日期时间转换为 只获取当天的 00:00:00
如: 2011-08-08 12:12:12 转化为 2011-08-08 00:00:00、
package reviewDemo;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
public class Demo30 {
public static void main(String[] args) {
Calendar c = Calendar.getInstance();
Date d = c.getTime();
System.out.println(d);
SimpleDateFormat sd = new SimpleDateFormat("yyyy-M-d HH:mm:ss
E");
String s = sd.format(d);
System.out.println(s);
c.set(2015, 8, 23, 13, 24, 15);
d = c.getTime();
System.out.println(sd.format(d));
c.add(Calendar.DAY_OF_MONTH, -3);
d = c.getTime();
System.out.println(sd.format(d));
}
}
输出：
Thu Jul 04 08:56:51 CST 2013
2013-7-4 08:56:51 星期四
2015-9-23 13:24:15 星期三
2015-9-20 13:24:15 星期日
14、System
System 类包含一些与系统相关的类字段和方法。它不能被实例化，类中所有属性和方法都
是 static,可直接被 System 调用。
常用方法：
static void exit(int status) 终止虚拟机的运行.对于发生了异常情况而想终止虚拟机的运行,传
递一个非 0 数值,对于正常情况下退出系统传递 0 值;
该方法实际调用的是 Runtime.getRuntime().exit(int status)；
static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 数组拷贝
static long currentTimeMillis() 返回以毫秒为单位的当前时间。
String getenv(String name) 获得指定的环境变量;
static void gc() 运行垃圾回收器。
实际上调用了 Runtime 中的 gc()方法;
Runtime.getRuntime().exec("notepad ");
static Properties getProperties() 取得当前的系统属性。
static String getProperty(String key) 取得指定键指示的系统属性。
static String getProperty(String key, String def) 获取用指定键描述的系统属性,def 表示默认
信息。
Eg：package reviewDemo627;
import java.util.Properties;
public class Demo32 {
public static void main(String[] args) {
Properties p = System.getProperties();
System.out.println(p);
System.out.println(System.getenv());
}
}
|
相关文章
- 10-07黑马程序员_Java异常 Java常用库类
- 10-07黑马程序员 五、异常处理和常用类）