Java基础：常见对象

最新推荐文章于 2023-06-15 17:30:06 发布

Jack-Chan

最新推荐文章于 2023-06-15 17:30:06 发布

阅读量1.4k

点赞数 1

分类专栏： Java基础 Java基础入门文章标签： Java Java基础 Java语法 Java常见对象

本文链接：https://blog.csdn.net/axi295309066/article/details/47448431

版权

Java基础同时被 2 个专栏收录

39 篇文章 6 订阅

订阅专栏

Java基础入门

38 篇文章 27 订阅

订阅专栏

第一讲 API

一、API概述

1、API(Application Programming Interface) ：应用程序编程接口

2、编写一个机器人程序去控制机器人踢足球，程序就需要向机器人发出向前跑、向后跑、射门、抢球等各种命令，没有编过程序的人很难想象这样的程序如何编写。但是对于有经验的开发人员来说，知道机器人厂商一定会提供一些用于控制机器人的Java类，这些类中定义好了操作机器人各种动作的方法。其实，这些Java类就是机器人厂商提供给应用程序编程的接口，大家把这些类称为Xxx Robot API。本章涉及的Java API指的就是JDK中提供的各种功能的Java类。

3、Java API就是Java提供给我们使用的类，这些类将底层的实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用。我们可以通过查帮助文档来了解Java提供的API如何使用。

二、学习汉语和学习编程的异同点

学习编程和学习汉语的异同点：

A：学好汉语，首先必须掌握汉语的语法，学好编程，也必须先学习编程语言的基本语法，我们前面讲解的就可以认为的Java的编程语法。

B：学好汉语，还要掌握大量的成语，虽然不是要把所有的成语都掌握，但至少掌握的越过，描述事物时用词就会越恰当，越准确，越快捷，文章也会写的越流畅。同理，学习编程语言掌握了大量的API，就像掌握的了大量的成语一样，可以让我们在处理某些问题时会轻而易举，同时，我们还能够从这些API中学到大师们组织Java类的方法，划分类的技巧。

C：学好汉语，除了要掌握语法和成语外，还应该学会写文章的技巧和手法，比如说议论文该怎么写(风头论点明确，猪肚论据充分，豹尾论尾有力)，才能写出好的文章。同理，学习编程，也需要掌握分析和解决问题的手法，养成良好的编程风格和习惯，体会出编程的感觉。学习汉语，我们可以从大量的唐诗宋词和现代散文中去体会写文章的技巧，同时听取老师的讲解和分析。同样，学习编程，也要听取有经验的程序的分析和讲解，并从别人的优秀的程序中去找感觉和经验。

当然了，他们还是有一些区别的。最大的区别及时，学习汉语是，好多东西必须先记住了，用的时候，才能有。有句成员不是说：书到用时方恨少吗。但是，学习编程了，就不用这样了，可以用的时候，临时获取，现学现用，当然这是指我们有了一定的编程感觉和经验后了。

如何算学会呢?很多人都认为我把老师的代码多敲几遍就算学会了，我就应该会做很多的东西了，但是，事实是什么呢，是我们老师讲解能听懂，也能看懂很多代码，就是不会写，这是正常的现象，因为我们的内功还不够，还得继续修炼。我们学习汉语，能看懂一般的文章，能写篇小文章，就算学会了，同理，学习编程也是这样的，能看懂老师，在会写老师写过的代码了，然后多思考，多总结，随着时间的积累，才能真正的走向高手的水平。到那个时刻估计就是：只要给我API，你要做什么，我就能做什么。以前是学好数理化，走遍天下都不怕，现在是掌握API，编程世界我不怕。

第二讲常用类

一、Object类

1、Object类概述

类层次结构的根类，所有类都直接或者间接的继承自该类。

2、构造方法

public Object()
回想面向对象中为什么说：子类的构造方法默认访问的是父类的无参构造方法

3、Object类的成员方法

