Java基础

Alveus

已于 2022-05-27 17:39:17 修改

阅读量216

点赞数 1

分类专栏： Java学习文章标签： java eclipse 开发语言

于 2020-07-16 16:25:17 首次发布

本文链接：https://blog.csdn.net/Alveus/article/details/106048475

版权

Java学习专栏收录该内容

5 篇文章 0 订阅

订阅专栏

文章目录

基础知识
流程控制
字符串
数组
类和对象
包装类
数字处理类

基础知识

HelloWorld

public static void main(String[] args) {
		System.out.println("Hail Hydra!");
	}

基本数据类型及Eclipse技巧

八进制：数字0开头
十六进制：0X或0x开头
byte int long float double char boolean 转义字符

public static void main(String[] args) {
		// main,syso Alt+/
		System.out.println("Hail Hydra!");
		System.out.println("PSQ");
	}

	public static void main(String[] args) {
		//1. byte short int long
		//byte b -128~127 1字节-8位
		//short -32768~32767 2字节-16位
		//int -2147483648~2147483647 4字节-32位
		//long -9223372036854775808~9223372036854775807 8字节~64位
		System.out.println(Integer.MAX_VALUE);
		System.out.println(Integer.MIN_VALUE);
		System.out.println(Long.MAX_VALUE);
		System.out.println(Long.MIN_VALUE);
		
		//2. double float
		//Java中默认所有小数double，所有整数int
		float a=3.0f; //同强制类型转换 8字节强转4字节 /float a=3.0F
		
		//3. boolean true/false
		boolean b=true;
		
		//4. char 2字节-16位
		//1个 数字/字母/特殊符号/汉字
		char c='a';
		
	}

Eclipse中鼠标选中类后F2重命名类，alt+/补全

窗口(Window)->显示视图(Show View)->任务(Task)，任务框中->显示(Show)->待办事项(TODOS)

变量和常量

命名规则

项目(Java Project): Study 首字母大写

包(package)：com.oracle(域名).test(作用) 全部小写

类(class): Test01/TestStart 驼峰式

标识符和关键字

Java语言规定标识符由任意顺序的字母、下画线_、美元符号$和数字组成，并且第一个字符不能是数字。在Java语言中标识符中的字母是严格区分大小写的。
Java语言使用unicode标准字符集，最多可以标识65535个字符，因此，Java语言中的字母不仅包括通常的拉丁文字a、b、c等，还包括汉字、日文以及其他许多语言中的文字。

声明常量

常量名通常使用大写字母
final 数据类型常量名称[=值]

当定义的final变量属于“成员变量”时，必须在定义时就设定它的初值，否则将会产生编译错误。

一般会根据变量的“有效范围”将变量分为“成员变量”和“局部变量”

成员变量

在类体中所定义的变量被称为成员变量，成员变量在整个类中都有效。类的成员变量又可分为两种，即静态变量和实例变量。

class var{int x = 45;static int y = 90}

静态变量的有效范围可以跨类，甚至可达到整个应用程序之内。对于静态变量，除了能在定义它的类内存取，还能直接以“类名.静态变量”的方式在其他类内使用。

局部变量

在类的方法体中定义的变量（方法内部定义，“{”与“}”之间的代码中声明的变量）称为局部变量。局部变量只在当前代码块中有效。在类的方法中声明的变量，包括方法的参数，都属于局部变量。
局部变量可与成员变量的名字相同，此时成员变量将被隐藏

运算符

在Java中可以把赋值运算符连在一起使用。如：
x = y = z = 5;
+ - * / % ++ -- & && | || >> << ^ ~ 三元运算符?:
Java还提供了无符号右移>>>，无论最高位是0还是1，左侧被移空的高位都填入0
移位运算符适用的数据类型有byte、short、char、int和long

注释与编码规范

// /**/
多行注释中可嵌套单行注释，但在多行注释中不可以嵌套多行注释

文档注释

/** */为文档注释标记。符号/**与*/之间的内容均为文档注释内容。当文档注释出现在声明（如类的声明、类的成员变量的声明、类的成员方法声明等）之前时，会被Javadoc文档工具读取作为Javadoc文档内容。文档注释的格式与多行注释的格式相同。

编码规范

每条语句要单独占一行，一条命令要以分号结束。
在声明变量时，尽量使每个变量的声明单独占一行，即使是相同的数据类型也要将其放置在单独的一行上，这样有助于添加注释。对于局部变量应在声明的同时对其进行初始化。
在Java代码中，关键字与关键字间如果有多个空格，这些空格均被视作一个。
为了方便日后的维护，不要使用技术性很高、难懂、易混淆判断的语句。由于程序的开发与维护不能是同一个人，所以应尽量使用简单的技术完成程序需要的功能。

流程控制

if switch while do-while for
foreach语句是for语句的特殊简化版本

for(元素变量x:遍历对象obj) {
			引用了x的语句
		}

字符串

String类

String s;
声明字符串变量必须经过初始化才能使用，否则编译器会报出“变量未被初始化错误”。
（1）String(char a[])
用一个字符数组a创建String对象。
在这里插入图片描述
（2）String(char a[], int offset, int length)
提取字符数组a中的一部分创建一个字符串对象。参数offset表示开始截取字符串的位置(包含第offset位)，length表示截取字符串的长度。

（3）String(char[] value)
该构造方法可分配一个新的String对象，使其表示字符数组参数中所有元素连接的结果。
在这里插入图片描述

public static void main(String[] args) {
		String str1,str2;
		str1 = "We are students";
		str2 = "We are students";
		System.out.println(str1==str2);
		/*True*/
	}

此时str1与str2引用相同的字符串常量，因此具有相同的实体。
在这里插入图片描述
使用“+”运算符可实现连接多个字符串的功能
Java中一句相连的字符串不能分开在两行中写
如果一个字符串太长，为了便于阅读，必须将这个字符串分在两行上书写。则需要使用“+”将两个字符串连起来，之后在加号处换行
字符串也可同其他基本数据类型进行连接。如果将字符串同这些数据类型数据进行连接，会将这些数据直接转换成字符串

public static void main(String[] args) {
		int booktime=4;
		float practice=2.5f;
		System.out.println("Spend "+booktime+" hours everyday to read\n"
				+practice+"hours to practice computer skills");
	}

