java----权限修饰符、代码块和常用API（详细介绍）

最新推荐文章于 2022-12-29 16:42:37 发布

℡summer

最新推荐文章于 2022-12-29 16:42:37 发布

阅读量271

点赞数

分类专栏： java基础学习文章标签： java

本文链接：https://blog.csdn.net/midsummer_/article/details/107555484

版权

java基础学习专栏收录该内容

10 篇文章 0 订阅

订阅专栏

权限修饰符

概述

在Java中提供了四种访问权限，使用不同的访问权限修饰符修饰时，被修饰的内容会有不同的访问权限，

public：公共的
protected：受保护的
(空的)：默认的
private：私有的

不同权限的访问能力

	public	protected	（空的）	private
同一类中	√	√	√	√
同一包中(子类与无关类)	√	√	√
不同包的子类	√	√
不同包中的无关类	√

public class Fu {

    public void method1(){}
    protected void method2(){}
     void method3(){}
    private void method4(){}

    public void method(){
        method1();
        method2();
        method3();
        method4();
    }
}
class Zi extends Fu{// 同包的子类
    public void method(){
        method1();
        method2();
        method3();
        //method4();// 编译报错
    }
}
public class Test1 {
    public static void main(String[] args) {// 同包的无关类
        Fu f = new Fu();
        f.method1();
        f.method2();
        f.method3();
        //f.method4();// 编译报错

    }
}

不同包

public class Zi extends Fu {// 不同包的子类
    public void method(){
        method1();
        method2();
        //method3();// 编译报错
        //method4();// 编译报错
    }
}

public class Test {// 不同包的无关类
    public static void main(String[] args) {
        Fu f = new Fu();
        f.method1();
        //f.method2();// 编译报错
        //f.method3();// 编译报错
        //f.method4();// 编译报错
    }
}

可见，public具有最大权限。private则是最小权限。

编写代码时，如果没有特殊的考虑，建议这样使用权限：

成员变量使用private ，隐藏细节。
构造方法使用public ，方便创建对象。
成员方法使用public ，方便调用方法。
类使用public

代码块

构造代码块

格式: {}
位置: 类中,方法外
执行: 每次在调用构造方法的时候,就会执行
使用场景: 统计创建了多少个该类对象

例如:
public class Person {
    {
        System.out.println("Person 构造代码块");
    }

    public Person() {
        System.out.println("Person 空参构造");
    }
}
public class Test1 {
    public static void main(String[] args) {
        Person p1 = new Person();
        Person p2 = new Person();

    }
}

静态代码块

格式：

格式:static{}
位置: 类中,方法外
执行: 当类被加载的时候执行,并只执行一次
使用场景: 例如加载驱动,这种只需要执行一次的代码就可以放在静态代码块中         

public class Person {
	private String name;
	private int age;
 //静态代码块
	static{
		System.out.println("静态代码块执行了");
	}
}

局部代码块

格式:{}
位置: 方法中
执行: 调用方法,执行到局部代码块的时候就执行
使用场景: 节省内存空间,没有多大的意义
例如:
public static void main(String[] args) {
     int a = 10;
     //局部代码块
     //局部代码块的作用就是限制变量的作用域,早早的从内存中消失，节约内存
     //但是现在内存不值钱,所以局部代码块没有使用意义
     {
         int b = 20;
     }

     //int a = 30;    //在同一个区域不能定义重名变量
     //不报错，以为作用域不同
     int b = 40;
 }

常用API

String类

概述

String 类代表字符串，Java 程序中的所有字符串文字（例如“abc”）都被实现为此类的实例。也就是说，Java 程序中所有的双引号字符串，都是 String 类的对象。String 类在 java.lang 包下，所以使用的时候不需要导包！

String类常用的构造方法

常用的构造方法

public String() 创建一个空字符串对象  例如: ""
public String(byte[] bytes) 根据byte数组中的内容,来创建对应的字符串对象
public String(byte[] bytes, int offset, int length) 指定byte数组的范围,根据指定范围中的内容,来创建对应的字符串对象
public String(char[] value) 根据char数组中的内容,来创建对应的字符串对象
public String(String original) 新创建的字符串是该参数字符串的副本。
直接写字符串字面值也是String类对象  例如: String str = "abc";    常用

使用String类的构造方法

public class Test {
    public static void main(String[] args) {
        /*
            String类的概述:
                public String() 创建一个空字符串对象  例如: ""
                public String(byte[] bytes) 根据byte数组中的内容,来创建对应的字符串对象
                public String(byte[] bytes, int offset, int length) 指定byte数组的范围,根据指定范围中的内容,来创建对应的字符串对象
                public String(char[] value) 根据char数组中的内容,来创建对应的字符串对象
                public String(String original) 新创建的字符串是该参数字符串的副本。
                直接写字符串字面值也是String类对象  例如: String str = "abc";    常用
         */
        // 空字符串: ""    空: null
        // 创建一个空字符串对象  例如: ""
        String str1 = new String();// str1表示的字符串内容是: ""
        System.out.println("str1:"+str1+"====");

        // 根据byte数组中的内容,来创建对应的字符串对象
        byte[] bys = {97,98,99,100};
        String str2 = new String(bys);// str2表示的字符串内容是: "abcd"
        System.out.println("str2:"+str2);

        // 指定byte数组的范围,根据指定范围中的内容,来创建对应的字符串对象
        String str3 = new String(bys, 1, 2);// str3表示的字符串内容是: "bc"
        System.out.println("str3:"+str3);

        // 据char数组中的内容,来创建对应的字符串对象
        char[] chs = {'a','b','c','d'};
        String str4 = new String(chs);// str4表示的字符串内容:"abcd"
        System.out.println("str4:"+str4);

        // 新创建的字符串是该参数字符串的副本。
        String str6 = new String("abcd");// str6表示的字符串内容:"abcd"
        System.out.println("str6:"+str6);// abcd

        // 直接写字符串字面值也是String类对象
        String str5 = "abcd";
        System.out.println("str5:"+str5);// "abcd"

    }
}

创建字符串对象两种方式的区别

通过构造方法创建

通过 new 创建的字符串对象，每一次 new 都会申请一个内存空间，虽然字符串内容相同，但是地址值不同

char[] chs = {'a','b','c'};
String s1 = new String(chs);// s1字符串的内容: abc
String s2 = new String(chs);// s2字符串的内容: abc
// 上面的代码中,JVM首先会先创建一个字符数组,然后每一次new的时候都会有一个新的地址,只不过s1和s2参考的字符串内容是相同的

