Java从入门到精通

Java是一种通过解释方式来执行的语言，是一种跨平台的程序设计语言，用Java语言编写的程序，可以运行在任何平台和设备上。

int型、byte型、short型、long型

单精度浮点类型（float)和双精度浮点类型（double)

char型

转义字符是一种特殊的字符变量它以”\“开头，后跟一个或多个字符。转义字符具有特定的含义，不同于字符原有的意义。

boolean型

标识符是用来标识类名、变量名、方法名、数组名、文件名的有效字符序列。                                                                                                                      Java语言规定标识符由任意顺序的字母、下画线（_）、美元符号（$）和数字组成，并且第一字符不能是数字，不能是Java中的关键字（保留字）。

关键字又称保留字，是Java语言中已经被赋予特定意义的一些单词，不可以把这些单词作为标识符来使用。

声明变量是告诉编译器这个变量的数据类型，在程序运行过程中，空间内的只是变化的，这个内存空间就称为变量，在声明变量时可以赋值，也可以直接赋给初值。

在程序运行过程中一直不会改变的量称为常量，也称为“final变量”。常量在整个程序中只能被赋值一次。
  在Java语言中声明一个常量，除了要指定数据类型，还需要通过final关键字进行限定。常量名通常是用大写字母，但这并不是必须的。
 当变量被final关键字修饰时，该变量就变成了常量，必须在定义时就设定它的初值，否则将会产生编译错误。

变量的有效范围是指程序代码能够访问该变量的区域，若超出该区域，则在编译时会出现错误。在程序中，一般会根据变量的“有效范围”将变量分为“成员变量”和“局部变量”。

赋值运算符以符号”=“表示，其功能是将右方操作数所含的值赋给左方的操作数。

使用赋值运算符同时为两个变量赋值：

Java中的算术运算符主要有+（加）、-（减）、*（乘）、/（除）、%（求余）。

使用算术运算符模拟计算器：

自增、自减运算符是单目运算符，符号在前，先运算后使用；符号在后，先使用后运算。

++a(--a)        //先使a的值加（减）1，再使用变量a

a++(a--)       //先使用变量a，再使a的值加（减）1

比较运算符属于二元运算符，用于程序中的变量之间、变量和自变量之间以及其他类型的信息之间的比较。

返回类型为布尔型的表达式，如比较运算，可以被组合在一起构成一个更复杂的表达式。这是通过逻辑运算符来实现的。逻辑运算符包括&（&&）（逻辑与）、||（逻辑或）、！（逻辑非）。逻辑与算符的操作元必须是boolean型数据。

&&、&：两者为真，结果才为真

||：只要有一者为真，结果才为真

！：非真即假，非假即真

位运算符除"按位与"和"按位或"运算符外，其他只能用于处理整数的操作数，包括byte、short、chair、int和long等数据类型。位运算是完全针对位方面的操作。

   ”按位与“运算：两者都为1，结果为1

   ”按位或“运算：只要有一者为1，结果为1

   ”按位取反“运算：0变1，1变0

   ”按位异或“运算：两者相同为0，不同为1

移位操作

Java中的位移运算有三种：

     1、<<:左移。（整体左移，空位补0，溢出去掉）

     2、>>：右移。（整体右移，整数补0，负数补1，溢出去掉）

     3、>>>:无符号右移。（整体右移，空位补0，溢出去掉）

三元运算符的使用格式：

条件式？值：值2

 三元运算符的运算规则为：若条件式的值为true，则整个表达式取值1，否则取2。例如：

boolean b=20<45?true:false;

运算符的优先级决定了表达式中运算执行的先后顺序，优先级由高到低的顺序依次是：增量和减量运算、算术运算、比较运算、逻辑运算、赋值运算

从低级类型向高级类型的转换，一定不会丢失数据，系统将自动执行，称为隐式类型转换。从低到高排列的顺序为byte<short<int<long<float<double。

从高级类型向低级类型的转换，有可能会丢失数据，称为显式类型转换（又称为强制类型转换）

“//”为单行注释标记，从符号“//”开始直到换行为止的所有内容均为注释而被编译器忽略。

”/**/“为多行注释标记，符号”/*“与”*/“之间的所有内容均为注释内容。注释中的内容可以换行。