获取字符串信息

长度

str.length();

查找

indexOf(String s)
该方法用于返回参数字符串s在指定字符串中首次出现的索引位置。从当前字符串的开始位置搜索s的位置；如果没有检索到字符串s，该方法的返回值是-1。

lastIndexOf(String str)
将最后一次出现str的索引位置返回。如果没有检索到字符串str，该方法返回-1。
如果lastIndexOf()方法中的参数是空字符串""（注意没有空格），则返回的结果与调用该字符串length()方法的返回结果相同。

charAt()
获取指定索引位置的字符

字符串操作

截取子串:
substring(int beginIndex) （含换行符）
substring(int beginIndex, int endIndex)（左闭右开）

public static void main(String[] args) {
		String str="HelloWorld\n";
		String sub1=str.substring(3);
		String sub2=str.substring(0,3);
		System.out.println(sub1+sub2);
	}

/*
Output:
loWorld
Hel
*/

trim():返回字符串的副本，忽略前导空格和尾部空格

字符串替换：
str.replace(char oldChar,char newChar)

判断字符串的开始与结尾：
startsWith()方法与endsWith()方法分别用于判断字符串是否以指定的内容开始或结束
返回值为boolean

判断字符串相同：
不能用==，==比较的是两个字符串的地址

String tom = new String("I am a student");
String jerry = new String("I am a student");
boolean b = (tom == jerry);

此时，布尔型变量b的值为false，因为字符串是对象，tom、jerry是引用。
在这里插入图片描述

 String b = "123";
 String c = "123";
 Boolean r = (c==b);// r 为true

直接使用=创建变量没有二次创建空间

判断相等应用 :(返回值均为boolean)
equals()
equalsIgnoreCase() 忽略大小写

字典序比较：
compareTo()
按字典顺序比较两个字符串，该比较基于字符串中各个字符的Unicode值，如果按字典顺序此String对象位于参数字符串之前，则比较结果为一个负整数；如果按字典顺序此String对象位于参数字符串之后，则比较结果为一个正整数；如果这两个字符串相等，则结果为0。

大小写转换:
toLowerCase()
toUpperCase()
数字或非字符不受影响。

字符串分割：
使用split()方法可以使字符串按指定的分割字符或字符串对内容进行分割，并将分割后的结果存放在字符串数组中。split()方法提供了以下两种字符串分割形式。
（1）str.split(String sign)
该方法可根据给定的分割符对字符串进行拆分。
其中，sign为分割字符串的分割符，也可以使用正则表达式。
没有统一的对字符进行分割的符号。如果想定义多个分割符，可使用符号“|”。例如，“,|=”表示分割符分别为“,”和“=”。
（2）split(String sign,int limit)
该方法可根据给定的分割符对字符串进行拆分，并限定拆分的次数。

public static void main(String[] args) {
		String str="192.168.0.1";
		String[] firstArray=str.split("\\.");
		String[] secondArray=str.split("\\.",2); //进行两次分割
		System.out.println("原值:["+str+"]");
		System.out.print("全部分割:");
		for(String a:firstArray){
			System.out.print("["+a+"]");
		}
		System.out.println(); //换行
		System.out.print("分割两次:");
		for(String a:secondArray){
			System.out.print("["+a+"]");
		}
		System.out.println();
	}

/* 
原值:[192.168.0.1]
全部分割:[192][168][0][1]
分割两次:[192][168.0.1]
*/

格式化字符串

format(String format,Object…args)
该方法使用指定的格式字符串和参数返回一个格式化字符串，格式化后的新字符串使用本地默认的语言环境。
format(Local l,String format,Object…args)
l：格式化过程中要应用的语言环境。如果l为null，则不进行本地化。

System.out.printf("浮点型变量的值为 " +
                  "%f, 整型变量的值为 " +
                  " %d, 字符串变量的值为 " +
				  "is %s", floatVar, intVar, stringVar);
String fs;
fs = String.format("浮点型变量的值为 " +
					"%f, 整型变量的值为 " +
					" %d, 字符串变量的值为 " +
					" %s", floatVar, intVar, stringVar);
	//两种方法等价

%x 整数类型（十六进制）
%o 整数类型（八进制）
%a 十六进制浮点类型
%e 指数类型
%% 百分比类型

日期和时间字符串格式化

在这里插入图片描述

package hive;
import java.util.Date;
public class test {

	public static void main(String[] args) {
		Date date=new Date();
		String hour=String.format("%tH",date);
		String minute=String.format("%tM",date);
		String second=String.format("%tS",date);
		System.out.println("现在是:"+hour+"时"+minute+"分"+second+"秒");
	}

}
/*
现在是:23时07分31秒
*/

package hive;
import java.util.Date;
public class test {

	public static void main(String[] args) {
		Date date=new Date();
		String time=String.format("%tc",date);
		String form=String.format("%tF",date);
		System.out.println("完整时间："+time);
		System.out.println("年-月-日："+form);
	}

}
/*
完整时间：周二 5月 12 23:28:20 CST 2020
年-月-日：2020-05-12
*/

/* Edited By Hive */
import java.util.Date;
import java.util.Locale;
public class test {

	public static void main(String[] args) {
		Date date=new Date();
		String time=String.format(Locale.ENGLISH,"%tc",date);
		System.out.println("Now the time is: "+time);
		String day=String.format("%tj",date);
		System.out.println("This year,"+day+" days has passed away.");
		String snum=String.format("%ts",date);
		System.out.println(snum+"s has passed away since 1970.");
		System.out.println("Hail Hydra!");
	}

}

常规类型格式化

在这里插入图片描述

使用正则表达式

在这里插入图片描述
在正则表达式中“.”代表任何一个字符，因此在正则表达式中如果想使用普通意义的点字符“.”，必须使用转义字符“\”。
在正则表达式中可以使用方括号括起若干个字符来表示一个元字符，该元字符可代表方括号中的任何一个字符。例如，reg = “[abc]4”，这样字符串a4、b4、c4都是和正则表达式匹配的字符串。方括号元字符还可以为其他格式。如：
　[ ^456]：代表4、5、6之外的任何字符。
　[a-r]：代表a~r中的任何一个字母。
　[a-zA-Z]：可表示任意一个英文字母。
　[a-e[g-z]]：代表a~ e或g~z中的任何一个字母（并运算）。
　[a-o&&[def]]：代表字母d、e、f（交运算）。
　
在正则表达式中允许使用限定修饰符来限定元字符出现的次数。
在这里插入图片描述