直接赋值方式创建

以“”方式给出的字符串，只要字符序列相同(顺序和大小写)，无论在程序代码中出现几次，JVM 都只会建立一个 String 对象，并在字符串池中维护

String s3 = "abc";
String s4 = "abc";
// 上面的代码中,针对第一行代码,JVM会建立一个String对象放在字符串池中,并给s3参考;第二行代码,则让s4直接参考字符串池中String对象,也就是说他们本质上是同一个对象

public class Test {
    public static void main(String[] args) {
        /*
             创建字符串对象两种方式的区别:
                - 通过构造方法创建: 通过 new 创建的字符串对象，每一次 new 都会申请一个内存空间，虽然字符串内容相同，但是地址值不同
                - 直接赋值方式创建: 以“”方式给出的字符串，只要字符序列相同(顺序和大小写)，无论在程序代码中出现几次，JVM 都只会建立一个 String 对象，并在字符串池中维护
         */
       // 通过构造方法创建
        char[] chs = {'a', 'b', 'c', 'd'};
        String str1 = new String(chs);// str1字符串内容是:abcd
        String str2 = new String(chs);// str2字符串内容是:abcd
        System.out.println(str1 == str2);// 比较2个对象的地址值   false

        System.out.println("=========================");

        // 直接赋值方式创建
        String str3 = "abcd";// str3字符串内容是:abcd
        String str4 = "abcd";// str4字符串内容是:abcd
        System.out.println(str3 == str4);// 比较2个对象的地址值   true

        System.out.println(str1 == str3);// 比较2个对象的地址值   false

    }
}

String类的特点

String类的字符串不可变，它们的值在创建后不能被更改

String s1 = "abc";
s1 += "d";// s1 = s1 + "d"
System.out.println(s1); 
// 内存中有"abc"，"abcd","d",3个对象，s1从指向"abc"，改变指向，指向了"abcd"。

虽然 String 的常量值是不可变的，但是它们可以被共享

String s1 = "abc";
String s2 = "abc";
// 内存中只有一个"abc"对象被创建，同时被s1和s2共享。

字符串效果上相当于字符数组( char[] )

例如： 
String str = "abc";

相当于： 
char[] data = {'a', 'b', 'c'};     
String str = new String(data);// str表示的字符串内容: abc
// String底层是靠字符数组实现的jdk8,jdk9底层是字节数组。

byte[] bys = {97,98,99};
String str = new String(bys);

字符串的比较

==号的比较

比较基本数据类型：比较的是具体的值

int num1 = 10;
int num2 = 20;
num1 == num2  ===> 10==20  结果:false

比较引用数据类型：比较的是对象地址值

String str1 = new String("abc");
String str2 = new String("abc");
str1 == str2 ===> str1存储的对象地址值 == str2存储的对象地址值  结果: false

  // ==比较运算符:
    private static void method01() {
        // 基本数据类型比较的是2个变量中的值是否相同
        int num1 = 10;
        int num2 = 10;
        System.out.println(num1 == num2);// true

        // 引用数据类型比较的是2个对象的地址值是否相同
        String str1 = "abc";

        char[] chs = {'a','b','c'};
        String str2 = new String(chs);// "abc"

        System.out.println(str1 == str2);// false
    }

equals方法的作用

字符串是对象,它比较内容是否相同,是通过一个方法来实现的,就是equals()方法

方法介绍

public boolean equals(String s)     比较两个字符串内容是否相同、区分大小写

示例代码

public class StringDemo02 {
    public static void main(String[] args) {
        //构造方法的方式得到对象
        char[] chs = {'a', 'b', 'c'};
        String s1 = new String(chs);
        String s2 = new String(chs);

        //直接赋值的方式得到对象
        String s3 = "abc";
        String s4 = "abc";

        //比较字符串内容是否相同
        System.out.println(s1.equals(s2));// true
        System.out.println(s1.equals(s3));// true
        System.out.println(s3.equals(s4));// true
    }
}

扩展

public boolean equalsIgnoreCase (String anotherString) ：将此字符串与指定对象进行比较，忽略大小写。

示例

 public static void main(String[] args) {
        //  public boolean equalsIgnoreCase (String anotherString)
        // 1.创建一个字符串对象
        String str1 = "hello";

        // 2.创建一个字符串对象
        String str2 = "Hello";

        // 3.使用equalsIgnoreCase()方法比较str1和str2字符串是否相等
        boolean res1 = str1.equalsIgnoreCase(str2);
        System.out.println("res1的值是:"+res1);// true
    }

String类获取功能的方法

获取功能的方法

- public int length () ：返回此字符串的长度。
- public String concat (String str) ：将指定的字符串连接到该字符串的末尾。
- public char charAt (int index) ：返回指定索引处的 char值。
- public int indexOf (String str) ：返回指定子字符串第一次出现在该字符串内的索引。
- public int indexOf (String str,int fromIndex) ：返回指定子字符串第一次出现在该字符串内的索引,从指定的索引开始。
- public  int lastIndexOf(String str)  ：返回指定子字符串最后一次出现在该字符串内的索引。
- public  int lastIndexOf(String str,int fromIndex)  ：返回指定子字符串最后一次出现在该字符串内的索引,从指定的索引开始反向搜索。
- public String substring (int beginIndex) ：返回一个子字符串，从beginIndex开始截取字符串到字符串结尾。
- public String substring (int beginIndex, int endIndex) ：返回一个子字符串，从beginIndex到endIndex截取字符串。含beginIndex，不含endIndex。

