从零开始的学JAVA生活day_08

最新推荐文章于 2021-12-04 22:57:24 发布

ZMh张明辉

最新推荐文章于 2021-12-04 22:57:24 发布

阅读量123

点赞数

本文链接：https://blog.csdn.net/Y_W_Z_/article/details/119189653

版权

1.jdk中的常用API

1.1Math

1.1.1Math对象常用属性

Math.PI 返回圆周率（约等于3.14159）。 Math.E 返回算术常量 e，即自然对数的底数（约等于2.718）。

1.1.2Math对象常用方法

package cn.lanqiao.MathTest;

public class MaTest {
    public static void main(String[] args) {
        double x = -2.1;
        double y = 4.2;
        System.out.println(Math.E);
        System.out.println(Math.abs(x));                // 返回数的绝对值。
        System.out.println(Math.ceil(x) );              // 对数进行上舍入。
        System.out.println(Math.floor(x) );             //对数进行下舍入。
        System.out.println(Math.max(x,y) );             //返回 x 和 y 中的最高值。
        System.out.println(Math.min(x,y));              //返回 x 和 y 中的最低值。
        System.out.println(Math.random());              //返回 0 ~ 1 之间的随机数。
        System.out.println(Math.round(x));              //把数四舍五入为最接近的整数。

    }
}

1.1.3产生一个0--10之间的随机数

public static void main(String[] args) {
    for(int i = 0 ; i < 10;i++){
      int random = (int)(Math.random() *10);
        System.out.println(random);
    }
}

产生3-8之间的随机数

public class MathTest {
    public static void main(String[] args) {
        for(int i = 0 ; i < 10;i++){
          int random = (int)(Math.random() *5) + 3 ;
            System.out.println(random);
        }
    }
}

总结：Math就是好用，不用倒包，直接拿来用。

1.2Random

要是想用Random，二话不说直接倒包、新建对象（）。

public class RandomTest {
    public static void main(String[] args) {
        Random r = new Random();
        for(int i = 0 ; i < 10 ; i++){
            int ran = r.nextInt();//-2的31次方  到 2的31次方减一
            System.out.println(ran);
        }
        System.out.println("----------------------");
        for(int i = 0 ; i < 10 ; i++){
            int ran = r.nextInt(10);// 产生一个0--bound之间的整数   bound随机数的上限
            System.out.println(ran);
        }
        System.out.println("----------------------");
        for(int i = 0 ; i < 10 ; i++){
            int ran = r.nextInt(10) +20;// 产生20--30之间的随机数
            System.out.println(ran);
        }
    }
}

1.3System

for(int i = 0 ; i < 10 ; i++){
    int ran = r.nextInt(10);// 产生一个0--bound之间的整数   bound随机数的上限
    if(ran == 5 ){
        System.exit(-1);// 终止jvm运行
    }
    System.out.println(ran);
}

1.4包装类

引入了八种基本类型所对应的类。这个类就称为基本类型的包装类。

Byte Short Integer Long Float double 他们都是Number的子类 都是数字型

基本类型	包装类
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

转化成包装类的原因：

便于在开发中对基本数据类型的数据进行相关的操作

1.4.1integer（int 的包装类）

方法

int a = 6;
//Integer in = new Integer();                 //不能这么构造一个Integer,必须给给一个变量（）
Integer  t = Integer.valueOf(a);            //int类型转integer类型
String b = t.toString();                    //integer类型转String类型
int c =t.intValue();                        //integer类型转int类型
String s = t.toString(a);                   //可以指定一个int类型的变量变成Stirng

1.4.2int和String之间的相互转换

两个方法，不用倒包

int a = 6;
String b = String.valueOf(a);                   //使用String类提供的valueOf
String c = a+"";                                //直接在数字后边加上一个空字符串

1.4.3String和int之间的相互转换

方式一：

Integer.valueOf(String s) 可以将String类型转换为Integer，然后使用Integer的intValue() 将Ineger转换为int类型

参照上面Integer中的方法

方法二：（需要导包）

1.4.4自动装箱和自动拆箱

自动装箱和自动拆箱 就是将 基本类型和包装类 之间进行像话转换。jdk1.5之后引入的