（1）public int hashCode()
A：返回该对象的哈希码值。默认情况下，该方法会根据对象的地址来计算。
B：不同对象的，hashCode()一般来说不会相同。但是，同一个对象的hashCode()值肯定相同。
C：不是对象的实际地址值，可以理解为逻辑地址值。举例：物体和编号。
（2）public final Class getClass()
A：返回此 Object 的运行时类。
B：可以通过Class类中的一个方法，获取对象的真实类的全名称：public String getName()

package cn.itcast_01;

/*
 * Object:类 Object 是类层次结构的根类。每个类都使用 Object 作为超类。
 * 每个类都直接或者间接的继承自Object类。
 * 
 * Object类的方法：
 * 		public int hashCode():返回该对象的哈希码值。
 * 			注意：哈希值是根据哈希算法计算出来的一个值，这个值和地址值有关，但是不是实际地址值。
 * 			           你可以理解为地址值。
 * 
 *		public final Class getClass():返回此 Object 的运行时类
 *			Class类的方法：
 *				public String getName()：以 String 的形式返回此 Class 对象所表示的实体
 */
public class StudentTest {
	public static void main(String[] args) {
		Student s1 = new Student();
		System.out.println(s1.hashCode()); // 11299397
		Student s2 = new Student();
		System.out.println(s2.hashCode());// 24446859
		Student s3 = s1;
		System.out.println(s3.hashCode()); // 11299397
		System.out.println("-----------");

		Student s = new Student();
		Class c = s.getClass();
		String str = c.getName();
		System.out.println(str); // cn.itcast_01.Student
		
		//链式编程
		String str2  = s.getClass().getName();
		System.out.println(str2);
	}
}

运行结果：

（3）public String toString()
A：返回该对象的字符串表示。
底层源码。
public static String valueOf(Object obj) {
return (obj == null) ? "null" : obj.toString();
}
B：它的值等于：
getClass().getName() + '@' + Integer.toHexString(hashCode())
C：由于默认情况下的数据对我们来说没有意义，一般建议重写该方法。
a：手动重写
b：自动生成

package cn.itcast_02;

/*
 * public String toString():返回该对象的字符串表示。
 * 
 * Integer类下的一个静态方法：
 * 		public static String toHexString(int i)：把一个整数转成一个十六进制表示的字符串
 * 
 * 这个信息的组成我们讲解完毕了，但是这个信息是没有任何意义的。所以，建议所有子类都重写该方法。
 * 怎么重写呢?
 * 		把该类的所有成员变量值组成返回即可。
 * 重写的最终版方案就是自动生成toString()方法。
 * 
 * 注意：
 * 	 直接输出一个对象的名称，其实就是调用该对象的toString()方法。
 */
public class StudentDemo {
	public static void main(String[] args) {
		Student s = new Student();
		System.out.println(s.hashCode());
		System.out.println(s.getClass().getName());
		System.out.println("--------------------");
		System.out.println(s.toString());// cn.itcast_02.Student@42552c
		System.out.println("--------------------");
		// toString()方法的值等价于它
		// getClass().getName() + '@' + Integer.toHexString(hashCode())
		// this.getClass().getName()+'@'+Integer.toHexString(this.hashCode())

		// cn.itcast_02.Student@42552c
		// cn.itcast_02.Student@42552c

		System.out.println(s.getClass().getName() + '@'
				+ Integer.toHexString(s.hashCode()));

		System.out.println(s.toString());

		// 直接输出对象的名称
		System.out.println(s);
	}
}

运行结果：

（4）public boolean equals(Object obj)
A：指示其他某个对象是否与此对象“相等”。
B：默认情况下比较的是对象的引用是否相同。
C：由于比较对象的引用没有意义，一般建议重写该方法。
a：手动重写
b：自动生成
D：==和equals()的区别。

==：基本类型：比较的就是值是否相同；引用类型：比较的就是地址值是否相同
equals：引用类型：默认情况下，比较的是地址值。不过，我们可以根据情况自己重写该方法。一般重写都是自动生成，比较对象的成员变量值是否相同