使用获取功能的方法

  public class Test {
    public static void main(String[] args) {
        String str = "itheima-itcast";

        //  public int length () ：返回此字符串的长度。
        int len = str.length();
        System.out.println("str的长度是:"+str.length());// str的长度是:14

        // public String concat (String str) ：将指定的字符串连接到该字符串的末尾。
        String newStr = str.concat("666");
        System.out.println("原来的字符串str:"+str);// itheima-itcast
        System.out.println("拼接后的字符串newStr:"+newStr);// itheima-itcast666

        //  public char charAt (int index) ：返回指定索引处的 char值。
        char c = str.charAt(1);
        System.out.println("1索引位置上的字符:"+c);// t

        // public int indexOf (String str) ：返回指定子字符串第一次出现在该字符串内的索引。
        String str1 = "itheima-itcast-itheima-itcast-itheima-itcast";
        int index1 = str1.indexOf("itcast");
        System.out.println("itcast子字符串在str1中第一次出现的位置:"+index1);// 8

        // public  int lastIndexOf(String str)  ：返回指定子字符串最后一次出现在该字符串内的索引。
        int index2 = str1.lastIndexOf("itcast");
        System.out.println("itcast子字符串在str1中最后一次出现的位置:"+index2);// 38

        // public int indexOf (String str,int fromIndex) ：返回指定子字符串第一次出现在该字符串内的索引,从指定的索引开始。
        int index3 = str1.indexOf("itcast", index1+1);
        System.out.println(index3);// 23

        // public  int lastIndexOf(String str,int fromIndex)  ：返回指定子字符串最后一次出现在该字符串内的索引,从指定的索引开始反向搜索。
        int index4 = str1.lastIndexOf("itcast", index2-1);
        System.out.println(index4);// 23

        // public String substring (int beginIndex) ：返回一个子字符串，从beginIndex开始截取字符串到字符串结尾。
        String subStr1 = str1.substring(4);
        System.out.println("subStr1:"+subStr1);// ima-itcast-itheima-itcast-itheima-itcast

        //  public String substring (int beginIndex, int endIndex) ：返回一个子字符串，从beginIndex到endIndex截取字符串。含beginIndex，不含endIndex。
        String subStr2 = str1.substring(4, 38);
        System.out.println("subStr2:"+subStr2);// ima-itcast-itheima-itcast-itheima-
    }
}

常用的方法：
        concat();  //把两个字符串拼接起来，获取一个新的字符串
        ★length();  //获取字符串的长度(其实就是获取字符串中 字符的个数)      
        ★equals();  //比较两个字符串的内容是否相同。    //区分大小写
        equalsIgnoreCase();  //比较两个字符串的内容是否相同。    //忽略大小写
        ★charAt();  //根据给定的索引，获取对应位置的字符
        ★indexOf(); //获取指定的字符 在字符串中 第一次出现的位置(索引)，找不到返回-1
            //int index = a1.indexOf('h');   从头找，'h'第一次出现的位置
            //int index = a1.indexOf('h',3); 从索引为3的元素开始往后找，'h'第一次出现的位置
       lastIndexOf();  //获取指定的字符 在字符串中 最后一次出现的位置(索引)，找不到返回-1
            //int index = a1.lastIndexOf('h');   从尾部找，'h'最后一次出现的位置
            //int index = a1.lastIndexOf('h',3); 从索引为3的元素开始往前找，'h'最后一次出现的位置 
       ★substring(); //截取字符串，返回新的字符串
                    //String newStr = a1.substring(2);       //从给定索引，直接截取到字符串末尾
           //String newStr = a1.substring(2,5);     //包左不包右(前闭后开), 能取索引2的元素，不能取索引5的元素
		★isEmpty(); //判断字符串是否为空(长度为0返回true，不为0返回false)
        ★contains();    //判断字符串中是否包含 给定的字符串。
        endsWith(); //判断字符串是否以 给定的字符串 结尾。
        startsWith(); //判断字符串是否以 给定的字符串 开头。
		
        ★replace(); //用新内容替代旧内容，返回新的字符串    
        toLowerCase();  //把字母都转成其对应的小写形式。
        toUpperCase();  //把字母都转成其对应的大写形式。
		toCharArray() // 把字符串转换为数组
		getBytes() // 把字符串转换为字节数组        
		★trim();            //移除首尾空格。
		★split();   //根据给定的内容，切割字符串，返回字符串数组

StringBuilder类

字符串拼接问题

由于String类的对象内容不可改变，所以每当进行字符串拼接时，总是会在内存中创建一个新的对象。例如：

public class StringDemo {
    public static void main(String[] args) {
        String s = "Hello";
        s += "World";// s = s + "World";
        System.out.println(s);// HelloWorld
        // 在内存中有三个字符串对象,分别是:"Hello"  "World"  "HelloWorld"
    }
}

在API中对String类有这样的描述：字符串是常量，它们的值在创建后不能被更改。

根据这句话分析我们的代码，其实总共产生了三个字符串，即"Hello"、"World"和"HelloWorld"。引用变量s首先指向Hello对象，最终指向拼接出来的新字符串对象，即HelloWord 。

由此可知，如果对字符串进行拼接操作，每次拼接，都会构建一个新的String对象，既耗时，又浪费空间。为了解决这一问题，可以使用java.lang.StringBuilder类。

StringBuilder类概述以及与String类的区别

StringBuilder类概述

StringBuilder 是一个可变的字符串类，我们可以把它看成是一个容器，这里的可变指的是 StringBuilder 对象中的内容是可变的

StringBuilder类和String类的区别

String类：内容是不可变的
StringBuilder类：内容是可变的

StringBuilder类的构造方法

常用的构造方法

    public StringBuilder()创建一个空白可变字符串对象，不含有任何内容
    public StringBuilder(String   str)根据字符串的内容，来创建可变字符串对象

示例代码

public class StringBuilderDemo01 {
    public static void main(String[] args) {
        //public StringBuilder()：创建一个空白可变字符串对象，不含有任何内容
        StringBuilder sb = new StringBuilder();
        System.out.println("sb:" + sb);
        System.out.println("sb.length():" + sb.length());

        //public StringBuilder(String str)：根据字符串的内容，来创建可变字符串对象
        StringBuilder sb2 = new StringBuilder("hello");
        System.out.println("sb2:" + sb2);
        System.out.println("sb2.length():" + sb2.length());
    }
}

StringBuilder类拼接和反转方法

添加和反转方法

public StringBuilder append(任意类型) 拼接数据，并返回对象本身
public StringBuilder insert(int offset, 任意类型) 在指定位置插入数据,并返回对象本身
public StringBuilder reverse()  反转字符串,并返回对象本身

示例代码

public class Test1 {
    public static void main(String[] args) {
        /*
            public StringBuilder append(任意类型) 拼接数据，并返回对象本身
            public StringBuilder reverse()  反转字符串,并返回对象本身
            public StringBuilder insert(int offset, 任意类型) 在指定位置插入数据,并返回对象本身
         */
        StringBuilder sb1 = new StringBuilder("itheima");
        // 拼接
        StringBuilder sb2 = sb1.append(666);
        System.out.println(sb1 == sb2);// 比较的是地址值  true
        System.out.println("拼接后的字符串:"+sb1);// itheima666
        sb1.append("itcast").append(888);
        System.out.println("拼接后的字符串:"+sb1);// itheima666itcast888
        System.out.println("拼接后的字符串:"+sb2);// itheima666itcast888

        System.out.println("==============================");
        // 对sb1指向的可变字符串内容进行反转
        sb1.reverse();
        System.out.println("反转后的字符串:"+sb1);// 888tsacti666amiehti

        System.out.println("==============================");
        // 在sb1指向的可变字符串中索引为1的位置插入czbk
        sb1.insert(1,"czbk");
        System.out.println(sb1);// 8czbk88tsacti666amiehti

    }
}

