java从入门到精通
2023-06-08 19:31:31 0 举报AI智能生成
Java第一章到十一章的知识小总结
作者其他创作
大纲/内容
初始java
java简介
Java是一门高级的面向对象的程序设计语言，ava是一种通用的，基于类的，面向对象的编程语言。它是用于应用程序开发的计算平台。因此，Java是快速，安全和可靠的。它被广泛用于在笔记本电脑，数据中心，游戏机，科学超级计算机，手机等中开发Java应用程序。
java语言的特性
1.简单：Java源代码的书写不拘泥于特定的环境，可以用记事本、文本编辑器等编辑软件来实现，然后将源文件进行编译，编译通过后可直接运行，通过调试则可得到想要的结果。
2.面向对象：面向对象是指以对象为基本粒度，其下包含属性和方法。对象的说明用属性表达，而通过使用方法来操作这个对象。面向对象技术使得应用程序的开发变得简单易用，节省代码。
3.分布性：Java设计成支持在网络上应用，它是分布式语言。Java既支持各种层次的网络连接，又以Socket类支持可靠的流（stream）网络连接，所以用户可以产生分布式的客户机和服务器。
4.可移植性：所谓的跨平台性，是指软件可以不受计算机硬件和操作系统的约束而在任意计算机环境下正常运行。
5.解释性：Java字节码提供对体系结构中性的目标文件格式，代码设计成可有效地传送程序到多个平台。Java程序可以在任何实现了Java解释程序和运行系统（run-time system）的系统上运行。
6.安全性：全性可以分为四个层面，即语言级安全性、编译时安全性、运行时安全性、可执行代码安全性。语言级安全性指Java的数据结构是完整的对象，这些封装过的数据类型具有安全性。编译时要进行Java语言和语义的检查，保证每个变量对应一个相应的值，编译后生成Java类。运行时Java类需要类加载器载入www jxzxmr net，并经由字节码校验器校验之后才可以运行。 Java类在网络上使用时，对它的权限进行了设置，保证了被访问用户的安全性。
7.健壮性：Java原来是用作编写消费类家用电子产品软件的语言，所以它是被设计成写高可靠和稳健软件的。Java消除了某些编程错误，使得用它写可靠软件相当容易。
8.多线程：多线程在操作系统中已得到了最成功的应用。多线程是指允许一个应用程序同时存在两个或两个以上的线程，用于支持事务并发和多任务处理。 Java除了内置的多线程技术之外，还定义了一些类、方法等来建立和管理用户定义的多线程。
9.高性能：ava是一种先编译后解释的语言，所以它不如全编译性语言快。但是有些情况下性能是很要紧的，为了支持这些情况，Java设计者制作了“及时”编译程序，它能在运行时把Java字节码翻译成特定CPU（中央处理器）的机器代码，也就是实现全编译了。
10.动态：Java语言设计成适应于变化的环境，它是一个动态的语言。例如，Java中的类是根据需要载入的，甚至有些是通过网络获取的。
搭建java环境
JDK下载：打开浏览器，输入网址：http://jdk.java.net，在页面下方的Reference implentaions下载11版本
在windows10系统下载搭建JDK环境：具体操作请移步百度
熟悉Eclipse开发工具
具体操作移步本博客：https://blog.csdn.net/qq_74168627/article/details/129181970?spm=1001.2014.3001.5502
java语言基础
java主类结构
1.包声明：一个Java应用程序是由若干个类组成的，关于包的详细讲解可参见11章
2.声明成员变量和局部变量：通常将类的属性称为类的全局变量（成员变量），将方法中属性称为局部变量，全局变量声明在类体中，局部变量声明在方法体中，全局变量和局部变量都有各自应用的范围
3.编写主方法：main()方法是类体中的方法，该方法从"{"开始，至"}"结束，public,static,void分别是main()方法的修饰符，静态修饰符和返回值修饰符，Java程序中的main()方法必须声明为public static void。Sting[] args是一个字符串类型的数组，它是main()方法的参数，main()方法是程序开始执行的位置
4.导入API类库：在Java语言中可以通过import关键字导入相关的类，在JDK的API中，提供了130多个包，如java.awt,java.io等，可以通过JDK的API文档来查看这些包中的类，把握类的继承结构，类的应用，成员变量，构造方法表等，并对每个变量的使用目的进行了解，API文档是程序开发人员不可或缺的工具
基本数据类型
1.整型用来存放整数
2.浮点型分为单精度和双精度浮点型
3.布尔型用来表示真或假
4.字符型用来存放字符类
5.转义字符是一种特殊的字符变量，它以”\“开头，后头跟一个或多个字符
ps：浮点值属于近似值，在系统中运算后的结果可能和实际有偏差
2.浮点型分为单精度和双精度浮点型
3.布尔型用来表示真或假
4.字符型用来存放字符类
5.转义字符是一种特殊的字符变量，它以”\“开头，后头跟一个或多个字符
ps：浮点值属于近似值，在系统中运算后的结果可能和实际有偏差
变量与常量
常量：在程序运行过程中一直不会改变的量，只能被赋值一次。
变量：可以多次赋值，分为局部变量和成员变量，局部变量优先级高于成员变量，就近原则。
成员变量：在类体中所声明的变量被称为成员变量，它在整个变量都有用。
局部变量：在类的方法体中声明的变量，它只在当前代码块中有效。
关键字：又称保留字，是Java中已经被赋予特定意义的一些单词，不能被作为标识符来使用。
标识符：标识符：可以简单地理解为一个名字，是用来标识类名，变量名，方法名，数组名，文件名的有效字符序列
标识符的组成有三点要求：
1.标识符由任意顺序的字母，下划线（_），美元符号（$），和数字组成。
2.但是开头不能为数字。
3.不能是Java中的关键字。
1.标识符由任意顺序的字母，下划线（_），美元符号（$），和数字组成。
2.但是开头不能为数字。
3.不能是Java中的关键字。
运算符
赋值：“=”
"="：将右方操作数所含的值赋给左方。
"="：将右方操作数所含的值赋给左方。
算术运算符："+","-","*","%","/"
"+"：加
"-"：减
"*"：乘
"%"：取余
"/"：除
"+"：加
"-"：减
"*"：乘
"%"：取余
"/"：除
自增和自减运算符："++","--"
"++"：自增
"--"：自减
"++"：自增
"--"：自减
比较运算符：">","<","==",">=","<=","!="
">"：大于
"<"：小于
"=="：等于
">="：大于或等于
"<="：小于或等于
"!="：比较左右是否相等
">"：大于
"<"：小于
"=="：等于
">="：大于或等于
"<="：小于或等于
"!="：比较左右是否相等
逻辑运算符："&&","||","!"
"&&"逻辑与:从左往右，两者都为真，结果才是真。
"||"逻辑或：从左往右，只要有一者为真，结果就是真。
"!"逻辑非:从右往左，非真即假，非假即真。
"&&"逻辑与:从左往右，两者都为真，结果才是真。
"||"逻辑或：从左往右，只要有一者为真，结果就是真。
"!"逻辑非:从右往左，非真即假，非假即真。
位运算符："&","|","~","^","<<",">>",">>>"
"&"与：两者都为1，结果才是1。
"|"或：只要有一者为1，结果就是1。
"~"取反：0变1，1变0。
"^"异或：两者相同即为0，不同为1。
"<<"左移：空位补0，溢出去掉。
">>"右移：正数补0，负数补1溢出去掉。
">>>"无符号右移：整体右移，空位补0，溢出去掉。
"&"与：两者都为1，结果才是1。
"|"或：只要有一者为1，结果就是1。
"~"取反：0变1，1变0。
"^"异或：两者相同即为0，不同为1。
"<<"左移：空位补0，溢出去掉。
">>"右移：正数补0，负数补1溢出去掉。
">>>"无符号右移：整体右移，空位补0，溢出去掉。
三元运算符："? :"
三元运算符的使用格式为：条件式 ？ 值1 ： 值2
三元运算符在底层逻辑和if语句是一样的
三元运算符的使用格式为：条件式 ？ 值1 ： 值2
三元运算符在底层逻辑和if语句是一样的
数据类型转换
隐式类型转换（自动类型转换）：从低级类型转向高级类型的转换，系统将自动转换，而且这个过程一定不会丢失数据
显示类型转换（强制类型转换）：把高精度的变量的值赋值给低精度的变量的操作，这个操作有可能会丢失数据
代码注释与编码规范
单行注释：”//“单行注释，从”//“开始直到换行为止所有内容均为注释
多行注释：”/**/“为多行注释，符号”/*“与”*/“之间的所有内容均为注释，多行注释内的内容可以换行
编码规范：编码并没有明确的规定该如何编码，但是我们为了让代码在其他人手中更容易看懂和理解，所以才要统一一下编码规范，这也是程序员所需要具备的良好习惯
流程控制
复合语句：java的复合语句是以整个区块为单位的语句，所以又称块语句，由”{“开始，”}“结束
if条件语句
简单的if语句：效果为“如果满足某条件就执行某段语句”
语法如下：
if...else语句：如果满足某条件，就执行某种处理，否则执行另一种处理
语法如下：
if...else if多分支语句：如果满足某条件，就进行某种处理，否则如果满足另一条件则执行另一种处理
语法如下：
switch多分支语句：计算表达式的值，如果与case后的常量值相同则执行该case语句后的若干个语句直到遇到break语句为止，此时，如果该case语句中没有break语句，将继续执行后面case中的语句，直到遇到break，如果没有一个常量的值与表达式的值相同，则执行default后的语句，default语句是可选的，如果不存在，且switch中的表达式的值不与任何case的常量值相同，switch将不做任何处理
语法如下：
循环语句
while循环语句：也叫条件判断语句，它的循环方式为利用一个条件来控制是否要继续反复执行这个语句
语法如下：
do......while循环语句：与while循环语句类似，区别是while先判断条件是否成立再执行循环，而do...while循环语句则先执行一次循环后，在判断条件是否成立，do...while循环语句至少会循环一次。
语法如下：
for循环语句：for循环有两种语句，一种是传统的for语句，一种是foreach语句
for语句：for循环可以用来重复执行某条语句，直到某个条件得到满足
语法如下：
foreach语句：它是for语句的特殊简化版本，不能完全取代for语句，但任何foreach都可以改写为for语句版本，它不是一个关键字
语法如下：
循环控制
break语句：break可以跳出当前循环，就近原则，哪个循环离它近它跳出哪个循环，不能越级跳出。
语法如下：
continue语句：是针对break语句的补充，作用并不是立即跳出当前循环而是跳过本次循环，回到循环的条件判断环节，重新开始判断
语法如下：
数组
数组概述：数组是具有相同数据类型的一组数据的集合
一维数组：一维数组是一组相同数据类型数据的线性集合
创建一维数组
先声明后分配内存：要真正的使用数组还要为它分配内存空间，在为数组分配内存空间之必须指明数组的长度。
数组的声明：数组元素的类型[] 数组名；
数元素的类型数组名 []；
数元素的类型数组名 []；
数组的内存分配：数组名字 = new 数组元素的类型[数组元素的个数]；
声明的同时分配内存
数组元素的类型 数组名 = new 数组元素的类型[数组元素的个数]；
初始化一维数组：数组与基本数据类型一样可以进行初始化操作。数组的初始化可以分别初始化数组中每个元素
两种方法：
使用一维数组
代码例子：public class liti5_1 {
public static void main(String[] args) {
// TODO Auto-generated method stub
int day[] = new int[] {31,28,31,30,31,30,31,30,31,31,30,31};
//创建一个int类型的一维数组day
for (int i = 0;i < day.length; i ++) { //循环输出
System.out.println((i +1) + "月有"+ day[i] + "天"); //输出
}
}
}
public static void main(String[] args) {
// TODO Auto-generated method stub
int day[] = new int[] {31,28,31,30,31,30,31,30,31,31,30,31};
//创建一个int类型的一维数组day
for (int i = 0;i < day.length; i ++) { //循环输出
System.out.println((i +1) + "月有"+ day[i] + "天"); //输出
}
}
}
代码结果：
二维数组：如果一堆数组中的各个元素仍是一个数组，那么它就是二维数组，通常用于表示表
创建二维数组
先声明后分配内存
声明：数组元素的类型[][] 数组名；
数元素的类型数组名 [][]；
数元素的类型数组名 [][]；
声明的同时分配内存
分配内存：数组元素的类型[][] 数组名；
数元素的类型数组名 [][]；
数元素的类型数组名 [][]；
初始化二维数组
语法如下：
使用二维数组
代码例子：public class liti5_2 {
public static void main(String[] args) {
// TODO Auto-generated method stub
int a[][] = new int[3][4]; //定义一个int型的二维数组a指定3行4列
for (int i = 0; i < a.length; i ++) { //循环找到每个一维数组的地址
for (int j = 0; j < a[i].length; j ++) { //循环输出每个一维数组中的值
System.out.print(a[i][j]);
}
System.out.println();
}
}
}
代码例子：public class liti5_2 {
public static void main(String[] args) {
// TODO Auto-generated method stub
int a[][] = new int[3][4]; //定义一个int型的二维数组a指定3行4列
for (int i = 0; i < a.length; i ++) { //循环找到每个一维数组的地址
for (int j = 0; j < a[i].length; j ++) { //循环输出每个一维数组中的值
System.out.print(a[i][j]);
}
System.out.println();
}
}
}
结果如下：
数组的基本操作
遍历数组：遍历数组就是获取数组中的每个元素，通常遍历数组都是用for循环来实现
填充替换数组元素：数组中的元素定义完后，可以跳过Array类的静态方法fill()来对数组中的元素进行替换，fill()方法有两种参数
语法如下：
对数组进行排序：通过Array类的静态方法sort()可以对数组进行排序
语法如下：
复制数组：Array中的copyOf()方法与copyOfRange()方法可以实现对数组的复制
copyOf语法如下：
copyOfRange语法如下：
查询数组：Array中的binarySearch()方法，可以用二分搜索法来搜索指定数组，以获得指定对象，它有两种方法
Arrays.binarySearch查询指定元素：
Arrays.binarySearch查询指定范围：
数组排序算法
冒泡排序法：是最常用的数组排序算法之一，它排序数组元素的过程总是将小的数往前放，较大的往后放，类似水中冒泡往上升的动作，所以叫冒泡排序
基本思想：比较相邻的元素，把较小的元素移动到数组前面，把较大的元素放到数组后面，这样较小的元素就像气泡一样从底部上升到顶部
算法示例：冒泡排序由双层循环实现，外层循环用于控制层数，一般要循环数组长度减一次才能保证完成排序，内层循环主要用于对比数组中每个相邻的元素大小判断是否交换位置
算法实现
public class liti5_12 {
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] array = {63,4,24,1,3,15}; //创建一个数组，元素是乱的
liti5_12 sorter = new liti5_12();//创建冒泡排序的对象
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) { //遍历数组
System.out.print(">"+ i); //输出每个数组元素值
}
System.out.println();
}
}
public class liti5_12 {
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] array = {63,4,24,1,3,15}; //创建一个数组，元素是乱的
liti5_12 sorter = new liti5_12();//创建冒泡排序的对象
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) { //遍历数组
System.out.print(">"+ i); //输出每个数组元素值
}
System.out.println();
}
}
结果如下：
直接选择排序：属于一种选择排序，排序速度要比冒泡排序快点，也是常用的排序，初学者应该掌握
基本思想：将指定排序位置元素与其他数组元素对比，如果满足条件就交换元素值，直接排序并不是和冒泡排序一样交换相邻元素，而是把满足条件的元素与指定的排序位置元素交换
算法示例：挑出元素中最小或者最大的一个元素，顺序的放在已排序好的数列的最后，直到全部待排序的数据元素排列完
算法实现
public class liti5_13 {
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] array = {63,4,24,1,3,15}; //创建一个数组，元素是乱的
liti5_12 sorter = new liti5_12();//创建冒泡排序的对象
sorter.sort(array); //调用排序方法，对数组排
}
public void sort(int[] array) {
int index;
for(int i = 1; i < array.length; i ++) {
index = 0;
for(int j = 0; j < array.length - i; j ++) {
if(array[j] > array[index]) {
index = j;
}
}
int temp = array[array.length - i];//把第一个元素值保存到临时变量中
array[array.length - i] = array[index];//把第二个元素值保存到第一个元素单中
array[index = temp; //把临时变量（第一个元素原值）保存到第二个元素单中
}
showArray(array); //输出直接选择排序后的数组元素
}
public void showArray(int[] array) {
for(int i: array) { //遍历数组
System.out.print(">"+ i); //输出每个数组元素值
}
System.out.println();
}
}
public class liti5_13 {
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] array = {63,4,24,1,3,15}; //创建一个数组，元素是乱的
liti5_12 sorter = new liti5_12();//创建冒泡排序的对象
sorter.sort(array); //调用排序方法，对数组排
}
public void sort(int[] array) {
int index;
for(int i = 1; i < array.length; i ++) {
index = 0;
for(int j = 0; j < array.length - i; j ++) {
if(array[j] > array[index]) {
index = j;
}
}
int temp = array[array.length - i];//把第一个元素值保存到临时变量中
array[array.length - i] = array[index];//把第二个元素值保存到第一个元素单中
array[index = temp; //把临时变量（第一个元素原值）保存到第二个元素单中
}
showArray(array); //输出直接选择排序后的数组元素
}
public void showArray(int[] array) {
for(int i: array) { //遍历数组
System.out.print(">"+ i); //输出每个数组元素值
}
System.out.println();
}
}
结果如下：
反转排序：以相反的顺序把原有数组的元素重新排序，也是经常用到的一种排序方法
基本思想：将数组最后一个元素和第一个元素交换，倒数第二个元素和第二个元素交换，以此类推，直到把所有元素反转替换
算法示例：反转排序是对数组两边的元素进行替换，所以只需要循环数组长度的半数次，如果数组长度位奇数，例如数组长度为7，那么只会循环3次，中间的数不变
算法实现
public class liti5_14 {
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] array = {10,20,30,40,50,60}; //创建一个数组
liti5_14 sorter = new liti5_14();//创建反转排序的对象
sorter.sort(array); //调用排序对象方法，将数组排序
}
public void sort(int[] array) {
System.out.println("数组原有内容：");
showArray(array); //输出排序前的数组元素
int temp;
int len = array.length;
for(int i = 0;i < len / 2;i++) {
temp = array[i];
array[i] = array[len - 1 - i];
array[len - 1 - i] = temp;
}
System.out.println("数组反转后内容");
showArray(array); //输出排序后的数组元素
}
public void showArray(int[] array) {
for(int i: array) { //遍历数组
System.out.print("\t"+ i); //输出每个数组元素值
}
System.out.println();
}
}
public class liti5_14 {
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] array = {10,20,30,40,50,60}; //创建一个数组
liti5_14 sorter = new liti5_14();//创建反转排序的对象
sorter.sort(array); //调用排序对象方法，将数组排序
}
public void sort(int[] array) {
System.out.println("数组原有内容：");
showArray(array); //输出排序前的数组元素
int temp;
int len = array.length;
for(int i = 0;i < len / 2;i++) {
temp = array[i];
array[i] = array[len - 1 - i];
array[len - 1 - i] = temp;
}
System.out.println("数组反转后内容");
showArray(array); //输出排序后的数组元素
}
public void showArray(int[] array) {
for(int i: array) { //遍历数组
System.out.print("\t"+ i); //输出每个数组元素值
}
System.out.println();
}
}
结果如下：
类和对象
对象：在现实生活中，任何事物都可以称作对象
静态属性：静态部分也就是不能动的，拿鸟举例，如：翅膀，名称，头，便是我们所说的静态部分
静态方法，静态变量：static修饰的变量和方法称为静态变量和静态方法
动态属性：动态部分则是可以执行的动作，同样拿鸟举例，如：吃东西，飞行
对象的创建：通过new操作符来创建对象，每实例化一个对象就会自动调用一次构造方法，实质上这个过程就是创建对象的过程
语法如下：Tese tese = new Tese();
Tese tese = new Tese("a");
Tese tese = new Tese("a");
访问对象的属性和行为:使用new操作符创建一个对象后，可以使用”对象.类成员“来获取对象的属性和行为
代码示例：
package liudanyuan;
public class lei6_8 {
//定义成员变量
String name;
String Color;
String vioce;
public lei6_8(String name,String color,String vioce) {
this.name = name;
this.Color = color;
this.vioce = vioce;
}
public void call() { //叫
System.out.println(vioce);
}
public static void main(String[]args) {
lei6_8 d1 = new lei6_8("毛毛","白色","汪汪汪");
System.out.print(d1.name+"的颜色是"+d1.Color);//访问对象的属性
System.out.print(",叫起来的声音：");
d1.call(); //访问对象的行为
lei6_8 d2 = new lei6_8("灰灰","灰色","嗷呜~");
System.out.print(d2.name+"的颜色是"+d2.Color);
System.out.print(",叫起来的声音：");
d2.call();
}
}
package liudanyuan;
public class lei6_8 {
//定义成员变量
String name;
String Color;
String vioce;
public lei6_8(String name,String color,String vioce) {
this.name = name;
this.Color = color;
this.vioce = vioce;
}
public void call() { //叫
System.out.println(vioce);
}
public static void main(String[]args) {
lei6_8 d1 = new lei6_8("毛毛","白色","汪汪汪");
System.out.print(d1.name+"的颜色是"+d1.Color);//访问对象的属性
System.out.print(",叫起来的声音：");
d1.call(); //访问对象的行为
lei6_8 d2 = new lei6_8("灰灰","灰色","嗷呜~");
System.out.print(d2.name+"的颜色是"+d2.Color);
System.out.print(",叫起来的声音：");
d2.call();
}
}
结果如下：
对象的引用：在java语言中，尽管一切都可以看作对象，但真正的操作标识符实质上是一个引用
语法如下：类名 对象的引用变量
对象的销毁：每个对象都有生命周期，当对象的生命周期结束时，分配给对象的内存地址需要被回收，在其他语言中，需要用户手动回收废弃的对象，java有一套完整的垃圾回收机制，用户不用担心废弃的对象占用内存，垃圾回收器会自动回收无用却占用内存的资源
类：我们可以把类看成一个箱子，一种事物便是一类，如：鸟是鸟类，家禽是家禽类，人是人类。
一个事物不能是一类事物，如：一只鸟不能是鸟类
一个事物不能是一类事物，如：一只鸟不能是鸟类
成员变量：对象中的静态属性也就是成员变量
成员方法：对象中的动态属性也就是成员方法
权限修饰符：类修饰符分为三种：pubilc，private，protected
重点讲一下pubilc和private：
pubilc是共有的，你在里面写的所有东西其他的类都能用，不管这个类和你有没有关系，他都能用你写在里面的东西
private是私有的，不管你和我有没有关系，就算你和我有关系，你也不能用我写在里面的东西
protected则是你和我有关系那你就可以查看我写的东西，你和我没关系则不能查看
如果你想要在私有的里面的东西有两中方法：getter和setter，这两种getter是获取的意思，setter是设置的意思
pubilc是共有的，你在里面写的所有东西其他的类都能用，不管这个类和你有没有关系，他都能用你写在里面的东西
private是私有的，不管你和我有没有关系，就算你和我有关系，你也不能用我写在里面的东西
protected则是你和我有关系那你就可以查看我写的东西，你和我没关系则不能查看
如果你想要在私有的里面的东西有两中方法：getter和setter，这两种getter是获取的意思，setter是设置的意思
如果你想要在私有的里面的东西有两中方法：getter和setter，这两种getter是获取的意思，setter是设置的意思
局部变量：在成员方法中定义一个变量，这个变量就是局部变量
局部变量的有效范围
this关键字：本意是这个类，当你的name=name，根据就近原则，你只是把参数name赋值给了参数本身，成员变量的值并没有发生改变，这时加上一个this，使this.name代表的是代码中的成员变量了， 而第二个name指的是参数
类的构造方法：在类中，除了成员方法还有一个特殊类型的方法——构造方法
new便是构造方法，当你在代码中输入new电脑便会自动产生一个变量
new便是构造方法，当你在代码中输入new电脑便会自动产生一个变量
类的主方法：public static void main(String[] args)
封装：把静态和动态放进类里面的这个动作就叫做封装，封装也是面向对象编程的核心思想，采用封装的思想保证了类内部数据的完整性
继承：类与类之间同样具有关系，这种关系被称为关联。
拿鸟举例：鸟类和大雁，鸟类里面包含大雁，大雁有的鸟类也有，而鸟类有的大雁不一定有，所有鸟类是大雁的父类，大雁是鸟类的子类
当我们已经创建了一个鸟类时，在想要创建一个大雁类时，我们可以直接将鸟类中有用的东西保留下来，如：翅膀，爪子。在添加一些大雁具有的独特属性和行为，这样就节省了定义鸟与大雁之间共有的属性和行为的时间，这就叫做继承，子类继承父类
拿鸟举例：鸟类和大雁，鸟类里面包含大雁，大雁有的鸟类也有，而鸟类有的大雁不一定有，所有鸟类是大雁的父类，大雁是鸟类的子类
当我们已经创建了一个鸟类时，在想要创建一个大雁类时，我们可以直接将鸟类中有用的东西保留下来，如：翅膀，爪子。在添加一些大雁具有的独特属性和行为，这样就节省了定义鸟与大雁之间共有的属性和行为的时间，这就叫做继承，子类继承父类
多态：拿鸟举例：在鸟类里有不同种类的鸟如大雁，布谷鸟，麻雀，老鹰，这种就是多态
继承，多态，抽象类与接口
类的继承：继承在面向对象开发思想中是一个非常重要的概念继承使用关键字extends
extends语法：class Child extends Parent{}
java只支持单继承，即一个类只能继承一个父类，所以不能出现以下情况：
class Child extends Parent1，pareent2{}
java只支持单继承，即一个类只能继承一个父类，所以不能出现以下情况：
class Child extends Parent1，pareent2{}
子类继承父类之后可以调用父类创建好的属性和方法
Object类：Object类比较特殊，他是所有类的父类，类似中国神话中女娲一样的存在，是java类层中的最高层类，用户创建一个类时，除非已经指定要从其他类继承，否则就是默认继承Object。
getClass()方法:用来查询类的名称
语法如下：getClass().getname();
toString()方法:将一个对象返回为字符串形式
代码示例：
public class ilti7_3 {
//成员变量
String name;
int age;
public ilti7_3(String name,int age) { //构造方法
this.name = name;
this.age = age;
}
public String toString() {
return "我叫"+name+"，今年"+age+"岁。";//定义一个方法名为toString
}
public static void main(String[] args) {
// TODO Auto-generated method stub
ilti7_3 s1 = new ilti7_3("张三",16);
System.out.println(s1);
ilti7_3 s2 = new ilti7_3("李四",19);
System.out.println(s2);
}
}
public class ilti7_3 {
//成员变量
String name;
int age;
public ilti7_3(String name,int age) { //构造方法
this.name = name;
this.age = age;
}
public String toString() {
return "我叫"+name+"，今年"+age+"岁。";//定义一个方法名为toString
}
public static void main(String[] args) {
// TODO Auto-generated method stub
ilti7_3 s1 = new ilti7_3("张三",16);
System.out.println(s1);
ilti7_3 s2 = new ilti7_3("李四",19);
System.out.println(s2);
}
}
结果如下：
equals()方法：比较两个对象的实际内容是否相同
代码示例：
public class liti7_4 {
int di;
String name;
public liti7_4(int id, String name) {
super();
this.di = id;
this.name = name;
}
public boolean epuals(Object obj) {
if(this == obj)
return true;
if(obj == null)
return false;
if(getClass() != obj.getClass())
return false;
liti7_4 other = (liti7_4)obj;
if(di != other.di)
return false;
return true;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
liti7_4 p1 = new liti7_4(220,"tom");
liti7_4 p2 = new liti7_4(220,"汤姆");
liti7_4 p3 = new liti7_4(330,"张三");
Object o = new Object();
System.out.println(p1+ "与"+p2+"是否为同一个人");
System.out.println("equals()方法的结果："+ p1.epuals(p2));
System.out.println("==运算符的结果："+(p1 == p2));
System.out.println();
System.out.print(p1+"与"+p3+"是否为同一个人");
System.out.println(p1.epuals(p3));
System.out.println();
System.out.print(p1 + "与" + o + "是否为同一个人");
System.out.println(p1.epuals(o));
}
}
public class liti7_4 {
int di;
String name;
public liti7_4(int id, String name) {
super();
this.di = id;
this.name = name;
}
public boolean epuals(Object obj) {
if(this == obj)
return true;
if(obj == null)
return false;
if(getClass() != obj.getClass())
return false;
liti7_4 other = (liti7_4)obj;
if(di != other.di)
return false;
return true;
}
public static void main(String[] args) {
// TODO Auto-generated method stub
liti7_4 p1 = new liti7_4(220,"tom");
liti7_4 p2 = new liti7_4(220,"汤姆");
liti7_4 p3 = new liti7_4(330,"张三");
Object o = new Object();
System.out.println(p1+ "与"+p2+"是否为同一个人");
System.out.println("equals()方法的结果："+ p1.epuals(p2));
System.out.println("==运算符的结果："+(p1 == p2));
System.out.println();
System.out.print(p1+"与"+p3+"是否为同一个人");
System.out.println(p1.epuals(p3));
System.out.println();
System.out.print(p1 + "与" + o + "是否为同一个人");
System.out.println(p1.epuals(o));
}
}
结果如下：
对象类型的转换
向上转型：子类对象赋值给父类引用
语法如下：Animal a = new Dog();
自动类型转换，不会丢失数据
向下转型：父类对象赋值给子类引用
语法如下：Dog a = (Dog)new Animal();
强制类型转换，可能丢失数据
使用instanceof关键字判断对象类型
判断对象是否属于该其类或其子类
语法如下：对象名 instanceof 类名；
判断对象是否属于该接口的实现类
语法如下：对象名 instanceof 接口名;
方法的重载：方法的重载就是在同一个类中允许存在一个以上的同名方法，只要这些方法的参数个数或参数类型不同即可
使用不定长参数超载加法运算方法
语法如下：返回值 方法名(参数数据类型...参数名称)
final关键字
final变量：最终的，最后的。它可以用来声明变量，一旦该变量被设定，就不可再改变我们称之为常量
语法如下：final double PI = 3.14;
final方法：final修饰方法不可被重写
语法如下：private final void test(){......}
final类：被final修饰的类不可被继承，不可被更改如果希望一个类不可被任何类继承，或更改，可以使用将这个类设置为final类。
语法如下：final 类名{}
多态：利用多态可以使程序具有良好的扩展性，并可以对所有类对象进行通用的处理，拥有多种结果都可以叫多态
代码示例：public class liti7_8 {
public static int add(int a,int b) { //定义一个方法
return a+b;
}
public static double add(double a,double b) {//与第一个方法名相同，参数不同
return a+b;
}
public static int add(int a) { //与第一个方法参数个数不同
return a;
}
public static int add(int a,double b) {//先int参数后double参数
return a; //输出int参数值
}
public static int add(double a,int b) {//先double参数，后int参数
return b; //输出int参数值
}
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("调用add(int,int)方法："+ add(1,2));
System.out.println("调用add(double,double)方法："+ add(2.1,3.3));
System.out.println("调用add(int)方法："+ add(1));
System.out.println("调用add(int,double)方法："+ add(1,8.0));
System.out.println("调用add(double,int)方法："+ add(5.0,8));
}
}
public static int add(int a,int b) { //定义一个方法
return a+b;
}
public static double add(double a,double b) {//与第一个方法名相同，参数不同
return a+b;
}
public static int add(int a) { //与第一个方法参数个数不同
return a;
}
public static int add(int a,double b) {//先int参数后double参数
return a; //输出int参数值
}
public static int add(double a,int b) {//先double参数，后int参数
return b; //输出int参数值
}
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("调用add(int,int)方法："+ add(1,2));
System.out.println("调用add(double,double)方法："+ add(2.1,3.3));
System.out.println("调用add(int)方法："+ add(1));
System.out.println("调用add(int,double)方法："+ add(1,8.0));
System.out.println("调用add(double,int)方法："+ add(5.0,8));
}
}
结果如下：
抽象类与接口
抽象类与抽象方法（abstract）：
抽象类：仅用来描述特征且极具抽象性类，在java中被定义为抽象类
定义抽象类语法如下：抽象类语法：修饰符 abstract class 类名{}
抽象方法：与传统方法不同，抽象方法没有方法体，有抽象方法的类一定是抽象类,当父类是抽象类，有抽象方法时，它的子类要么重写父类的抽象方法，要么定义为抽象类（抽象方法重写之后就是普通方法了）
抽象方法语法如下：修饰符 abstract 返回参数 方法名 (传入参数);
接口（interface）：接口是抽象类的延伸，可以将它看作是纯粹的抽象类，接口中所有的方法都是抽象方法·，由于java语言每个类只能继承一个父类，因此接口的作用就凸显出来，一个类可以实现多个接口，可以看作一个类可以拥有多个父类（便于理解并不是官方意思）
接口语法如下：修饰符 interface 接口名
实现（implements）：java语言每个类可以实现多个接口
实现语法如下：修饰符 class 类名 implements 接口1，接口2，...{}
包和内部类
类名冲突：在Java中，我们可以使用class关键字来进行定义一个类，在程序被编译后就会产生一个.class文件。类的定义是规定类名不能重复的，如果程序内只定义了少量的类，那自然不用担心这个问题。
但是，随着类的数量增多，那么难免会出现这个问题，如果根据需求需要定义两个名字相同但是程序逻辑不同的类时，那么该如何解决呢，最好的方法就是将这个两个类放置在不同的包下面。类的定义规定，在同一个类包下面不允许出来同名的类，但是在不同类包下面就允许出现这种情况，相当于将两个同名的类放入了不同的盒子内，避免出现这个问题。
但是，随着类的数量增多，那么难免会出现这个问题，如果根据需求需要定义两个名字相同但是程序逻辑不同的类时，那么该如何解决呢，最好的方法就是将这个两个类放置在不同的包下面。类的定义规定，在同一个类包下面不允许出来同名的类，但是在不同类包下面就允许出现这种情况，相当于将两个同名的类放入了不同的盒子内，避免出现这个问题。
完整的类路径：如果一个程序内存在多个同名不同包的max类，那么该如何使用指定包的类呢？
在使用该类时使用该类的类路径，也成为绝对路径。
在使用该类时使用该类的类路径，也成为绝对路径。
语法如下：java.util.Date date=new java.util.Date(); // 选择Java.util包下的Date类
java.sql.Date date2=new java.sql.Date(100) // 选择Java.sql包下的Date类
java.sql.Date date2=new java.sql.Date(100) // 选择Java.sql包下的Date类
创建包（package）：在进行创建包的时候需要注意的是，Java包的命名规则建议使用全小写字母进行命名。
需要了解的是如果一个类没有被定义在一个指定的包内，那么该类就被归纳到默认包(default package)中。
在某个包下面创建一个类的话，需要在这个类的开头加上表达式 package 包名，该表达式需要放置在程序的第一行，使用package关键字指定包名之后，包名也会成为类名的一部分，在不同包下使用该类的话，需要使用 import 包名.类名 的格式。
需要了解的是如果一个类没有被定义在一个指定的包内，那么该类就被归纳到默认包(default package)中。
在某个包下面创建一个类的话，需要在这个类的开头加上表达式 package 包名，该表达式需要放置在程序的第一行，使用package关键字指定包名之后，包名也会成为类名的一部分，在不同包下使用该类的话，需要使用 import 包名.类名 的格式。
语法如下package test; //指定包名，表示该类在本包内
public class dome{
}
public class dome{
}
导入包（import）：在Java中，如果需要使用到其它包内的类的话，除了使用该类的绝对路径之外，我们还可以使用Java中 import 关键字来指定。例如，如果在其它包内也定义了一个Math，那么假如我们只想使用该Math类的话，那么我们可以使用import关键字进行导包。
使用import导包
语法如下：import com.mr.*;
import com.mr.Math
import com.mr.Math
使用import导入静态成员
语法如下：import static 静态成员
内部类：内部类顾名思义，就定义在一个类内部的类。
成员内部类：定义在一个类成员位置的内部类，称为成员内部类，在成员内部类中可以使用外部类的的任意成员变量与成员方法，即使该外部类成员变量被private所修饰。
语法如下：class OuterClass{
class innerClass{
}
}
class innerClass{
}
}
匿名内部类：匿名内部类本质是一个隐藏了名字的内部类。匿名类是只有在创建时才会编写类体的一种写法。
语法如下：new 继承/实现(){
//重写的方法
};
//重写的方法
};
匿名内部类在一对大括号 { } 的范围内是一个类，整体却是一个new出来的对象。
异常处理：
异常的抛出与捕捉
抛出异常：通常，为了保证程序有效的运行，需要对抛出的异常进行相应的处理
可以通过Integer类的parseInt()方法来实现，但如果该字符串不是数字形式，该方法会抛出异常，程序会在出现异常的位置终止
捕捉异常
try-catch语句块：用来捕捉和处理异常的
语法如下：
finally语句块：无论程序是否出现异常，都会执行finally语句
但是在以下四种情况不会执行finally语句块
1.在finally语句块中出现异常
2.在前面的代码块中使用了System.exit()退出程序
3.程序所在线程死亡
4.关闭cpu
1.在finally语句块中出现异常
2.在前面的代码块中使用了System.exit()退出程序
3.程序所在线程死亡
4.关闭cpu
java常见的异常类
自定义异常：用户只需要继承Exception类即可自定义异常类
大体可以分为以下几个步骤
1.创建自定义异常类
2.在方法中通过throw关键字抛出异常对象
3.如果在当前抛出异常的方法中处理异常，可以使用try-catch语句块捕获并处理，否则在方法的声明处通过throw关键字指明要抛出给方法调用者的异常，继续进行下一步操作
1.创建自定义异常类
2.在方法中通过throw关键字抛出异常对象
3.如果在当前抛出异常的方法中处理异常，可以使用try-catch语句块捕获并处理，否则在方法的声明处通过throw关键字指明要抛出给方法调用者的异常，继续进行下一步操作
在方法中抛出异常
使用throws关键字抛出异常：throws关键字通常被用于声明方法时，用来指定可能抛出的异常，多个异常可使用逗号分隔
使用throw关键字抛出异常：throw通常用于方法体中，并且抛出一个异常对象，程序在执行到throw语句立刻中断，它后面的语句不会执行
运行时异常
RuntimeException异常时程序运行中抛出的异常，java类库的每个包中都定义了异常类所有这些类都是Throwable类的子类，Throwable类派生了两个子类，分别是Exception类和Error类，Error类及其子类用来描述java运行系统中的内部错误以及资源耗尽的错误，这类错误比较严重，Exception类称为非致命性类，可以通过捕捉处理来使程序继续执行，Exception类又根据错误发生的原因分为 RuntimeException异常和除 RuntimeException异常之外的异常。
异常的使用原则
java异常强制用户考虑程序的强健性和安全性，异常处理不应用来控制程序的正常流程，其主要作用是捕获程序在运行时发生的异常并进行相应处理，编写代码处理某个方法可能出现异常时，可遵循以下几条原则
1.在当前方法声明中使用try-catch语句捕获异常
2.一个方法被覆盖时，覆盖它的方法必须抛出相同的异常或者异常的子类
3.如果父类抛出多个异常，则覆盖方法必须抛出那些异常的一个子类，不能抛出新异常
1.在当前方法声明中使用try-catch语句捕获异常
2.一个方法被覆盖时，覆盖它的方法必须抛出相同的异常或者异常的子类
3.如果父类抛出多个异常，则覆盖方法必须抛出那些异常的一个子类，不能抛出新异常
字符串
Sting类：单个字符使用char类型保存，而多个字符组成的文本就需要使用String类型来保存了，String类型最多可以保存2的32次方-1个字节（占用4Gb空间大小）
声明字符串：字符串必须要包含在一对双引号（""）之内
例如
"12,32","ABCD","你好"
可以通过以下语法来声明字符串变量
String str;
使用String声明变量s：
String s;
"12,32","ABCD","你好"
可以通过以下语法来声明字符串变量
String str;
使用String声明变量s：
String s;
创建字符串：在java中将字符串作为对象来处理，因此可以像创建其它类对象一样来创建字符串对象创建对象要使用类的构造方法，String类的常用构造方法如下
1.String(char a[])
该方法用一个字符数组a创建String对象，代码如下：
char a[] = {'g','o','o','d'};
String s = new String(a);
//上述代码等同于以下代码
String s = new String("good")；
该方法用一个字符数组a创建String对象，代码如下：
char a[] = {'g','o','o','d'};
String s = new String(a);
//上述代码等同于以下代码
String s = new String("good")；
2.String (char a[],int offset,int length)
该方法提取字符数组a中的一部分创建一个字符串对象。参数offset表示开始截取字符串的位置，length表示截取字符串的长度，代码如下：
char a[] = {'s','t','u','d','e','n','t'};
String s = new String(a,2,4);
//上述代码等同于以下代码
String s = new String("uden");
该方法提取字符数组a中的一部分创建一个字符串对象。参数offset表示开始截取字符串的位置，length表示截取字符串的长度，代码如下：
char a[] = {'s','t','u','d','e','n','t'};
String s = new String(a,2,4);
//上述代码等同于以下代码
String s = new String("uden");
3.String(char[] valie)
该构造方法可分配一个新的String对象，使其表示字符数组参数中所有的元素连接的结果，代码如下：
char a[] = {'s','t','u','d','e','n','t'};
String s = new String(a);
//上述代码等同于以下代码
String s = new String("student");
该构造方法可分配一个新的String对象，使其表示字符数组参数中所有的元素连接的结果，代码如下：
char a[] = {'s','t','u','d','e','n','t'};
String s = new String(a);
//上述代码等同于以下代码
String s = new String("student");
连接字符串：对于已经声明的字符串，也可以对其进行相应操作，连接字符串就是字符串操作中比较简单的一种，可对于多个字符串进行连接，也可以使字符串与其他数据类型进行连接
连接多个字符串：使用“+”运算符可实现多个字符串连接，“+”运算符可以连接多个Sting对象并产生一个新的String对象
连接其他数据类型：字符串也可以同其他数据类型相连接，如果将字符串同其他数据类型进行连接，会将其他数据类型直接转换为字符串
获取字符串信息：字符串作为对象，可通过相应方法获取字符串的有效信息 ，如获取某字符串的长度，每个索引位置的字符等
获取字符串长度：使用String类的length()方法可获取声明的字符串对象的长度。
语法如下：str.length();
获取字符串长度，代码如下：
String str = "We are students";
int size = str.length();
String str = "We are students";
int size = str.length();
上段代码是将字符串str的长度赋值给int型变量size，此时变量size的值为15，这表示length()方法返回的字符串的长度（包括字符串中的空格）。
字符串查找：String类提供了两种查找字符串的方法，即indexOf()与lastindxOf()方法。这两种方法都允许在字符串中搜索指定条件的字符或字符串。indexOf()方法返回的是搜索的字符或字符串首次出现的位置，lastIndexOf()方法返回的是搜索的字符或字符串最后一次的位置。
1.inexOf(String s)：该方法用于返回参数字符串s在指定字符串中首次出现的索引位置。当调用String类的indexOf()方法时，会从当前字符串的开始位置搜索s的位置。如果没有检索到字符串s，该方法的返回值是-1。
语法如下：str.indexOf(substr)
查找字符a在字符串str中的索引位置，代码如下:
String str = "We are students";
int size = str.indexOf("a");//变量size的值为3
String str = "We are students";
int size = str.indexOf("a");//变量size的值为3
2.lastlndexOf(String str)：该方法用于指定字符串最后一次出现的索引位置。当调用String类的lastlndexOf()方法时，会从当前字符串的开始位置检索参数字符串str，并将最后一次出现str的索引位置返回。如果没有检索到字符串str，该方法返回-1。
语法如下：str.lastlndexOf(substr)
获取指定索引位置的字符：使用charAt()方法可将指定索引处的字符返回
语法如下：str.charAt(int index)
字符串操作
获取字符串：通过String类的substring()方法可对字符串进行截取。substring()方法被两种不同的重载形式，来满足不同的需要。这些形式的共同点就是都利用字符串的下标进行截取，且应明确字符串下标是从0开始的。
1.substring(int beginlndex)
该方法返回的是从指定的索引位置开始截取直到该字符串结尾的子串。
该方法返回的是从指定的索引位置开始截取直到该字符串结尾的子串。
语法如下：str.substring(int beginlndex)
2.substring(int beginlndex,int endlndex)
该方法返回的是从字符串某一索引位置开始截取至某一索引位置结束的子串
该方法返回的是从字符串某一索引位置开始截取至某一索引位置结束的子串
语法如下：substring(int beginlndex,int endlndex)
去除空格：trim()方法返回字符串的副本，忽略前导空格和尾部空格。
语法如下：str.trim();
字符串替换：replace()方法可实现将指定的字符或字符串替换成新的字符或字符串。
语法如下：str.replace(charSequence target, CharSequence replacement)
判断字符串的开头与结尾：startsWith()方法与endsWith()方法分别用于判断字符串是否以指定的内容开始或结束。这两个方法的返回值都为boolean类型。
1.startsWith()方法
该方法用于判断当前字符串对象的前缀是否为参数指定的字符串。
该方法用于判断当前字符串对象的前缀是否为参数指定的字符串。
语法如下：str.startsWith(String prefix)
2.endsWith()方法
该方法用于判断当前字符串是否为给定的子字符串。
该方法用于判断当前字符串是否为给定的子字符串。
语法如下：str.endsWith(String suffix)
判断字符串是否相等：对字符串对象进行比较不能简单地使用比较运算符“==”，因为比较运算符比较的是两个字符串的地址是否相同。即使两个字符串的内容相同，两个对象的内存地址也是不同的，使用两个字符串的内容相同，两个对象的内存地址也是不同的，使用比较运算符仍然会返回false。使用比较运算符比较两个字符串
代码如下：
String tom = new String("l am a student");
String jerry = new String("l am a student");
boolean b = (tom == jerry);
String tom = new String("l am a student");
String jerry = new String("l am a student");
boolean b = (tom == jerry);
此时，布尔型变量b的值为false，因为字符串是对象，tom、jerry是引用。如图所示：
按字典顺序比较两个字符串：compareTo()方法为按字典顺序比较两个字符串，该比较基于字符串中各个字符的Unicode值，按字典顺序将String对象表示的字符序列与参数字符串所表示的字符序列进行比较。如果按字典顺序此String对象位于参数字符串之前，则比较结果为一个负整数；如果按字典顺序此String对象位于参数字符串之后，则比较结果为一个正整数；如果这两个字符串相等，则结果为0。
语法如下：str.compareTo(String otherstr)
字母大小写转换：String类的toLowerCase()方法可将字符串中的所有大小字母改写为小写字母，而toUpperCase()方法可将字符串中的所有小写字母改写为大写字母。
1.toLowerCase()方法
该方法将字符串中的所有大写字母转换为小写。如果字符串中没有应该被转换的字符，则将原字符串返回；否则将返回一个新的字符串，将原字符串中每个大写字母都转换成小写，字符串长度不变。
该方法将字符串中的所有大写字母转换为小写。如果字符串中没有应该被转换的字符，则将原字符串返回；否则将返回一个新的字符串，将原字符串中每个大写字母都转换成小写，字符串长度不变。
语法如下：str.toLowerCase()
2.toUpperCase()方法
该方法将字符串中所有的小写字母转换为大写。如果字符串中没有应该被转换的字符，则将原字符串返回；否则返回一个新字符串，将原字符串中每个小写字母都转换为大写，字符串长度不变
该方法将字符串中所有的小写字母转换为大写。如果字符串中没有应该被转换的字符，则将原字符串返回；否则返回一个新字符串，将原字符串中每个小写字母都转换为大写，字符串长度不变
语法如下：str.toUpperCase()
字符串分割：使用split()方法可以使字符串按指定的分割字符或字符串进行分割，并将分割后的结果存放在字符串数组中。split()方法提供了以下两种字符串分割形式。
1.split(String sign)
该方法可根据给定的分割符对字符串进行拆分。
该方法可根据给定的分割符对字符串进行拆分。
语法如下:str.split(String sign)
2.split(String sign,int limit)
该方法可根据给定的分割符对字符串进行拆分，并限定拆分的次数。
该方法可根据给定的分割符对字符串进行拆分，并限定拆分的次数。
语法如下:str.split(String sign,int limit)
格式化字符串：Sting 类的静态format()方法用于创建格式化的字符串。format()方法有两种重载形式。
1..format(String format,Object...args)
该方法使用指定的格式字符串和参数返回一个格式化字符串，格式化后的新字符串使用本地默认的语言环境。
该方法使用指定的格式字符串和参数返回一个格式化字符串，格式化后的新字符串使用本地默认的语言环境。
语法如下：str.format(String format,Object...args)
2.format(Local l,String format,Object...args)
该方法使用指定的语言环境、格式字符串和参数返回一个格式化字符串，格式化后的新字符串便用其指定的语言环境。
该方法使用指定的语言环境、格式字符串和参数返回一个格式化字符串，格式化后的新字符串便用其指定的语言环境。
语法如下:str.format(Local l,String format,Object...args)
日期和时间字符串格式化：在应用程序设计中，经常需要显示日期和时间。如果想输出满意的日期和时间格式，一般需要编写大量的代码、经过各种算法才能实现。formatI()方法通过给定的特殊转换符作为参数来实现对日期和时间的格式化。
1.日期格式化：例子，返回一个月中的天数，代码如下:
Date date = new Date();//创建 Date 对象
dateStrings=String.format(“%te”date) ; //通过format()方法对 date 进行格式化
上述代码中变量 s的值是当前日期中的天数，如今天是 15 号，则 s 的值为 15;%te 是转换符。常用的日期格式化转换符如图所示。
Date date = new Date();//创建 Date 对象
dateStrings=String.format(“%te”date) ; //通过format()方法对 date 进行格式化
上述代码中变量 s的值是当前日期中的天数，如今天是 15 号，则 s 的值为 15;%te 是转换符。常用的日期格式化转换符如图所示。
2.时间格式化：使用 format()方法不仅可以完成日期的格式化也可以实现时间的格式化。时间的格式化转换符要比日期的格式化转换符更多、更精确，它可以将时间格式化为时、分、秒、毫秒等。
3.格式化常见的日期时间组合：格式化日期与时间组合的转换符定义了各种日期时间组合式，其中常见的如图所示。
常规类型格式化：常规类型格式化可应用于任何参数类型，可通过表中的转换符来实现。
使用正则表达式：正则表达式通常被用于判断语句中，用来检查某一字符串是否满足某一格式。正则表达式是含有-些具有特殊意义字符的字符串，这些特殊字符称为正则表达式的元字符。例如，“\\d”表示数字0~9中的任何一个，“\d”就是元字符。正则表达式中的元字符及其意义如表中所示。
在正则表达式中，可以使用方括号括起若干个字符来表示一个元字符，该元字特可代表方括号中的任何一个字符。例如，reg ="[abc]4”，这样字符串 a4、b4、c4 都是和正则表达式匹配的字符串，方括号元字符还可以为其他格式。如：
1.[456]: 表 4、5、6之外的任何字符。
2.[a-r]: 代表 a~r中的任何一个字母。
3.[a-zA-Z]: 可表示任意一个英文字母。
4.[a-e[g-z]]: 代表a~e或 g~z中的任何一个字母(并运算)。
5.[a-o&&[def]]: 代表字母 d、e、f (交运算)。
6.[a-d&&[bc]]: 代表字母a、d (差运算)。
1.[456]: 表 4、5、6之外的任何字符。
2.[a-r]: 代表 a~r中的任何一个字母。
3.[a-zA-Z]: 可表示任意一个英文字母。
4.[a-e[g-z]]: 代表a~e或 g~z中的任何一个字母(并运算)。
5.[a-o&&[def]]: 代表字母 d、e、f (交运算)。
6.[a-d&&[bc]]: 代表字母a、d (差运算)。
字符串生成器：创建成功的字符串对象，其长度是固定的，内容不能被改变和编译。虽然使用“+”可以达到附加新字符或字符串的目的，但“+”会产生一个新的 String 实例，会在内存中创建新的字符串对象。如重复地对字符串进行修改，将极大地增加系统开销。而JDK 新增了可变的字符序列 StringBuilder类大大提高了频繁增加字符串的效率。
代码示例：
package Package10;
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("String 消耗时间:"+time);//将执行的时间输出
StringBuilder builder = new StringBuilder("");//创建字符串生成器
starTime = System.currentTimeMillis();//更新操作执行前的时间
for (int i= 0;i< 10000; i++){//利用 for 循环进行操作
builder.append(i);//循环追加字符
}
endTime = System.currentTimeMillis();//更新操作后的时间//将操作时间输出
time = endTime - starTime;//更新追加操作执行的时间
System.out.println("StringBuilder 消耗时间:"+ time);//将操作时间输出
}
}
package Package10;
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("String 消耗时间:"+time);//将执行的时间输出
StringBuilder builder = new StringBuilder("");//创建字符串生成器
starTime = System.currentTimeMillis();//更新操作执行前的时间
for (int i= 0;i< 10000; i++){//利用 for 循环进行操作
builder.append(i);//循环追加字符
}
endTime = System.currentTimeMillis();//更新操作后的时间//将操作时间输出
time = endTime - starTime;//更新追加操作执行的时间
System.out.println("StringBuilder 消耗时间:"+ time);//将操作时间输出
}
}
结果如下：
通过这一实例可以看出，两种操作执行的时间差距很大。如果在程序中频繁地附加字符串，建议使用 StringBuilder类新创建的 StringBuilder对象初始容量是16个字符,可以自行指定初始长度。如果附加的字符超过可容纳的长度，则StringBuilder 对象将自动增加长度以容纳被附加的字符。若要使用StringBuilder类最后输出字符串结果，可使用 toString()方法。利用 StringBuilder 类中的方法可动态地执行添加、删除和插入等字符串的编辑操作。该类的常用方法如下。
1.append()方法
该方法用于向字符串生成器中追加内容。通过该方法的多个重载形式，可实现接受任何类型的数据，如int、boolean、char、String、double 或者另一个字符串生成器等。
该方法用于向字符串生成器中追加内容。通过该方法的多个重载形式，可实现接受任何类型的数据，如int、boolean、char、String、double 或者另一个字符串生成器等。
语法如下:append(content)
2.insert(int offset, arg)方法
该方法用于向字符串生成器中的指定位置插入数据内容。通过该方法的不同重载形式，可实现向字符串生成器中插入int、float、char 和 boolean 等基本数据类型的数据或其他对象。
该方法用于向字符串生成器中的指定位置插入数据内容。通过该方法的不同重载形式，可实现向字符串生成器中插入int、float、char 和 boolean 等基本数据类型的数据或其他对象。
语法如下:insert(int offset arg)
3.delete(int start , int end)方法
移除此序列的子字符串中的字符。该子字符串从指定的 stat 处开始，一直到索引 end-1 处的字符如果不存在这种字符，则一直到序列尾部。如果 start 等于 end，则不发生任何更改。
移除此序列的子字符串中的字符。该子字符串从指定的 stat 处开始，一直到索引 end-1 处的字符如果不存在这种字符，则一直到序列尾部。如果 start 等于 end，则不发生任何更改。
语法如下:delete(int start , int end)
常用类库
包装类
Integer类
java.lang 包中的 Integer 类、Byte 类、Short 类和 Long 类，分别将基本数据类型 int、byte、short和 long 封装成一个类，由于这些类都是 Number 类的子类，区别就是封装不同的数据类型，其包含方法基本相同，所以本节以Integer 类为例讲解整数包装类。
nteger 类在对象中包装了一个基本数据类型 int 的值，该类的对象包含一个 int 类型的字段。此外该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，同时还提供了其他一些处理 int 类时非常有用的常量和方法。Integer 类的常用方法如表：
nteger 类在对象中包装了一个基本数据类型 int 的值，该类的对象包含一个 int 类型的字段。此外该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，同时还提供了其他一些处理 int 类时非常有用的常量和方法。Integer 类的常用方法如表：
Double类
Double类
和 Float类是对 double、float 基本类型的封装，它们都是Number 类的子类，都是对浮点数进行操作，所以常用方法基本相同，本节将对 Double 类进行讲解。对于 Float 类，可以参考 Double类的相关内容。
Double类在对象中包装一个基本类型为 double 的值，每个Double类的对象都包含一个double类的字段。此外，该类还提供多个方法，可以将 double类型转换为 String类型，将 String类型转换为 doubl类型，也提供了其他一些处理 double 类型时有用的常量和方法。Double类的常用方法如表：
和 Float类是对 double、float 基本类型的封装，它们都是Number 类的子类，都是对浮点数进行操作，所以常用方法基本相同，本节将对 Double 类进行讲解。对于 Float 类，可以参考 Double类的相关内容。
Double类在对象中包装一个基本类型为 double 的值，每个Double类的对象都包含一个double类的字段。此外，该类还提供多个方法，可以将 double类型转换为 String类型，将 String类型转换为 doubl类型，也提供了其他一些处理 double 类型时有用的常量和方法。Double类的常用方法如表：
Boolean类
Boolean类
Boolean 类将基本类型为 boolean 的值包装在一个对象中。一个 Boolean 类型的对象只包含一个类型为boolean 的字段。此外，此类还为 boolean 类型和 String 类型的相互转换提供了许多方法，并提供了处理 boolean 类型时非常有用的其他一些常量和方法。Boolean类的常用方法如表：
Boolean 类将基本类型为 boolean 的值包装在一个对象中。一个 Boolean 类型的对象只包含一个类型为boolean 的字段。此外，此类还为 boolean 类型和 String 类型的相互转换提供了许多方法，并提供了处理 boolean 类型时非常有用的其他一些常量和方法。Boolean类的常用方法如表：
Character类
Character类
Character 类在对象中包装一个基本类型为 char 的值,该类提供了多种方法,以确定字符的类别(小写字母、数字等)，并可以很方便地将字符从大写转换成小写，反之亦然。Character 类提供了很多方法来完成对字符的操作，常用的方法如表：
Character 类在对象中包装一个基本类型为 char 的值,该类提供了多种方法,以确定字符的类别(小写字母、数字等)，并可以很方便地将字符从大写转换成小写，反之亦然。Character 类提供了很多方法来完成对字符的操作，常用的方法如表：
Number类
Number类
前面介绍了 Java 中的包装类，对于数值型的包装类，它们有一个共同的父类-Number 类，该类是一个抽象类，它是 Byte、Integer、Short、Long、Float 和 Double 类的父类，其子类必须提供将表示的数值转换为 byteint、short、long、float 和 double 的方法。例如，doubleValue()方法返回双精度浮点值，floatValue0方法返回单精度浮点值，这些方法如表：
前面介绍了 Java 中的包装类，对于数值型的包装类，它们有一个共同的父类-Number 类，该类是一个抽象类，它是 Byte、Integer、Short、Long、Float 和 Double 类的父类，其子类必须提供将表示的数值转换为 byteint、short、long、float 和 double 的方法。例如，doubleValue()方法返回双精度浮点值，floatValue0方法返回单精度浮点值，这些方法如表：
数字处理
数字格式化
数字格式化在解决实际问题时应用非常普遍，如表示某超市的商品价格，需要保留两位有效数字数字格式化操作主要针对的是浮点型数据，包括 double 型和 foat 型数据。在 Java 中使用 java.textDecimalFormat格式化数字，本节将着重讲解DecimalFormat类。
在Java 中，没有格式化的数据遵循以下原则:
在Java 中，没有格式化的数据遵循以下原则:
1.如果数据绝对值大于0.001 并且小于10000000，使以常规小数形式表示
2.如果数据绝对值小于0.001或者大于10000000，使用科学记数法表示。
由于上述输出格式不能满足解决实际问题的要求，通常将结果格式化为指定形式后输出。
在 Java中，可以使用DecimalFormat类进行格式化操作
2.如果数据绝对值小于0.001或者大于10000000，使用科学记数法表示。
由于上述输出格式不能满足解决实际问题的要求，通常将结果格式化为指定形式后输出。
在 Java中，可以使用DecimalFormat类进行格式化操作
DecimalForat类是NumberFormat 的一个子类，用于格式化十进制数字。它可以将一些数字格式化为整数、浮点数、百分数等。通过使用该类可以为要输出的数字加上单位或控制数字的精度。一般情况下，可以在实例化 DecimalFormat 对象时传递数字格式，也可以通过 DecimalFormat 类中的applyPatten0方法来实现数字格式化。当格式化数字时，可在 DecimalFormat类中使用一些特殊字符构成一个格式化模板，使数字按照-定的特殊字符规则进行匹配。表中列举了格式化模板中的特殊字符及其所代表的含义。
代码示例：
import java.text.DecimalFormat;
public class DecimalFormatSimpleDemo {
static public void SimgleFormat(String pattern,double value) {
DecimalFormat myFormat = new DecimalFormat(pattern);//实例化DecimalMformat对象
String output = myFormat.format(value);//将数字进行格式化
System.out.println(value +""+ pattern +""+ output);
}
static public void UseApplyPatternMethodFormat(String pattern,double value) {
DecimalFormat myFormat = new DecimalFormat();//实例化DecimalFormat对象
myFormat.applyPattern(pattern);//调用applyPattern()方法设置格式化模板
System.out.println(value +""+ pattern +""+ myFormat.format(value));
}
public static void main(String[] args) {
SimgleFormat("###,###.###",123456.789);//调用静态SimgleFormat()方法
SimgleFormat("00000000.###kg",123456.789);//在数字后加上单位
//按照格式模板格式化数字，不存在的位以0显示
SimgleFormat("000000.000",123.78);
//调用静态UseApplyPatternMethodFormat()方法
UseApplyPatternMethodFormat("#.###%",0.789);//将数字转换为百分数形式
UseApplyPatternMethodFormat("###.##",123456.789);//将小数点后格式化为两位
UseApplyPatternMethodFormat("0.00\u2030",0.789);//将数字转换为千分数形式
}
}
import java.text.DecimalFormat;
public class DecimalFormatSimpleDemo {
static public void SimgleFormat(String pattern,double value) {
DecimalFormat myFormat = new DecimalFormat(pattern);//实例化DecimalMformat对象
String output = myFormat.format(value);//将数字进行格式化
System.out.println(value +""+ pattern +""+ output);
}
static public void UseApplyPatternMethodFormat(String pattern,double value) {
DecimalFormat myFormat = new DecimalFormat();//实例化DecimalFormat对象
myFormat.applyPattern(pattern);//调用applyPattern()方法设置格式化模板
System.out.println(value +""+ pattern +""+ myFormat.format(value));
}
public static void main(String[] args) {
SimgleFormat("###,###.###",123456.789);//调用静态SimgleFormat()方法
SimgleFormat("00000000.###kg",123456.789);//在数字后加上单位
//按照格式模板格式化数字，不存在的位以0显示
SimgleFormat("000000.000",123.78);
//调用静态UseApplyPatternMethodFormat()方法
UseApplyPatternMethodFormat("#.###%",0.789);//将数字转换为百分数形式
UseApplyPatternMethodFormat("###.##",123456.789);//将小数点后格式化为两位
UseApplyPatternMethodFormat("0.00\u2030",0.789);//将数字转换为千分数形式
}
}
结果如下：
Math类
这些方法都被定义为 static 形式，所以在程序中应用比较简便可以使用如下形式调用：
Math.数学方法
在Math 类中，除函数方法外还存在一些常用数学常量，如 PI、E等。这些数学常量作为Math类的成员变量出现，调用起来也很简单。可以使用如下形式调用：
Math.PI
Math.E
Math 类中的常用数学运算方法较多，大致可以将其分为四大类别，分别为三角函数方法，指数函数方法，取整函数方法，以及取最大值、最小值和绝对值函数方法。
Math.数学方法
在Math 类中，除函数方法外还存在一些常用数学常量，如 PI、E等。这些数学常量作为Math类的成员变量出现，调用起来也很简单。可以使用如下形式调用：
Math.PI
Math.E
Math 类中的常用数学运算方法较多，大致可以将其分为四大类别，分别为三角函数方法，指数函数方法，取整函数方法，以及取最大值、最小值和绝对值函数方法。
1.三角函数方法
Math 类中包含的三角函数方法如下:
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):将狐度转换为角度。
Math 类中包含的三角函数方法如下:
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):将狐度转换为角度。
2.指数函数方法
Math 类中与指数相关的函数方法如下：
public static double exp(double a):用于获取e的a次方。
public static double log(double a):用于取自然对数，即取Ina的值。
public static double log10(double a):用于取底数为10 的a的对数。
public static double sqrt(double a): 用于取a的平方根，其中a 的值不能为负值。
public static double cbrt(doublea):用于取a的立方根。
public static double pow(double a,double b): 用于取a的b 次方。
Math 类中与指数相关的函数方法如下：
public static double exp(double a):用于获取e的a次方。
public static double log(double a):用于取自然对数，即取Ina的值。
public static double log10(double a):用于取底数为10 的a的对数。
public static double sqrt(double a): 用于取a的平方根，其中a 的值不能为负值。
public static double cbrt(doublea):用于取a的立方根。
public static double pow(double a,double b): 用于取a的b 次方。
3.取整函数方法
在具体的问题中，取整操作使用也很普遍，所以 Java 在 Math 类中添加了数字取整方法。Math类中主要包括以下几种取整方法:
public static double ceil(double a): 返回大于等于参数的最小整数。
public static double floor(double a):返回小于等于参数的最大整数。
public static double rint(double a): 返回与参数最接近的整数，如果存在两个同样接近的整数V则结果取偶数。
public staticintround(float a):将参数加上0.5后返回与参数最近的整数。
public static longround(double a): 将参数加上0.5 后返与参数最近的整数，然后强制转换为长整型。
在具体的问题中，取整操作使用也很普遍，所以 Java 在 Math 类中添加了数字取整方法。Math类中主要包括以下几种取整方法:
public static double ceil(double a): 返回大于等于参数的最小整数。
public static double floor(double a):返回小于等于参数的最大整数。
public static double rint(double a): 返回与参数最接近的整数，如果存在两个同样接近的整数V则结果取偶数。
public staticintround(float a):将参数加上0.5后返回与参数最近的整数。
public static longround(double a): 将参数加上0.5 后返与参数最近的整数，然后强制转换为长整型。
4.取最大、最小值和绝对值函数方法
在程序中最常用的方法就是取最大值、最小值、绝对值等，Math 类中包括的操作方法如下:
public static double max(double adouble b): 取a与b之间的最大值。
public static int min(int aint b): 取a与b之间的最小值，参数为整型。
public static long min(long a,long b): 取a与b之间的最小值，参数为长整型。
public static float min(float a,floatb):取a与b之间的最小值，参数为单精度浮点型
public static double min(double a,double b):取a与b之间的最小值，参数为双精度浮点型。
public static intabs(int a):返回整参数的绝对值。
public static longabs(long a):返回长整型参数的绝对值。
public static float abs(float a): 返回单精度浮点型参数的绝对值。
public static double abs(double a): 返回双精度浮点型参数的绝对值。
在程序中最常用的方法就是取最大值、最小值、绝对值等，Math 类中包括的操作方法如下:
public static double max(double adouble b): 取a与b之间的最大值。
public static int min(int aint b): 取a与b之间的最小值，参数为整型。
public static long min(long a,long b): 取a与b之间的最小值，参数为长整型。
public static float min(float a,floatb):取a与b之间的最小值，参数为单精度浮点型
public static double min(double a,double b):取a与b之间的最小值，参数为双精度浮点型。
public static intabs(int a):返回整参数的绝对值。
public static longabs(long a):返回长整型参数的绝对值。
public static float abs(float a): 返回单精度浮点型参数的绝对值。
public static double abs(double a): 返回双精度浮点型参数的绝对值。
Random类：Random 类是JDK 中的随机数生成器类，可以通过实例化一个 Radom 对象创建一个随机数生器
语法如下：Random r = new Random();
以这种方式实例化对象时，Java 编译器将以系统当前时间作为随机数生成器的种子。因为每时刻的时间不可能相同，所以产生的随机数不同。但是如果运行速度太快，也会产生两个运行结果相同的随机数。
用户也可以在实例化 Random 类对象时，设置随机数生成器的种子。
用户也可以在实例化 Random 类对象时，设置随机数生成器的种子。
语法如下：Random r = new Random(seedValue);
在Random 类中，提供了获取各种数据类型随机数的方法，下面列举几个常用的方法：
public intnextInt():返回一个随机整数。
public int nextInt(int n): 返回大于等于0且小于n的随机整数。
public long nextLong0: 返回一个随机长整型值。
public boolean nextBoolean0: 返回一个随机布尔型值。
public float nextFloat0:返回一个随机单精度浮点型值。
日 public doublenextDouble0:返回一个随机双精度浮点型值。
public double nextGaussian():返回一个概率密度为高斯分布的双精度浮点型值。
public intnextInt():返回一个随机整数。
public int nextInt(int n): 返回大于等于0且小于n的随机整数。
public long nextLong0: 返回一个随机长整型值。
public boolean nextBoolean0: 返回一个随机布尔型值。
public float nextFloat0:返回一个随机单精度浮点型值。
日 public doublenextDouble0:返回一个随机双精度浮点型值。
public double nextGaussian():返回一个概率密度为高斯分布的双精度浮点型值。
BigIntrger类
例如，将2转换为 BigInteger 类型，可以使用以下语句进行初始化操作:
BigIntege twoInstance = new BigIntege(“2”);
BigIntege twoInstance = new BigIntege(“2”);
一旦创建了对象实例，就可以调用 Bielncger 类中的一些方法进行运算操作，包括基本的数学这算和位运算以及一些取相反数、取绝对值等操作。列举了 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(Biplntegcr val): 用数组返回余数和商，结果数组中第一个值为商，第二个值为余数。
public BigInteger pow(intexponent): 进行取参数的exponent 次方操作。
public BigInteger negate0: 取相反数。
public BigInteger shifLeft(intn):将数字左移n位，如果n为负数，做右移操作。
public BigInteger shiftRight(intn):将数字右移n位，如果n为负数，做左移操作。
public BigInteger and(BigInteger val): 做与操作。
口 public BigInteger or(BigInteger val):做或操作。
publicintcompareTo(BigInteger val):做数字比较操作。
public boolean equals(Object x):当参数x是BigInteger类型的数字并且数值与对象实例的数值相等时，返回true。
public BigInteger min(BigInteger val):返回较小的数值。
public BigInteger max(BigIntegerval):返回较大的数值。
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(Biplntegcr val): 用数组返回余数和商，结果数组中第一个值为商，第二个值为余数。
public BigInteger pow(intexponent): 进行取参数的exponent 次方操作。
public BigInteger negate0: 取相反数。
public BigInteger shifLeft(intn):将数字左移n位，如果n为负数，做右移操作。
public BigInteger shiftRight(intn):将数字右移n位，如果n为负数，做左移操作。
public BigInteger and(BigInteger val): 做与操作。
口 public BigInteger or(BigInteger val):做或操作。
publicintcompareTo(BigInteger val):做数字比较操作。
public boolean equals(Object x):当参数x是BigInteger类型的数字并且数值与对象实例的数值相等时，返回true。
public BigInteger min(BigInteger val):返回较小的数值。
public BigInteger max(BigIntegerval):返回较大的数值。
BigDecimal类
BigDecimal类和BigInteger类都能实现大数字的运算，不同的是 BigDecimal类加入了小数的概念般的foat 型和 double 型数据只可以用来做科学计算或工程计算，但由于在商业计算中要求数字精度比较高，所以要用到 BigDecimal类。BigDecimal类支持任何精度的定点数，可以用它来精确计算货币值。在BigDecimal类中，常用的两个构造方法如表:
BigDecimal类型的数字可以用来做超大的浮点数的运算，如加、减、乘、除等，但是在所有的运算中除法是最复杂的，因为在除不尽的情况下商小数点后的末位的处理是需要考虑的。BigDecimal类实现的加、减、乘、除的方法 下表：
在上述方法中，BigDecimal类中divide()方法有多种设置，用于返回商小数点后的末位的处理，这些模式的名称与含义下表：
System类
控制台输出字符：System 类提供了标准输入、标准输出和错误输出流，也就是说，System 类提供了3 个静态对象:in、out 和 err。本书中的代码多次使用了这些对象，最常见的就是 out 对象。在控制台输出字符事，验出的方法有两种：
1.不会自动换行的print()方法
print()方法语法如下：
System.out.print(“Hello”);
此方法输出“Hello”文字，输出完毕后，光标会停留在“Hello”文字末尾，不会自动换行。
print()方法语法如下：
System.out.print(“Hello”);
此方法输出“Hello”文字，输出完毕后，光标会停留在“Hello”文字末尾，不会自动换行。
2.可以自动换行的println()方法
printin0方法在print后面加上了“In”后缀(就是 line的简写)，语法如下：
System.out.println(“书籍是人类进步的阶梯!”);
此方法输出“书籍是人类进步的阶梯!”后会自动换行。光标停留在下一行的开头。
printin0方法在print后面加上了“In”后缀(就是 line的简写)，语法如下：
System.out.println(“书籍是人类进步的阶梯!”);
此方法输出“书籍是人类进步的阶梯!”后会自动换行。光标停留在下一行的开头。
计时：System.currentTimeMillis()方法可以获取1970年1月1日零点至今的毫秒数。虽然 Date日期也有类似的方法，但代码会比System 类多，所以System.currentTimeMillis()方法是为获取当前毫秒梦最常用的方法。因为该方法的返回值精确到毫秒，所以可以利用该方法来记录程序的运行时间。
Scanner类
使用Scanner类首先要引入该类，其语法如下：
import java.util.Scanner;
import java.util.Scanner;
Scanner类提供了下表中的几种常用的方法，通过这些方法可以获取控制台输入的不同类型的值。
使用Scanner类扫描控制台的代码如下：
Scanner sc = new Scanner(System.in);
Scanner sc = new Scanner(System.in);
时间和日期类
Date类：Date类用于表示日期时间，使用该类表示时间需要使用其构造方法创建对象，
其构造方法及其说明如下图：
使用Date类的第2种构造方法创建一个Date类的对象，代码如下：
long timeMillis = System.currentTimeMillis();
Date date = new Date(TimeMillis);
上述代码中的System类的currentTimeMillis()方法主要用于获取当前系统时间距标准时间的毫秒数。另外，这里需要注意的是，创建Date类对象时使用的是long型整数，而不是double型，这主要是因为double类型可能会损失精度。Date类的常用方法及其说明，图如下：
long timeMillis = System.currentTimeMillis();
Date date = new Date(TimeMillis);
上述代码中的System类的currentTimeMillis()方法主要用于获取当前系统时间距标准时间的毫秒数。另外，这里需要注意的是，创建Date类对象时使用的是long型整数，而不是double型，这主要是因为double类型可能会损失精度。Date类的常用方法及其说明，图如下：
日期时间格式化：DateFormat类是日期时间格式化子类的抽象类，可以按照指定的格式对日期或时间进行格式化，DateFormat类提供了很多类方法，以获得基于默认或给定语环境和多种格式化风格的默认日期时间formatter，
格式化风格主要包括SHORT、MEDIUM、LONG和FULL4种：
SHORT: 完全为数字，如11.13.42或3:30pm。
MEDIUM: 较长，如Jan 12,1343。
LONG: 更长，如January 12,1343或3:30:32pm。
FULL: 完全指定，如Tuesday、April 12、1952AD或3:30:42pm PST。
SHORT: 完全为数字，如11.13.42或3:30pm。
MEDIUM: 较长，如Jan 12,1343。
LONG: 更长，如January 12,1343或3:30:32pm。
FULL: 完全指定，如Tuesday、April 12、1952AD或3:30:42pm PST。
使用DateFormat类还可以自定义日期时间的格式。要格式化一个当前语言环境下的日期，首先需要创建DateFormat类的一个对象，由于它是抽象类，因此使用其静态方法getDateInstance()进行创建，语法如下：DateFormat of = DateFormat.getDateInstanse();
使用getDateInstance()方法获取的是所在国家或地区的标准日期格式。另外，DateFormat 类还提供了一些其他静态方法。例如，使用 getTimeInstance()方法可获取所在国家或地区的时间格式，使用getDateTimelnstance()方法可获取日期和时间格式。DateFormat 类的常用方法及其说明下表：
由于DateFormat类是一个抽象类，不能用new 创建实例对象。因此，除了使用getXXXInstance()方法创建其对象，还可以使用其子类，如 SimpleDateFormat 类，该类是一个以与语言环境相关的方式来格式化和分析日期的具体类，它允许进行格式化(日期一文本)、分析(文本一日期)和规范化。
SimpleDateFormat类提供了19个格式化字符，可以让开发者随意编写日期格式，这19个格式化字符下表：
SimpleDateFormat类提供了19个格式化字符，可以让开发者随意编写日期格式，这19个格式化字符下表：
通常表中的字符出现的数量会影响数字的格式。例如，yyyy 表示4 位年份，这样输入会显示202l:yy 表示两位，这样输入就会显示为 21; 只有一个y的话，会按照 yyyy 显示:如果超过4个一些常用的日期时间格式如表中所示。y，如yyyyyy，会在4位年份左侧补0，结果为02021。一些常用的日期时间格式下表：
Calendar类
Calendar 提供了一个类方法 getInstance()，以获得此类型的一个通用的对象。Calendar 类的getInstance()方法返回一个 Calendar 对象，其日历字段已由当前日期和时间初始化，其使用方法如下:Calendar rightNow = Calendar.getInstance();
Calendar 类提供的常用字段及其说明下表：
Calendar类提供的常用方法及其说明下表：
Runtime类
执行本地命令：本地命令指的是操作系统的命令。例如，在 Linux 系统下就表示shell命令，在 Windows 系统下表示 cmd 命令。
Runtime类提供exec0方法让Java 代码可以执行系统的命令，exec0方法有很多重载的形式，例如：
process esec(String command)
process esec(String cmdarray)
command:要执行的系统命令，字符串类型。
cmdarray:要执行的命令和相应的命令参数，字符串数组类型
process esec(String command)
process esec(String cmdarray)
command:要执行的系统命令，字符串类型。
cmdarray:要执行的命令和相应的命令参数，字符串数组类型
其实这两个重载方式很类似，如执行“javac hello.java”这行命令，使用第一种重载方式的代码如下：
Runtime.getRuntime().exec(“javac hello.java);
Runtime.getRuntime().exec(“javac hello.java);
使用第二种重载方式的代码如下:
String command[] = {“javac”,“hello.java”};
Runtime.getRuntime().exec(command);
String command[] = {“javac”,“hello.java”};
Runtime.getRuntime().exec(command);
查看内存：Runtime 类可以通过 freeMemory()方法查看当前Java 虚拟机可用内存的剩余量。如果程序能够实时监控内存剩余量，就可以尽量控制程序对内存的占用，从而避免出现“内存溢出”的情况。同样，也可以用来对测试程序性能，检验程序算法是否导致内存紧张。
收藏
收藏
0 条评论
下一页
