黑马程序员 五、异常处理和常用类)

  1. 云栖社区>
  2. 博客>
  3. 正文

黑马程序员 五、异常处理和常用类)

奋斗蒙 2017-04-26 11:50:00 浏览1061
展开阅读全文
 五、黑马程序员—异常处理和常用类
第五篇
 
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());
}
}


网友评论

登录后评论
0/500
评论
奋斗蒙
+ 关注