package cn.itcast_03;

/*
 * public boolean equals(Object obj):指示其他某个对象是否与此对象“相等”。 
 * 这个方法，默认情况下比较的是地址值。比较地址值一般来说意义不大，所以我们要重写该方法。
 * 怎么重写呢?
 * 		一般都是用来比较对象的成员变量值是否相同。
 * 重写的代码优化：提高效率，提高程序的健壮性。
 * 最终版：
 * 		其实还是自动生成。
 * 
 * 看源码：
 * 		public boolean equals(Object obj) {
 * 			//this - s1
 * 			//obj - s2
 *       	return (this == obj);
 *   	}
 */
public class StudentDemo {
	public static void main(String[] args) {
		Student s1 = new Student("林青霞", 27);
		Student s2 = new Student("林青霞", 27);
		System.out.println(s1 == s2); // false
		Student s3 = s1;
		System.out.println(s1 == s3);// true
		System.out.println("---------------");

		System.out.println(s1.equals(s2)); // obj = s2; //false
		System.out.println(s1.equals(s1)); // true
		System.out.println(s1.equals(s3)); // true
		Student s4 = new Student("风清扬",30);
		System.out.println(s1.equals(s4)); //false
		
		Demo d = new Demo();
		System.out.println(s1.equals(d)); //ClassCastException

	}
}

class Demo {}

（5）protected void finalize()

A：当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。

B：垃圾回收器不会马上回收垃圾，但是我们可以建议它尽快回收垃圾。(System.gc()方法)

C：主要针对堆内存。

（6）protected Object clone()

创建并返回此对象的一个副本，这种克隆机制十分高效，而且二者之间完全隔离。

自定义类实现克隆步骤：

A：自定义类实现Cloneable接口，这是一个标记性接口，实现这个接口的类的对象可以实现自我克隆。

B：自定义类中重写Object类的clone()方法。

C：重写clone()方法时通过super.clone()调用Object类的clone()方法来得到该对象的副本，并返回该副本。

注意：

A：克隆和两个引用指向同一个对象的区别?

B：Object类clone()方法虽然简单，易用，但仅仅是一种”浅克隆”,它只克隆该对象所有的Field值，不会对引用类型的Field所引用的对象进行克隆。开发中，我们也可以实现对象的”深度克隆”。

package cn.itcast_04;

/*
 *	protected void finalize()：当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。用于垃圾回收，但是什么时候回收不确定。
 *	protected Object clone():创建并返回此对象的一个副本。
 *		A:重写该方法
 *
 *  Cloneable:此类实现了 Cloneable 接口，以指示 Object.clone() 方法可以合法地对该类实例进行按字段复制。 
 *  	这个接口是标记接口，告诉我们实现该接口的类就可以实现对象的复制了。
 */
public class StudentDemo {
	public static void main(String[] args) throws CloneNotSupportedException {
		//创建学生对象
		Student s = new Student();
		s.setName("林青霞");
		s.setAge(27);
		
		//克隆学生对象
		Object obj = s.clone();
		Student s2 = (Student)obj;
		System.out.println("---------");
		
		System.out.println(s.getName()+"---"+s.getAge());
		System.out.println(s2.getName()+"---"+s2.getAge());
		
		//以前的做法
		Student s3 = s;
		System.out.println(s3.getName()+"---"+s3.getAge());
		System.out.println("---------");
		
		//其实是有区别的
		s3.setName("刘意");
		s3.setAge(30);
		System.out.println(s.getName()+"---"+s.getAge());
		System.out.println(s2.getName()+"---"+s2.getAge());
		System.out.println(s3.getName()+"---"+s3.getAge());
		
	}
}

运行结果：

二、Scanner类

1、Scanner类概述

JDK5以后用于获取用户的键盘输入

2、构造方法

public Scanner(InputStream source)：构造一个新的 Scanner，它生成的值是从指定的输入流扫描的。

package cn.itcast_01;