”/***/“为文档注释记。符号”/**“与”*/“之间的内容均为文档注释内容。

if条件语句是一个重要的编程语句，用于告诉程序在某个条件成立的情况下执行某段语句，而在另一种情况下语句。

if....else if语句是条件语句中最常用的一种形式，它会针对某种条件有选择地做出处理。通常表现为“如果满足某种条件，就进行某种处理，否则就进行另一种处理”。

if....else if语句多分支语句用于针对某一事件的多种情况进行处理。通常表现为“如果满足某种条件，就进行某种处理，否则如果满足另一种条件则执行另一种处理”。

在编程中，一个常见的问题就是检测一个变量是否符合某个条件，如果不符合，在用另一个值来检测，以此类推。当然，这种问题使用if语句也可以完成。

while 语句也称条件判断语句 ，它的循环方式为利用一个条件来控制是否继续反复执行这个语句。

流程图：

do...while循环语句与while语句类似，他们之间的区别是while语句为先判断条件是否成立再执行循环体，而do...while循环语句先执行一次循环后，再判断条件是否成立。do...while循环语句“{}”中的程序段至少要被执行一次。

流程图：

for循环是Java程序设计中最有用的循环语句之一。一个for循环可以用来重复执行某条语句，知道某个条件得到满足。

流程图：

使用break语句可以跳出switch结构。在循环结构中，可用break语句跳出当前循环，从而终端当前循环。

continue语句是针对break语句的充分。continue不是立即跳出循环体，而是跳过本次循环，回到循环的条件测试部分，重新开始执行循环。

数组作为对象允许使用new关键字进行内存分配。在使用数组之前，必须首先定义数组变量所属的类型。

1、先声明，再用new关键字进行内存分配

声明一维数组两种方式：

数组元素类型  数组名字[];

数组元素类型[]  数组名字；

2、为数组分配内存同时设置初始值

数组元素的类型 数组名=new数组元素类型[数组元素的个数]{值1，值2...};

使用一维数组输出1~12月每个月份的天数，代码如下：

public class Hello{//创建类
 public static void main(String[] args) {//主方法
  int day[]=new int[] {31,28,31,30,31,30,31,31,30,31,30,31};//创建并初始化一维数组
  for(int i=0;i<12;i++)//利用for循环将信息输出
   System.out.println((i+1)+"月有"+day[i]+"天");//输出每月的天数
 }
} 

运行结果：

1、先声明，再用new关键字进行内存分配

数组元素的类型 数组名字[行数][列数];

数组元素的类型[行数][列数 数组名字；

2、为数组分配内存同时设置初始值

数组名=new 数组元素的类型[][]{{值1，值2...},{值1，值2...}}

遍历数组就是获取数组中的每个元素。通常遍历数组都是使用for循环来实现。
 使用foreach语句遍历二维数组，代码如下：
public class Hello{//创建类
 public static void main(String[] args) {//主方法
  int arr2[][]={{4,3},{1,2}};//定义二维数组
  System.out.println("数组中的元素：");//提示信息
  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+"、");//输出信息
    }
   }
  }
 }
运行结果：

数组中的元素定义完成后。可通过Arrays类的静态方法fill（）来对数组中的元素进行替换。该方法通过各种重载形式可完成对任意类型的数组元素的替换。

代码如下：
import java.util.Arrays;//导入java.util.Arrays类
public class part{//创建类
 public static void main(String[] args) {//主方法
  int arr[]=new int[5];//创建int型数组
  Arrays.fill(arr,8);//使用同一个值对数组进行填充
  for(int i=0;i<arr.length;i++) {//循环便利数组中的元素
   System.out.println("第"+i+"个元素是："+arr[i]);//将数组中的元素依次输出
  }
 }
  }
 运行结果：

通过Arrays类的静态方法sort（）可以实现对数的排序。sort（）方法提供了多种重载形式，可以对任意类型的数组进行升序排序。

代码如下：
import java.util.Arrays;//导入java.util.Arrays类
public class part{//创建类
    public static void main(String[] args) {//主方法
  int arr[]=new int[] {23,42,12,8};//声明数组
  Arrays.sort(arr);//将数组进行排序
  for(int i=0;i<arr.length;i++){//循环遍历排序后的数组
   System.out.println(arr[i]);//将排序后数组中的各个元素输出
 }
    }
 }