【例】在项目中创建类Judge，在主方法中实现使用正则表达式来判断指定的变量是否为合法的E-mail地址。

public class Judge {
	public static void main(String[] args) {
		 // 定义要匹配E_mail地址的正则表达式
		String regex = "\\w+@\\w+(\\.\\w{2,3})*\\.\\w{2,3}";
		String str1 = "aaa@"; // 定义要进行验证的字符串
		String str2 = "aaaaa";
		String str3 = "1111@111ffyu.dfg.com";
		if (str1.matches(regex)) { // 判断字符串变量是否与正则表达式匹配
			System.out.println(str1 + "是一个合法的E-mail地址格式");
		}
		if (str2.matches(regex)) {
			System.out.println(str2 + "是一个合法的E-mail地址格式");
		}
		if (str3.matches(regex)) {
			System.out.println(str3 + "是一个合法的E-mail地址格式");
		}
	}
}

正则表达式分析：
通常情况下E-mail的格式为“X @X.com.cn”。字符X表示任意的一个或多个字符，@为E-mail地址中的特有符号，符号@后还有一个或多个字符，之后是字符“.com”，也可能后面还有类似“.cn”的标记。总结E-mail地址的这些特点，因此可以书写正则表达式“\w+@\w+(\.\w{2,3})*\.\w{2,3}”来匹配E-mail地址。字符集“\w”匹配任意字符，符号“+”表示字符可以出现1次或多次，表达式(\\.\\w{2,3})*表示形如“.com”格式的字符串可以出现0次或多次。而最后的表达式“\.\w{2,3}”用于匹配E-mail地址中的结尾字符，如“.com”。

字符串生成器

创建成功的字符串对象，其长度是固定的，内容不能被改变和编译。虽然使用“+”可以达到附加新字符或字符串的目的，但“+”会产生一个新的String实例，会在内存中创建新的字符串对象。如果重复地对字符串进行修改，将极大地增加系统开销。
J2SE 5.0新增了可变的字符序列String- Builder类，大大提高了频繁增加字符串的效率。

【例】在项目中创建类Jerque，在主方法中编写如下代码，验证字符串操作和字符串生成器操作的效率。

public class Jerque { 
	public static void main(String[] args) { // 主方法
		String str = ""; // 创建空字符串
		// 定义对字符串执行操作的起始时间
		long starTime = System.currentTimeMillis();
		for (int i = 0; i < 10000; i++) { // 利用for循环执行10000次操作
			str = str + i; // 循环追加字符串
		}
		long endTime = System.currentTimeMillis(); // 定义对字符串操作后的时间
		long time = endTime - starTime; // 计算对字符串执行操作的时间
		System.out.println("Sting消耗时间：" + time); // 将执行的时间输出
		StringBuilder builder = new StringBuilder(""); // 创建字符串生成器
		starTime = System.currentTimeMillis(); // 定义操作执行前的时间
		for (int j = 0; j < 10000; j++) { // 利用for循环进行操作
			builder.append(j); // 循环追加字符
		}
		endTime = System.currentTimeMillis(); // 定义操作后的时间
		time = endTime - starTime; // 追加操作执行的时间
		System.out.println("StringBuilder消耗时间：" + time); // 将操作时间输出
	}
}
Sting消耗时间：135
StringBuilder消耗时间：1

若要使用StringBuilder最后输出字符串结果，可使用toString()方法。
该类的常用方法如下。
（1）append()方法
（2）insert(int offset, arg)方法
（3）delete(int start , int end)方法（一直到索引end -1处的字符，如果不存在这种字符，则一直到序列尾部。如果start等于end，则不发生任何更改。）

package hive;
public class test {

	public static void main(String[] args) {
		StringBuilder bf=new StringBuilder("hello");
		bf.insert(5,"world");
		System.out.println(bf.toString());
		bf.delete(0,4);
		System.out.println(bf.toString());
	}

}
helloworld
oworld

数组

一维数组

先声明，再用new运算符进行内存分配,或声明时直接分配内存
两种声明方式
在这里插入图片描述
声明数组后，想真正使用数组，还要为它分配内存空间。在为数组分配内存空间时必须指明数组的长度。为数组分配内存空间的语法格式如下：
数组名字 = new 数组元素的类型[数组元素的个数];

int arr[];
arr=new int[10];
arr[1]=233;//将创建的数组对象赋给引用变量arr

二维数组

int myarr[][];
对于高维数组，有两种为数组分配内存的方式：
（1）直接为每一维分配内存空间
a = new int[2][4]
在这里插入图片描述
（2）分别为每一维分配内存
a = new int[2][];a[0] = new int[2];a[1] = new int[3];

数组操作

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

遍历二维数组

传统方法：循环嵌套
使用foreach语句可能会更简单

int arr2[][] = { { 4, 3 }, { 1, 2 } };
		int i = 0;
		for (int x[] : arr2) { 
			i++;
			int j = 0;
			for (int e : x) { 
				j++;
				if (i == arr2.length && j == x.length) { 
					System.out.print(e); 
				} 
				else
					System.out.print(e + "、"); 
			}
		}

填充替换数组

（1）fill(int[] a,int value)
该方法可将指定的int值分配给int型数组的每个元素。
（2）fill(int[] a,int fromIndex,int toIndex,int value)
填充的范围从索引fromIndex（包括）一直到索引toIndex（不包括）。如果fromIndex == toIndex，则填充范围为空。

数组排序

通过Arrays类的静态sort()方法可以实现对数组的排序。sort()方法提供了多种重载形式，可对任意类型的数组进行升序排序
Arrays.sort(object)
其中，object是指进行排序的数组名称。
Java中的String类型数组的排序算法是根据字典编排顺序排序的，因此数字排在字母前面，大写字母排在小写字母前面。

数组复制

Arrays类的copyOf()方法与copyOfRange()方法可以实现对数组的复制。copyOf()方法是复制数组至指定长度，copyOfRange()方法则将指定数组的指定长度复制到一个新数组中。