/*
 * Scanner:用于接收键盘录入数据。
 * 
 * 前面的时候：
 * 		A:导包
 * 		B:创建对象
 * 		C:调用方法
 * 
 * System类下有一个静态的字段：
 * 		public static final InputStream in; 标准的输入流，对应着键盘录入。
 * 
 * 		InputStream is = System.in;
 * 
 * class Demo {
 * 		public static final int x = 10;
 * 		public static final Student s = new Student();
 * }
 * int y = Demo.x;
 * Student s = Demo.s;
 * 
 * 
 * 构造方法：
 * 		Scanner(InputStream source)
 */
import java.util.Scanner;

public class ScannerDemo {
	public static void main(String[] args) {
		// 创建对象
		Scanner sc = new Scanner(System.in);

		int x = sc.nextInt();
		
		System.out.println("x:" + x);
	}
}

运行结果：

3、Scanner类的成员方法

（1）基本格式
hasNextXxx() 判断是否还有下一个输入项,其中Xxx可以是Int,Double等。如果需要判断是否包含下一个字符串，则可以省略Xxx
nextXxx() 获取下一个输入项。Xxx的含义和上个方法中的Xxx相同
默认情况下，Scanner使用空格，回车等作为分隔符

package cn.itcast_02;

import java.util.Scanner;

/*
 * 基本格式：
 * 		public boolean hasNextXxx():判断是否是某种类型的元素
 * 		public Xxx nextXxx():获取该元素
 * 
 * 举例：用int类型的方法举例
 * 		public boolean hasNextInt()
 * 		public int nextInt()
 * 
 * 注意：
 * 		InputMismatchException：输入的和你想要的不匹配
 */
public class ScannerDemo {
	public static void main(String[] args) {
		// 创建对象
		Scanner sc = new Scanner(System.in);

		// 获取数据
		if (sc.hasNextInt()) {
			int x = sc.nextInt();
			System.out.println("x:" + x);
		} else {
			System.out.println("你输入的数据有误");
		}
	}
}

运行结果：

（2）常用方法
public int nextInt()：获取一个int类型的值
public String nextLine()：获取一个String类型的值

package cn.itcast_03;

import java.util.Scanner;

/*
 * 常用的两个方法：
 * 		public int nextInt():获取一个int类型的值
 * 		public String nextLine():获取一个String类型的值
 * 
 * 出现问题了：
 * 		先获取一个数值，在获取一个字符串，会出现问题。
 * 		主要原因：就是那个换行符号的问题。
 * 如何解决呢?
 * 		A:先获取一个数值后，在创建一个新的键盘录入对象获取字符串。
 * 		B:把所有的数据都先按照字符串获取，然后要什么，你就对应的转换为什么。
 */
