Java面向对象进阶

Java面向对象

基本类型包装类

包装类介绍

Java提供的基本类型包装类，使得Java能够更好的体现面向对象的思想，同时也使得基本类型能够支持对象操作

包装类实际上就是将我们的基本数据类型，封装成一个类（运用了封装的思想）

自动装箱/拆箱：

Integer i = 10;
    
    int a = i;
    

本质上就是：

Integer i =  Integer.valueOf(10);
    //自动装箱
    int a = i.intValue();
  //自动拆箱

包装类对象比较：

public static void main(String[] args) {
    
    Integer a = new Integer(10);
    
    Integer b = new Integer(10);
    
    System.out.println(a == b);
    //虽然a和b的值相同，但是并不是同一个对象，所以说==判断为假
}

public static void main(String[] args) {
    
    Integer a = 10, b = 10;
    
    System.out.println(a == b);
//true
}
    

通过自动装箱转换的Integer对象，如果值相同，得到的会是同一个对象：IntegerCache会默认缓存-128~127之间的所有值，将这些值提前做成包装类放在数组中存放，这是为了提升效率，因为小的数使用频率非常高，有些时候并不需要创建那么多对象，创建对象越多，内存也会消耗更多。同样的，Long、Short、Byte类型的包装类也有类似的机制。

字符串常用方法：

Integer i = Integer.valueOf("5555");
    //字符串转Integer
Integer i = Integer.decode("0xA6");
    //十六进制和八进制的字符串进行解码
 System.out.println(Integer.toHexString(166));
    //十进制的整数转换为8进制

特殊包装类

用于计算超大数字的BigInteger

BigInteger i = BigInteger.valueOf(Long.MAX_VALUE);
    
i = i.multiply(BigInteger.valueOf(Long.MAX_VALUE));
       //即使是long的最大值乘以long的最大值，也能给你算出来
i = i.pow(100);
       //long的最大值来个100次方吧
i = i.divide(BigDecimal.valueOf(3), 100, RoundingMode.CEILING);

//计算10/3的结果，精确到小数点后100位
//RoundingMode是舍入模式，就是精确到最后一位时，该怎么处理，这里CEILING表示向上取整

数组

一维数组

数组是相同类型数据的有序集合，数组可以代表任何相同类型的一组内容（包括引用类型和基本类型）其中存放的每一个数据称为数组的一个元素

数组类型比较特殊，它本身也是类，但是编程不可见（底层C++写的，在运行时动态创建）即使是基本类型的数组，也是以对象的形式存在的，并不是基本数据类型。

public static void main(String[] args) {
    
    int[] array = new int[10];
       //在创建数组时，需要指定数组长度，也就是可以容纳多个int变量的值
  	Object obj = array;
   //因为同样是类，肯定是继承自Object的，所以说可以直接向上转型
}
    

数组每个位置上都有默认值，如果是引用类型，就是null，如果是基本数据类型，就是0，或者是false

数组的下标是从0开始的，不是从1开始的

int[] array = new int[10];
    
array[0] = 888;
       //就像使用变量一样，是可以放在赋值运算符左边的，我们可以直接给对应下标位置的元素赋值

数组本身也是一个对象，数组对象也是具有属性的

int[] array = new int[10];
    
System.out.println("当前数组长度为："+array.length);
       //length属性是int类型的值，表示当前数组长度，长度是在一开始创建数组的时候就确定好的

由于基本数据类型和引用类型不同，所以说int类型的数组时不能被Object类型的数组变量接收的；如果是引用类型的话，是可以的

String[] arr = new String[10];
    
Object[] array = arr;
        //数组同样支持向上转型	
Object[] arr = new Object[10];
    
String[] array = (String[]) arr;
   //也支持向下转型

可变长参数

可变长参数本质就是一个数组：

public void test(String... strings){
   //strings这个变量就是一个String[]类型的
    for (String string : strings) {
    
        System.out.println(string);
   //遍历打印数组中每一个元素
    }

}
    

字符串

String类

每个用双引号括起来的字符串，都是String类型的一个实例对象

String str = "Hello World!";
    
String str = new String("Hello World!");
      //这种方式就是创建一个新的对象

直接使用双引号创建的字符串，如果内容相同，为了优化效率，那么始终都是同一个对象：

String str1 = "Hello World";
    
String str2 = "Hello World";
    
System.out.println(str1 == str2);
    

如果我们使用构造方法主动创建两个新的对象，那么就是不同的对象了：

String str1 = new String("Hello World");
    
String str2 = new String("Hello World");
    
System.out.println(str1 == str2);
    

String常用方法：

System.out.println(str.length());
       //length方法可以求字符串长度，这个长度是字符的数量
//双引号括起来的字符串本身就是一个实例对象
System.out.println("Hello World".length());
       //虽然看起来挺奇怪的，但是确实支持这种写法
String sub = str.substring(0, 3);
       //分割字符串，并返回一个新的子串对象
String[] strings = str.split(" ");
       //使用split方法进行字符串分割，比如这里就是通过空格分隔，得到一个字符串数组
char[] chars = str.toCharArray();
  //字符数组和字符串之间转换
char[] chars = new char[]{
'奥', '利', '给'}
    ;
    
String str = new String(chars);
    

StringBuilder

StringBuilder类型，实际上是专门用于构造字符串的，我们可以使用它来对字符串进行拼接、裁剪等操作，弥补了字符串不能修改的不足：

StringBuilder builder = new StringBuilder();
       //一开始创建时，内部什么都没有
builder.append("AAA");
       //我们可以使用append方法来讲字符串拼接到后面
builder.append("BBB");
    
System.out.println(builder.toString());
       //当我们字符串编辑完成之后，就可以使用toString转换为字符串了
builder.delete(2, 4);
       //删除2到4这个范围内的字符

正则表达式

正则表达式(regular expression)描述了一种字符串匹配的模式（pattern），可以用来检查一个串是否含有某种子串、将匹配的子串替换或者从某个串中取出符合某个条件的子串等

限定符表如下：

声明：本文内容由网友自发贡献，本站不承担相应法律责任。对本内容有异议或投诉，请联系2913721942#qq.com核实处理，我们将尽快回复您，谢谢合作！