自动装箱：可以将基本类型直接赋值给对应的包装类
自动拆箱：就是和自动装箱相反的过程

二者地位相同
```
        Integer i1 = 100;//自动装箱
        int ii1 = i1;//自动拆箱
```
1.4.5包装类的缓存问题

整型 char 所对应的包装类在自动装箱的同时，对于-128~127 之间的值会进行缓存处理，目的就是提高效率

每当自动装箱过程发生时(或者手动调用valueOf()时)，就会先判断数据是否在该区间，如果在则**直接获取数组中对应的包装类对象的引用，如果不在该区间，则会通过new调用包装类的构造方法来创建对象。

    public static void main(String[] args) {
        Integer i1 = 100;//自动装箱
        Integer i2 = 100;
        System.out.println(i1 == i2);//true
        Integer i3 = 128;
        Integer i4 = 128;
        System.out.println(i3 == i4);//false
    }

2.时间日期类

2.1Date

时间的表示：GMT 格林尼治时间

UTD 协调世界时间

中国标准时间：CST

2.2Date类常用的方法

        Date date = new Date();         //Date()
        long d = date.getTime();        //.getTime()
        System.out.println(d);
        Date a = new Date(600);         //Date(long)

2.3时间格式化（SimpleDateFormat 类）

SimpleDateFormat是一个具体的类，用于以区域设置敏感的方式格式化和解析日期。它允许格式化（日期文本），解析（文本日期）和归一化。

格式：

javaSimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd  hh:mm:ss");

public static void main(String[] args) throws ParseException {
    Date d1 = new Date();
  //  SimpleDateFormat sdf = new SimpleDateFormat();
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd  hh:mm:ss");
    String strDate = sdf.format(d1);//日期的格式化
    System.out.println(strDate);
    String str = "2021-7-22  11:42:32";
    Date date =  sdf.parse(str);//日期的解析
    System.out.println(date);
}

解析异常：

/*
        工具类：
        1  具有通用性 和普遍适用性
        2 工具类中的方法 通常都是static
 */
public class DateUtils {
    private DateUtils(){

    }
    //1 对Date进行格式换   将Date转换为了String
    public  static String date2String(Date date,String format){
        SimpleDateFormat sdf =new SimpleDateFormat(format);
        String strDate = sdf.format(date);
        return  strDate;
    }

    // 2 String类型的日期  解析为Date
    public static Date  str2Date(String strDate,String format) throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        Date d = sdf.parse(strDate);
        return  d;
    }
}

public class DateUtilTest {
    public static void main(String[] args) throws ParseException {
        //获取系统当前日期
        Date  date = new Date();
        String s1 = DateUtils.date2String(date,"yyyy-MM-dd hh:mm:ss");
        String s2 = DateUtils.date2String(date,"yyyy/MM/dd hh:mm:ss");
        String s3 = DateUtils.date2String(date,"yyyy年MM月dd hh:mm:ss");
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s3);
        String strDate = "2020-11-11 16:30:23";
        Date d1 =  DateUtils.str2Date(strDate,"yyyy-MM-dd hh:mm:ss");
        System.out.println(d1);
    }
}

2.4Calendar类

获取Calendar对象

    public static void main(String[] args) {//获取当前时间，并打印
        Calendar c = Calendar.getInstance();
       int year = c.get(Calendar.YEAR);
       int month = c.get(Calendar.MONTH)+ 1;// 月份的表示是从0--11
       int day = c.get(Calendar.DAY_OF_MONTH) ;
       int houre = c.get(Calendar.HOUR_OF_DAY );
       int min = c.get(Calendar.MINUTE);
       int sec = c.get(Calendar.SECOND);
        System.out.println(year +"-"+month+"-"+day+"   "+houre+":"+min+":"+sec);
    }

    public static void main(String[] args) {
        Calendar c = Calendar.getInstance();
        c.set(2020,11,11,12,12,12);//设置固定日期并打印
       int year = c.get(Calendar.YEAR);
       int month = c.get(Calendar.MONTH)+ 1;// 月份的表示是从0--11
       int day = c.get(Calendar.DAY_OF_MONTH) ;
       int houre = c.get(Calendar.HOUR_OF_DAY );
       int min = c.get(Calendar.MINUTE);
       int sec = c.get(Calendar.SECOND);
        System.out.println(year +"-"+month+"-"+day+"   "+houre+":"+min+":"+sec);
    }