运行结果：

Arrays类的copyOf()方法与copyOfRange()方法可以实现对数组的复制。copyOf()方法是复制数组至指定长度，copyOfRange()方法则将指定数组的指定长度复制到一个新数组中。
复制数组元素：空位补0，溢出去掉
复制数组部分元素：前在后不在

Arrays类的binarySearch()方法，可使用二分法搜索指定数组，以获得指定对象。该方法返回要搜索要搜索的索引值。binarySearch()方法提供了多种重载形式，用于满足各种类型数组的查找需要。

查询数组元素：先排序在查询，前含后不含

冒泡排序的基本思想是对比相邻的元素值，如果满足条件就交换元素值，把较小的元素移动到数组前面，把较大的元素移动到数组后面（也就是交换两个元素的位置），这样较小的元素就像气泡一样从底部上升到顶部。

直接选择排序的基本思想是将指定排序位置元素与其他数组元素分别对比，如果满足条件就交换元素值。 
      注意这里与冒泡排序的区别，不是交换相邻元素，而是把满足条件的元素与指定的排序位置元素交换（如从最后一个元素开始排序），这样排序好的位置逐渐扩大，直至整个数组都变成已排序好的格式。

把数组最后一个元素与第一个元素替换，倒数第二个元素与第二个元素替换，以从类推 ，直接把所有数组元素反转替换。

对象是事物存在的实体，世间万物皆对象。对象分为两个部分，即静态部分与动态对象部分
静态部分：不能动的部分，称为“属性"
动态部分：对象可执行的动作，称为“行为”

类是统一事物的统称，如果将现实世界中的一事物抽象成对象，类就是这类对象的统称。 类是对象的设计图；类是封装对象的属性和行为的载体，具有相同属性和行为的一类实体被称为类。类对象的行为是以方法的形式定义的，对象的属性是以成员变量的形式定义的，所以类包括对象的属性和方法。

面向对象程序设计具有以下特点：封装性、继承性和多态性。
      封装是面向对象编程的核心思想。将对象的属性和行为封装起来，其载体就是类，类通常对客户隐藏其实现细节，这就是封装的思想。
      采用封装的思想保证了类内部数据结构的完整性，提高了程序的可维护性。

类与类之间同样具有关系，这种关系被称为关联。两个类之间的关系有很多种，继承是关联中的一种。设计软件时，使用继承思想可以缩短软件开发的周期，复用那些已经定义好的类可以提高系统性能，减少系统在使用过程中出现错误的概率。

将父类对象应用与子类的特征就是多态。

  在Java中，对象的属性也称为成员变量，成员变量可以是任意类型，整个类中均为成员变量作用范围。

public class part{//类
 private String name;//String类型的成员变量
 public String getName() {//name的Getter方法
  return name;
 }
 public void setName(String name) {//name的Setter方法
  this.name=name;//将参数值赋予类中的成员变量
 }
 }

在Java语言中，使用成员方法对应于类对象的行为。

Java中的权限修饰符主要包括public、protect、default、private,这些修饰符控制着对类和类的成员变量以及成员方法的访问。

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

可以将局部变量的有效范围称为变量的作用域，局部变量的有效范围从该变量的声明开始到该变量的结束为止。
      在相互不嵌套的作用域中可以同时声明两个名称和类型相同的局部变量，但在相互嵌套的区域中不可以这样声明。

this关键字用来表示本类当前的对象，当前对象不是某个new出来的实体对象，而是当前正在编辑的类。this关键字只能在本类中使用。

public void setName(String name) {//定义一个setName()方法
  this.name=name;//将参数值赋予类中的成员变量
 }
 }

对象可以认为是在一类事物中抽象出某一个特例，可以通过这个特例来处理这类事物出现的问题。在Java语言中，通过new操作符来创建对象。前文在讲解构造方法时介绍过，每实例一个对象就会自动调用一次构造用一次构造方法，实质上这个过程就是创建对象的过程。
      准确地说，可以在Java语言中使用new操作符调用构造方法创建对象。语法如下：

Test test=new Test();
Test test=new Test("a");