public class ScannerDemo {
	public static void main(String[] args) {
		// 创建对象
		Scanner sc = new Scanner(System.in);

		// 获取两个int类型的值
		// int a = sc.nextInt();
		// int b = sc.nextInt();
		// System.out.println("a:" + a + ",b:" + b);
		// System.out.println("-------------------");

		// 获取两个String类型的值
		// String s1 = sc.nextLine();
		// String s2 = sc.nextLine();
		// System.out.println("s1:" + s1 + ",s2:" + s2);
		// System.out.println("-------------------");

		// 先获取一个字符串，在获取一个int值
		// String s1 = sc.nextLine();
		// int b = sc.nextInt();
		// System.out.println("s1:" + s1 + ",b:" + b);
		// System.out.println("-------------------");

		// 先获取一个int值，在获取一个字符串
		// int a = sc.nextInt();
		// String s2 = sc.nextLine();
		// System.out.println("a:" + a + ",s2:" + s2);
		// System.out.println("-------------------");<pre name="code" class="java">        }

运行结果：

三、Arrays类

1、Arrays类概述

针对数组进行操作的工具类。提供了排序，查找等功能。

2、成员方法

（1）public static String toString(int[] a)：把数组转成字符串

（2）public static void sort(int[] a)：对数组进行排序

（3）public static int binarySearch(int[] a,int key)：二分查找

package cn.itcast_05;

import java.util.Arrays;

/*
 * Arrays:针对数组进行操作的工具类。比如说排序和查找。
 * 1:public static String toString(int[] a) 把数组转成字符串
 * 2:public static void sort(int[] a) 对数组进行排序
 * 3:public static int binarySearch(int[] a,int key) 二分查找
 */
public class ArraysDemo {
	public static void main(String[] args) {
		// 定义一个数组
		int[] arr = { 24, 69, 80, 57, 13 };

		// public static String toString(int[] a) 把数组转成字符串
		System.out.println("排序前：" + Arrays.toString(arr));

		// public static void sort(int[] a) 对数组进行排序
		Arrays.sort(arr);
		System.out.println("排序后：" + Arrays.toString(arr));

		// [13, 24, 57, 69, 80]
		// public static int binarySearch(int[] a,int key) 二分查找
		System.out.println("binarySearch:" + Arrays.binarySearch(arr, 57));
		System.out.println("binarySearch:" + Arrays.binarySearch(arr, 577));
	}
}

运行结果：

四、Math类

1、Math类概述

Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。

2、成员方法

public static int abs(int a)：绝对值
public static double ceil(double a)：向上取整
public static double floor(double a)：向下取整
public static int max(int a,int b) ：最大值
public static double pow(double a,double b)：a的b次幂
public static double random()：随机数 [0.0,1.0)
public static int round(float a) ：四舍五入
public static double sqrt(double a)：正平方根

package cn.itcast_01;

/*
 * Math:用于数学运算的类。
 * 成员变量：
 * 		public static final double PI
 * 		public static final double E
 * 成员方法：
 * 		public static int abs(int a)：绝对值
 *		public static double ceil(double a):向上取整
 *		public static double floor(double a):向下取整
 *		public static int max(int a,int b):最大值 
 *		public static double pow(double a,double b):a的b次幂
 *		public static double random():随机数 [0.0,1.0)
 *		public static int round(float a) 四舍五入
 *		public static double sqrt(double a):正平方根
 */
public class MathDemo {
	public static void main(String[] args) {
		// public static final double PI
		System.out.println("PI:" + Math.PI);
		// public static final double E
		System.out.println("E:" + Math.E);
		System.out.println("--------------");

		// public static int abs(int a)：绝对值
		System.out.println("abs:" + Math.abs(10));
		System.out.println("abs:" + Math.abs(-10));
		System.out.println("--------------");

		// public static double ceil(double a):向上取整
		System.out.println("ceil:" + Math.ceil(12.34));
		System.out.println("ceil:" + Math.ceil(12.56));
		System.out.println("--------------");

		// public static double floor(double a):向下取整
		System.out.println("floor:" + Math.floor(12.34));
		System.out.println("floor:" + Math.floor(12.56));
		System.out.println("--------------");

		// public static int max(int a,int b):最大值
		System.out.println("max:" + Math.max(12, 23));
		// 需求：我要获取三个数据中的最大值
		// 方法的嵌套调用
		System.out.println("max:" + Math.max(Math.max(12, 23), 18));
		// 需求：我要获取四个数据中的最大值
		System.out.println("max:"
				+ Math.max(Math.max(12, 78), Math.max(34, 56)));
		System.out.println("--------------");

		// public static double pow(double a,double b):a的b次幂
		System.out.println("pow:" + Math.pow(2, 3));
		System.out.println("--------------");

		// public static double random():随机数 [0.0,1.0)
		System.out.println("random:" + Math.random());
		// 获取一个1-100之间的随机数
		System.out.println("random:" + ((int) (Math.random() * 100) + 1));
		System.out.println("--------------");

		// public static int round(float a) 四舍五入(参数为double的自学)
		System.out.println("round:" + Math.round(12.34f));
		System.out.println("round:" + Math.round(12.56f));
		System.out.println("--------------");
		
		//public static double sqrt(double a):正平方根
		System.out.println("sqrt:"+Math.sqrt(4));
	}
}

运行结果：

五、Random类

1、Random类概述

此类用于产生随机数，如果用相同的种子创建两个 Random 实例，则对每个实例进行相同的方法调用序列，它们将生成并返回相同的数字序列。

2、构造方法

public Random()：没有给种子，用的是默认种子，是当前时间的毫秒值
public Random(long seed)：给出指定的种子

3、成员方法

public int nextInt()：返回的是int范围内的随机数
public int nextInt(int n)：返回的是[0,n)范围的内随机数

package cn.itcast_01;

import java.util.Random;

/*
 * Random:产生随机数的类
 * 
 * 构造方法：
 * 		public Random():没有给种子，用的是默认种子，是当前时间的毫秒值
 *		public Random(long seed):给出指定的种子
 *
 *		给定种子后，每次得到的随机数是相同的。
 *
 * 成员方法：
 * 		public int nextInt()：返回的是int范围内的随机数
 *		public int nextInt(int n):返回的是[0,n)范围的内随机数
 */
public class RandomDemo {
	public static void main(String[] args) {
		// 创建对象
		// Random r = new Random();
		Random r = new Random(1111);

		for (int x = 0; x < 10; x++) {
			// int num = r.nextInt();
			int num = r.nextInt(100) + 1;
			System.out.println(num);
		}
	}
}

运行结果：

六、System类

1、System类概述

System 类包含一些有用的类字段和方法。它不能被实例化。

2、成员方法

public static void gc()：运行垃圾回收器。

public static void exit(int status)：终止当前正在运行的 Java 虚拟机。参数用作状态码；根据惯例，非 0 的状态码表示异常终止。

public static long currentTimeMillis()：返回以毫秒为单位的当前时间

public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length)：从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。

System.gc()可用于垃圾回收。当使用System.gc()回收某个对象所占用的内存之前，通过要求程序调用适当的方法来清理资源。在没有明确指定资源清理的情况下，Java提高了默认机制来清理该对象的资源，就是调用Object类的finalize()方法。finalize()方法的作用是释放一个对象占用的内存空间时，会被JVM调用。而子类重写该方法，就可以清理对象占用的资源，该方法有没有链式调用，所以必须手动实现。

从程序的运行结果可以发现，执行System.gc()前，系统会自动调用finalize()方法清除对象占有的资源，通过super.finalize()方式可以实现从下到上的finalize()方法的调用，即先释放自己的资源，再去释放父类的资源。

但是，不要在程序中频繁的调用垃圾回收，因为每一次执行垃圾回收，jvm都会强制启动垃圾回收器运行，这会耗费更多的系统资源，会与正常的Java程序运行争抢资源，只有在执行大量的对象的释放，才调用垃圾回收最好

package com.itheima;

import java.util.Arrays;

class Person1 {
	private String name;
	private int age;

