Java -- 浅谈API几个常用的类

野性酷女 2023-07-25 12:35 51阅读 0赞

Java有一个API手册，建议先看1.6或者1.8版本的，虽然有很多已经过时了，但是相对来说比较稳定，更有利于新手的学习和日常操作的使用，不建议一味地追求新版本，稳定最重要！  
![在一个城市站稳脚跟][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70_pic_center]

> API：Application Programming Interface应用编程接口，一切可以调用的东西都是API。  
> java.lang包，这个包会自动导入。  
> java.lang.Object  
> java.lang.String  
> java.lang.StringBuilder/StringBuffer  
> 正则表达式  
> 包装类等

一些简单的用法作用都融合在代码里面进行讲解

## 一、Object ##

##### 1、概念 #####

*  类 Object 是类层次结构的根类。每个类都使用 Object 作为超类。所有对象（包括数组）都实现这个类的方法。

##### 2、常用方法 #####

*  `toString()`返回该对象的字符串表示；
 *  `hashCode()`返回该对象的哈希码值；
 *  `equals(Object obj)`指示其他某个对象是否与此对象“相等”。

##### 3、测试 #####

package cn.tedu.api;
    
    //这个类用来测试 Object工具类
    //总结：
    //1、toString():默认使用的是Object里的，也就是打印地址值，如果你要查看属性值，需要重写toString()
    //2、hashCode():获取对象在内存中的哈希码值
    //3、equals():如果比较的是对象的地址值，直接使用默认的object提供的就可以，如果要比较的是属性值就需要重写
    public class Test_Object { 
    	public static void main(String[] args) { 
    		//1、给属性设置值，两种方式：调用set() + 创建对象时利用构造方法
    		Student s = new Student("daniel",18,"山东",130);// -- 触发含参构造
    		//2、想要查看属性的值
    		System.out.println(s.getAddr()+s.getAge()+s.getName()+s.getScore());//山东18daniel130.0
    		//3、能不能简化，查看属性的值 -- 在打印对象时，底层会自动调用toString()
    		//默认使用的是Object父类提供的,就相当于直接打印对象在内存中的地址值
    		//重写toString前：cn.tedu.api.Student@380fb434
    		//重写toString后：Student [name=daniel, age=18, addr=山东, score=130.0]
    		System.out.println(s);
    		System.out.println(s.hashCode());//5、返回对象在内存中的哈希码值 -- 编号940553268
    		System.out.println("运算对象的地址值是："+Integer.toHexString(940553268));//模拟对象的地址值的获取
    		
    		//equals():比较两个对象是否相等？
    		Student s2 = new Student("daniel",18,"山东",130);
    		//默认使用了Object提供的equals(),使用==比较
    		// ==比较引用类型变量时，比较的是地址值
    		// ==比较基本类型变量时，比较的是值本身
    		//重写equals()前：false，因为比较的是地址值
    		System.out.println(s.equals(s2));
    	}
    }
    
    //创建学生类
    class Student extends Object{ 
    	//构造方法
    	public Student() { }
    	
    	//含参构造，右键 source --> 倒数第三个
    	public Student(String name, int age, String addr, double score) { 
    		super();
    		this.name = name;
    		this.age = age;
    		this.addr = addr;
    		this.score = score;
    	}
    
    	// 封装 属性
    	private String name;
    	private int age;
    	private String addr;
    	private double score;
    	
    	//提供全局访问点,get获取，set设置
    	public String getName() { 
    		return name;
    	}
    	public void setName(String name) { 
    		//当变量名相同时，通过this调用成员变量
    		this.name = name;
    	}
    	public int getAge() { 
    		return age;
    	}
    	public void setAge(int age) { 
    		this.age = age;
    	}
    	public String getAddr() { 
    		return addr;
    	}
    	public void setAddr(String addr) { 
    		this.addr = addr;
    	}
    	public double getScore() { 
    		return score;
    	}
    	public void setScore(double score) { 
    		this.score = score;
    	}
    
    	/* * 重写tostring(): * -- 由于目前student类中没有提供toString(),如果打印对象时， * 就会找object里的toString()采用默认实现方式，来实现对象的地址值 * 解决方案： * -- 不能改Object里的toString() -- 我们只能重写toString() */
    	
    	@Override
    	public String toString() { 
    		return "Student [name=" + name + ", age=" + age + ", addr=" + addr + ", score=" + score + "]";
    	}
    	//7、重写equals()方法,因为默认使用Object的equals()方法就是比较两个对象的地址值
    	//比较两个对象间的属性值，就算是new两次，但是两次的属性一模一样，必须认为两个对象是同一个人，让equals()返回true
    // @Override
    // public boolean equals(Object obj) { 
    // //要求参数obj必须是学生类型
    // Student s = (Student) obj;//向下转型
    // 
    // //如果两个对象所有属性值相同，返回true
    // if (this.name == s.name && this.addr == s.addr && this.age == s.age && this.score == s.score) { 
    // return true;
    // }
    // return false;
    // }
    
    	//自动生成的重写的equals();方法
    	@Override
    	public boolean equals(Object obj) { 
    		if (this == obj)
    			return true;
    		if (obj == null)
    			return false;
    		if (getClass() != obj.getClass())
    			return false;
    		Student other = (Student) obj;//向下转型
    		if (addr == null) { 
    			if (other.addr != null)
    				return false;
    		} else if (!addr.equals(other.addr))
    			return false;
    		if (age != other.age)
    			return false;
    		if (name == null) { 
    			if (other.name != null)
    				return false;
    		} else if (!name.equals(other.name))
    			return false;
    		if (Double.doubleToLongBits(score) != Double.doubleToLongBits(other.score))
    			return false;
    		return true;
    	}
    }