用户使用new操作对象符创建一个对象后，可以使用“对象.类成员”来获取对象的属性和行为。
描述狗的特征，代码如下：

public class People {  
 String name;//名字
 String color;//颜色
 String vioce;//叫声
 public People(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) {
  People d1=new People("毛毛","白色","汪汪汪");
  System.out.print(d1.name+"的颜色是"+d1.color);//访问对象的属性
  System.out.print("叫起来的声音：");
  d1.call();//访问对象的行为
  People d2=new People("灰灰","灰色","嗷呜~");
  System.out.print(d2.name+"的颜色是"+d2.color);
  System.out.print("叫起来的声音：");
  d2.call();
 }
}

运行结果：

真正的操作标识符实质上是一个引用。语法如下：
类名 对象的引用变量
b d1 =new b();
b是类名，d1是引用名，new b对象的实体；

      每个对象都有生命周期，当对象的生命周期结束时，分配给该对象的内存地址需要被回收。在其他语言中，需要用户手动回收废弃的对象。Java拥有一套完整的垃圾回收机制，用户不必担心废弃的对象占用内存，垃圾回收器会自动回收无用却占用内存的资源。
      但是垃圾回收器只能回收那些有new操作符创建的对象。某些不是对象不是通过new操作符在内存中获取存储空间的，这种对象无法被垃圾回收机制所识别。在Java中提供了一个finalize()方法。

getClass()方法
       getClass()方法是Object类定义的方法，它会返回对象执行时的Class实例，然后使用此实例调用getName()方法可以取得类的名称。      语法如下：
getClass().getname();
可以将getClass()方法与toString()方法联合使用。

toString()方法
      toString()方法的功能是将一个对象返回为字符串形式，它会返回一String实例。在实际的应用中通常重写toString（）方法，为对象提供一个特定的输出模式。当这个类转换为字符串或与字符串连接时，将自动调用重写的toString()方法。

equals()方法
      在Java语言中，有两种比较对象的方式，分别为”==“运算符与equals()方法。两者的区别在于：”==“比较的是两个对象引用内存地址是否相等，而equals()方法比较的是两个对象的实际内容。

子类转父类，即子类赋值给父类，用自动类型转换
Bird bird=new Pigeon();      //用向上转换，借助自动类型转换，将鸽子类转换为鸟类，告诉编译器：“某只鸽子是一只鸟”

父类转子类 ，即父类赋值给子类，用强制类型转换。语法如下：
子类类型  子类对象=（子类类型）父类对象；

final关键字可用于变量声明，一旦该变量被设定，就不可以在改变该变量的值。final关键字定义的变量必须在声明时对其进行赋值操作。final关键字还可以修饰对象引用。
用final修饰方法的不能被重写，否则会报错。

用final修饰变量不能被改变
      将方法定义为final类型，可以防止子类修改父类的定义与现实方式，同时定义为final的方法的执行效果要高于非final方法。

用final修饰类不能被继承
如果将某个设置为final类，则该类中所有方法都被隐藏式设置为final方法，但是final类中的成员变量可以被定义为final或非final形式。

有抽象方法的类一定是抽象类。
     父类有抽象方法，子类没有抽象方法，子类继承父类要重写父类的抽象方法。
抽象类的方法格式：
修饰符  abstract  class  类名{
}

接口是抽象类的延伸，接口的所有方法都是抽象方法，接口的所有方法都没有方法体。
接口的语法：
修饰符  interface  接口名{
}

Java语言每个类可以实现多个接口。
实现多个接口的语法：
修饰符 class  类名  implements  接口1，接口2...接口n{
}

编译器不会允许存在同名的类文件，解决这类问题的方法是将这两个类放置在不同的类包中。

进入Eclipse时复制文件储存路径，再打开文件管理器粘贴路径就可以之间进入Eclipse所保存文件的文件中。

类中定义包名的语法如下：                                                                                                                                                                                                           package  包名

      import关键字除导入包外，还可以导入静态成员。导入静态成员可以使编程更为方便，                                                                             使用import导入静态成员的语法如下：

import  static  静态成员

