JAVASE 面向对象08-包装类、内部类、正则表达式、日期类、BigDecimal类

成都在读大学生

已于 2024-06-03 11:03:23 修改

阅读量633

点赞数 22

分类专栏： JAVA开发-JAVASE基础文章标签： java 开发语言

于 2023-11-22 19:44:03 首次发布

本文链接：https://blog.csdn.net/weixin_64646820/article/details/134560933

版权

JAVA开发-JAVASE基础专栏收录该内容

33 篇文章 3 订阅

订阅专栏

java 提供常用类

需求1: 把100 ，转成对应2，8，16进制

需求2：判断一个数据是否在int范围内.

一、包装类

将基本数据类型封装成对象, 让我们可以在对象中定义更多的功能方法来操作数据

常用于：基本类型与字符串之间的转换

int -> String

String -> int

1.基本类型与包装类的对应

int -> Integer 类

byte -> Byte 类

short -> Short 类

long -> Long 类

float -> Float 类

double -> Double类

char -> Character 类

boolean -> Boolean

1.int 转 String

        // int - String
        //方法1：
        int num2 = 666;
        String s1 = num2 +"";

        // 方法2 ： 可以用String类里的方法
        // static String valueOf(int i)
        String s2 = String.valueOf(num2);
        System.out.println(s2);

        // 方法3  : Integer 类 
        //   new Integer().toString的方法
        String s3 = new Integer(num2).toString();
        System.out.println(s3);
        //方法4： Integer.toString()
        String s4 = Integer.toString(num2);
        System.out.println(s4);

2.String 转 int

// String - int
        // 方法1 :
        // 结构调用Integer构造方法
        String ss = "666";
        Integer integer1 = new Integer(ss);
        int i1 = integer1.intValue();
        System.out.println(i1);
       //方法2 ： Integer.parseInt();
        int i2 = Integer.parseInt(ss);
        System.out.println(i2);

3.自动拆箱与装箱

把int 变成 Integer 的对象，称为装箱

 // 666 变成了一个Integer对象, 称为装箱
        Integer i = Integer.valueOf(666);

        //自动先拆箱，再进行计算，然后，再把计算结果装箱
        // i = Integer.valueOf(i.intValue() + 100);
        i+=100;
        System.out.println(i);

// Integer 的对象变成 int 基本类型，称为拆箱

4.Integer缓冲池

Integer 初始化时会创建一个数组，这个数组会把 -128 到 127 提前放到数组里面

Integer.valueOf()获取Integer类的对象时，如果这个基本类型的值在-128-127这里范围内，直接返回对应数组存的Integer对象

如果，直接new 就不用缓冲池里的对象了

注：自动装箱相当于调用的是Integer.valueOf() 方法

Integer integer = Integer.valueOf(666);
        Integer integer1 = 666;
        Integer i = 128;
        Integer i2 = 128;
        System.out.println(i==i2);
        System.out.println(i.equals(i2));
        System.out.println("-------------");
        Integer i3 = new Integer(128);
        Integer i4 =  new Integer(128);
        System.out.println(i3==i4);
        System.out.println(i3.equals(i4));

        System.out.println("-------------");
        Integer i5 = new Integer(127);
        Integer i6 =  new Integer(127);
        System.out.println(i5==i6);
        System.out.println(i5.equals(i6));

        System.out.println("-------------");
        Integer i7 = 127;
        Integer i8 =  127;
        System.out.println(i7==i8);
        System.out.println(i7.equals(i8));

        System.out.println("-------------");
        Integer i9 = Integer.valueOf(128);
        Integer i10 = Integer.valueOf(128);
        System.out.println(i9==i10);
        System.out.println(i9.equals(i10));

Character类

可判断字符是否为数字，大写字母，小写字母等方法