## 二、String ##

##### 1、特点 #####

String 类代表字符串。Java 程序中的所有字符串字面值（如 “abc” ）都作为此类的实例实现。字符串是常量；它们的值在创建之后不能更改。字符串缓冲区支持可变的字符串。因为String 对象是不可变的，所以可以共享。

##### 2、创建String对象 #####

String s = "abc";
    String(char[] value) 
    String(byte[] bytes)

##### 3、常用方法 #####

*  `char charAt(int index)`  
    返回指定索引处的 char 值。
 *  `String concat(String str)`  
    将指定字符串连接到此字符串的结尾。
 *  `boolean endsWith(String suffix)`  
    测试此字符串是否以指定的后缀结束。
 *  `boolean equals(Object anObject)`  
    将此字符串与指定的对象比较。
 *  `byte[] getBytes()`  
    使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中。
 *  `int hashCode()`  
    返回此字符串的哈希码。
 *  `int indexOf(String str)`  
    返回指定子字符串在此字符串中第一次出现处的索引。
 *  `int lastIndexOf(String str)`  
    返回指定子字符串在此字符串中最右边出现处的索引。
 *  `int length()`  
    返回此字符串的长度。
 *  `String replace(char oldChar, char newChar)`  
    返回一个新的字符串，它是通过用 newChar 替换此字符串中出现的所有 oldChar 得到的。
 *  `String[] split(String regex)`  
    根据给定正则表达式的匹配拆分此字符串
 *  `boolean startsWith(String prefix)`  
    测试此字符串是否以指定的前缀开始。
 *  `String substring(int beginIndex)`  
    返回一个新的字符串，它是此字符串的一个子字符串。
 *  `String substring(int beginIndex, int endIndex)`  
    返回一个新字符串，它是此字符串的一个子字符串。
 *  `String toLowerCase()`  
    使用默认语言环境的规则将此 String 中的所有字符都转换为小写。
 *  `String toUpperCase()`  
    使用默认语言环境的规则将此 String 中的所有字符都转换为大写。
 *  `String trim()`  
    返回字符串的副本，忽略前导空白和尾部空白。
 *  `static String valueOf(long l)`  
    返回 long 参数的字符串表示形式。

##### 4、测试案例 #####