	public Person1() {
		super();
	}

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

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}

	@Override
	protected void finalize() throws Throwable {
		System.out.println("当前的对象被回收了" + this);
		super.finalize();
	}

}

/*
 * System类包含一些有用的类字段和方法。它不能被实例化。
 * 
 * 方法： public static void gc()：运行垃圾回收器。 public static void exit(int
 * status):终止当前正在运行的 Java 虚拟机。参数用作状态码；根据惯例，非 0 的状态码表示异常终止。 public static long
 * currentTimeMillis():返回以毫秒为单位的当前时间 public static void arraycopy(Object src,int
 * srcPos,Object dest,int destPos,int length)
 * 从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。
 */
public class SystemDemo {
	public static void main(String[] args) {
		Person1 p = new Person1("赵雅芝", 60);
		System.out.println(p);

		p = null; // 让p不再指定堆内存
		System.gc();

		// System.out.println("我们喜欢林青霞(东方不败)");
		// System.exit(0);
		// System.out.println("我们也喜欢赵雅芝(白娘子)");

		// System.out.println(System.currentTimeMillis());

		// 单独得到这样的实际目前对我们来说意义不大
		// 那么，它到底有什么作用呢?
		// 要求：请大家给我统计这段程序的运行时间
		long start = System.currentTimeMillis();
		for (int x = 0; x < 100000; x++) {
			System.out.println("hello" + x);
		}
		long end = System.currentTimeMillis();
		System.out.println("共耗时：" + (end - start) + "毫秒");

		// 定义数组
		int[] arr = { 11, 22, 33, 44, 55 };
		int[] arr2 = { 6, 7, 8, 9, 10 };

		// 请大家看这个代码的意思
		System.arraycopy(arr, 1, arr2, 2, 2);

		System.out.println(Arrays.toString(arr));
		System.out.println(Arrays.toString(arr2));
	}
}

