基本类型包装类

Integer类的概述和使用

Integer包装一个对象中的原始类型int的值

*/
public class IntegerDemo {
    public static void main(String[] args) {
    /*    Integer o = new Integer(100);     //过时
        System.out.println(o);*/
//        Integer mu = new Integer("100"); //过时
//        Integer mu = new Integer("mu");//报错NumberFormatException 不是数值型字符串。这里必须写数值
//        System.out.println(mu);
    Integer a=Integer.valueOf(100);
    Integer b=Integer.valueOf(200);
    Integer c=Integer.valueOf("89");   //必须数值
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
    }
}

Int和String相互转换： valueOf把int转String

parseInt把String转int

public class IntegerDemo {
    public static void main(String[] args) {
        //int转String ---方式1
/*       int num=100;
        String a=""+num;   //把Int类型转化为String类型
        System.out.println(a); //值String类型
        //int转String ---方式2
        String s=String.valueOf(100);//把100转换成String类型，String来接收
        System.out.println(s);*/

        //String转integer在转int---方式1
        String num1 = "100";
        Integer b = Integer.valueOf(num1);
        int c=b.intValue();
        System.out.println(c);
        //---方式2
        int y=Integer.parseInt(num1);
        System.out.println(y);
    }
}

//需求：有一个字符串”91 27 46 38 50“，用程序实现输出”27 38 46 50 91“
public class it2 {
    public static void main(String[] args) {
        String a = "91 27 46 38 50";
        String[] arr = a.split(" ");
      /* for (int i = 0; i <arr.length ; i++) {
            String s = arr[i];
            System.out.print(s+" ");
        }*/

      /* Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));*/
      //把字符串数组的元素存储到int数组中
        int[] arr1 = new int[arr.length]; //定义一个int数组
        for (int i = 0; i <arr1.length ; i++) {
            arr1[i] = Integer.parseInt(arr[i]);   //将字符串类型转换成int类型
//            System.out.println(arr[i]);
        }
        Arrays.sort(arr1);
        StringBuilder t = new StringBuilder(); //字符串容器
        for (int i = 0; i <arr1.length ; i++) {
            if(i==arr1.length-1){ // 最后一个元素
                t.append(arr1[i]);   //添加到容器中
            }else{
                t.append(arr1[i]).append(" ");
            }
        }
        String s = t.toString();
        System.out.println(s);
    }
}

//装箱：把基本类型转换为对应包装类型
//    拆箱：把包装类型转换为基本数据类型
public class it2 {
    public static void main(String[] args) {
       /* Integer a=Integer.valueOf(100);   //仅仅调方法实现的叫装箱
        Integer c=100;        //直接赋值的叫自动装箱，其实底层隐藏了Integer.valueOf(100)

        int i = c.intValue() + 200; //将c转换成基本类型在+200.这里是手动拆箱
        System.out.println(i); //300

        c+=200;    //隐含了自动装箱和自动拆箱
        System.out.println(c);
*/
        Integer ii=null; //实际开发中，先进行非空判断
        if(ii!=null){
            ii+=300;
        }
    }
}

Date类构造方法

public class it2 {
    public static void main(String[] args) {
        Date a=new Date();
        System.out.println(a);
        long date=1000*60*60;
        Date d2=new Date(date);
        System.out.println(d2);
    }
}

getTime() 获取的是日期对象

setTime()

public class it2 {
    public static void main(String[] args) {
        Date a=new Date();
   /*     System.out.println(a);
        long date=1000*60*60;
        Date d2=new Date(date);
        System.out.println(d2);*/
//        long time = a.getTime();
        long time =System.currentTimeMillis();
        a.setTime(time);
        System.out.println(a);
//        System.out.println(time*1.0/1000/60/60/24/365+"年");
    }
}

上面的两种方法不利于阅读。所以引出了SimpleDateFormat类

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

        Date a = new Date();
        SimpleDateFormat s = new SimpleDateFormat("yyyy年MM月dd日HH时mm分ss秒");
        String format = s.format(a);
//        System.out.println(format); //输出2019/8/31 上午11:22，格式化后日期
        System.out.println(format);
        System.out.println("---------");
        //格式化 String---Date
        String ss = "2019-08-31 11:34:42";
        SimpleDateFormat c = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date parse = c.parse(ss);
        System.out.println(parse);    //Sat Aug 31 11:34:42 CST 2019
    }
}

日期工具类

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
* @author murongkang
* @date 2019-08-31 12:27
*/
//需求：定义一个DateUtils工具类，含两个方法，把日期转为指定格式字符串，把字符串解析为指定格式日期
    //    然后定义一个测试类Demo测试方法
    public class DateUtils {
    private DateUtils(){   //私有无参构造方法

    }

    //    把日期转为指定格式字符串
    public static String method(Date date,String format) { //这里的参数是日期参数、要转换成的参数

        SimpleDateFormat s = new SimpleDateFormat(format);
        String s1 = s.format(date);
        return s1;
    }
    //    把字符串解析为指定格式日期
    public static Date method1(String ss,String format) throws ParseException {

        SimpleDateFormat s = new SimpleDateFormat(format);
        Date p = s.parse(ss);
        return p;
    }

}

