第三篇Java核心技术复习

最新推荐文章于 2024-07-30 20:50:32 发布

678628737

最新推荐文章于 2024-07-30 20:50:32 发布

阅读量44

点赞数

文章标签： java

本文链接：https://blog.csdn.net/2301_76552183/article/details/131097873

版权

本次的复习博客的内容主要是围绕着第九，十，十一章这三章的一个复习博客复习内容从bilibili第七十二个视频至八十八个视频

第七十二个视频异常（Exception）什么是异常

什么是异常？

比如程序运行时磁盘空间不足，网络连接中断，被装载的类不存在等等，针对这种情况，在java语言中，引入异常以异常类的形式对这些非正常情况进行封装，通过异常处理机制对程序运行时发生的各种问题进行处理

他先通过下面一个实例来表达异常的作用

代码

package 哔哩哔哩;
public class Example1 {
public static void main(String[] args) {
// TODO Auto-generated method stub
int result =divide(16,2);//调用divide()方法
System.out.println("x除以y等于："+result);
}
//下面的方法实现了两个整数相除
public static int divide(int x,int y) {
int result =x/y;//让整数相除
return result;
}
}

代码图

运行结果图

如果将y的参数改为0的话代码将会报错因为0不能作为除数报错就是异常也就是本章我们主要学习的内容

代码如下

异常中也是有着一个继承体系

如图Throwable类这个类是所有的错误异常的父类，

通过图中可以看出 Throwable有两个直接子类Error和Exception，其中Error代表程序中的错误，Exception代表程序中产生的异常

两个直接子类的详细讲解

1.Error类为错误类他表示是java运行时产生的系统内部错误或者资源耗尽的错误，是一个仅靠修改程序本身是不能恢复执行的只能重新改没有别的办法如果出现了这个问题只能修改改对了才能运行

2.Exception类称为异常类这个异常类跟上面不一样的是上面的是出现问题了不能程序自己处理，只能程序员自己修改，异常类的不同点就是如果出现异常的话程序会自己处理然后输出异常原因异常类的众多子类有一个特殊的RuntimeException类，该类以及子类用于运行时异常

方法声明	功能描述
StringgetMessage（）	返回此throwable的详细消息字符串
voidprintStackTrace（）	将此throwable及其追踪输出至标准错误流
void printStackTrace（PrintStream s）	将此thrpwable及其追踪输出到指定的输出流

第七十三个视频try...catch和finally

java提供了一种对异常进行处理的方式——异常捕获。异常捕获是通过使用try...catch语句

try{
//程序代码块
}catch（ExceptionType（Exception其他子类）e）{
//对ExceptionType的处理
}

其中在try代码块中编写可能发生异常的java语句catch代码块中编写针对异常进行处理的代码。当try代码，当程序中发生异常，系统会将这个异常信息封装成一个异常对象，并将这个对象传递给catch代码块，catch代码快需要一个参数指明它所能够接受异常类型，这个参数必是Exception类或他的子类通过实例讲解以上内容

代码

package 哔哩哔哩;
public class Example2 {
public static void main(String[] args) {
// TODO Auto-generated method stub
//下面代码定义了一个try...catch语句捕捉依次
try {
int result = divide(4,0);//调用divide方法
System.out.println(result);
}catch (Exception e) {//对异常进行处理
System.out.println("捕捉的异常为："+e.getMessage());
}
System.out.println("程序继续向下执行");
}
//下面的方法实现了两个整数相除
public static int divide(int x,int y) {
int result = x/y;//定义变量result记录两个数相处的结果
return result ;
}
}

代码图

运行结果图

第七十四个视频throws关键字

上一节中由于调用自己写的divide（）方法，因此很清楚该方法可能会发生异常，试想一下，如果去调用一个别人写的方法时，是否能知道别人写的方法是否会有异常呢？这很难判断所以针对这种情况，java中允许在方法的后面使用throws关键字对外声明该方法有可能发生的异常，这样调用者再调用方法时，就明确的知道该方法有异常，并且必须在程序中对异常进行处理

throws关键字声明抛出异常的语句格式如下

修饰符 返回值类型 方法名 （[参数1，参数2....]）throws   ExceptionType1[,ExceptionType2.....]