StringBuilder和String相互转换

String转换为StringBuilder

public StringBuilder(String s)：通过StringBuilder的构造方法就可以实现把 String 转换为 StringBuilder

StringBuilder转换为String

public String toString()：通过StringBuilder类中的 toString() 就可以实现把 StringBuilder 转换为 String

示例代码

public class StringBuilderDemo02 {
    public static void main(String[] args) {
        /*
        //StringBuilder 转换为 String
        StringBuilder sb = new StringBuilder();
        sb.append("hello");

        //String s = sb; //这个是错误的做法

        //public String toString()：通过 toString() 就可以实现把 StringBuilder 转换为 String
        String s = sb.toString();
        System.out.println(s);
        */

        //String 转换为 StringBuilder
        String s = "hello";

        //StringBuilder sb = s; //这个是错误的做法

        //public StringBuilder(String s)：通过构造方法就可以实现把 String 转换为 StringBuilder
        StringBuilder sb = new StringBuilder(s);

        System.out.println(sb);
    }
}

Object类

概述

java.lang.Object类是Java语言中的根类，即所有类的父类。

如果一个类没有特别指定父类，那么默认则继承自Object类。例如：
```
public class MyClass /*extends Object*/ {
  	// ...
}
```
根据JDK源代码及Object类的API文档，Object类当中包含的方法有11个。主要学习其中的2个：
public String toString()：返回该对象的字符串表示。
public boolean equals(Object obj)：指示其他某个对象是否与此对象“相等”。

toString方法

目标:

toString方法的概述

public String toString()：返回该对象的字符串表示，其实该字符串内容就是：对象的类型名+@+内存地址值。

由于toString方法返回的结果是内存地址，而在开发中，经常需要按照对象的属性得到相应的字符串表现形式，因此也需要重写它。

重写toString方法

如果不希望使用toString方法的默认行为，则可以对它进行覆盖重写。例如自定义的Person类：