package cn.tedu.String;
    
    import java.util.Arrays;
    
    //这个类用来测试String工具类
    //String 是一个最终类，不能被继承
    //String 底层维护了一个char[]，一旦被创建，长度不能修改
    public class Test_String { 
    	public static void main(String[] args) { 
    		//1、创建字符串对象
    		
    		char[] chars = { 'a','b','c'};
    		String str = new String(chars);//自动匹配char[]构造
    		
    		byte[] bytes = { 97,98,99,100};
    		String str2 = new String(bytes);//自动匹配byte[]构造
    		
    		String str3 = "abc";
    		//2、调用常见功能
    		System.out.println(str.charAt(2));//c，获取指定下标对应的字符
    		System.out.println(str.concat(" + concat拼接字符串"));//相当于拼接字符串
    		
    		//判断是否以指定元素结尾
    		System.out.println(str.endsWith("a"));//false
    		System.out.println(str.endsWith("c"));//true
    		
    		System.out.println(str=="abc");//false，==比较的是引用类型的变量，比较地址值
    		System.out.println(str.equals("abc"));//true，判断是否与指定数据相等，String已经重写了equals()可以比较属性值
    		System.out.println(str.getBytes());//[B@380fb434，用来把数据存入byte数组
    		System.out.println(str.hashCode());//96354，获取对象在内存中的哈希码值
    		System.out.println(str.indexOf("a"));//0，返回指定数据在字符串中第一次出现的下标
    		
    		str = "abcdea";//思考：我们真的把str的值改掉了吗？？
    						//-- 原来的值不会改变，看起来的重新赋值动作在底层会创建新的字符串
    		System.out.println(str.lastIndexOf("a"));//获取指定数据在字符串中最后一次出现的下标
    		System.out.println(str.length());//
    		System.out.println(str.replace('a', 'x'));//把字符串中出现的所有a字符，替换成x字符
    		
    		str = "a0bdcc0gh";
    		System.out.println(Arrays.toString(str.split("0")));//按照指定数据切割字符串
    		System.out.println(str.startsWith("a"));//判断是否以指定数据开始
    		System.out.println(str.substring(1));//从指定下标处开始，向后截取所欲字符串[1,n]
    		System.out.println(str.substring(0, 2));//从指定下标处开始，到指定处结束，但是含头不含尾[a,b)
    		
    		str = "aBcDeF";
    		System.out.println(str.toLowerCase());//将字符串中的所有元素变成小写
    		System.out.println(str.toUpperCase());//将字符串中的所有元素变成大写
    		
    		str = " aBcD eF ";
    		System.out.println(str.trim());//去除前导和后导的空格，不管中间的
    		
    		System.out.println(String.valueOf(9.9)+1);//把其他类型转成String类型
    		//+1是为了验证9.9是不是字符串类型
    	}
    }

## 三、StringBuffer/StringBuilder ##

##### 1、特点 #####

1.  封装了char\[\]数组；
2.  是可变的字符序列；
3.  提供了一组可以对字符内容修改的方法；
4.  常用`append()`来代替字符串做字符串连接；
5.  内部字符数组默认初始容量是16：`initial capacity of 16 characters；`
6.  如果大于16会尝试将扩容，新数组大小原来的变成2倍+2，容量如果还不够，直接扩充到需要的容量大小。`int newCapacity = value.length * 2 + 2;`
7.  `StringBuffer 1.0出道线程安全，StringBuilder1.5出道线程不安全`

##### 2、构造方法 #####

*  `StringBuilder()`  
    构造一个不带任何字符的字符串生成器，其初始容量为 16 个字符。

##### 3、常用方法 #####

*  `StringBuilder append(String str)`  
    将指定的字符串追加到此字符序列。

##### 4、测试案例 #####

package cn.tedu.String;
    
    //这个类用来测试字符串优化效率
    /* * 总结： * 1、因为+拼接字符串效率低，因为字符串是常量，不能改，每次拼接时都会产生新的字符串对象 * 2、现在用工具类拼接字符串对象 */
    public class Test_StringBufferOrBuilder { 
    	public static void main(String[] args) { 
    		method2();
    		method();//先用“+”拼接字符串
    	}
    
    	public static void method() { 
    		//1、定义字符串
    		String str = "字符串";
    		//2、拼接1000次并输出
    		//定义变量，记录拼接结果
    		String result = "";
    		
    		long start = System.currentTimeMillis();//计时开始ms
    		for (int i = 0; i < 1000; i++) { 
    			result = result + str;
    		}
    		long end = System.currentTimeMillis();//计时结束
    		System.out.println(end - start);//4
    	}
    	public static void method2() { 
    		String str = "字符串";
    		
    		//1、创建工具类对象、
    		StringBuilder sb = new StringBuilder();
    
    		long start = System.currentTimeMillis();//计时开始ms
    		for (int i = 0; i < 10000; i++) { 
    			sb.append(str);//用工具类拼接
    		}
    		long end = System.currentTimeMillis();//计时结束
    		System.out.println(end - start);//for循环执行时间--0
    	}
    }