throws关键字需要卸载方法声明的后面throws后面需要声明方法中发生异常的类型，通过将这种做法称为方法声明抛出一个异常

代码

package 哔哩哔哩;
public class Example3 {
public static void main(String[] args) {
// TODO Auto-generated method stub
int result =divide(4,2);
System.out.println(result);
}
//下面的方法实现了两个整数相除并使用throws关键字声明抛出
public static int divide(int x,int y) throws Exception {
int result =x/y;
return result;
}
}

代码图

运行结果图

第七十五个视频运行时异常和编译时异常

在实际开发中，经常会在程序编译时产生一些异常，而这些异常必须要进行处理，这种异常被称为编译时异常，也成为checked异常，另外还有一种异常时在程序运行时产生的，这种异常即使不编写异常处理代码，依然可以通过编译因此被称为运行时异常，也称为unchecked异常，接下来分别对两种异常进行详细的讲解

1.编译时异常

在java中Exception类中RuntimeException类及其子类都是编译时异常，编译时异常的特点时java编译器会对其进行检查如果出现异常就必须对一场进行处理否则程序无法通过编译，处理编译时期的异常有两种方法
1.1使用try...catch语句对异常进行捕获

1.2使用throws关键字声明抛出异常，调用者对其处理

2.运行时异常

RuntimeException类及其子类的都是运行时异常。运行时异常的特点时java编译器不会对其进行检查，也就是说在程序中出现这类异常时，即使没有使用tyr...carch语句捕捉或者使用throws关键字抛出，程序也能通过编译，运行时异常一般是由程序中的逻辑出现错误引起的，在程序运行时无法恢复，比如通过数组的角标访问数组的元素时，如果超过了数组的最大角标，就会发生运行时异常，代码如下所示

int[]arr =new int[5];
System.out.println(arrp[6]);

上面代码中，由于数组arr的length为5，因为数组是从0开始的所以最大角标是4，当使用arr[6]访问数组中的元素就会发生数组角标越界的异常

第七十六个视频自定义异常

JDK中定义了大量的异常类，虽然这些异常类可以描述编程出现的大部分异常情况，但是在程序开发终有时可能需要描述程序中特有的异常情况，例如之前的divide（）方法不允许被除数为负数。为了解决的这个问题，在java中用户自定义异常。但自定义的异常类必须继承自Exception或其子类
在实际开发中，如果没有特殊的要求，自定义的异常类只需要继承Exception在构造方法中使用super（）语句调用Exception的构造方法即可。

既然定义了异常没那么该如何使用呢，这时就需要用到throw关键字throw关键字用于方法中声明抛出异常的实例对象语法如下

throw Exception 异常对象

第七十七个视频访问控制

在java中，针对类、成员方法和属性提供了四个访问级别，分别是 private、default、protected、public 下面通过一张图将这四种控制级别由小到大依次列出

上图中展示了java中的四种放控制级别，具体如下

private（类访问级别）：如果类的成员被private访问控制符来修饰，则这成员只能被该类的其他成员，其他类无法直接访问，类的良好封装就是通过private关键字来实现的

default（包访问级别）如果一个类或者类的成员不适用任何访问控制符，则称它为默认访问控制级别，这个类或者类的成员只能被本包中的其他类访问

protected（子类访问级别）：如果一个类的成员被protected访问控制修饰符，那么这个成员既能被同一个包下的其他类访问，也能被不同包下该类的子类访问

public（公共访问级别）：这是一个最宽松的访问控制级别，如果一个类或者类的成员被public访问控制修饰符，那么这个类或者类的成员被所有的类访问，不管访问类与被访问类是否在同有个包中

访问范围	private	default	protected	public
同一类中	1	1	1	1
同一包中		1	1	1
子类中			1	1
全局范围				1

表中的勾号用1代替

第七十八个视频第五章javaAPI

String类StringBuffer类 System类和Runtime类

Math类与 Random类包装类

学习目标分为三个方面

1.掌握 String类和StringBuffer类的使用

2.熟悉包装类的使用

3.了解System类Runtime类Math类和Random类的使用

5.1String类和StringBuffer类