ublic class Person {

    public String name;
    public int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person() {
    }

    // 快捷键: alt+insert--->toString方法
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
public class Test1 {
    public static void main(String[] args) {

        Object obj = new Object();
        System.out.println(obj.toString());// java.lang.Object@1c53fd30
        System.out.println(obj);// java.lang.Object@1c53fd30
        // 结论:说明打印对象,其实打印的就是该对象调用toString方法的返回值

        System.out.println("======================");

        // Person类没有重写toString方法
        // Person p = new Person();
        // System.out.println(p);// com.itheima.demo6_toString方法.Person@75412c2f
        // System.out.println(p.toString());// com.itheima.demo6_toString方法.Person@75412c2f

        // Person类重写toString()方法,按照重写后的返回值来打印输出
        Person p = new Person("张三",18);
        System.out.println(p);
        System.out.println(p.toString());
    }
}

在IntelliJ IDEA中，可以点击Code菜单中的Generate...，也可以使用快捷键alt+insert，点击toString()选项。选择需要包含的成员变量并确定。

小贴士：在我们直接使用输出语句输出对象名的时候,其实通过该对象调用了其toString()方法。

小结

toString方法默认返回的字符串内容格式: 对象的类型+@+十六进制数的地址值
打印对象的时候,其实就是打印该对象调用toString方法返回的字符串内容
如果打印对象的时候不希望打印的是地址值的形式,那么就可以去重写toString方法,指定返回的字符串内容格式 ---->一般开发中,重写toString方法—alt+insert—>toString() 回车

equals方法

equals方法的概述

public boolean equals(Object obj)：指示其他某个对象是否与此对象“相等”。

equals方法的使用

默认地址比较

Object类的equals()方法默认实心是==比较,也就是比较2个对象的地址值,对于我们来说没有用

对象内容比较

如果希望进行对象的内容比较，即所有或指定的部分成员变量相同就判定两个对象相同，则可以覆盖重写equals方法。例如：

import java.util.Objects;

public class Person {	
	private String name;
	private int age;
	
  
    // 快捷键: alt+insert--->equals and hashCode
    @Override
    public boolean equals(Object o) {
        // 如果两个对象的地址值相同,就直接返回true,结束方法
        if (this == o) return true;
        // 如果参数为null,就直接返回false,结束方法
        // 或者如果2个对象的类型不一致,就直接返回false,结束方法
        if (o == null || getClass() != o.getClass()) return false;
        // 说明比较的2个对象一定是Person类型,并且不为null
        Person person = (Person) o;// 向下转型
        // 比较姓名和年龄是否相同
        return age == person.age &&
                Objects.equals(name, person.name);
        // 姓名比较: 把2个对象的name交给Objects的equals方法进行比较
        // 好处:避免空指针异常
    }

}

这段代码充分考虑了对象为空、类型一致等问题，但方法内容并不唯一。大多数IDE都可以自动生成equals方法的代码内容。在IntelliJ IDEA中，可以使用Code菜单中的Generate…选项，也可以使用快捷键alt+insert，并选择equals() and hashCode()进行自动代码生成。

tips：Object类当中的hashCode等其他方法，今后学习。

小结

概述: equals方法可以判断两个对象是否相同

1.Object类的equals方法默认比较的是2个对象的地址值是否相同  ==一样的效果
2.如果在开发中,希望调用equals方法比较的不是2个对象的地址值,那么就需要重写equals方法,指定比较规则
  一般开发中,重写toString方法,使用idea的快捷键alt+insert--->equals and hashCode 回车

Objects类

在刚才IDEA自动重写equals代码中，使用到了java.util.Objects类，那么这个类是什么呢？

在JDK7添加了一个Objects工具类，它提供了一些方法来操作对象，它由一些静态的实用方法组成，这些方法是null-save（空指针安全的）或null-tolerant（容忍空指针的），用于计算对象的hashCode、返回对象的字符串表示形式、比较两个对象。

在比较两个对象的时候，Object的equals方法容易抛出空指针异常，而Objects类中的equals方法就优化了这个问题。方法如下：

public static boolean equals(Object a, Object b):判断两个对象是否相等。

可以查看一下源码，学习一下：

// Objects.equals(name, person.name);
// name.equals(person.name)  如果name为null,报控制住异常
public static boolean equals(Object a, Object b) { 
    // 如果2个对象的地址值相同,就直接返回true(逻辑或短路)
    // 如果2个对象的地址值不同:
    // 第一个参数为null,就直接返回false(逻辑与短路)
    // 第一个参数不为null,才去调用第一个对象的equals方法进行比较
    return (a == b) || (a != null && a.equals(b));  
}

native方法

在Object类的源码中定义了 native 修饰的方法， native 修饰的方法称为本地方法。这种方法是没有方法体的,我们查看不了它的实现,所以大家不需要关心该方法如何实现的

当我们需要访问C或C++的代码时，或者访问操作系统的底层类库时，可以使用本地方法实现。

也就意味着Java可以和其它的编程语言进行交互。
本地方法的作用：就是当Java调用非Java代码的接口。方法的实现由非Java语言实现，比如C或C++。

Object类源码(部分)：

package java.lang;
/**
 * Class {@code Object} is the root of the class hierarchy.
 * Every class has {@code Object} as a superclass. All objects,
 * including arrays, implement the methods of this class.
 *
 * @author  unascribed
 * @see     java.lang.Class
 * @since   JDK1.0
 */
public class Object {
	//本地方法
    private static native void registerNatives();
    //静态代码块
    static {
        registerNatives();
    }
    ......
    ......
}

Date类

概述

java.util.Date类表示一个日期时间，内部精确到毫秒。

Date类中的构造方法

继续查阅Date类的描述，发现Date拥有多个构造函数，只是部分已经过时，我们重点看以下两个构造函数

public Date()：从运行程序的此时此刻到时间原点经历的毫秒值,转换成Date对象，分配Date对象并初始化此对象，以表示分配它的时间（精确到毫秒）。
public Date(long date)：将指定参数的毫秒值date,转换成Date对象，分配Date对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”，即1970年1月1日00:00:00 GMT）以来的指定毫秒数。

tips: 由于中国处于东八区（GMT+08:00）是比世界协调时间/格林尼治时间（GMT）快8小时的时区，当格林尼治标准时间为0:00时，东八区的标准时间为08:00。

简单来说：使用无参构造，可以自动设置当前系统时间的毫秒时刻；指定long类型的构造参数，可以自定义毫秒时刻。例如：

import java.util.Date;

public class Demo01Date {
    public static void main(String[] args) {
           // 创建当前系统时间对象
        Date nowDate = new Date();
        System.out.println("nowDate: "+nowDate);// Sun Jul 12 10:58:00 CST 2020

        // 创建距离标准基准时间1分钟对应的时间对象
        Date d = new Date(1*60*1000);
        System.out.println("d:"+d);// Thu Jan 01 08:01:00 CST 1970
    }
}

tips:在使用println方法时，会自动调用Date类中的toString方法。Date类对Object类中的toString方法进行了覆盖重写，所以结果为指定格式的字符串。

Date类中的常用方法

Date类中的多数方法已经过时，常用的方法有：

public long getTime() 获取当前日期对象距离标准基准时间的毫秒值。
public void setTime(long time) 设置当前日期对象距离标准基准时间的毫秒值.也就意味着改变了当前日期对象
public boolean after(Date when) 测试此日期是否在指定日期之后。
public boolean before(Date when)测试此日期是否在指定日期之前。

示例代码

public class DateDemo02 {
    public static void main(String[] args) {
         // 创建当前系统时间对象
        Date nowDate = new Date();
        System.out.println("nowDate:"+nowDate);// Sun Jul 12 11:05:56 CST 2020

        // 获取当前日期对象距离标准基准时间的毫秒值。
        long time1 = nowDate.getTime();
        System.out.println("time1:"+time1);// 1594523087044

        // 设置nowDate日期对象距离标准基准时间的毫秒值
        nowDate.setTime(1000);
        System.out.println("nowDate:"+nowDate);// Thu Jan 01 08:00:01 CST 1970

        System.out.println("=============================");

        Date d1 = new Date(1*60*1000);// 前
        Date d2 = new Date();// 后
        System.out.println("d1表示的时间是否在d2表示的时间之后: "+d1.after(d2));// false
        System.out.println("d1表示的时间是否在d2表示的时间之前: "+d1.before(d2));// true
    }
}

DateFormat类

概述

DateFormat类:
    概述:java.text.DateFormat是表示一个日期格式化的抽象类,由于抽象类不能创建对象,所以只能使用其子类
    DateFormat子类: SimpleDateFormat类
    作用:
         把String类型的日期转化为Date类型的日期  --->解析
         把Date类型的日期转化为String类型的日期  --->格式化
SimpleDateFormat类:
    概述: 表示一个日期格式化类
    构造方法:
        public SimpleDateFormat(String pattern);创建一个日期格式化对象,由参数指定日期格式
        日期格式的组成:
                        y   年
                        M   月
                        d   日
                        H   时
                        m   分
                        s   秒
        常用的日期格式:
                        yyyy-MM-dd HH:mm:ss
                        yyyy-MM-dd
                        yyyy年MM月dd日 HH:mm:ss
                        yyyy年MM月dd日
    成员方法:
         public String format(Date date)：将Date对象格式化为字符串。Date--->String
         public Date parse(String source)：将字符串解析为Date对象。 String-->Date

常用方法

DateFormat类的常用方法有：

public String format(Date date)：将Date对象格式化为字符串。

public Date parse(String source)：将字符串解析为Date对象。

public class SimpleDateFormatDemo {
    public static void main(String[] args) throws ParseException {
         // 创建日期格式化对象,并指定日期格式
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        // Date--->String
        Date nowDate = new Date();
        String nowDateStr = sdf.format(nowDate);
        System.out.println("nowDateStr:"+nowDateStr);// 2020-07-12 11:29:02

        System.out.println("===============================");
        // String--->Date
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入出生日期,格式为yyyy-MM-dd HH:mm:ss");
        String birthdayStr = sc.nextLine();

        Date birthdayDate = sdf.parse(birthdayStr);
        System.out.println("birthdayDate:"+birthdayDate);
    }
}

Calendar类

概述

java.util.Calendar类表示一个“日历类”，可以进行日期运算。它是一个抽象类，不能创建对象，我们可以使用它的子类：java.util.GregorianCalendar类。
有两种方式可以获取GregorianCalendar对象：
- 直接创建GregorianCalendar对象；
- 通过Calendar的静态方法getInstance()方法获取GregorianCalendar对象【本次课使用】

Calendar类的常用方法

获取日历对象:public static Calendar getInstance();

Calendar类的常用方法:

 - public static Calendar getInstance() 获取当前日期的日历对象
- public int get(int field) 获取某个字段的值。
                  - 参数field:表示获取哪个字段的值,可以使用Calender中定义的常量来表示
                   Calendar.YEAR : 年
                   Calendar.MONTH ：月
                   Calendar.DAY_OF_MONTH：月中的日期
                   Calendar.HOUR：小时
                   Calendar.MINUTE：分钟
                   Calendar.SECOND：秒
                   Calendar.DAY_OF_WEEK：星期

- public void set(int field,int value) 设置某个字段的值
- public void add(int field,int amount)为某个字段增加/减少指定的值

public class Test2 {
    public static void main(String[] args) {
        // 获取当前系统时间对应的日历对象
        Calendar cal = Calendar.getInstance();

        // 获取cal日历对象中的年
        int year = cal.get(Calendar.YEAR);
        System.out.println("年:"+year);// 2020

        // 获取cal日历对象中的月
        int month = cal.get(Calendar.MONTH);
        System.out.println("月:"+month);// 6

        // 修改cal对象中的年字段的值为1998
        cal.set(Calendar.YEAR,1998);
        System.out.println("年:"+ cal.get(Calendar.YEAR));// 1998

        // 为年字段增加2年
        cal.add(Calendar.YEAR,2);
        System.out.println("年:"+ cal.get(Calendar.YEAR));// 2000


        // 为年字段减少2年
        cal.add(Calendar.YEAR,-2);
        System.out.println("年:"+ cal.get(Calendar.YEAR));// 1998

    }
}

Calendar类的额外扩展2个方法:

void setTime(Date date)  使用给定的 Date 设置此 Calendar 的时间。
boolean before(Object when) 判断此 Calendar 表示的时间是否在指定 Object 表示的时间之前，返回判断结果。
boolean after(Object when) 判断此 Calendar 表示的时间是否在指定 Object 表示的时间之后，返回判断结果

public class Test3 {
    public static void main(String[] args)throws ParseException {
        // 获取当前系统时间对应的日历对象
        Calendar cal = Calendar.getInstance();
        System.out.println("年:"+cal.get(Calendar.YEAR));// 2020
        System.out.println("月:"+cal.get(Calendar.MONTH));// 6
        System.out.println("日:"+cal.get(Calendar.DAY_OF_MONTH));// 12

        System.out.println("++===========================");
        // 需求: 获取一个日历对象,该日历对象表示你的出生年月日
        String birthday = "1999-11-11";
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date birthdayDate = sdf.parse(birthday);

        // 修改cal日历对象表示的日期时间
        cal.setTime(birthdayDate);
        System.out.println("年:"+cal.get(Calendar.YEAR));// 1999
        System.out.println("月:"+cal.get(Calendar.MONTH));// 10
        System.out.println("日:"+cal.get(Calendar.DAY_OF_MONTH));// 11

        System.out.println("++===========================");
        // 获取当前系统时间对应的日历对象
        Calendar cal1 = Calendar.getInstance();
        // 比较cal和cal1谁在前
        System.out.println(cal.before(cal1));// true
        System.out.println(cal.after(cal1));// false


    }
}

注意

1.中国人:一个星期的第一天是星期一,外国人:一个星期的第一天是星期天
2.日历对象中的月份是: 0-11

Math类

概述

java.lang.Math(类): Math类包含执行基本数字运算的方法。
它不能创建对象，它的构造方法被“私有”了。因为他内部都是“静态方法”，通过“类名”直接调用即可。

Math类的常用方法

 public static int abs(int a) 获取参数a的绝对值：
 public static double ceil(double a) 向上取整  例如:3.14 向上取整4.0
 public static double floor(double a) 向下取整 例如:3.14 向下取整3.0
 public static double pow(double a, double b)  获取a的b次幂
 public static long round(double a) 四舍五入取整 例如:3.14 取整3  3.56 取整4
 public static int max(int a, int b)  返回两个 int 值中较大的一个。
 public static int min(int a, int b)  返回两个 int 值中较小的一个。

案例代码

public class Demo {
    public static void main(String[] args) {
        System.out.println("10的绝对值:"+Math.abs(10));// 10
        System.out.println("-10的绝对值:"+Math.abs(-10));// 10

        System.out.println("3.14向上取整:"+Math.ceil(3.14));// 4.0
        System.out.println("3.54向上取整:"+Math.ceil(3.54));// 4.0
        System.out.println("-3.54向上取整:"+Math.ceil(-3.54));// -3.0

        System.out.println("==================================");
        System.out.println("3.14向下取整:"+Math.floor(3.14));// 3.0
        System.out.println("3.54向下取整:"+Math.floor(3.54));// 3.0
        System.out.println("-3.54向下取整:"+Math.floor(-3.54));// -4.0

        System.out.println("==================================");
        System.out.println("2的3次幂:"+Math.pow(2,3));// 8.0

        System.out.println("==================================");
        System.out.println("3.14四舍五入取整:"+Math.round(3.14));// 3
        System.out.println("3.54四舍五入取整:"+Math.round(3.54));// 4
        System.out.println("-3.54四舍五入取整:"+Math.round(-3.54));// -4


        System.out.println("==================================");
        System.out.println("获取10和20之间的最大值:"+Math.max(10,20));// 20
        System.out.println("获取10和20之间的最小值:"+Math.min(10,20));// 10

    }
}

System类

概述

java.lang.System类中提供了大量的静态方法，可以获取与系统相关的信息或系统级操作。

System类的常用方法

public static void exit(int status) 终止当前运行的Java虚拟机，非零表示异常终止
public static long currentTimeMillis() 返回当前时间(以毫秒为单位)
static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) 拷贝数组中的元素到另一个数组
      参数1src: 源数组
      参数2srcPos:源数组要拷贝的元素的起始索引(从哪个索引位置开始拷贝)
      参数3dest: 目标数组
      参数4destPos:目标数组接收拷贝元素的起始索引(从哪个索引位置开始接收)
      参数5length:需要拷贝多少个元素(拷贝多少个)