> **StringBuilder和StringBuffer的区别：**  
> 1、 在线程安全上，  
> –StringBuffer是旧版本就提供的，线程安全的。@since JDK1.0  
> –StringBuilder是jdk1.5后产生，线程不安全的。@since 1.5  
> 2、 在执行效率上，StringBuilder > StringBuffer > String  
> 3、 源码体现：本质上都是在调用父类抽象类AbstractStringBuilder来干活，只不过Buffer把代码加了>同步关键字，使得程序可以保证线程安全问题。  
> `abstract class AbstractStringBuilder implements Appendable, CharSequence {}`  
> ![在这里插入图片描述][20200416222058408.png]  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70]

## 四、包装类 ##

##### 1、概念 #####

为了丰富基本类型的功能，提供了对应的包装类型；

*  与基本类型的对应关系

<table> 
 <thead> 
  <tr> 
   <th align="center">基本类型</th> 
   <th align="center">包装类</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">byte</td> 
   <td align="center">Byte</td> 
  </tr> 
  <tr> 
   <td align="center">short</td> 
   <td align="center">Short</td> 
  </tr> 
  <tr> 
   <td align="center">int</td> 
   <td align="center">Integer</td> 
  </tr> 
  <tr> 
   <td align="center">long</td> 
   <td align="center">Long</td> 
  </tr> 
  <tr> 
   <td align="center">float</td> 
   <td align="center">Float</td> 
  </tr> 
  <tr> 
   <td align="center">double</td> 
   <td align="center">Double</td> 
  </tr> 
  <tr> 
   <td align="center">char</td> 
   <td align="center">Character</td> 
  </tr> 
  <tr> 
   <td align="center">boolean</td> 
   <td align="center">Boolean</td> 
  </tr> 
 </tbody> 
</table>

**☆** 简单介绍两个的用法，其余的都一样

#### （一）Integer ####

Integer ----包装了基本类型的int

##### 1、创建对象 #####

*  **`Integer(int value)`**  
    构造一个新分配的 Integer 对象，它表示指定的 int 值。
 *  **`static Integer valueOf(int i)`**  
    返回一个表示指定的 int 值的 Integer 实例。

##### 2、常用方法 #####

*  **`int intValue()`**  
    以 int 类型返回该 Integer 的值。
 *  **`static int parseInt(String s)`**  
    将字符串参数作为有符号的十进制整数进行解析。

##### 3、测试案例 #####

> **测试案例内部涉及【自动装箱】和【自动拆箱】的功能**

package cn.tedu.api;
    
    //这个类用来测试包装类
    public class Test_Integer { 
    	public static void main(String[] args) { 
    		//包装类和基本类型可以相互转换
    		//基本类型转包装类：valueOf() 或者构造方法 -- 目的是使用包装类型身上的功能 -- 自动装箱
    		//包装类转基本类型：intValue() -- 拿到包装类包着的值做运算 -- 自动拆箱
    
    		//1、创建Integer对象
    		//就是拿到基本类型 的参数 5 ，经过包装，，形成了包装类型的对象
    		Integer in = new Integer(5);
    		Integer in2 = Integer.valueOf(5);
    		
    		//静态方法valueOf()高效(-128~127范围内)，超出范围就不高效了
    		//如果要保存相同数据，只是第一次没存时会存一次，以后要存相同的数据时就不会再存储了。
    		Integer in3 = Integer.valueOf(5);
    		System.out.println(in2);
    		System.out.println(in3);
    		System.out.println(in2 == in3);//true
    		
    		Integer in4 = Integer.valueOf(500);
    		Integer in5 = Integer.valueOf(500);
    		System.out.println(in4 == in5);//false
    		
    		//2、调用常用方法
    		int value = in.intValue();
    		
    		int sum = in.parseInt("100");//把字符串类型的数字转换成基本类型
    		System.out.println(sum + 1);//101
    		
    		
    		//TODO double -- Double 
    		//自动装箱：把基本类型double变成包装类型，Double --valueOf()
    // Double d1 = new Double(9.9);
    		Double d = Double.valueOf(9.9);
    		
    		//自动拆箱：把包装类型转换成基本类型 --doubleValue()
    		double d4 = d.doubleValue();
    		double d3 = d.parseDouble("8.8");//把字符串类型的数字，转换成基本类型
    		
    	}
    }