在应用程序中经常会用到字符串，所谓字符串就是指一连串的字符，他是有多个单个字符连接而成的，如多个应为字母所组成的一个英文单子。字符串中可以包含任意字符，这些字符必须包含在一堆双引号内 ""例如"abc"在java中定义了String和StringBuffer两个类来封装字符串，并提供了一系列操作字符串的方法他们都位于java.lang包中，因此不需要导报就可以直接使用，接下来将针对String类和StringBuffer类进行详细的讲解

在操作String类之前，首先需要对String进行初始化，在java中可以通过以下两种方式初始化对象

1.使用字符串常量直接初始化一个String对象，具体如下

String str1 ="dingguojun"

使用String构造方法初始化字符串对象，String的构造方法如下所示

方法声明	功能描述
String（）	创建一个内容为空的字符串
String（String value）	根据指定的字符串内容创建对象
String（char[] value）	根据只当的字符数组对象

下面一个实例讲解初始化操作

代码

package bilibi;
public class Example01 {
//String类的初始化操作
//1字符串常量直接赋值
//2String类的构造方法
//String（）空参数的构造方法，创建一个String类对象内容为空
//String（String a）创建一个String类对象，指定一个字符串内容
//Strin（char[]chs）创建一个String类对象，指定一个字符串作为内容
public static void main(String[] args) {
// TODO Auto-generated method stub
String str1 ="abc";
//String（）空参数的构造方法，创建一个String类对象内容为空
String str2 =new String();
//String（String a）创建一个String类对象，指定一个字符串内容
String str3 =new String("abcd");
//Strin（char[]chs）创建一个String类对象，指定一个字符串作为内容
char[] charArray =new char[] {'e','f','c'};
String str4 =new String (charArray);
System.out.println(str1);
System.out.println("a"+str2+"b");
System.out.println(str3);
System.out.println(str4);
}
}

代码图

运行结果图

第七十九个视频String类的常见操作

String类的实际开发中的应用非常广泛，因此灵活的使用String类是非常中欧给要的接下来介绍String类的常用的一些方法如表所示

方法声明	功能描述
int indexOf（int ch）	返回指定字符在此字符串中第一次出现的索引
int lastIndexOf(int ch)	返回指定字符在次字符串中最后一次出现的索引
int indexOf(String str)	返回指定子字符串在此字符串中第一次出现的索引
intlastIndexOf(String str)	返回指定子字符串在此字符串中最后一次出现出索引的索引
char charAt（int index）	返回字符串中index位置上的字符，其中index的取值范围是：o~（字符串缠绵高度-1）
boolean end With（String suffix）	判断此字符串是否以指定的字符串结尾
int length（）	返回此字符串的长度
boolean equals（Object anObect）	将此字符串与只当的字符串比较
boolean isEmpty（）	判断仅当字符串长度为0时返回的true
boolean statsWith （String prefix）	判断此字符串是否以指定的字符串开始
boolean comains（CharSequence cs）	判断此字符串中是否包含指定的字符序列
String toLowerCase	使用默认语言环境的规划将String中的所有字符都转换为小写
String toUpperCase（）	使用默认语言环境的规划将String中的所有字符都转换为大写
static StringvalueOf(int i)	返回int参数的字符串表达形式
char[]toCjarArray（）	将此字符串转换为一个字符数组
String replace（Char Squence oldstr CharSequence new str）	返回一个新的字符出啊你，它是通过newstr替换此字符串中出现的所有oldstr得到的
String[]split(String regex)	根据参数regex将原来的字符串分割为若干个子字符串
String substring（int beginIndex）	返回一个新的字符串，它包含从指定的beginIndex初开始，直到此字符串末尾的所有字符
String syvstring （int beginIndex，int endIndex）	返回一个新的字符串，它包含从指定的beginIndex出开始直到索引endIndex-1除的所有字符
String trim（）	返回一个新的字符串，他去错了源字符串的首尾空格

此表可能有误 ppt上太模糊了所以可能有点模糊

下面例题讲解获取字符串长度

代码

package bilibi;
public class Example02 {
//String的基本操作
//在程序中，需要对字符串进行一些基本操作，如获得字符串长度，获取指定位置的字符等
//public int length（）获取字符串长度
public static void main(String[] args) {
// TODO Auto-generated method stub
String s = "abcdefghijkl";
System.out.println("获取字符串长度："+s.length());
}
}