在一个类中使用内部类，可以在内部类中直接存取其所在类的私有成员变量。成员内部类的语法如下：
class OuterClass{                //外部类
       class InnerClass{           //内部类
}
}                                                                                                                                                                                                                                           成员内部类不止可以在外部类中使用，其他类中也可以使用。在其他类中创建内部类对象的语法非常特殊，语法如下：

外部类  outer=new   外部类（）；
外部类.内部类 inner=outer.new   内部类（）；

使用this关键字获取内部类与外部类的引用
如果在外部类中定义的成员变量与内部类的成员变量名称相同，可以使用this关键字。

匿名内部类是只在创建对象时才会编写类体的一种写法。匿名内部类的特点是“现用现写”，其语法如下：
new  父类/父接口（）{
子类实现的内容
}

在Java语言中，字符串必须包含在一对双引号（"  ")之内。例如：
"23.23"、"ABCDE"、"您好"

可以通过以下语法格式来声明字符串变量：
String str;
String:指定该变量为字符串类型
str：任意有效的标识符，表示字符串变量的名称

在Java3语言中，将字符串作为对象来处理，因此可以像创建其他类型对象一样来创建字符串对象。创建对象要使用类的构造方法。String类的常用构造方法如下：
1、String(char a[])
该方法用一个字符数组a创建对象。
2、String（char a[],int offset,int length)
该方法提取字符数组a中的一部分创建一个字符串对象。参数offset表示开始截取字符串的位置，length表示截取字符串的长度。
3、Strring(char[] value)
该构造方法可分配一个新的String对象，使其表示字符数组参数中所有元素连接的结果。

使用”+“运算符可实现连接多个字符串的功能。”+“运算符可以连接多个String对象并产生一个新的String对象。
先连接一副对联的上、下联，再分行输出在控制台上。代码如下：
public class Test1{//创建类
 public static void main(String args[]) {//主方法
  String s1=new String("春色绿千里");//声明String对象s1
  String s2=new String("马蹄香万家");//声明String对象s2
  String s=s1+"\n"+s2;//将对象s1、"\n"和对象s2连接并将结果赋值给s
  System.out.println(s);//将s输出
 }
}
运算结果：

字符串也可以同其他基本类型进行连接。如果将字符串同其他数据类型数据进行连接，会将其他数据类型的数据直接转换成字符串。

使用String类的length（）方法可获取声明的字符串对象的长度。语法如下：
str.length();

String类提供了两种查找字符串的方法，即indexOf()与lastIndexOf()方法。这两种方法都允许在字符串中搜索指定条件的字符或字符串。indexOf()方法返回的是搜索的字符或字符串首次出现的位置。
1、indexOf(String s)
      该方法用于返回参数字符串s在指定字符串中首次出现的索引位置。当调用String类的indexOf()方法时，会从当前字符串的开始位置搜索s的位置。
       //查找字符串里第一次出现该元素的位置str.indexOf("1")
int indexof=str.indexOf("1");
System.out.println(indexof);
2、lastIndexOf(String str)
      该方法用于返回指定字符串最后一次出现的索引位置。当调用String类的lastIndexOf()方法时，或从当前字符串的开始位置检索参数字符串str，并将最后一次出现str的索引位置返回。
       //查找字符串里最后一次出现该元素的位置str.lastIndexOf
int lastIndexOf=str.lastIndexOf("1");
System.out.println(lastIndexOf);

使用charAt()方法可将指定索引处的字符返回。
//获取指定索引号的字符
char charAt=str.charAt(3);
System.out.println(charAt);

1、substring(int beginIndex)
该方法返回的是从指定的索引位置开始截取直到该字符串结尾的子串。语法如上：
2、substring(int beginIndex,int endIndex)
该方法返回的是从字符串某一索引位置开始截取至某一索引位置结束的子串。语法如上：

trim()方法返回字符串的副本，忽略前导空格和尾部空格，语法如下：
str.trim()

replace()方法可实现将指定的字符或字符串替换成新的字符或字符串，语法如下：
str.replace(CharSequence target,CharSequence replacement)
target:要替换的字符或字符串
replacement:用于替换原来字符串的内容

将单词中的字母a替换为字母A，代码如下：
public class Test1{
 public static void main(String args[]) {
  String str="address";//定义字符串str
  String newstr=str.replace("a","A");//将str中“a”替换成"A"并返回新字符串newstr
  System.out.println(newstr);//将字符串newstr输出
 }
}
运行结果：