（1）copyOf()方法
copyOf(arr,int newlength)
　newlength：int型常量，指复制后的新数组的长度。如果新数组的长度大于数组arr的长度，则用0填充（根据复制数组的类型来决定填充的值，整型数组用0填充，char型数组则使用null来填充）；如果复制后的数组长度小于数组arr的长度，则会从数组arr的第一个元素开始截取至满足新数组长度为止。

（2）copyOfRange()方法
copyOfRange(arr,int formIndex,int toIndex)
toIndex：要复制范围的最后索引位置。可大于数组arr的长度。新数组不包括索引是toIndex的元素。

数组查询

Arrays类的binarySearch()方法，可使用二分搜索法来搜索指定数组，以获得指定对象。该方法返回要搜索元素的索引值。
（1）binarySearch(Object[],Object key)
在这里插入图片描述
上面的代码中变量index的值是元素“8”在数组arr中索引在0~1内的索引位置。由于在指定的范围内并不存在元素“8”，index的值是“-”（插入点）。如果对数组进行排序，元素“8”应该在“25”的前面，因此插入点应是元素“25”的索引值2，所以index的值是-2。
如果数组中的所有元素都小于指定的键，则为a.length（注意，这保证了当且仅当此键被找到时，返回的值将大于等于0）。
注意
必须在进行此调用之前对数组进行排序（通过sort()方法）。如果没有对数组进行排序，则结果是不确定的。如果数组包含多个带有指定值的元素，则无法保证找到的是哪一个。

（2）binarySearch(Object[],int fromIndex,int toIndex,Object key)
搜索区间左闭右开
如果要搜索的元素key在指定的范围内，则返回搜索键的索引；否则返回-1或“-”（插入点）。如果范围中的所有元素都小于指定的键，则为toIndex（注意，这保证了当且仅当此键被找到时，返回的值将大于等于0）

数组排序算法

public class BubbleSort {
	public static void main(String[] args) {
		int[] array = { 63, 4, 24, 1, 3, 15 };
		BubbleSort sorter = new BubbleSort();
		sorter.sort(array);
	}
	
	public void sort(int[] array) {
		for (int i = 1; i < array.length; i++) {
			for (int j = 0; j < array.length - i; j++) {
				if (array[j] > array[j + 1]) {
					int temp = array[j];
					array[j] = array[j + 1];
					array[j + 1] = temp;
				}
			}
		}
		showArray(array);
	}
	
	public void showArray(int[] array) {
		for (int i : array) {// foreach格式遍历数组
			System.out.print(" >" + i);
		}
		System.out.println();
	}
	
}

类和对象

类

类修饰符权限

访问包位置	private	protected	public
本类	可见	可见	可见
同包其他类或子类	不可见	可见	可见
其他包的类或子类	不可见	不可见	可见

当声明类时不使用修饰符设置类的权限，则这个类预设为包存取范围，即只有一个包中的类可以调用这个类的成员变量或成员方法。注：包存区范围不同于protected，来自其他包的子类仍然适用protected

如果在成员方法内定义一个变量，那么这个变量被称为局部变量。局部变量是在方法被执行时创建，在方法执行结束时被销毁。局部变量在使用时必须进行赋值操作或被初始化，否则会出现编译错误

this除了可以调用成员变量或成员方法之外，还可以作为方法的返回值

类的构造方法

构造方法特点：没有返回值、构造方法的名称与本类的名称相同。

普通没有返回值的方法使用public void methodEx()形式进行定义，但构造方法不需要用void关键字进行修饰。

语法格式如下：

public Book(){
    //...
}

如果类中没有明确定义构造方法，编译器会自动创建一个不带参数的默认构造方法。

只有在类中没有定义任何构造方法时，编译器才会在该类中自动创建一个不带参数的构造方法。

静态变量、常量和方法

被声明为static的变量、常量和方法被称为静态成员。静态成员属于类所有，可以在本类或其他类使用类名和“.”运算符调用静态成员。

静态数据与静态方法的作用通常是为了提供共享数据或方法，如数学计算公式等，使用时直接使用类名调用这些静态成员即可。静态成员同样遵循public、private和protected修饰符的约束。

public class StaticTest{
    final static double PI=3.14; 	//在类中定义静态常量
    static int id;				 	//在类中定义静态变量
    
    public static void method1(){	//在类中定义静态方法
        //...
    }
    
    public void method2(){
        System.out.println(StaticTest.PI); //调用静态常量
        System.out.println(StaticTest.id); //调用静态变量
        StaticTest.method1();				//调用静态方法
    }
}

**注意：**虽然静态成员也可以用“对象.静态成员”的形式进行调用，但不建议用，因为这样容易混淆静态成员和非静态成员。

在Java语言中对静态方法有两点规定：

在静态方法中不可以使用this关键字
在静态方法中不可以直接调用非静态方法
在Java中规定不能将方法体内的局部变量声明为static的

**技巧：**如果在执行类时希望先执行类的初始化动作，可以使用static定义一个静态区域。如:

public class example {
    static {
        // ...
    }
}

当这段代码被执行时，首先执行static块中的程序，并且只会执行一次。

类的主方法

主方法是类的入口点

public static void main(String[] args){
    //...
}

特性：

主方法是静态的，所以如要直接在主方法中调用其他方法，则该方法必须也是静态的。
主方法没有返回值。
主方法的形参为数组。其中args[0]~args[n]分别代表程序的第一个参数到第n个参数，可以使用args.length获取参数的个数。

对象

对象的创建

通过new操作符来创建对象

Test test1=new Test();
Test test2=new Test("a");

test对象被创建出来时，就是一个对象的引用，这个引用在内存中为对象分配了存储空间。每个对象都在内存中占据独立的内存地址，当一个对象的生命周期结束时，由Java虚拟机自带的垃圾回收机制处理，不能再被使用

访问对象的属性和行为

使用对象.类成员来获取对象的属性和行为。

public class TransferProperty {
	int i = 47; // 定义成员变量
	
	public void call() { // 定义成员方法
		System.out.println("调用call()方法");
		for (i = 0; i < 3; i++) {
			System.out.print(i + " ");
			if (i == 2) {
				System.out.println("\n");
			}
		}
	}
	
	public TransferProperty() {
		// 定义构造方法
	}
	