代码图

运行结果图

获取字符串中指定位置上的字符

代码

package bilibi;
public class Example02 {
//String的基本操作
//在程序中，需要对字符串进行一些基本操作，如获得字符串长度，获取指定位置的字符等
//public int length（）获取字符串长度
//public char cahrAt（int index）获取字符串中指定位置上的字符
public static void main(String[] args) {
// TODO Auto-generated method stub
String s = "abcdefghijkl";
System.out.println("获取字符串长度："+s.length());
System.out.println("获取字符串中第一个字符："+s.charAt(0));
}
}

代码图

运行结果图

还有一些基本使用操作

代码

package bilibi;
public class Example02 {
//String的基本操作
//在程序中，需要对字符串进行一些基本操作，如获得字符串长度，获取指定位置的字符等
//public int length（）获取字符串长度
//public char cahrAt（int index）获取字符串中指定位置上的字符
//public int indexOf(char ch )获取指定字符串在字符串中第一次出现的位置
//public int lastIndexOf (char ch)获取指定字符串中最后一次出现的位置
//public int indexOf(String str) 获取指定子字串中第一次出现的位置
//public int lastIndexOf(String str)获取指定子串在字符串中最后一次出现的位置
public static void main(String[] args) {
// TODO Auto-generated method stub
String s = "abcdabcdkl";
System.out.println("获取字符串长度："+s.length());
System.out.println("获取字符串中第一个字符："+s.charAt(0));
System.out.println("获取字符c第一次出现的位置"+s.indexOf('c'));
System.out.println("获取字符c最后一次出现的位置"+s.lastIndexOf('c'));
System.out.println("获取子串ab第一次出现的位置"+s.indexOf("ab"));
System.out.println("获取子串ab最后一次出现的位置"+s.lastIndexOf("ab"));
}
}

代码图

运行结果图

下面例题讲解的是将字符串转换为字符数组

代码

package bilibi;
public class Example03 {
//String类的转换操作
//程序开发中，经常需要对字符串进行转换操作，例如将字符串转换为数组的形式，将字符串进行大小写的转换
//public char[]toChatArray()将此字符串转换成字符数组
public static void main(String[] args) {
// TODO Auto-generated method stub
//声明一个字符串
String s = "abcdefg";
//将此字符串转换为字符数组
char [] charArray =s.toCharArray();
for(int i =0;i<charArray.length;i++) {
if(i==charArray.length-1) {
//数组最后一个元素直接打印元素值
System.out.println(charArray[i]);
}else {
//打印逗号
System.out.print(charArray[i]+",");
}
}
}
}

代码图

运行结果图

将指定的int值转换成字符串类型

代码

package bilibi;
public class Example03 {
//String类的转换操作
//程序开发中，经常需要对字符串进行转换操作，例如将字符串转换为数组的形式，将字符串进行大小写的转换
//public char[]toChatArray()将此字符串转换成字符数组
//public static String valueOf(int n)将指定的int值转换成字符串类型
public static void main(String[] args) {
// TODO Auto-generated method stub
//声明一个字符串
String s = "abcdefg";
//将此字符串转换为字符数组
char [] charArray =s.toCharArray();
for(int i =0;i<charArray.length;i++) {
if(i==charArray.length-1) {
//数组最后一个元素直接打印元素值
System.out.println(charArray[i]);
}else {
//打印逗号
System.out.print(charArray[i]+",");
}
}
System.out.println("将int值转换成String类型后的结果"+String.valueOf(12));
}
}

代码图

运行结果图

将字符串全部转换成大写字母

代码

package bilibi;
public class Example03 {
//String类的转换操作
//程序开发中，经常需要对字符串进行转换操作，例如将字符串转换为数组的形式，将字符串进行大小写的转换
//public char[]toChatArray()将此字符串转换成字符数组
//public static String valueOf(int n)将指定的int值转换成字符串类型
//public String toUppercase()将此字符串的字符全部换成大写字母，会返回一个新的字符串
public static void main(String[] args) {
// TODO Auto-generated method stub
//声明一个字符串
String s = "abcdefg";
//将此字符串转换为字符数组
char [] charArray =s.toCharArray();
for(int i =0;i<charArray.length;i++) {
if(i==charArray.length-1) {
//数组最后一个元素直接打印元素值
System.out.println(charArray[i]);
}else {
//打印逗号
System.out.print(charArray[i]+",");
}
}
System.out.println("将int值转换成String类型后的结果"+String.valueOf(12));
System.out.println("将字符串转换成大写字母后的结果"+s.toUpperCase());
}
}