运行结果：

七、BigInteger类

1、BigInteger类概述

可以让超过Integer范围内的数据进行运算

2、构造方法

public BigInteger(String val)：将 BigInteger 的十进制字符串表示形式转换为 BigInteger

3、成员方法

public BigInteger add(BigInteger val)：加
public BigInteger subtract(BigInteger val)：减
public BigInteger multiply(BigInteger val)：乘
public BigInteger divide(BigInteger val)：除
public BigInteger[] divideAndRemainder(BigInteger val)：返回商和余数的数组

package cn.itcast_02;

import java.math.BigInteger;

/*
 * public BigInteger add(BigInteger val):加
 * public BigInteger subtract(BigInteger val):减
 * public BigInteger multiply(BigInteger val):乘
 * public BigInteger divide(BigInteger val):除
 * public BigInteger[] divideAndRemainder(BigInteger val):返回商和余数的数组
 */
public class BigIntegerDemo {
	public static void main(String[] args) {
		BigInteger bi1 = new BigInteger("100");
		BigInteger bi2 = new BigInteger("50");

		// public BigInteger add(BigInteger val):加
		System.out.println("add:" + bi1.add(bi2));
		// public BigInteger subtract(BigInteger val):加
		System.out.println("subtract:" + bi1.subtract(bi2));
		// public BigInteger multiply(BigInteger val):加
		System.out.println("multiply:" + bi1.multiply(bi2));
		// public BigInteger divide(BigInteger val):加
		System.out.println("divide:" + bi1.divide(bi2));

		// public BigInteger[] divideAndRemainder(BigInteger val):返回商和余数的数组
		BigInteger[] bis = bi1.divideAndRemainder(bi2);
		System.out.println("商：" + bis[0]);
		System.out.println("余数：" + bis[1]);
	}
}

运行结果：

八、BigDecimal类

1、BigDecimal类概述

由于在运算的时候，float类型和double很容易丢失精度，演示案例。所以，为了能精确的表示、计算浮点数，Java提供了BigDecimal，不可变的、任意精度的有符号十进制数。

2、构造方法

public BigDecimal(String val)：将 BigDecimal 的字符串表示形式转换为 BigDecimal

3、成员方法

public BigDecimal add(BigDecimal augend)：加

public BigDecimal subtract(BigDecimal subtrahend)：减
public BigDecimal multiply(BigDecimal multiplicand)：乘
public BigDecimal divide(BigDecimal divisor)：除
public BigDecimal divide(BigDecimal divisor,int scale,int roundingMode)：商，几位小数，如何舍取

package cn.itcast_02;

import java.math.BigDecimal;

/*
 * 构造方法：
 * 		public BigDecimal(String val)
 * 
 * public BigDecimal add(BigDecimal augend)
 * public BigDecimal subtract(BigDecimal subtrahend)
 * public BigDecimal multiply(BigDecimal multiplicand)
 * public BigDecimal divide(BigDecimal divisor)
 * public BigDecimal divide(BigDecimal divisor,int scale,int roundingMode):商，几位小数，如何舍取
 */
public class BigDecimalDemo {
	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 bd1 = new BigDecimal("0.09");
		BigDecimal bd2 = new BigDecimal("0.01");
		System.out.println("add:" + bd1.add(bd2));
		System.out.println("-------------------");