	public static void main(String[] args) {
		TransferProperty t1 = new TransferProperty(); // 创建一个对象
		TransferProperty t2 = new TransferProperty(); // 创建另一个对象
		
		t2.i = 60; // 将类成员变量赋值为60
		
		// 使用第一个对象调用类成员变量
		System.out.println("第一个实例对象调用变量i的结果：" + t1.i);
		t1.call(); // 使用第一个对象调用类成员方法
		
		// 使用第二个对象调用类成员变量
		System.out.println("第二个实例对象调用变量i的结果：" + t2.i);
		t2.call(); // 使用第二个对象调用类成员方法
	}
}

/*
 第一个实例对象调用变量i的结果：47
调用call()方法
0 1 2 

第二个实例对象调用变量i的结果：60
调用call()方法
0 1 2  

 */

public class AccessProperty {
	static int i = 47; // 定义静态成员变量
	
	public AccessProperty() { 
		
	}
	
	public static void main(String[] args) {
		AccessProperty t1 = new AccessProperty();
		AccessProperty t2 = new AccessProperty();
		t2.i = 60;
		System.out.println("第一个实例对象调用变量i的结果：" + t1.i);
		System.out.println("第二个实例对象调用变量i的结果：" + t2.i);
	}
}
/*
第一个实例对象调用变量i的结果：60
第二个实例对象调用变量i的结果：60
t2.i=60改变了静态成员变量的值，使用对象t1调用成员变量的值也为60
*/

对象的引用

Book类的引用可以使用以下代码：
Book book;
通常一个引用不一定需要有一个对象相关联。引用与对象相关联的语法如下：
Book book=new Book();

对象的比较

在Java语言中有两种比较对象的方式，分别为==运算符与equals()方法。这两种方式有着本质区别:

equals()方法是String类中的方法，它用于比较两个对象引用所指的内容是否相等；
==运算符比较的是两个对象引用的地址是否相等

对象的销毁

Java虚拟机垃圾回收机制:

对象引用超过其作用范围，这个对象将被视为垃圾
将对象赋值为null，这个对象将被视为垃圾

垃圾回收器只能回收那些由new操作符创建的对象。不是通过new操作符在内存中获取存储空间的对象无法被垃圾回收机制所识别。

如果用户在类中定义了finalize()方法，在垃圾回收时会首先调用该方法，在下一次垃圾回收动作发生时，才真正回收被对象占用的内存。

需要明确的是，垃圾回收或finalize()方法并不保证一定会发生。如果Java虚拟机内存损耗待尽，它将不会执行垃圾回收处理。为此，Java提供了System.gc()方法来强制启动垃圾回收器

包装类

Java为每个基本类型都提供了包装类，如int型数值的包装类Integer，boolean型数值的包装类Boolean等，这样可以把这些基本类型转换为对象来处理

需要说明的是，Java可以直接处理基本类型，但在有些情况下需要将其作为对象来处理，这时就需要将其转换为包装类。

Integer

java.lang包中的Integer类、Long类和Short类，可将基本类型int、long和short封装成一个类。其包含的方法基本相同

以Integer类为例

构造方法

Integer (int number) Integer (String str)

Integer number = new Integer(7); 
Integer number = new Integer("45");

要用数值型String变量作为参数，否则将会抛出NumberFormatException异常。

常用方法

方法	返回值	功能描述
byteValue()	byte	以byte类型返回该Integer值
compareTo(anoterInteger)	int	比较两数数值，相等返回0，调用对象数值小于参数返回负值，反之正值
equals(Object IntegerObj)	boolean	比较两对象是否相等
intValue()	int	以int型返回此Integer对象
shortValue()	short	以short型返回此Integer对象
toString	String	返回一个表示该Integer值的String对象
valueOf(String str)	Integer	返回保存指定String值的Integer对象
parseInt(String str)	int	返回包含在字符串str中的数字的等价整数值

toString()方法将对象转换为十进制字符串表示

toBinaryString() toHexString() toOctalString()方法分别将值转换成二进制、十六进制和八进制字符串

常量

MAX_VALUE：表示int类型可取的最大值，即2³¹-1。
MIN_VALUE：表示int类型可取的最小值，即-2³¹。
SIZE：用来以二进制补码形式表示int值的位数。
TYPE：表示基本类型int的Class实例。

Boolean

构造方法

Boolean(boolean value) Boolean(String str)

Boolean b1 = new Boolean(true); 
Boolean b2 = new Boolean("ok");

如果String参数不为null且在忽略大小写时等于true，则分配一个表示true值的Boolean对象，否则获得一个false值的Boolean对象。

常用方法

方法	返回值	功能描述
booleanValue()	boolean	将Boolean对象的值以对应的boolean值返回
equals(Object obj)	boolean	判断调用对象与obj是否相同，参数不为null且相同时返回true
parseBoolean(String s)	boolean	将字符串解析为boolean值
toString()	String	返回表示该boolean值的String对象
valueOf(String s)	Boolean	返回一个用指定字符串表示值的Boolean对象

常量

TRUE：对应基值true的Boolean对象。
FALSE：对应基值false的Boolean对象。
TYPE：基本类型boolean的Class对象。

Byte

构造方法

Byte(byte value) Byte(String str)

byte mybyte = 45;	Byte b = new Byte(mybyte); 
Byte mybyte = new Byte("12");

常用方法

方法	返回值	功能描述
byteValue()	byte	以一个byte值返回Byte对象
compareTo(anoterByte)	int	在数字上比较两个Byte对象
doubleValue()	double	以一个double值返回Byte对象
intValue()	int	以一个int值返回Byte对象
parseByte(String s)	byte	将String型参数解析成等价的字节(byte)形式
toString()	String	返回表示此Byte值的String对象
valueOf(String str)	byte	返回一个指定String所给出的值的Byte对象
equals(Object obj)	boolean	比较，返回一个boolean值

常量

MIN_VALUE：byte类型可取的最小值
MAX_VALUE：byte类型可取的最大值
SIZE：用于以二进制补码形式表示byte值的位数
TYPE：表示基本类型byte的Class实例

Character

构造方法

Character(char value)

Character mychar = new Character('s');

常用方法