代码图

运行结果图

程序开发中，用户输入数据时经常会有一些错误和空格，这时可以使用String类的replace（）和trim（）方法进行字符串的替换和去除空格的操作，接下来通过一个实例来学习这两种方法

代码

package bilibi;
public class Example04 {
//String类的替换与去除空格的操作
//程序开发中，用户输入数据时经常会有一些空格和错误，这时可以使用String类的replace()和trim（）方法，进行字符串的替换和去除空格操作
//public String replace（String oldStr，String newStr）
//将原有i字符串中的oldStr字符串内容有newStr字符串所替换，返回一个新的字符串
//public String trim（）返回一个新字符串，它去除了原有字符串的两端空格
public static void main(String[] args) {
// TODO Auto-generated method stub
//声明一个字符串
String s="itcast";
String s2="i t c a s t ";
//替换操作
System.out.println("将it替换成cn.it之后的结果"+s.replace("it", "cn.it"));
//去除空格操作
System.out.println("去除左右空格的结果："+s2.trim());
System.out.println("去除全部空格后的结果"+s2.replace(" ",""));
}
}

代码图

运行结果图

操作字符串时，经常需要都字符串进行一些判断，如判断字符串是否以指定的字符串开始，结束，是否包含指定的字符串，字符串是否包含指定的字符串，字符串是否为空等等，在String类中针对字符串的判断提供操作提供很多方法

代码

package bilibi;
//String类的判断操作
//操作字符串时，经常需要对字符串进行一些判断，如果判断字符串是否以指定的字符串开始，结束，是否包含指定的字符串，字符串是否为空等。
//public boolean startsWith (String str)判断字符串是否以给定字符串str开头
//public boolean endWith（String str）判断字符串是否以给定字符串str结尾
//public boolean contains（String str）判断字符串是否包含给定的字符串str
//public boolean isEmpty（）判断字符串内容是否为空
//public boolean equals（String str）判断字符串与给定字符串str的是否相等
public class Example05 {
public static void main(String[] args) {
// TODO Auto-generated method stub
//声明一个字符串
String s ="String";
String s2 ="String";
System.out.println("判断字符串是否以str开通："+s.startsWith("str"));
System.out.println("判断字符串是否以ng结尾："+s.endsWith("ng"));
System.out.println("判断字符串是否包含tri："+s.contains("tri"));
System.out.println("判断当前字符串内容是否为空"+s.isEmpty());
System.out.println("判断两个字符串的内容是否相同"+s.equals(s2));
}
}

代码图

运行结果图

在String类中针对字符串的截取和分割操作提供了两个方法，其中systring（）方法用于截取字符串的一部分，split（）方法可以将字符进行分割，通过以下案例讲解使用方法

代码

package bilibi;
//String类的截取和分割
//在String类中针对字符串的截取和分割操作提供了两种方法
//其中。substring（）方法用于截取字符串的一部分
//split（）方法可以将字符串按照某个字符进行分割
//public String substring（int start）返回一个新的字符串，他从原有字符串指定位置开始截取，到字符串的末尾结束
public String substring（int start，int end ）返回一个他从原有的字符串指定位置开始截取，到指定位置结束
//public String []split (String regex)按照指定的字符串进行分割返回一个字符串数组
public class Example06 {
public static void main(String[] args) {
// TODO Auto-generated method stub
String s ="羽毛球-篮球-乒乓球";
//截取操作
System.out.println("从第5个字符开始截取到末尾的结果："+s.substring(4));
System.out.println("从第五个字符开始截取到第六个字符结束的结果："+s.substring(4,6));//前含后不含
//分割操作
System.out.println("打印分割后的每个字符串内容");
String [] strArray =s.split("-");
for(int i =0;i<strArray.length;i++) {
//羽毛球，篮球，乒乓球
if(i==strArray.length-1) {
System.out.println(strArray[i]);
}else{
//打印逗号
System.out.print(strArray[i]+",");
}
}
}
}