BigInteger类

 BigInteger bi = new BigInteger("8");
        BigInteger bi2 = new BigInteger("3");
        BigInteger biResult = bi.add(bi2);
        BigInteger biResult2 = bi.subtract(bi2);
        // multiply() :相相乘
        // divide(): 相除
        System.out.println(biResult);
        System.out.println(biResult2);

BigDecimal类

注意：精度不想丢失，使用BigDecimal, 实始化的时，用字符串

 BigDecimal bd = new BigDecimal("1");
        BigDecimal bd2 = new BigDecimal("3");
        BigDecimal addResult = bd.add(bd2);
        BigDecimal subResult = bd.subtract(bd2);
        BigDecimal mulResult = bd.multiply(bd2);
        BigDecimal deResult = bd.divide(bd2,2, RoundingMode.HALF_UP);

二、正则表达式

含义：是指一个用来描述或者匹配一系列符合某句语法规则的字符串的一个字符串( 就是一种规则 )

举例：校验qq (5-15位，必须是数字，首字符不能是0)

手机号码的格式

email的格式

身份证号码的格式

A： 字符 

   具体字符 x  .  如 'a'  表示字符 a 
   \\ 表示一个反斜线
   \n 换行符
   \r 回车符
   
B：字符类 []表示一位字符  
   [abc] : , 要么a , b 或c
   [^abc]: 除a,b,c之外
   [a-zA-Z]:a-z或A-Z这个范围内
   [0-9]: 0-9字符都包括

C:预定义字符类
   . 任何字符。 如果就想让表示 .本身，怎么表示 ： \.
   \d 相当于 [0-9]   表示数字 
   \w 相当于 [a-zA-Z_0-9]  
   \D 相当于 [^0-9]   表示数字 
   \W 相当于 [^a-zA-Z_0-9] 
   
D: 边界匹配器
  ＾: 以什么开头
  ＄：以什么结尾
  
F: 数量词
　　X?　　X－次或一次也没有
   X*    X 0次或多次也没有
   X+     X 1次或多次也没有 
   X{n}    X恰好n次
   X{n,}   X至少n次
   X{n,m}  X， n-m次，不能超过m

校验qq (5-15位，必须是数字，首字符不能是0)

String checkQQ="[1-9][0-9]{4,14}";
// 用到表达式的方法有
// 判断 ，分割，替换，获取
 判断

三、日期类

1.Date类

Date ：表示特定的瞬间，精确到毫秒

构造方法

Date d = new Date(); //返回当前的日期

Date d2 = new Date(毫秒数); // 1970年1月1 0:0:0 + 加上给定的毫秒数，计算出来的日期（考虑时区）
方法：

getTime(); //获取日期对应的毫秒数

setTime(); //设置日期到1970-1-1 0:0:0的毫秒数

2.DateFormat类

DateFormat 是日期/时间格式化子类的抽象类。

是抽象类，不能实例化，所以用它的子类SimpleDateFormate

模式：

年 y

月 M

日 d

时 H

分 m

秒 s

Date - > String (格式化)

String -> Date (解析)

 // Date - String (格式化)
        Date d = new Date();
        // xxxx年xxx月xx日 xx:xx:xx
        SimpleDateFormat  sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        System.out.println(sdf.format(d));

        // String - Date (解析)
        String str2 = "2023-11-20 16:06:55";
        // 字符串日期格式，要与SimpleDateFormat给日期模式一致
        SimpleDateFormat  sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date d2 = sdf2.parse(str2);

3.Calendar 类

add()

set()

 Calendar calendar = Calendar.getInstance(); //获取 Calendar 类的实例对象
        //获取年
       int year = calendar.get(Calendar.YEAR);
        System.out.println(year);

        //获取月
        int month = calendar.get(Calendar.MONTH);
        System.out.println(month);

        //获取月
        int day = calendar.get(Calendar.DATE);
        System.out.println(day);

        System.out.println(year+"年"+(month+1)+"月"+day+"日");

四、内部类

1.内部类是什么？