方法	返回值	功能描述
charValue()	char	返回此Character对象的值
compareTo(anotherCharacter)	int	根据数字比较，相等则返回0
equals(Object obj)	boolean	比较，返回boolean
toUpperCase(char ch)	char	转换为大写
toLowerCase(char ch)	char	转换为小写
toString()	String	返回一个表示指定char值的String对象
isUpperCase(char ch)	boolean	判断是否为大写
isLowerCase(char ch)	boolean	判断是否为小写

常量

CONNECTOR_PUNCTUATION：返回byte型值，表示Unicode规范中的常规类别“Pc”。
TITLECASE_LETTER：返回byte型值，表示Unicode规范中的常规类别“Lt”。
UNASSIGNED：返回byte型值，表示Unicode规范中的常规类别“Cn”

Double

Double和Float包装类是对double、float基本类型的封装，对Double类进行介绍

每个Double类的对象都包含一个double类型的字段(字段即其他语言中的“变量”)

构造方法

Double(double value) Double(String str)

常用方法

方法	返回值	功能描述
byteValue()	byte	以byte形式返回Double对象值
compareTo(Double d)	int	数值比较，相等返回0
equals(Object obj)	boolean	比较，返回boolean
intValue()	int	以int形式返回double值
isNaN()	boolean	如果此double值是非数字(NaN)值，返回true，否则false
toString()	String	返回此Double对象的字符串表示形式
valueOf(String str)	Double	返回一个指定String表示的double值的Double对象
doubleValue()	double	以double形式返回此Double对象
longValue()	long	以long形式返回此double值

常量

MAX_EXPONENT：返回int值，表示有限double变量可能具有的最大指数
MIN_EXPONENT：返回int值，表示标准化double变量可能具有的最小指数
NEGATIVE_INFINITY：返回double值，表示保存double类型的负无穷大值的常量
POSITIVE_INFINITY：返回double值，表示保存double类型的正无穷大值的常量

Number

抽象类Number是BigDecimal、BigInteger、Byte、Double、Float、Integer、Long和Short类的父类，Number的子类必须提供将表示的数值转换为byte、double、float、int、long和short的方法。这些方法如表所示。

方法	返回值	功能描述
byteValue()	byte	以byte形式返回指定的数值
intValue()	int	以int形式返回指定的数值
floatValue()	float	以float形式返回指定的数值
shortValue()	short	以short形式返回指定的数值
longValue()	long	以long形式返回指定的数值
doubleValue()	double	以double形式返回指定的数值

Number类的方法分别被Number的各子类所实现，也就是说，在Number类的所有子类中都包含以上这几种方法。

数字处理类

Java提供了许多数字处理类，包括DecimalFormat类（用于格式化数字）、Math类（为各种数学计算提供了工具方法）、Random类（为处理随机数问题提供了各种方法）、BigInteger类与BigDecimal类（为所有大数字的处理提供了相应的数学运算操作方法）

数字格式化

在Java中没有格式化的数据遵循以下原则

如果数据绝对值大于0.001并且小于10000000，使以常规小数形式表示
如果数据绝对值小于0.001或者大于10000000，使用科学记数法表示

可以在实例化DecimalFormat对象时传递数字格式，也可以通过DecimalFormat类中的applyPattern()方法来实现数字格式化

字符	说明
0	代表阿拉伯数字，使用特殊字符"0"表示数字的一位阿拉伯数字，如果该位不存在数字，则显示0
#	代表阿拉伯数字，使用特殊字符"#"表示数字的一位阿拉伯数字，如果该位存在数字，则显示字符；如果该位不存在数字，则不显示
.	小数分隔符或货币小数分隔符
-	负号
,	分组分隔符
E	分隔科学记数法中的尾数和指数
%	本符号放置在数字的前缀或后缀，将数字乘以100显示为百分数
\u2030	本符号放置在数字的前缀或后缀，将数字乘以1000显示为千分数
\u00A4	本符号放置在数字的前缀或后缀，作为货币记号
’	单引号，当上述特殊字符出现在数字中时，应为特殊符号添加单引号，系统会将此符号视为普通符号处理

import java.text.*;
// import java.text.DecimalFormat;

public class DFSimpleDemo {
	
	// 使用实例化对象时设置格式化模式
	static public void SingleFormat(String pattern, double value) {
		// 实例化DecimalFormat对象
		DecimalFormat myFormat = new DecimalFormat(pattern); 
		String output = myFormat.format(value); // 将数字进行格式化
		System.out.println(value + " " + pattern + " " + output);
	}
	
	// 使用applyPattern()方法对数字进行格式化
	static public void UseAPFormat(String pattern, double value) {
		DecimalFormat myFormat=new DecimalFormat();//实例化DecimalFormat对象
		myFormat.applyPattern(pattern); // 调用applyPatten()方法设置格式化模板
		System.out.println(value + " " + pattern + " " + myFormat.format(value));
	}
	
	public static void main(String[] args) {
		// 调用静态SingleFormat()方法
		SingleFormat("###,###.###", 123456.789);
		SingleFormat("00000000.###kg", 123456.789); // 在数字后加上单位
		
		// 调用静态UseAPMethodFormat()方法
		UseAPFormat("#.###%", 0.789); // 将数字转换为百分数形式
		// 将小数点后格式化为两位
		UseAPFormat("###.##", 123456.789);
		// 将数字转化为千分数形式
		UseAPFormat("0.00\u2030", 0.789);
	}
}

/*
123456.789 ###,###.### 123,456.789
123456.789 00000000.###kg 00123456.789kg
0.789 #.###% 78.9%
123456.789 ###.## 123456.79
0.789 0.00‰ 789.00‰
*/

在DecimalFormat类中除了可通过格式化模板来格式化数字之外，还可以使用一些特殊方法对数字进行格式化设置。例如

DecimalFormat myF=new DecimalFormat(); //实例化DecimalFormat类对象
myF.setGroupingSize(2);					//设置将数字分组时每组的长度
myF.setGroupingUsed(false);				//设置是否分组

数学运算

Math类

Math类中提供了众多数学函数方法，主要包括三角函数方法、指数函数方法、取整函数方法、取最大值、最小值以及平均值函数方法。这些方法都被定义为static形式调用：Math.Method

数学常量，如PI、E等。这些数学常量作为Math类的成员变量出现。调用：Math.PI Math.E