public class Demo {
    public static void main(String[] args) throws ParseException {
        //创建日期对象
        Date date = new Date();
        String s = DateUtils.method(date, "yyyy年MM月dd日 HH:mm:ss");
        System.out.println(s);
        String s2 = DateUtils.method(date, "yyyy年MM月dd日");
        System.out.println(s2);
        System.out.println("-----------");

        //创建字符串对象
        String s1 ="2019-09-2 12:13:12";
        Date date1 = DateUtils.method1(s1, "yyyy-MM-dd HH:mm:ss"); //调用方法，传参数
        System.out.println(date1); //输出Mon Sep 02 12:13:12 CST 2019
    }
}

import java.awt.desktop.SystemEventListener;
import java.util.Calendar;
import java.util.Date;
import java.util.Scanner;

/**
* @author murongkang
* @date 2019-08-31 13:55
*/
public class Calendar1 {
    public static void main(String[] args) {
        Calendar i = Calendar.getInstance(); //多态的形式
//        System.out.println(i);
    /*    int year = i.get(Calendar.YEAR);
        int month = i.get(Calendar.MONTH) + 1;
        int date = i.get(Calendar.DATE);
        System.out.println(year + "年" + month + "月" + date + "日");*/ //2019年8月31日

        //3年前的今天
      /* i.add(Calendar.YEAR,-3);    //2016年8月31日
        int year = i.get(Calendar.YEAR);
        int month = i.get(Calendar.MONTH) + 1;
        int date = i.get(Calendar.DATE);
        System.out.println(year + "年" + month + "月" + date + "日");*/

        //10年后的5天前
     /*   i.add(Calendar.YEAR,10);
        i.add(Calendar.DATE,-5);
        int year = i.get(Calendar.YEAR);
        int month = i.get(Calendar.MONTH) + 1;
        int date = i.get(Calendar.DATE);
        System.out.println(year + "年" + month + "月" + date + "日");*/

        i.set(2048, 11, 11); //月从0开始的，11代表12月
        int year = i.get(Calendar.YEAR);
        int month = i.get(Calendar.MONTH) + 1;
        int date = i.get(Calendar.DATE);
        System.out.println(year + "年" + month + "月" + date + "日");
    }
}

import java.util.Calendar;
import java.util.Scanner;

/**
* @author murongkang
* @date 2019-08-31 15:45
*/
public class Eryuetain {
    public static void main(String[] args) {
        //键盘输入年份
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入年份");
        int year = sc.nextInt();
        //设置日历的年月日
        Calendar c = Calendar.getInstance();
        c.set(year,2,1);

        //3月1号往前推一天，就是2月的最后一天
        c.add(Calendar.DATE,-1);
        //获取这一天输出即可
        int i = c.get(Calendar.DATE);
        System.out.println(year+"年2月有"+i+"天");
    }
}

异常处理两种方法：

一：try---catch

格式：

try{

可能出现异常的代码（异常对象）；

}catch( 异常类名变量名){

异常的代码处理；

}

执行流程：程序从try开始执行,出现异常，会自动生成一个异常对象，

然后异常对象会交给Java运行时系统,当系统接收到异常对象，会到Catch中去找匹配的异常类，找到后处理，执行后程序还可以继续执行。

public class ExceptionDemo1 {
    public static void main(String[] args) {
        System.out.println("开始");
        method();
        System.out.println("结束");
    }
    public static void method(){
       try {                         //把异常代码块放进去
           int[] arr = {1, 2, 3};
           System.out.println(arr[3]);
       }catch (ArrayIndexOutOfBoundsException e){                     //异常将执行
//           System.out.println("你访问的数组的索引位置不存在");
           e.printStackTrace();         //建议用e对象调用方法，后面仍然可以执行
       }
    }
}

开始

java.lang.ArrayIndexOutOfBoundsException: Index 3 out of bounds for length 3

结束

at it03.ExceptionDemo1.method(ExceptionDemo1.java:16)

at it03.ExceptionDemo1.main(ExceptionDemo1.java:10)

Throwable的成员方法

异常第二种处理方法：throws

格式：throws 异常类名；

注意：这个方法是跟在方法的括号后面的。

上面的运行异常，不会向下继续执行。所以还要用try--catch。

上面图：抛出异常后，在调用方法时会有异常，要再次处理异常。

异常：编译异常、运行异常、自定义异常。

posted @ 2020-02-03 18:01 Mrmukk 阅读(109) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

木木

What?Where?Why?

基本类型包装类