1、startsWith()方法
该方法用于判断当前字符串对象的前缀是否为参数指定的字符串。语法如下：
str.startsWith(String prefix)
 prefix：作为前缀的字符串

2、endsWith()方法
该方法用于判断当前字符串是否为以给定的字符串结束。语法如下：
str.endsWith(String suffix)
suffix：作为后缀的字符串

对字符对象进行不能简单地使用比较运算符“==”，因为比较运算符比较的是两个字符串的地址是否相同。即使两个字符串的内容相同，两个对象的内存地址也是不同的，使用比较运算符仍然会返回。
       要比较两个字符串内容是相同相等，应使用equals()方法和equalsIgnoreCase()方法 。
1、equals()方法
        如果两个字符串具有相同的字符和长度，则使用equals()方法进行比较时，返回true。否则false。语法如下：
str.equlas(String  otherstr)

2、equalsIgnoreCase()方法 
      使用equlas（）方法对字符串进行比较时是区分大小写的，而使用equalsIgnoreCase()方法是在忽略了大小写的情况下比较两个字符串是否相等，返回结果仍然为boolean类型。语法如下：
str.equalsIgnoreCase(String otherstr)

  compareTo()方法为按字典顺序比较两个字符串，该比较基于字符串中各个字符串的Unicode值，按照字典顺序将String对象表示的字符序列与参数字符串所表示的字符序列进行比较。语法如下：
str.compareTo(String otherstr)
判断字母b的位置。代码如下：
public class Test1{
 public static void main(String args[]) {
//用于比较的3个字符串
  String str=new String("b");
  String str2=new String("a");
  String str3=new String("c");
  System.out.println(str+"compareTo"+str2+":"+str.compareTo(str2));//将str与str2比较的结果输出
  System.out.println(str+"compareTo"+str3+":"+str.compareTo(str3));//将str与str2比较的结果输出
 }
}
运行结果：

      String类的toLowerCase()方法可将字符串中的所有大写字母改写为小写字母，而toUpperCase()方法可将字符串中的所有小写字母改为大写字母。
1、toLowerCase()方法
      如果字符串中没有应该被转换的字符，则将原字符串返回；否则将返回一个新的字符串，将原字符串中每个大写字母都转换成小写，字符串长度不变。语法如下：
str.toLower()
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) 
sign:分割字符串的分割符，也可以使用正则表达式 
limit:限制的分割次数

      String类的静态format()方法用于创建格式化的字符串。format()方法有两种 重载形式。
1、format(Sring format,Object...args)
该方法使用指定的格式字符串和参数返回一个格式化字符串，格式化后的新字符串使用本地默认的语言环境。语法如下：
str.format(Sring format,Object...args) 
2、format(Local,Sring format,Object...args)
该方法使用指定的语言环境、格式字符串和参数返回一个格式化字符串，格式化后的新字符串使用其指定的语言环境。语法如下：
str. format(Local I,Sring format,Object...args)

2、时间格式化
     使用format()方法不仅可以完成日期的格式化，也可以实现时间格式化。时间的格式化转换符要比日期的格式化转换符更多、更精确，它可以将时间格式化为时、分、秒、毫。

3、格式化常见的日期时间组合
按照格式输出当下的年、月、日。代码如下：
import java.util.Date;//导入java.util.Date类
public class Test1{
 public static void main(String args[]) {
  Date date=new Date();//创建Date对象date
  String time=String.format("%tc",date);//将date进行格式化
  String form=String.format("%tF",date);
  System.out.println("全部的时间信息是："+time);//将格式化后的日期时间输出
  System.out.println("年-月-日格式："+form);
 }
}
运行结果：

常规类型格式化可应用于任何参数类型，如图所示：

Java是一种面向对象语言，但在Java中不能定义基本数据类型的对象，为了能将基本数据类型视为对象进行处理，Java提出了包装类的概念，它主要是将基本数据类型封装在包装类中。包装类及其对应的基本数据类型如表所示：