在类的内部定义的类。称为这个类的内部类

如：Ａ类中定义了B类，Ｂ类就是内部类

2.内部类的访问特点：

１．内部类可以直接访问外部类的成员，包括私有的

２．外部类要访问内部类的成员，必须创建对象

3.内部的划分（根据位置分类）

成员位置（成员内部类）

局部位置（局部内部类）

public class Example02 {
    //成员变量
    //定义内部类，这就是成员内部类
    class Inner{
        
    }
    //成员方法
    public void show(){
        //局部内部类
        class Inner2{
            
        }
    }
}

4.成员内部类的使用

直接访问成员内部类

A：在外部内部提供一个方法，返回内部对象

B: 外部类名.内部类名对象名 = new 外部类名().new 内部类名();

//        Outer outer = new Outer();
//        outer.method();

        Outer.Inner inner = new Outer().new Inner();
        inner.show();

5.成员内部类的修饰符

private 为了保证数据的安全性

static 为了让数据访问更方便（内部类用static修饰后，可以把内部类看成外部类的成员）;

注意：被静态修饰的内部类，只能访问外部类的静态成员；

静态内部类访问外部类数据，必须是用静态修饰

内部类被静态修饰后，方法即可以是静态的，也可以是非静态的；

案例：

有一个人（人有身体，身体内有心脏）

class Body{

class Heart{

public void operator(){

System.out.println(“心脏搭桥”);

}

Body.Heart bh = new Body().new Heart();

bh.operator();

6.面试题

Outer2.this: 通过外部类的名称，限定this 对象

class Outer2{
    public int num =10;
    class Inner2{
        public int num = 20;
        public void show(){
            int num = 30;
            System.out.println(num);  // 30
            System.out.println(this.num);  //20
            System.out.println(Outer2.this.num);  //10
        }
    }
}

7.局部内部类

局部内部类，可以直接访问外部类的成员

外部内部类，要访问局部内部类，可以创建内部类的对象，通过对象名.方法，去调用内部类的功能

注：局部内部类内，要使用局部变量, 要求是常量。默认会加final ；所以建议大家，把final修饰加上

为什么？要求局部内部类直的局部变量是常量

因为：局部变量是方法调用完就消失，而内部类上调用方法时，是通过对象去调用，对象调用后，不会立即消失，所以要求局部变量是一常量;

8.匿名内部类

是一个对象

是一个继承了该类或者实现了该接口的子类的匿名对象

格式：匿名内部类
new 类名或接口名(){
   //重写的方法
}

// 传统写法
interface inter1{
   void show();
}

class inter1Impl implements inter1{
   void show(){
      
   }
}
inter1Impl impl = new inter1Impl();

注：匿名内部类，只能使用1次。如果需要多次使用类，就单独去写一个类

9.面试题

interface Inter{

   void show();

}
class Outer{
   // 补齐代码
   public static Inter method(){
       return new Inter{
          @Override
          void show(){
            System.out.println("hello world");
          }
       };
   }
}

class OuterDemo{
   public static void main(String[] args){
      Outer.method().show();
   }
}
//要求输入出“hello world”;

lambda表达式

https://blog.csdn.net/weixin_53679823/article/details/132587543

成都在读大学生

关注

22
点赞
踩
28

收藏

觉得还不错? 一键收藏
0
评论
JAVASE 面向对象08-包装类、内部类、正则表达式、日期类、BigDecimal类

包装类1.基本类型与包装类的对应1.int 转 String2.String 转int3.自动拆箱与装箱4.Integer缓冲池Character类BigInteger类BigDecimal类正则表达式1.Date类2.DateFormat类3.Calendar类四、内部类1.内部类是什么?2.内部类的访问特点:3.内部的划分(根据位置分乡4.成员内部类的使用5.成员内部类的修饰符6.面试题7.局部内部类8.匿名内部类9.面试题lambda表达式
复制链接

扫一扫