		BigDecimal bd3 = new BigDecimal("1.0");
		BigDecimal bd4 = new BigDecimal("0.32");
		System.out.println("subtract:" + bd3.subtract(bd4));
		System.out.println("-------------------");

		BigDecimal bd5 = new BigDecimal("1.015");
		BigDecimal bd6 = new BigDecimal("100");
		System.out.println("multiply:" + bd5.multiply(bd6));
		System.out.println("-------------------");

		BigDecimal bd7 = new BigDecimal("1.301");
		BigDecimal bd8 = new BigDecimal("100");
		System.out.println("divide:" + bd7.divide(bd8));
		System.out.println("divide:"
				+ bd7.divide(bd8, 3, BigDecimal.ROUND_HALF_UP));
		System.out.println("divide:"
				+ bd7.divide(bd8, 8, BigDecimal.ROUND_HALF_UP));
	}
}

运行结果：

九、Calendar类

1、Calendar类概述

Calendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法。

2、成员方法

public static Calendar getInstance()：获取实例
public int get(int field)：返回给定日历字段的值。日历类中的每个日历字段都是静态的成员变量，并且是int类型。
public void add(int field,int amount)：根据给定的日历字段和对应的时间，来对当前的日历进行操作。
public final void set(int year,int month,int date)：设置当前日历的年月日

package cn.itcast_02;

import java.util.Calendar;

/*
 * public void add(int field,int amount):根据给定的日历字段和对应的时间，来对当前的日历进行操作。
 * public final void set(int year,int month,int date):设置当前日历的年月日
 */
public class CalendarDemo {
	public static void main(String[] args) {
		// 获取当前的日历时间
		Calendar c = Calendar.getInstance();

		// 获取年
		int year = c.get(Calendar.YEAR);
		// 获取月
		int month = c.get(Calendar.MONTH);
		// 获取日
		int date = c.get(Calendar.DATE);
		System.out.println(year + "年" + (month + 1) + "月" + date + "日");

		// // 三年前的今天
		// c.add(Calendar.YEAR, -3);
		// // 获取年
		// year = c.get(Calendar.YEAR);
		// // 获取月
		// month = c.get(Calendar.MONTH);
		// // 获取日
		// date = c.get(Calendar.DATE);
		// System.out.println(year + "年" + (month + 1) + "月" + date + "日");

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

		c.set(2011, 11, 11);
		// 获取年
		year = c.get(Calendar.YEAR);
		// 获取月
		month = c.get(Calendar.MONTH);
		// 获取日
		date = c.get(Calendar.DATE);
		System.out.println(year + "年" + (month + 1) + "月" + date + "日");
	}
}

运行结果：

3、Calendar练习

1、获取任意一年的二月有多少天

package cn.itcast_03;

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

/*
 * 获取任意一年的二月有多少天
 * 
 * 分析：
 * 		A:键盘录入任意的年份
 * 		B:设置日历对象的年月日
 * 			年就是A输入的数据
 * 			月是2
 * 			日是1
 * 		C:把时间往前推一天，就是2月的最后一天
 * 		D:获取这一天输出即可
 */
public class CalendarTest {
	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);

		// 获取这一天输出即可
		System.out.println(c.get(Calendar.DATE));
	}
}

运行结果：

Jack-Chan

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Java基础：常见对象

API(Application Programming Interface) ：应用程序编程接口编写一个机器人程序去控制机器人踢足球，程序就需要向机器人发出向前跑、向后跑、射门、抢球等各种命令，没有编过程序的人很难想象这样的程序如何编写。但是对于有经验的开发人员来说，知道机器人厂商一定会提供一些用于控制机器人的Java类，这些类中定义好了操作机器人各种动作的方法。其实，这些Java类就是机器人厂商提供给应用程序编程的接口，大家把这些类称为Xxx Robot API。本章涉及的Java API指的就是JDK
复制链接

扫一扫