常用数学运算方法

三角函数方法

public static double sin(double a) //返回角的三角正弦
public static double cos(double a) //返回角的三角余弦
public static double tan(double a) //返回角的三角正切
public static double asin(double a) //返回一个值的反正弦
public static double acos(double a) //返回一个值的反余弦
public static double atan(double a) //返回一个值的反正切
public static double toRadians(double angdeg) //将角度转换为弧度
public static double toDegrees(double angrad) //将弧度转换为角度

指数函数方法

public static double exp(double a) //用于获取e的a次方，即取eª
public static double log(double a) //用于取自然对数，即取lna的值
public static double log10(double a) //用于取底数为10的对数
public static double sqrt(double a) //用于取a的平方根，其中a的值不能为负值
public static double cbrt(double a) //用于取a的立方根
public static double pow(double a,double b) //用于取a的b次方

取整函数方法

public static double ceil(double a) //返回大于等于参数的最小整数
public static double floor(double a) //返回小于等于参数的最大整数
public static double rint(double a) //返回与参数最接近的整数，两个同为整数且同样接近取偶数
public static int round(float a) //将参数加上0.5后返回与参数最近的整数
public static long round(double a) //将参数加上0.5后返回与参数最近的整数，强制转换为长整型

最大最小绝对值函数方法

public static double max(double a,double b) //取a与b之间的最大值
public static int min(int a,int b) //取a与b之间的最小值，参数为整型
public static long min(long a,long b) //取a与b之间的最小值，参数为长整型
public static float min(float a,float b) //取a与b之间的最小值，参数为浮点型
public static double min(double a,double b) //取a与b之间的最小值，参数为双精度型
public static int abs(int a) //返回整型参数的绝对值
public static long abs(long a) //返回长整型参数的绝对值
public static float abs(float a) //返回浮点型参数的绝对值
public static double abs(double a) //返回双精度型参数的绝对值

随机数

Java中主要提供了两种生成随机数的方式：调用Math类的random()方法，调用Random类

Math.random()方法

默认生成大于等于0.0且小于1.0的double型随机数，即0<=Math.random()<1.0

int a=(int)(Math.random()*n); //返回>=0 && <n的随机数
int b=m+(int)(Math.random()*n); //返回>=m && <m+n的随机数

public class MathRondom {
	/**
	 * 定义产生偶数的方法
	 * @author Hive
	 * @param num1 起始范围参数
	 * @param num2 终止范围参数
	 * @return 随即的范围内偶数
	 */
	public static int setRange(double num1, double num2) {
		// 产生num1~num2之间的随机数
		int s = (int) num1 + (int) (Math.random() * (num2 - num1)); 
		
		if (s % 2 == 0) { // 判断随机数是否为偶数
			return s;
		} 
		else	// 如果是奇数
			return s + 1; // 将结果加1后返回
	}
	
	public static void main(String[] args) {
		System.out.println("任意一个2~32之间的偶数：" + setRange(2, 32));
	}
}

使用Math类的random()方法也可以随机生成字符

(char)('a'+Math.random()*('z'-'a'+1));    //生成a~z之间的字符
(char)(cha1+Math.random()*(cha2-cha1+1)); //生成任意两个字符之间的随机字符

public class RandomChar {
	
	// 定义获取任意字符之间的随机字符
	public static char GetRandomChar(char cha1, char cha2) {
		return (char) (cha1 + Math.random() * (cha2 - cha1 + 1));
	}
	
	public static void main(String[] args) {
		// 获取a~z之间的随机字符
		System.out.println("任意小写字符" + GetRandomChar('a', 'z'));
		// 获取A~Z之间的随机字符
		System.out.println("任意大写字符" + GetRandomChar('A', 'Z'));
		// 获取0~9之间的随机字符
		System.out.println("0到9任意数字字符" + GetRandomChar('0', '9'));
	}
}

注意：random()方法返回的值实际上是伪随机数，它通过复杂的运算而得到一系列的数。该方法是通过当前时间作为随机数生成器的参数，所以每次执行程序都会产生不同的随机数。

Random类

java.util.Random类

通过实例化一个Random对象可以创建一个随机数生成器。Java编译器将以系统当前时间作为随机数生成器的种子。如果运行速度太快，会产生两次运行结果相同的随机数。

用户可以在实例化Random类对象时，设置随机数生成器的种子。语法如下：

Random r1=new Random(); 
Random r2=new Random(seedValue); 

//Random类中获取各种数据类型随机数的方法
public int nextInt() //返回一个随机整数。
public int nextInt(int n) //返回大于等于0且小于n的随机整数。
public long nextLong() //返回一个随机长整型值。
public boolean nextBoolean() //返回一个随机布尔型值。
public float nextFloat() //返回一个随机浮点型值
public double nextDouble() //返回一个随机双精度型值。
public double nextGaussian() //返回一个概率密度为高斯分布的双精度值。

import java.util.Random;

public class RandomDemo {
	public static void main(String[] args) {
		Random r = new Random(); // 实例化一个Random类
		System.out.println("随机产生一个整数:" + r.nextInt());
		System.out.println("随机产生一个大于等于0小于10的整数：" + r.nextInt(10));
		System.out.println("随机产生一个布尔型的值：" + r.nextBoolean());
		System.out.println("随机产生一个双精度型的值：" + r.nextDouble());
		System.out.println("随机产生一个浮点型的值：" + r.nextFloat());
		System.out.println("随机产生一个概率密度为高斯分布的双精度值："+ r.nextGaussian());
	}
}

高精度运算

java.math.BigInteger类：针对大整数的处理类
java.math.BigDecimal类：针对大小数的处理类

BigInteger

实例化一个BigInteger对象：public BigInteger(String val)

BigInteger two=new BigInteger("2"); //将十进制2转换为BigInteger形式