代码图

运行结果图

String在获取某个字符时，会用到字符的索引当访问字符时，如果字符的索引不存在则会发生字符串角标越界异常

代码

package bilibi;
//String 类的异常演示
//String的字符串在获取某个字符，会用到字符的索引，当访问字符串中的字符时
//如果字符的索引不存在，则会发生字符角标越界异常
public class Example07 {
public static void main(String[] args) {
// TODO Auto-generated method stub
String s =("abcde12345");
System.out.println(s.charAt(10));
}
}

代码图

运行结果图

第八十个视频StringBuffer类

由于字符串是常量，因此一旦创建，其内容和长度是不可改变的。如果需要对一个字符串进行修改，则只能创建新的字符串，为了便于对字符串进行修改，在JDK中提供哦哦那个了一个StringBuffer类（也称字符串缓冲区）StringBuffer类喝String类最大的区别在于它的内容和长度都是可以改变的StringBuffer类似一个字符容器，当其中添加或删除字符时，并不会产生新的StringBuffer对象

下面通过一个实例来演示这个语句的使用方法

代码

package bilibi;
//StringBuffer的构造方法
//public StringBuffer（）空参数构造方法
//StringBuffer（）类的常用方法
//publicBuffer
//public StringBuffer append （String aty）向字符串换种去的末尾添加新数据，发挥当前的StringBuffer对象自身
//public StringBuffer inset(int index,String str)向字符串缓冲区的位置，插入指定的数据
//public StringBuffer delete(int start,int end)删除字符串缓冲区指定范围内的数据
//public StringBuffer deleteCharAt(int index)删除字符串缓冲区的指定位置上的数据
//public StringBuffer replace (int start,int end,String str)替换字符串缓冲区指定范围内的字符串
//public StringBuffer setCharAt(int index ,char ch)替换字符串缓冲区指定位置上的字符
public class Example08 {
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("1,添加-------------------");
add();
System.out.println("2,删除-------------------");
remove();
System.out.println("3,修改-------------------");
alter();
}
public static void add() {
//定义一个字符串缓冲区
StringBuffer sb=new StringBuffer();
//向缓冲区的末尾添加指定字符串
sb.append("abcdefg");
System.out.println("appernd添加数据后的结果"+sb);
//向换种去指定位置插入字符串
sb.insert(2,"123");
System.out.println("insert插入数据后的结果："+sb);
}
public static void remove () {
//定义一个字符串缓冲对象
StringBuffer sb =new StringBuffer("abcdefg");
sb.delete(1,5);
System.out.println("删除知道那个范围数据后的结果："+sb);
//删除字符串缓冲区指定范围的字符
sb.deleteCharAt(2);
System.out.println("删除知道那个范围数据后的结果："+sb);
//清空字符串缓冲区
sb.delete(0,sb.length());
System.out.println("清除缓冲区后的结果;"+sb);
}
public static void alter() {
//定义一个字符串缓冲区
StringBuffer sb =new StringBuffer("abcdefg");
//修改指定位置上的字符
sb.setCharAt(1,'P');
System.out.println("修改指定位置数据后的结果："+sb);
//修改指定范围内的数据
sb.replace(1, 3,"qq");
System.out.println("替换指定范围字符串后的结果");
}
}

代码图

运行结果图

第八十一个视频记录一个字串在整串中出现的次数

代码

package bilibi;
//记录一个字串在整串出现的次数
/*思路
* 1.定义一个整串定义一个子串
* 2.获取子串在整船中出线的次数
*/
public class StringTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
//定义一个整串定义一个字串
String str ="asbdajfbgvxvabcgaywfgbakjfabcasudabcfasfafa";
String key ="abc";
//获取字串在郑传出现的次数
//获取子串在整串中出线的次数
int count =getKeyStringCount(str,key);
System.out.println("couth="+count);
}
public static int getKeyStringCount(String str,String key) {
//定义一个计数器，用来记录出现的次数
int count =0;
if(!str.contains(key)) {
return count;
}
int index =0;
while((index =str.indexOf(key))!=-1) {
count++;
str=str.substring(index+key.length());
}
return 0;
}
}