包装类         对应基本数据类型  包装类   对应基本数据类型
Byte            byte                      Short        short
Integer       int                         Long         long
Float           float                     Double      double
Character   char                      Boolean     boolean

Integer类在对象中包装了一个基本数据类型int的值，该类的对象包含一个int类型的字段。此外，该类提供了多个方法，能在int类型和String类型之间相互转换，同时还提供了其他一些处理int类型时非常有用的常量和方法。

   Boolean类将基本类型为boolean的值包装在一个对象中。一个Boolean类型的对象只包含一个类型为boolean的字段。此外，此类还为boolean类型和String类型的相互转换提供了许多方法，并提供了处理boolean类型时非常有用的其他一些常量和方法。
Boolean类的常用方法。代码如下：
public class Test2{
 public static void main(String[] args) {
  Boolean b1=Boolean.valueOf("true");//创建Boolean对象
  Boolean b2=Boolean.valueOf("ok");
  System.out.println("b1:"+b1.booleanValue());
  System.out.println("b2:"+b2.booleanValue());
 }
}
运行结果：

Character类在对象中包装一个基本类型为char的值，该类提供了多种方法，以确定字符的类别（小写字母、数字），并可以很方便地将字符从大写转换成小写，反之亦然。
Character类的常用方法 。代码如下：
public class Test2{
 public static void main(String[] args) {
  Character mychar1=Character.valueOf('A');
  Character mychar2=Character.valueOf('a');
  if(Character.isUpperCase(mychar1)) {//判断是否为大写字母
   System.out.println(mychar1+"是大写字母");
   //转换为小写转换并输出
   System.out.println("装换为小写字母的结果："+Character.toLowerCase(mychar1));
  }
  if(Character.isLowerCase(mychar2)) {
   System.out.println(mychar2+"是小写字母");
   //转换为大写并输出
   System.out.println("装换为大写字母的结果："+Character.toUpperCase(mychar2));
 }
}
运行结果：

对于数值型的包装类，他们有一个共同的父类—— Number类，该类是一个抽象类，它是Byte、Integer、Short、Long、Float和Double类的父类，其子类必须提供将表示的数值转换为byte、int、short、long、float、和double的方法。

     数字格式化在解决实际问题时应用非常普遍，如表示某超市的商品价格，需要保留两位有效数字。数字格式化操作主要针对的是浮点型数据，包括double型和float型数据。在Java中使用java.text.DecimalFormat格式化数字。
 在Java中，没有格式化的数据遵循以下原则:
1、如果数据绝对值大于0.001并且小于10000000，使以常规小数形式表示。
2、如果数据绝对值小于0.001并且大于10000000，使用科学记数法表示。

Math类提供了众多数学函数方法，主要包括三角函数方法，指数函数方法，取整函数方法，取最大值，最小值，以及平均值函数方法。这些方法都被定义为static形式，所以在程序中应用比较简便。可以使用如下形式调用：
Math.数学方法

Random类时JDK中的随机数生成器类，可以通过实例化一个Random对象创建一个随机数生成器，语法如下：
Random r=new Random();

      BigInteger 类的数字范围较 Integer 类的数字范围要大得多。前文介绍过 Integer 类是 int 的包装类， int 的最大值为-1，如果要计算更大的数字，使用 Integer 类就无法实现了，所以 Java 中提 gInteger 类来处理更大的数字。BigInteger类支持任意精度的整数，也就是说，在运算中 BigInto类可以准确地表示任何大小的整数值而不会丢失信息。
      在BigInteger 类中封装了多种操作，除了基本的加、减、乘、除操作，还提供了绝对值、相反数、最大公约数以及判断是否为质数等操作。
使用 BigInteger 类，可以实例化一个 BigInteger 对象，并自动调用相应的构造函数。BigInteger 类具有很多构造函数，但最直接的一种方式是参数以字符串形式代表要处理的数字。
      例如，将2转换为BigInteger 类型，可以使用以下语句进行初始化操作:
BigInteger twolnstance= new BigInteger("2");