案例代码

public class Demo {
    public static void main(String[] args) {
       /* System.out.println("Hello World!1");
        System.out.println("Hello World!2");
        // 结束程序运行
        System.exit(0);
        System.out.println("Hello World!3");*/


        System.out.println("==========================================");
        long time = System.currentTimeMillis();
        System.out.println("time:"+time);

        long time2 = new Date().getTime();
        System.out.println("time2:"+time2);

        System.out.println("==========================================");
        int[] src = {1,2,3,4,5,6,7};
        int[] dest = {10,20,30,40,50,60,70};

        // 需求:把src数组中的2,3,4拷贝到dest目标数组中,使得目标数组的元素为:{10,20,30,2,3,4,70};
        System.arraycopy(src,1,dest,3,3);

        // System.out.println("源数组:"+Arrays.toString(src));
        // System.out.println("目标数组:"+Arrays.toString(dest));
        for (int i = 0; i < dest.length; i++) {
            System.out.println(dest[i]);
        }
    }

BigInteger类

概述

java.math.BigInteger 类，不可变的任意精度的整数。如果运算中，数据的范围超过了long类型后，可以使用
BigInteger类实现，该类的计算整数是不限制长度的。

BigInteger类的构造方法

BigInteger(String value) 将 BigInteger 的十进制字符串表示形式转换为 BigInteger。超过long类型的范围，已经不能称为数字了，因此构造方法中采用字符串的形式来表示超大整数，将超大整数封装成BigInteger对象。

BigInteger类成员方法

BigInteger类提供了对很大的整数进行加add、减subtract、乘multiply、除divide的方法，注意：都是与另一个BigInteger对象进行运算。

add(BigInteger value) 返回其值为 (this + val) 的 BigInteger，超大整数加法运算
subtract(BigInteger value) 返回其值为 (this - val) 的 BigInteger，超大整数减法运算
multiply(BigInteger value) 返回其值为 (this * val) 的 BigInteger，超大整数乘法运算
divide(BigInteger value) 返回其值为 (this / val) 的 BigInteger，超大整数除法运算，除不尽取整数部分

【示例】

public class Test {
    public static void main(String[] args) {
        BigInteger b1 = new BigInteger("123456789123456789123456789");
        BigInteger b2 = new BigInteger("100000000000000000000000000");

        // 加法
        BigInteger sum = b1.add(b2);
        System.out.println("sum:"+sum);// 223456789123456789123456789

        // 减法
        BigInteger sub = b1.subtract(b2);
        System.out.println("sub:"+sub);// 23456789123456789123456789

        // 乘法
        BigInteger mup = b1.multiply(b2);
        System.out.println("mup:"+mup);// 12345678912345678912345678900000000000000000000000000

        // 除法
        BigInteger div = b1.divide(b2);
        System.out.println("div:"+div);// 1


        // long numL = 123456789123456789123456789L;// 编译报错,因为超过了long类型表示的数据范围
        // long numL = 100000000000000000000000000L;// 编译报错,因为超过了long类型表示的数据范围
    }
}

BigDecimal类

概述

使用基本类型做浮点数运算精度问题；

看程序说结果：

public static void main(String[] args) {
    System.out.println(0.09 + 0.01);
    System.out.println(1.0 - 0.32);
    System.out.println(1.015 * 100);
    System.out.println(1.301 / 100);
}

对于浮点运算，不要使用基本类型，而使用"BigDecimal类"类型
java.math.BigDecimal(类):提供了更加精准的数据计算方式。

BigDecimal类构造方法

构造方法名	描述
BigDecimal(double val)	将double类型的数据封装为BigDecimal对象
BigDecimal(String val)	将 BigDecimal 的字符串表示形式转换为 BigDecimal

注意：推荐使用第二种方式，第一种存在精度问题；

BigDecimal类常用方法

BigDecimal类中使用最多的还是提供的进行四则运算的方法，如下：

public BigDecimal add(BigDecimal value)加法运算
public BigDecimal subtract(BigDecimal value)减法运算
public BigDecimal multiply(BigDecimal value)乘法运算
public BigDecimal divide(BigDecimal value)除法运算

注意：对于divide方法来说，如果除不尽的话，就会出现java.lang.ArithmeticException异常。此时可以使用divide方法的另一个重载方法；

public BigDecimal divide(BigDecimal divisor, int scale, RoundingMode roundingMode):  

divisor：除数对应的BigDecimal对象；
scale:精确的位数；
roundingMode: 取舍模式
RoundingMode枚举: 
RoundingMode.HALF_UP 四舍五入

// 基本用法
public class Test {
    public static void main(String[] args) {
        // 加法
        BigDecimal b1 = new BigDecimal("0.09");
        BigDecimal b2 = new BigDecimal("0.01");
        BigDecimal res1 = b1.add(b2);
        System.out.println("res1:"+res1);// 0.10

        // 减法
        BigDecimal b3 = new BigDecimal("1.0");
        BigDecimal b4 = new BigDecimal("0.32");
        BigDecimal res2 = b3.subtract(b4);
        System.out.println("res2:"+res2);// 0.68

        // 乘法
        BigDecimal b5 = new BigDecimal("1.015");
        BigDecimal b6 = new BigDecimal("100");
        BigDecimal res3 = b5.multiply(b6);
        System.out.println("res3:"+res3);// 101.500

        // 除法
        BigDecimal b7 = new BigDecimal("1.301");
        BigDecimal b8 = new BigDecimal("100");
        BigDecimal res4 = b7.divide(b8);
        System.out.println("res4:"+res4);// 0.01301

        System.out.println("=============================================");
        System.out.println(0.09 + 0.01);// 期望:0.10  最终结果: 无限趋近的小数
        System.out.println(1.0 - 0.32);//  期望:0.68  最终结果: 无限趋近的小数
        System.out.println(1.015 * 100);// 期望:101.5  最终结果: 无限趋近的小数
        System.out.println(1.301 / 100);// 期望:0.01301  最终结果: 无限趋近的小数
    }
}


// 注意事项:
public class Test2 {
    public static void main(String[] args) {
        /*
             注意事项:
                    1.如果使用这个BigDecimal(double val)构造方法创建的BigDecimal对象,进行小数运算,无法处理小数运算精度问题
                    2.如果使用这个public BigDecimal divide(BigDecimal value)除法运算,当除不尽的情况会发生运行异常
                    解决办法:使用divide另一个重载的方法
                        public BigDecimal divide(BigDecimal divisor, int scale, RoundingMode roundingMode):
                            divisor：除数,对应的BigDecimal对象；
                            scale:精确的位数；
                            roundingMode: 取舍模式
                            RoundingMode枚举: RoundingMode.HALF_UP 四舍五入
         */
        // 注意事项1:
        BigDecimal b1 = new BigDecimal(0.09);
        BigDecimal b2 = new BigDecimal(0.01);
        BigDecimal res1 = b1.add(b2);
        System.out.println("res1:"+res1);// 期望:0.10 实际结果还是一个无限趋近的小数

        System.out.println("===============================================");
        // 注意事项2:
        BigDecimal b3 = new BigDecimal("10.0");
        BigDecimal b4 = new BigDecimal("3.0");
         //BigDecimal res2 = b3.divide(b4);// 发生运行异常ArithmeticException
         //System.out.println("res2:"+res2);
        // 解决
        BigDecimal res2 = b3.divide(b4, 2, RoundingMode.HALF_UP);
        System.out.println("res2:"+res2);// 3.33


        BigDecimal b5 = new BigDecimal("20.0");
        BigDecimal b6 = new BigDecimal("3.0");
        BigDecimal res3 = b5.divide(b6, 2, RoundingMode.HALF_UP);
        System.out.println("res3:"+res3);// 6.67


    }
}

Arrays类

概述

java.util.Arrays类：该类包含用于操作数组的各种方法（如排序和搜索）

Arrays类常用方法

public static void sort(int[] a)：按照数字顺序排列指定的数组
public static String toString(int[] a)：返回指定数组的内容的字符串表示形式

示例代码：

public static void main(String[] args) {
     int[] arr = {3,2,5,7,1,9};
        System.out.println("排序前:"+Arrays.toString(arr));// [3, 2, 5, 7, 1, 9]
        // 对arr进行升序排序
        Arrays.sort(arr);
        // 打印数组中的元素
        System.out.println("排序后:"+Arrays.toString(arr));// [1, 2, 3, 5, 7, 9]

}

包装类

概述

Java提供了两个类型系统，基本类型与引用类型，使用基本类型在于效率，然而很多情况，会创建对象使用，因为对象可以做更多的功能，如果想要我们的基本类型像对象一样操作，就可以使用基本类型对应的包装类，如下：

基本类型	对应的包装类（位于java.lang包中）
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

Integer类

概述

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

Integer类构造方法及静态方法

public Integer(int   value) 根据 int 值创建 Integer 对象(过时)
public Integer(String s) 根据 String 值创建 Integer 对象(过时)
public static Integer valueOf(int i) 返回表示指定的 int 值的 Integer   实例
public static Integer valueOf(String s) 返回保存指定String值的 Integer 对象
public int intValue()  以 int 类型返回该 Integer 的值。

示例代码

public class IntegerDemo {
    public static void main(String[] args) {
        // 基本数据类型--->对应的包装类类型
        //Integer i1 = new Integer(100);// i1对象包装的就是基本数据类型的100
        //Integer i2 = new Integer("100");//  i2对象包装的就是基本数据类型的100

        Integer i3 = Integer.valueOf(100);// 包装的就是基本数据类型的100
        Integer i4 = Integer.valueOf("100");// 包装的就是基本数据类型的100

        // 包装类类型--->基本数据类型
        int num3 = i3.intValue();
        System.out.println(num3+1);// 101
    }
}

装箱与拆箱

概述

基本类型与对应的包装类对象之间，来回转换的过程称为”装箱“与”拆箱“：

装箱：从基本类型转换为对应的包装类对象。
拆箱：从包装类对象转换为对应的基本类型。

// 装箱: 基本数据类型--->对应的包装类类型
Integer i3 = Integer.valueOf(100);// 包装的就是基本数据类型的100

// 拆箱: 包装类类型--->基本数据类型
int num3 = i3.intValue();

自动装箱与自动拆箱

由于我们经常要做基本类型与包装类之间的转换，从Java 5（JDK 1.5）开始，基本类型与包装类的装箱、拆箱动作可以自动完成。例如：

// 自动装箱:
Integer i4 = 100;

// 自动拆箱:
int num4 = i4;

基本类型与字符串之间的转换

基本类型转换为String

转换方式
方式一：直接在数字后加一个空字符串
方式二：通过String类静态方法valueOf()
示例代码

public class IntegerDemo {
    public static void main(String[] args) {
       // 基本类型--->字符串
        String str1 = 100 + "";
        String str2 = true + "";// "true"
        
        String str3 = String.valueOf(100);// "100"
        String str4 = String.valueOf(true);// "true"
       
    }
}

String转换成基本类型

除了Character类之外，其他所有包装类都具有parseXxx静态方法可以将字符串参数转换为对应的基本类型：

public static byte parseByte(String s)：将字符串参数转换为对应的byte基本类型。
public static short parseShort(String s)：将字符串参数转换为对应的short基本类型。
public static int parseInt(String s)：将字符串参数转换为对应的int基本类型。
public static long parseLong(String s)：将字符串参数转换为对应的long基本类型。
public static float parseFloat(String s)：将字符串参数转换为对应的float基本类型。
public static double parseDouble(String s)：将字符串参数转换为对应的double基本类型。
public static boolean parseBoolean(String s)：将字符串参数转换为对应的boolean基本类型。

代码使用（仅以Integer类的静态方法parseXxx为例）如：

转换方式
- 方式一：先通过Integer类的valueOf方法将字符串数字转成Integer，再调用xxxValue方法得到基本数据类型
- 方式二：通过Integer静态方法parseInt()进行转换
示例代码

public class IntegerDemo {
    public static void main(String[] args) {

        // 字符串-->基本类型
        int num = Integer.parseInt("100");
        boolean flag = Boolean.parseBoolean("true");
        System.out.println(num);
        System.out.println(flag);

        // 扩展: 字符串--->包装类--->自动转换为基本类型
        Integer i = Integer.valueOf("100");
        //int i = Integer.valueOf("100");
        Double d = Double.valueOf("3.14");
        Boolean b = Boolean.valueOf("true");
    }
}

注意:如果字符串参数的内容无法正确转换为对应的基本类型，则会抛出java.lang.NumberFormatException异常。

小结

基本类型—>字符串: 基本类型的数据+空字符串
字符串–>基本类型: 包装类名.parseXXX(字符串)

℡summer

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java----权限修饰符、代码块和常用API（详细介绍）

权限修饰符概述在Java中提供了四种访问权限，使用不同的访问权限修饰符修饰时，被修饰的内容会有不同的访问权限，public：公共的protected：受保护的(空的)：默认的private：私有的不同权限的访问能力publicprotected（空的）private同一类中√√√√同一包中(子类与无关类)√√√不同包的子类√√不同包中的无关类√public class Fu { public vo
复制链接

扫一扫