//几种运算方法
public BigInteger add(BigInteger val) //做加法运算。
public BigInteger subtract(BigInteger val) //做减法运算。
public BigInteger multiply(BigInteger val) //做乘法运算。
public BigInteger divide(BigInteger val) //做除法运算。
public BigInteger remainder(BigInteger val) //做取余操作。
public BigInteger[] divideAndRemainder(BigInteger val) //用数组返回商(下标0)和余数(下标1)
public BigInteger pow(int exp) //进行取参数的exp次方操作。
public BigInteger negate() //取相反数。
public BigInteger shiftLeft(int n) //将数字左移n位，如果n为负数，做右移操作。
public BigInteger shiftRight(int n) //将数字右移n位，如果n为负数，做左移操作。
public BigInteger and(BigInteger val) //做与操作。
public BigInteger or(BigInteger val) //做或操作
public int compareTo(BigInteger val) //做数字比较操作。
public boolean equals(Object x) //当参数x是BigInteger类型的数字并且数值相等时，返回true。
public BigInteger min(BigInteger val) //返回较小的数值。
public BigInteger max(BigInteger val) //返回较大的数值

import java.math.*;

public class BigIntegerDemo {
	public static void main(String[] args) {
		
		BigInteger bigInstance = new BigInteger("4"); // 实例化一个大数字
		
		// 取该大数字加2的操作
		System.out.println("加法操作：" + bigInstance.add(new BigInteger("2")));
		
		// 取该大数字减2的操作
		System.out.println("减法操作："
				+ bigInstance.subtract(new BigInteger("2")));
		
		// 取该大数字乘以2的操作
		System.out.println("乘法操作："
				+ bigInstance.multiply(new BigInteger("2")));
		
		// 取该大数字除以2的操作
		System.out.println("除法操作："
				+ bigInstance.divide(new BigInteger("2")));
		
		// 取该大数字除以3的商
		System.out.println("取商："
				+ bigInstance.divideAndRemainder(new BigInteger("3"))[0]);
		
		// 取该大数字除以3的余数
		System.out.println("取余数："
				+ bigInstance.divideAndRemainder(new BigInteger("3"))[1]);

		// 取该大数字的2次方
		System.out.println("做2次方操作：" + bigInstance.pow(2));
		
		// 取该大数字的相反数
		System.out.println("取相反数操作：" + bigInstance.negate());
	}
}

BigDecimal

在BigDecimal类中常用的两个构造方法

public BigDecimal(double val)
public BigDecimal(String val)

//BigDecimal类中实现加、减、乘、除的方法
public BigDecimal add(BigDecimal augend) //加法
public BigDecimal subtract(BigDecimal subtrahend) //减法
public BigDecimal multiply(BigDecimal multiplicand) //乘法
public BigDecimal divide(BigDecimal divisor,int scale,int roundingMode) //除法
						//方法中3个参数分别代表除数、商的小数点后的位数、近似处理模式。

BigDecimal类中divide()方法的多种处理模式:

模式	含义
BigDecimal.ROUND_UP	商最后一位如果>0，向前进位，正负数都如此
BigDecimal.ROUND_DOWN	商最后一位无论什么数字都省略
BigDecimal.ROUND_CEILING	商如果是正数，按照ROUND_UP处理；如果是负数，按照ROUND_DOWN处理，两种处理都使近似值大于实际值
BigDecimal.ROUND_FLOOR	与ROUND_CEILING相反，两种处理都使近似值小于实际值
BigDecimal.ROUND_HALF_DOWN	四舍五入，<=5舍弃，>5进位
BigDecimal.ROUND_HALF_UP	四舍五入，<5舍弃，>=5进位
BigDecimal.ROUND_HALF_EVEN	如果商倒数第二位为奇数，按ROUND_HALF_UP 处理，反之ROUND_HALF_DOWN

import java.math.*;

/**
 * BigDecimal法实现加、减、乘、除运算
 * @author Hive
 */

public class BigDecimalDemo {
	static final int location = 10;
	
	/**
	 * 定义加法方法，参数为加数与被加数
	 * 
	 * @param value1相加的第一个数
	 * @param value2相加的第二个数
	 * @return 两数之和
	 */
	public BigDecimal add(double value1, double value2) {
		// 实例化Decimal对象
		BigDecimal b1 = new BigDecimal(Double.toString(value1));
		BigDecimal b2 = new BigDecimal(Double.toString(value2));
		return b1.add(b2); // 调用加法方法
	}
	
	/**
	 * 定义减法方法，参数为减数与被减数
	 * 
	 * @param value1被减数
	 * @param value2减数
	 * @return 运算结果
	 */
	public BigDecimal sub(double value1, double value2) {
		BigDecimal b1 = new BigDecimal(Double.toString(value1));
		BigDecimal b2 = new BigDecimal(Double.toString(value2));
		return b1.subtract(b2); // 调用减法方法
	}
	
	/**
	 * 定义乘法方法，参数为乘数与被乘数
	 * 
	 * @param value1第一个乘数
	 * @param value2第二个乘数
	 * @return
	 */
	public BigDecimal mul(double value1, double value2) {
		BigDecimal b1 = new BigDecimal(Double.toString(value1));
		BigDecimal b2 = new BigDecimal(Double.toString(value2));
		return b1.multiply(b2); // 调用乘法方法
	}
	
	/**
	 * 定义除法方法，参数为除数与被除数
	 * 
	 * @param value1 被除数
	 * @param value2 除数
	 * @return
	 */
	public BigDecimal div(double value1, double value2) {
		return div(value1, value2, location); // 调用自定义除法方法
	}
	
	// 定义除法方法，参数分别为除数与被除数以及商小数点后的位数
	public BigDecimal div(double value1, double value2, int b) {
		if (b < 0) {
			System.out.println("b值必须大于等于0");
		}
		BigDecimal b1 = new BigDecimal(Double.toString(value1));
		BigDecimal b2 = new BigDecimal(Double.toString(value2));
		// 调用除法方法，商小数点后保留b位，并将结果进行四舍五入操作
		return b1.divide(b2, b, BigDecimal.ROUND_HALF_UP);
	}
	
	public static void main(String[] args) {
		BigDecimalDemo b = new BigDecimalDemo();
		System.out.println("两个数字相加结果：" + b.add(-7.5, 8.9));
		System.out.println("两个数字相减结果：" + b.sub(-7.5, 8.9));
		System.out.println("两个数字相乘结果：" + b.mul(-7.5, 8.9));
		System.out.println("两个数字相除结果，结果小数后保留10位："+b.div(10, 2));
		System.out.println("两个数字相除，保留小数后5位："+b.div(-7.5,8.9, 5));
	}
}