       BigDecimal类和BigInteger类都能实现大数字的运算，不同的是BigDecimal类加入了小鼠的概念。一般的float型和double型数据只可以用来做科学计算或工程计算，但由于在商业计算重要计算中要求数字精度比较高，所以要用到BigDecimal类。BigDecimal类支持任何精度的定点数，可以用来精度计算货币值。

System类提供了标准输入、标准输出和错误输出流，也就是说，System类提供了3个静态对象:n、out和err。本书中的代码多次使用了这些对象，最常见的就是 out 对象。

java输出换行的方法有以下两种：
System.out.print("\n");
System.out.println();

System.currentTimeMillis()方法可以获取自1970年1月1日零点至今的毫秒数。该方法的返回值精确到毫秒，所以可以利用该方法来记录程序的运行时间。
查看执行一万次字符串所有拼接所消耗的时间。代码如下：
public class Test2{
 public static void main(String[] args) {
  long start=System.currentTimeMillis();//程序开始记录时间
  String str=null;//创建null字符串
  for(int i=0;i<10000;i++) {//循环一万次
   str+=i;//字符串与循环变量拼接
   }
  long end=System.currentTimeMillis();//记录循环结束时间
  System.out.println("循环用时："+(end-start)+"毫秒");
  
  }
 }
运行结果：

Date类用来表示日期时间，使用该类表示时间需要使用其构造方法创建对象，

构造方法                 说明
Date()                    分配Date对象并初始化此对象，以表示分配它的时间(精确到毫秒)
Date(long date)     分配Date对象并初始化此对象，以表示自标准基准时间(即1970年1月1日00:00:00GMT)起经过指定毫秒数date后的时间                             
        System类的currentTimeMillis0方法主要用来获取当前系统时间距标准基准时间的毫秒数。另外，这里需要注意的是，创建 Date 对象时使用的是 long 型整数，而不是 double 型，这主要是因为double类型可能会损失精度。

             Date类的常用方法及其说明
方法                             说明
after(Date when)        测试当前日期是否在指定的日期之后
before(Date when)     测试当前日期是否在指定的日期之前
getTime()                    获得自1970年1月1日00:00:00GMT开始到现在所经过的毫秒数
setTime(long time)     设置当前Date对象所表示的日期时间值,该值用以表示1970年1月1日00:00:00GMT以后time毫秒的时间点

DateFormat 类是日期时间格式化子类的抽象类，可以按照指定的格式对日期或时间进行格式化DateFormat 类提供了很多类方法，以获得基于默认或给定语言环境和多种格式化风格的默认日期时间Formatter，格式化风格主要包括SHORT、MEDIUM、LONG和FULL4种。

                DateFormat类的常用方法及其说明
方法                                 说明
format(Date date)           将一个Date对象实例格式化为日期/时间字符串
getCalendar()                  获取与此日期/时间格式器关联的日历
getDatelnstance()           获取日期格式器，该格式器具有默认语言环境的默认格式化风格
getDateTimeInstance()   获取日期/时间格式器，该格式器具有默认语言环境的默认格式化风格
getInstance0)                  获取为日期和时间使用SHORT风格的默认日期/时间格式器
getTimeInstance()           获取时间格式器，该格式器具有默认语言环境的默认格式化风格
parse(String source)        将字符串解析成一个日期，并返回这个日期的Date对象                                                                                                                           
               常用时间格式  
日期时间                        对应的格式
2023/10/25                   yyyy/MM/dd
2023.10.25                    yyyy.MM.dd
2023-09-15                   yyyy-MM-dd
2023年10月24日           10时25分07秒  星期二 yyyy年MM月dd日 HH时mm分ss秒 EEE
下午5时                          ah时
今天已经过去了297天    今天已经过去了D天

本地命令指的是操作系统的命令。例如，在 Linux 系统下就表示 shell 命令，在 Windows 系统下就表示cmd命令。
      Runtime类提供exec0方法让Java代码可以执行系统的命令，exec0方法有很多重载的形式，例如:
Process exec(String command)
Process exec(Stringl cmdarray)
command:要执行的系统命令，字符串类型
ccmdarray:要执行的命令和相应的命令参数，字符串数组类型。

Runtime类可以通过 freeMemory0方法查看当前Java虚拟机可用内存的剩余量。如果程序能够实时监控内存剩余量，就可以尽量控制程序对内存的占用，从而避免出现“内存溢出”的情况。同样，也可以用来对测试程序性能，检验程序算法是否导致内存紧张。