> ## **自动装箱和自动拆箱：** ##
> 
> 1、自动装箱：把基本类型包装成一包装类的对象  
> `Integer a = 5;`//a是引用类型，引用了包装对象的地址。  
> 编译器会完成对象的自动装箱：`Integer a = Integer.valueOf(5);`
> 
> 2、自动拆箱：从包装对象中，自动取出基本类型值  
> `int i = a;`//a现在是包装类型，没法给变量赋值，需要把5取出来。  
> 编译器会完成自动拆箱：`int i = a.intValue();`

## 五、日期类 ##

##### 1、概述 #####

*  存在于java.util.Date包；
 *  用来封装一个毫秒值表示一个精确的时间点；
 *  从1970-1-1 0点开始的毫秒值。

##### 2、创建对象 #####

*  `Date()`  
    分配 Date 对象并初始化此对象，以表示分配它的时间（精确到毫秒）；
 *  `new Date()`：封装的是系统当前时间的毫秒值
 *  `new Date(900000000000L)`：封装指定的时间点

##### 3、常用方法 #####

*  `int getDate()`  
    已过时。 从 JDK 1.1 开始，由 Calendar.get(Calendar.DAY\_OF\_MONTH) 取代；
 *  `int getDay()`  
    已过时。 从 JDK 1.1 开始，由 Calendar.get(Calendar.DAY\_OF\_WEEK) 取代；
 *  `int getHours()`  
    已过时。 从 JDK 1.1 开始，由 Calendar.get(Calendar.HOUR\_OF\_DAY) 取代；
 *  `int getMinutes()`  
    已过时。 从 JDK 1.1 开始，由 Calendar.get(Calendar.MINUTE) 取代；
 *  `int getMonth()`  
    已过时。 从 JDK 1.1 开始，由 Calendar.get(Calendar.MONTH) 取代；
 *  `int getSeconds()`  
    已过时。 从 JDK 1.1 开始，由 Calendar.get(Calendar.SECOND) 取代；
 *  `long getTime()`  
    返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数；

> 虽然这些方法都已经过时，但是不影响我们的正常使用，他只是被某些新的方法替代了而已。

##### 4、测试案例 #####

## 六、日期工具----SimpleDateFormat ##

##### 1、概述 #####

日期格式化工具，可以把Date对象格式化成字符串，也可以日期字符串解析成Date对象；

##### 2、创建对象 #####

*  `SimpleDateFormat(String pattern)`  
    用给定的模式和默认语言环境的日期格式符号构造

new SimpleDateFormat(格式)
    格式：yyyy-MM-dd HH:mm:ss
    MM/dd/yyyy..

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70 1]  
以下示例显示如何在美国地区中解释日期和时间模式。 给定的日期和时间是2001-07-04 12:08:56当地时间在美国太平洋时间时区。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70 2]

##### 3、常见方法 #####

*  `Date parse(String text)`  
    解析字符串的文本，生成 Date。
 *  `String format(Date date)`  
    将Date类型的日期，转成 字符串类型

##### 4、练习：计算自己的生存天数 #####

接收用户输入的出生日期，计算存活天数

package cn.tedu.api;
    
    import java.text.ParseException;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    import java.util.Scanner;
    
    //这个类用来测试日期格式化工具：计算存活天数
    public class Test_SimpleDateFormat { 
    	public static void main(String[] args) throws ParseException { 
    		//1、输入出生日期 -- String 
    		//nextLine():接收用户输入的一整行数据
    		String birthday = new Scanner(System.in).nextLine();
    		
    		//2、把String类型的日期转成Date类型
    		//参数中需要指定日期的格式 ：y-年，M-月，d-天
    		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    		Date birth = sdf.parse(birthday);
    		
    		//3、做个时间差
    		long bir = birth.getTime();//获取到出生日期对应的毫秒值
    		long now = System.currentTimeMillis();//获取现在的毫秒值
    		System.out.println((now - bir)/1000/60/60/24);
    	}
    }