代码图

运行结果图

第八十二个视频 System类

System类对于读者来说并不陌生应为在之前所学的知识中，需要打印结果时，使用的都是System.out.println（）语句，这句代码就使用了System类System类定义了一些与系统相关属性的方法，他所提供的属性喝方法都是静态的，想要引用这些属性喝方法，直接使用System类即可

代码

package bilibi;
import java.util.Properties;
import java.util.Set;
public class Example9 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Properties properties =System.getProperties();
System.out.println(properties);
Set<String>PropertyNames =properties.stringPropertyNames();
for(String key:PropertyNames) {
String value =System.getProperty(key);
System.out.println(key+"--->"+value);
}
}
}

代码图

运行结果图

2.currentTimeMillis（）

currentTimeMillis（）方法返回一个long类型的值，该值表示当前时间与19701月1日0点0分0秒之间的时间差，单位十毫秒也通常也将改制称作为时间戳

代码、

package bilibi;
public class Example10 {
public static void main(String[] args) {
// TODO Auto-generated method stub
long startTime = System.currentTimeMillis();
int sum =0;
for (int i =0;i<100000000;i++) {
sum+=i;
}
long endTime =System.currentTimeMillis();
System.out.println("程序运行时间为："+(endTime - startTime)+"毫秒");
}
}

代码图

运行结果图

第八十三个视频 Runt ime类

Runtime类用于表示虚拟机运行时的状态，它用于封装JVM虚拟机进程，每次使用java命令启动虚拟机都对应一个Runtime实例，并且只有一个实例，因此该类采用单例模式进行设计，对象不可以直接实例化，若向在程序中获得一个Runtime实例，只能通过下列方式

Runtime ren = Runtime。getRuntime（）；

例题

代码

package bilibi;
public class Example11 {
public static void main(String[] args) {
// TODO Auto-generated method stub
Runtime rt = Runtime.getRuntime();
System.out.println("处理器的个数："+rt.availableProcessors()+"个");
System.out.println("空间内容数量："+rt.freeMemory()/1024/1024+"M");
System.out.println("最大可用内存数量："+rt.maxMemory()/1024/1024+"M");
}
}

代码图

运行结果图

第八十四个视频Math类

Math类时数学操作类，提供了一个系列用于数学运算的静态方法，包括绝对值，三角函数。Math类中有两个静态常量PI和E，分别代表着常量Π和e

由于Math类比较简单因此初学者可以查看API文档学习

代码

package bilibi;
/*public static int abs(int a)//返回参数绝对值
* public static double ceil(double a)//返回大于参数的最小整数
* public static double floor (double a)发挥小于参数的最大整数
* public static long round (double a)四舍五入
* public static float min (float a ,float b)//返回两个数较大值
* public static double random (double a,double b) ]//返回两个数较小值
* public static double random ()返回一个的大于等于0 0小于1 0的随机小数
*/
public class Example12 {
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("计算绝对值后的结果"+Math.abs(-1));
System.out.println("求大于参数的最后整数"+Math.ceil(5.6));
System.out.println("求小数参数的最大整数"+Math.floor(-4.2));
System.out.println("对小数进行四舍五入的结果"+Math.round(-4.6));
System.out.println("求两个数的较大值"+Math.max(2.1,-2.1));
System.out.println("求两个数的较小值"+Math.min(2.1, -2.1));
System.out.println("生成一个大于等于0.0小于1.0的随机值"+Math.random());
}
}

代码图

678628737

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
第三篇Java核心技术复习

运行时异常的特点时java编译器不会对其进行检查，也就是说在程序中出现这类异常时，即使没有使用tyr...carch语句捕捉或者使用throws关键字抛出，程序也能通过编译，运行时异常一般是由程序中的逻辑出现错误引起的，在程序运行时无法恢复，比如通过数组的角标访问数组的元素时，如果超过了数组的最大角标，就会发生运行时异常，代码如下所示。上一节中由于调用自己写的divide（）方法，因此很清楚该方法可能会发生异常，试想一下，如果去调用一个别人写的方法时，是否能知道别人写的方法是否会有异常呢？
复制链接

扫一扫