获取任意一年的二月有多少天

    public static void main(String[] args) {
        Calendar c = Calendar.getInstance();
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入你要获取的年份：");
        int  year = sc.nextInt();
        c.set(year,3,1);//设置日历为当年的3月1日
        c.add(Calendar.DATE,-1);//将系统当前日期 往前减一天
        int date = c.get(Calendar.DATE);
        System.out.println(year+"年的2月份有"+date+"天");
    }

3.BigDecimal类

BigDecimal 用来对超过16位有效位的数进行精确地运算

float和double只是取一个大概的值，所以他们是不准的

3.1方法

BigDecimal add(BigDecimal augend)返回BigDecimal，其值是(this + augend)，其标为max(this.scale(), augend.scale())` 。
subtract(BigDecimal subtrahend)返回BigDecimal，其值是(this - subtrahend)，其标为max(this.scale(), subtrahend.scale())`
multiply(BigDecimal multiplicand)返回BigDecimal，其值是(this × multiplicand)，其标为(this.scale() + multiplicand.scale())` 。
divide(BigDecimal divisor) 返回BigDecimal ，其值为(this / divisor) ，优先级为(this.scale() - divisor.scale()) ; 如果不能表示确切的商（因为它具有非终止的十进制扩展），则抛出一个ArithmeticException 。

 public static void main(String[] args) {
        BigDecimal bd1 = new BigDecimal(0.1);
        System.out.println(bd1);//0.1000000000000000055511151231257827021181583404541015625
        BigDecimal bd2= new BigDecimal("0.1");//推荐使用字符串来创建浮点数的Bigdecimal对象
        System.out.println(bd2);
        BigDecimal bd3 = new BigDecimal(17);
        BigDecimal bd4 = new BigDecimal(4);
        BigDecimal add = bd3.add(bd4);
        BigDecimal sub = bd3.subtract(bd4);
        BigDecimal mul = bd3.multiply(bd4);
        BigDecimal div = bd3.divide(bd4,1, RoundingMode.HALF_EVEN );
        System.out.println(add);
        System.out.println(sub);
        System.out.println(mul);
        System.out.println(div);
    }

4.异常

4.1 异常概述

异常：就是在程序执行过程中，发生的不正常情况。（开发中语法错误和逻辑错误不属于异常。）

4.2 异常的分类

Error： java虚拟机无法解决的严重问题。如：jvm系统内部错误资源耗尽等严重的情况。一般不用处理。

Exception：因为编程错误或偶然的外在因素导致的一般性问题，可以使用针对性的代码进行处理。

如：空指针异常读物的文件不存在网络连接中断数据下标越界

对于程序出现的错误，一般有两种解决方法：

1 遇到错误就终止程序的运行。

2 有开发者在编程中，针对可能出现的问题，即使的增加检测和错误信息的提示以及针对特定错误做出相应的处理。

异常通常分为：编译期异常和运行期异常

4.2.1 运行时异常

是在编译器不要求强制处置的异常，一般啊是指在编程时的逻辑错误，是程序应该积极避免其出现的异常

5.2.2. 编译期异常

是编译器要求必须处置的异常，即程序在运行时由于外界因素造成的一般性异常，编译器要求java程序必须进行相应的处理，否则程序无法正常运行。

4.3. 常见的异常

一般所说的异常指Exception

RuntimeException 子类：

ArithmeticException
ClassCastException
IndexOutOfBoundsException
NullPointerException

Excpetion子类：

ParseException

      String[] strArr = {"aa","bb","cc"};
        System.out.println(3/0);//ArithmeticException
      //  System.out.println(strArr[3]);//下标越界异常
        strArr = null;
        System.out.println(strArr.length);//空指针异常

4.4 异常处理机制

java中的异常处理采用抓抛模型。

4.4.1 处理机制一

try{
    有可能发生异常的代码
}catch(异常类型  变量){
    发生对应的异常时的处理方式
}finally{
    无论是否发生异常 都需要执行的代码
}

public static void main(String[] args) {
        String[] strArr = {"aa","bb","cc"};
        try{
            strArr = null;
            System.out.println(strArr.length);//空指针异常
            System.out.println(strArr[3]);//下标越界异常
            System.out.println(3/0);//ArithmeticException
        }catch (ArithmeticException ae){
            System.out.println(ae.getMessage());
        }catch (ArrayIndexOutOfBoundsException ae){
            ae.printStackTrace();
        }catch (RuntimeException re){
            System.out.println("运行时异常");
        }

    }

在处理异常的时候 catch可以有多个可以同时捕获同级的多个异常，但是如果存捕获的异常见存在继承关系，父类一定是处于最后

        try{
            strArr = null;
            System.out.println(strArr.length);//空指针异常
            System.out.println(strArr[3]);//下标越界异常
            System.out.println(3/0);//ArithmeticException
        }catch (ArithmeticException | ArrayIndexOutOfBoundsException | NullPointerException   ae){//jdk7以后的写法  只能是同级别的异常
            System.out.println(ae.getMessage());
        }

面试题

public class ExceptionDemo {
    public static void main(String[] args) {
      int i = test();
      System.out.println(i);//30
    }
    public static int test(){
        int i = 10;
        try{
            i= i +10;
            System.out.println(i/0);
            return i;
        }catch (Exception e){
            i = i+10;
            return i;
        }finally {
            i = i +10;
            return  i;//finally块的return 会将try块中的return的值覆盖掉
        }
    }

4.4.2 处理机制二

声明抛出异常 throws

   public static Date  str2Date(String strDate,String format) throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        Date d = sdf.parse(strDate);
        return  d;
    }

当一个方法抛出异常的时候。那么这个异常就会抛给方法的调用者，作为方法的调用者，则需要选择对于该方法存在的异常的处理方式：抓抛

层层外抛，直到main 抛给jvm ，此时jvm就采用默认的处理方式：

1 在控制台打印堆栈信息

2 终止程序执行。

throws抛出异常的特点：

抛的是异常的类型（在try--catch中捕获的是异常的对象）；

抛出异常可以抛出多个异常类型（在try--catch中捕获的时候只能捕获一个异常对象）

4.5 自定义异常

一般情况下自定义异常自定的是运行时异常也可以是编译期异常

如果要自定义运行时异常则自定义异常只需要继承RuntimeExcepetion即可

如果要定义一个编译期异常则只需要继承Exception即可

自定义异常的实现：

定义一个无参构造在其中使用super调用父类的无参构造

定义带参构造使用错误描述信息作为参数调用父类的带参构造即可

public class MyException extends   Exception{
    public  MyException(){
        super();
    }
    public MyException(String msg){
        super(msg);
    }
}

public class MyExceptionTest {
    public void regist(int num) throws MyException {
        if(num < 0 ){
            throw new MyException("人数为负，不符合要求");//在代码内部手动抛出一个异常  是我们自定义异常的对象
        }else{
            System.out.println("注册成功");
        }
    }
    public void manager(){
        try {
            regist(-100);
        } catch (MyException e) {
            e.printStackTrace();
        }
        System.out.println("注册操作结束");
    }

    public static void main(String[] args) {
        MyExceptionTest my = new MyExceptionTest();
        my.manager();
    }
}

throw和throws区别：

1编写的位置： throw 在方法的内部

throws 在方法的声明上

2 抛出的类型 throw 抛出的是一个对象

throws 抛出的是异常的类型

3 抛出的个数 throw 抛一个对象

throws 可以抛出多个类型

ZMh张明辉

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
从零开始的学JAVA生活day_08

1.jdk中的常用API1.1Math1.1.1Math对象常用属性Math.PI 返回圆周率（约等于3.14159）。 Math.E 返回算术常量 e，即自然对数的底数（约等于2.718）。1.1.2Math对象常用方法package cn.lanqiao.MathTest;public class MaTest { public static void main(String[] args) { double x = -2.1; ...
复制链接

扫一扫