## 七、BigDecimal/BigInteger ##

##### 1、概念 #####

*  BigDecimal用来解决java中浮点数运算不精确的现象
 *  BigInteger用来解决java中大整数的运算

#### 以BigDecimal为例 ####

##### 1、概念 #####

用来解决java中浮点数运算不精确的现象

##### 2、创建对象 #####

*  `BigDecimal(double val)`  
    将 double 转换为 BigDecimal，后者是 double 的二进制浮点值准确的十进制表示形式。
 *  `BigDecimal(String val)`  
    将 BigDecimal 的字符串表示形式转换为 BigDecimal。

##### 3、常用方法 #####

*  `add(BigDecimal bd)`： 做加法运算
 *  `subtract(BigDecimal bd)` ： 做减法运算
 *  `multiply(BigDecimal bd)` ： 做乘法运算
 *  **`divide(BigDecimal bd)` ： 做除法运算（比较特殊，注意与其他方法的区别）**
 *  **`divide(BigDecimal bd,保留位数,舍入方式)`：除不尽时使用**
 *  `setScale(保留位数，舍入方式)`：同上
 *  `pow(int n)`：求数据的几次幂

##### 4、测试案例 #####

接收用户输入的两个数字，做运算。

package cn.tedu.api;
    
    import java.math.BigDecimal;
    import java.util.Scanner;
    
    
    public class Test_BigDecimal { 
    	public static void main(String[] args) { 
    // method();//暴露不精确的现象
    		method2();//解决方案
    	}
    
    	public static void method2() { 
    		double a = new Scanner(System.in).nextDouble();
    		double b = new Scanner(System.in).nextDouble();
    		
    		//1、把a和b变成BigDecimal类型
    		//！！！构造方法不建议使用double参数的（还是不精确），我们建议使用String参数的构造方法
    		BigDecimal bd = new BigDecimal(a+"");//加上一个空字符串使其转换成字符串类型
    		BigDecimal bd2 = new BigDecimal(b+"");
    		
    		BigDecimal bd3,bd4,bd5,bd6;
    		bd3 = bd.add(bd2);//加法运算
    		bd4 = bd.subtract(bd2);//减法运算
    		bd5 = bd.multiply(bd2);//乘法运算
    		
    // bd6 = bd.divide(bd2);//除法运算，
    		//除法报错，如果除法运算不精确就会报异常，BigDecimal.divide(BigDecimal) line: not available 
    		//divide(m,n,o);m是要做除法运算的对象名，n是要保留几位小数，o是舍入方式（四舍五入）
    		BigDecimal bd7 = bd.divide(bd2,3,BigDecimal.ROUND_HALF_UP);
    		
    		System.out.println(bd3);
    		System.out.println(bd4);
    		System.out.println(bd5);
    // System.out.println(bd6);
    		System.out.println(bd7);
    	}
    
    	public static void method() { 
    		//1、接收用户输入的两个整数
    		double a = new Scanner(System.in).nextDouble();
    		double b = new Scanner(System.in).nextDouble();
    		
    		//2、做+-*/运算
    		System.out.println(a+b);//不精确
    		System.out.println(a-b);//不精确
    		System.out.println(a*b);//不精确
    		System.out.println(a/b);//不精确
    	}
    }

**【温馨提示】**  
API里面的内容很多，方法也很多，需要自己抽出时间去测试每个方法的使用，并且记忆；单靠这几个常用的是不能保证自己的工作效率的，当然你也可以选择使用的时候去api里面查，现学现卖！！

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70 3]

**【下篇预告】**

*  IO流
 *  IO工具类们~~~

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70_pic_center]: /images/20230528/b608af274f894ad699f282d51c690ecd.png
[20200416222058408.png]: /images/20230528/6de7840d574d44e190b67ccec353b7d7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70]: /images/20230528/cb05531f0fbc4c7f809998baf02e192e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70 1]: /images/20230528/95d95bd169aa47ecaf335efc46c80896.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70 2]: /images/20230528/085a2fe98e5c4adbb22f0ffc98894920.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxMTgwODgxNDAyNQ_size_16_color_FFFFFF_t_70 3]: /images/20230528/56b0e9e838134492b968b7eae50da9f6.png