Java从入门到精通

是整数类型的数据

浮点数常量就是在数学中用到的小数，分为float单精度浮点数和double双精度浮点数两种类型。其中，单精度浮点数后面以F或f结尾，而双精度浮点数则以D或d结尾。当然，在使用浮点数时也可以在结尾处不加任何的后缀，此时虚拟机会默认为double双精度浮点数。浮点数常量还可以通过指数形式来表示。

字符常量用于表示一个字符，一个字符常量要用一对英文半角格式的单引号引起来，它可以是英文字母、数字、标点符号、以及由转义序列来表示的特殊字符。

字符串常量用于表示一串连续的字符，一个字符串常量要用一对英文半角格式的双引号引起来。
一个字符串可以包含一个字符或多个字符，也可以不包含任何字符，即长度为0。

布尔常量及布尔型的两个值true和false，该常量用于区分一个事物的真与假。

标识符：用来标识类名、变量名、方法名、数组名、文件名的有效字符序列。

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

告诉编译器这个变量的数据类型。

在程序运行过程中一直不会改变的量，通常也被称为“final变量”。

在程序中，一般会根据变量的“有效范围”将变量分为“成员变量”和“局部变量”。

 赋值运算符的作用就是将常量、变量或表达式的值赋给某一个变量，表中列出了Java中的赋值运算符及用法。
 在赋值运算符的使用中，需要注意以下几个问题：
        (1) 在Java中可以通过一条赋值语句对多个变量进行赋值
              int.X，Y，z；
              X=Y=Z=5；//为三个变量同时赋值
              intx=y=z=5；//这样写是错误的
       （2）除了“=”，其它的都是特殊的赋值运算符，以“+=”为例，x += 3就相当于x=x+3，首先会进行加法运算x+3，再将运算结果赋值给变量x。-=、*=、/=、%=赋值运算符都可依此类推
        在为变量赋值时，当两种类型彼此不兼容，或者目标类型取值范在为变量赋值时围小于源类型时，需要进行强制类型转换。
        然而在使用+=、-=、*=、/=、%= 运算符进行赋值时，强制类型转换会自动完成，程序不需要做任何显式地声明。

算术运算符就是用来处理四则运算的符号，这是最简单、最常用的运算符号
算术运算符看上去比较简单，也很容易理解，但在实际使用时有很多需要注意的问题，具体如下:
        (1)在进行自增 (++) 和自减 (--) 的运算时，如果运算符放在操作数的前面则是先进行自增或自减运算，再进行其它运算。反之，如果运算符放在操作数的后面则是先进行其它运算再进行自增或自减运算。
        (2)在进行除法运算时，当除数和被除数都为整数时，得到的结果也是一个整数。如果除法运算有小数参与，得到的结果会是一个小数
        (3) 在进行取模(%) 运算时，运算结果的正负取决于被模数(%左边的数)的符号，与模数(%右边的数)的符号无关

++a（--a）//表示在使用变量a之前，先计算a的值

a++（a--）//表示在使用变量a之后，再计算a的值

比较运算符用于对两个数值或变量进行比较，其结果是一个布尔值，即true或false。
==           相等于
！=          不等于
<             小于
>             大于                                                                                                                                                                                                                  <=          小于等于                                                                                                                                                                                                            >=          大于等于
比较运算符在使用时需要注意一个问题，不能将比较运算符“==”误写成赋值运算符“=”。

&&，与
true&&ture==ture

ture&&false==false

false&&false==false

两者都为真，结果才是真

|，或
true||ture==true

true||false==ture

false||false==false

只要有一者为真就是真

！，非
!true==false

!false==ture

非真即假非假即真

&，按位与
两者都为1，结果才是1

|，按位或
只要有一者为1，结果就为1

~，按位取反
0变1，1变0

^，按位异或
两者相同即为0，不同即为1

移位操作
<<，左移
整体左移，空位补0，溢出去掉

>>，右移
整体右移，正数补0，负数补1，溢出去掉

>>>，无符号右移
整体右移，空位补0，溢出去掉

使用格式：条件式？值1：值2

运算规则：若条件式的值为true，则整个表达式取值1，否则取值2

在对一些复杂的表达式进行运算时，要明确表达式中所有运算符参与运算的先后顺序，我们把这种顺序称为运算符的优先级。

从低级类型向高级类型的转换，系统自动执行，且不会丢失数据

把高精度的变量的值赋给低精度的变量，又称强制类型转换，可能会丢失数据

Java中的注释有三种类型，具体如下：

        单行注释：通常用于对程序中的某一行代码进行解释，用符号“//”，“//”后面为被注释的内容。

        多行注释：顾名思义就是在注释中的内容可以为多行，它以符号“/*”开头，以符号“*/”结尾。

        文档注释：以“/**”开头，并在注释内容末尾以“*/”结束。

（1）Java中的程序代码可分为结构定义语句和功能执行语句。其中结构定义语句用于声明一个类或方法功能执行语句用于实现具体的功能，每条功能执行语句的最后都必须用分号（；）结束。
    （2） Java语言严格区分大小写。
    （3）虽然Java没有严格要求，用什么样的格式来编排程序代码，但是出于可读性的考虑，应该让自己编写的程序代码，整齐美观，层次清晰。
    （4） Java程序中一句连续的字符串不能分开在两行中书写。
               如果为了便于阅读，想将一个太长的字符串分在两行中书写，可以先将这个字符串分成两个字符串，然后用加号将这两个字符串连起来，在加号处断行。

if语句是指如果满足某种条件，就进行某种处理，其语法格式如下所示:

if  (条件语句）{

        代码块

}


上述语法格式中，判断条件是一个布尔值，当值为true时，才会执行{}中的语句。
if语句的执行流程如下图所示

if（表达式）{

                语句1

        }else{

                语句2

        }

if后面“（）”内的表达式必须是Boolean型的。

if（判断条件1）｛
执行语句1
｝else if（判断条件）｛
执行语句2 
｝
…
else if（判断条件n）｛
执行语句n
｝else｛
执行语句n+1
｝

Switch语句也是一种很常见的选择语句。和if条件语句不同，他只能针对某个表达式的值做出判断，从而决定执行哪一段代码。
        在Switch语句中，使用Switch关键词来描述一个表达式，使用case关键字来描述和表达式结果比较的目标值，当表达式的值和某个目标值匹配时，会执行对应case下的语句，Switch语句的基本语法结果如下所示：

switch (表达式){
case 目标值 1:
执行语句 1
break;
case 目标值 2:
执行语句 2
break;
…………
执行语句 n+1
break;
}
 注意:1、条件表达式的返回值类型必须是以下类型之一:int 、byte、 char、short 、string(如果传                   入其他值，程序会报错。)
          2、case子句中的值常量N必须是常量，而且所有case子句中的值应是不同的。 
          3、break语句用来在执行完一个case分支后，是程序跳出switch语句，即终止 switch语句的执行。
          4、在一些特殊情况下，多个不同的case值执行一组相同的操作，这时可以不用break
while以及do..while循环嵌套

while语句和if条件语句有点类似，都是根据条件判断来决定是否执行后面的代码，区别在于，while循环语句会反复的进行条件判断，只要条件成立，｛｝内的执行语句就会执行，直到条件不成立，while循环结束。 
         While循环语句的语法结构如下所示： 


 while(循环条件) {
        执行语句
        .......
}

do...while循环语句和while循环语句功能类似。其语句结构如下：


do {
        执行语句
        .........
} while(循环条件);

用在switch条件语句和循环语句中，它的作用是终止某个case并跳出switch结构。        break：跳出当前循环体

while（...）                           do                                                        for

{                                              {                                                        {

        ...                                              ...                                                        ...

        break;                                        break;                                                break;

        ...                                                ...                                                        ...

}                                                }while（...）;                                       }

用在循环语句中，它的作用是终止本次循环，执行下一次循环。可以立刻重新开始下一轮循环，而不在循环循环后面的语句。  continue:跳过本次循环

while（...）                           do                                                        for

{                                              {                                                        {

        ...                                              ...                                                        ...

        continue;                                  continue;                                              continue;

        ...                                                ...                                                        ...

}                                                }while（...）;                                       }

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

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

        声明一维数组有下列两种方式：

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

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

        数组元素类型决定了数组的数据类型，它可以是Java中任意的数据类型，包括简单类型和组合类型。

        声明一维数组：int arr[]

        声明数组后我们还不能立即访问它的任何元素，因为声明数组只是给出了数组名字和元素的数据类型，要想使用它还要为它分配内存空间。

        在位数组分配内存空间时必须指明数组的长度，格式如下：

        数组名字=new 数组元素的类型[数组元素的个数]

        数组名字：被连接到数组变量的名称。

        数组元素的个数：指定数组中变量的个数，即数组的长度。

        为数组分配内存：arr=new int[5]

        2. 声明的同时为数组分配内存

        数组元素的类型 数组名=new 数组元素的类型[数组元素的个数]；

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

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

        声明一维数组有下列两种方式：

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

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

        数组元素类型决定了数组的数据类型，它可以是Java中任意的数据类型，包括简单类型和组合类型。

        声明一维数组：int arr[]

        声明数组后我们还不能立即访问它的任何元素，因为声明数组只是给出了数组名字和元素的数据类型，要想使用它还要为它分配内存空间。

        在位数组分配内存空间时必须指明数组的长度，格式如下：

        数组名字=new 数组元素的类型[数组元素的个数]

        数组名字：被连接到数组变量的名称。

        数组元素的个数：指定数组中变量的个数，即数组的长度。

        为数组分配内存：arr=new int[5]

        2. 声明的同时为数组分配内存

        数组元素的类型 数组名=new 数组元素的类型[数组元素的个数]；

int arr[ ]=new int [ ]{1,2,3,5,25};

int arr[ ]={34,23,12,6};

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

多维数组可以简单地理解为在数组中的嵌套数组。在程序中比较常见的就是二维数组。
二维数组的定义方式:
方式一：int【】【】arr=new int【n】【m】
特点：元素固定
方式二：int【】【】arr=new int【n】【】
特点：可以让一维数组储存的元素是可变的
方式三：int【】【】arr=｛｛1，2｝，｛3，4，5，6｝，｛7，8，9｝｝；
直接把里面的所有元素的都附上
二维数组的访问同样也是通过索引去访问的

二维数组在初始化的时候可以分行进行初始化
int arr[2][3] = { { 1, 2, 3 }, { 4, 5, 6 } };

二维数组也可以进行放在一起进行初始化
int arr[2][3] = { 1, 2, 3, 4, 5, 6 };

二维数组在初始化的时候可以进行部分初始化
int arr[2][3] = { { 1 }, { 2 } };
这个初始化就和1， 0， 0， 2， 0， 0初始化一样（一般初始值为0）
int arr[2][3] = { 1, 2, 3 };
这个就是1， 2， 3， 0，0，0

二维数组的初始化可以省略第一维的数字，但是不能省略第二维的数字
int arr[][3] = { { 1 }, { 2 }};
这里可以看出也是用1， 0， 0， 2， 0， 0初始化
int arr[][3] = { 1 ,2 ,3, 4 };
这里用这种方式进行初始化的时候，一维的数字大小是由这个初始化数字的数量多少来取的，例如这个例子是4个数字那么就是4/3+1（如果有余数再加1）

/*
 * 随机点名器
 * */
 
import java.security.SecureRandom;
import java.util.Scanner;
public class Bhs {
 
   // 1、存储全班同学的姓名 创建一个存储多个同学的姓名的容器（数组）
   // 键盘录入每个同学的姓名，存储到数组容器中
   
 
 public static void addStudentName(String[]students) {
  //键盘录入多个同学姓名存储到容器中
  Scanner sc =new Scanner (System.in);
  for(int i=0;i<students.length;i++){
   System.out.println("存储第"+(i + 1)+"个姓名：");
   students[i]=sc.next();
  }
}
 // 2、总览全班同学姓名
  
 public static void printStudentName(String[]students) {
  //遍历数组，得到每个同学姓名
  for(int i=0;i<students.length;i++) {
   String name =students[i];
   System.out.println("第"+(i+1)+"个学生姓名："+name);
  }
 }
 // 3、随机点其中一人
  
 public static String randomStudentName(String[] studrents) {
  //根据数组产孤独，获取随机数
  int index =new SecureRandom().nextInt(studrents.length);
  //通过随机索引从数组中获取名字
  String name =studrents[index];
  return name;
 }
 
public static void main(String[]args) {
 System.out.println("-----随机点名器--------");
 String[] students=new String[3];
 addStudentName(students);
 printStudentName(students);
 String randomName=randomStudentName(students);
 System.out.println("被点到名字的同学是："+randomName);
 
}
}

操作数组时，经常需要依次访问数组中的每个元素，这种操作叫做数字的遍历。

索引思想，操作数组中的元素，赋值还是获取值，都是依赖索引  arr［0］
索引思想：操作数组。arr［0］赋值，获取
循环：循环的变量，从0开始，每次递增。

1.fall（int[] a，int value）                                                   import java.util.Arrays;//导入java.util.Arrays类
public class Job5 {//创建类
 public static void main(String[] args) {//主方法
  // TODO Auto-generated method stub
  int arr[]=new int[5];//创建int型数组
  Arrays.fill(arr, 8);//使用同一个值对数组进行填充
  for(int i=0;i<arr.length;i++) {//循环遍历数组中的元素
   System.out.println("第"+i+"个元素是:"+arr[i]);//将数组中的元素依次输出
  }
 }
}                                                                                          2.fall（int[] a，int fromlndex，int tplndex，int value）      import java.util.Arrays;//导入java.util.Arrays类
public class Job6 {//创建类
 public static void main(String[] args) {//主方法
  // TODO Auto-generated method stub
  int arr[]=new int[] {45,12,2,10};//定义并初始化int型数组arr
  Arrays.fill(arr,1,2, 8);//使用fill（）方法替换数组指定范围内的元素
  for(int i=0;i<arr.length;i++) {//循环遍历数组中的元素
   System.out.println("第"+i+"个元素是:"+arr[i]);//将数组中的元素依次输出
  }
 }
}
       

在操作数组时，经常需要对数组中的元素进行排序，其中冒泡排序是比较常见的一种算法。冒泡过程中，不断比较数组中相邻的两个元素，较小者向上浮，较大者往下沉，整个过程中水中气泡上升的原理相似。
从第1个元素开始，将相邻的两个元素依次比较，直到最后两个元素完成比较，如果第1个元素比后一个大，则交换位置。整个过程完成后，触组中最后一个元素就是最大值。（相邻的两个元素进行比较换位 ）（数组元素换位：临时变量）                                                                                                                  import java.util.Arrays;//导入java.util.Arrays类
public class Job9 {//创建类
 public static void main(String[] args) {//主方法
  // TODO Auto-generated method stub
  int arr[]=new int[] {23,42,12,8};//声明数组
  Arrays.sort(arr);//将数组进行排序
  for(int i=0;i<arr.length;i++) {//循环遍历排序后的数组
   System.out.println(arr[i]);//将排序后数组中的各个元素输出
  }
 }
}

1.copyOf（arr，int newlength）                                          import java.util.Arrays;//导入java.util.Arrays类
public class Job7 {//创建类
 public static void main(String[] args) {//主方法
  // TODO Auto-generated method stub
  int arr[]=new int[] {23,42,12};//定义数组
  int newarr[]=Arrays.copyOf(arr, 5);//复制数组arr
  for(int i=0;i<newarr.length;i++) {//循环遍历复制后的新数组
   System.out.println(newarr[i]);//将新数组输出
  }
 }
}

2. copyOfRange                                                                    import java.util.Arrays;//导入java.util.Arrays类
public class Job8 {//创建类
 public static void main(String[] args) {//主方法
  // TODO Auto-generated method stub
  int arr[]=new int[] {23,42,12,84,10};//定义数组
  int newarr[]=Arrays.copyOfRange(arr,0,3);//复制数组
  for(int i=0;i<newarr.length;i++) {//循环遍历复制后的新数组
   System.out.println(newarr[i]);//将新数组中的每个元素输出
  }
 }
}
                         

1.binarySearch（Object[] a，Object key）                                              import java.util.Arrays;//导入java.util.Arrays类
public class Job10 {//创建类
 public static void main(String[] args) {//主方法
  // TODO Auto-generated method stub
  int ia[]=new int[] {1,8,9,4,5};//定义int型数组ia
  Arrays.sort(ia);//将数组进行排序
  int index=Arrays.binarySearch(ia, 4);//查找数组ia中元素4的索引位置
  System.out.println("4的索引位置是:"+index);//将索引输出
 }
}  

2.binarySearch（Object[] a，int fromlndex，int tolndex，Object key）        import java.util.Arrays;//导入java.util.Arrays类
public class Job11 {//创建类
 public static void main(String[] args) {//主方法
  // TODO Auto-generated method stub
  String str[]=new String[] {"ab","cd","ef","yz"};//定义Sring型数组str
  Arrays.sort(str);//将数组进行排序
  int index=Arrays.binarySearch(str,0,2, "cd");//在指定范围内搜索元素"cd"的索引位置
  System.out.println("cd的索引位置是:"+index);//将索引输出
 }
}     

比较相邻的元素。如果第一个比第二个大，就交换他们两个。

            对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。

            针对所有的元素重复以上的步骤，除了最后一个，即需要进行length-1次。

            第一次是对n个数进行n-1次比较，进行到最后第n个的一个是最大的；

            第二次是对n-1个数进行n-2次比较，进行到最后第n-1个的一个是最大的；

            ......

            持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。                                                                    
public class BubbleSort {
 
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        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);//输出冒泡排序后的数组元素
    }
    private void showArray(int[] array) {
        // TODO Auto-generated method stub
        for(int i:array) {//遍历数组
            System.out.print(">"+i);//输出每个数组元素值
            
        }
        System.out.println();
    }
 
}

直接选择排序是一种简单的排序方法。它每次从待排序的记录序列中选取关键字最小的记录，把它同当前记录序列中的第一个记录交换位置。具体的作法是：

(1)开始时,待排序序列为R[0]…R[n-1],经过选择和交换后,R[0]中存放最小关的记录
(2)第二次待排序记录序列为R[1]…R[n-1],经过选择和交换后,R[1]为仅次于R[0]的具有次小关键字的记录;
(3)如此类推,经过n-1次选择和交换之后,R[0]…R[n-1]成为有序序列,即可实现排序

反转排序就是以相反的顺序把原有数组的内容重新排序。

反转排序的基本思想比较简单，其实现思路是把数组最后一个元素与第一个元素替换，倒数第二个元素与第二个元素替换，依此类推，直到把所有数组元素反转替换。

对象是事物存在的实体。
通常会将对象划分为两个部分，即静态部分与动态部分。

        封装对象的属性和行为的载体，是同一类事物的统称，具有相同特性和行为的一类事物实体被称为类。

        如果将现实世界中的一个事物抽象成对象，类就是这类对象的统称。类是构造对象时所依赖的规范，类是时间事物的抽象称呼，而对象则是这个事物对应的实体。

        类对象的行为是以方法的形式定义的，对象的属性是以成员变量的形式定义的，所以类包括对象的属性和方法。                            不能将一个事物描述成一类事物，如一只鸟不能称为鸟类。

        封装是面向对象编程的核心思想

        在面向对象程式设计方法中，封装是指一种将抽象性函式接口的实现细节部分包装、隐藏起来的方法。

        采用封装的思想保证了类内部数据结构的完整性，使用类的用户不能轻易的直接操作类的数据结构，只能执行类允许公开的数据，这样就避免了外部操作对内部数据的影响，提高了程序的可维护性。                     

继承性主要描述的是类与类之间的关系，通过继承，可以在无需重写编写原有类的情况下，对原有类的功能进行扩展。

继承不仅增强了代码的复用性、提高开发效率，而且也减少了代码的重复性，还为程序的维护补充提供了便利。

多态性指的是在程序中允许出现重名现象，它指在一个类中定义的属性和方法被其它类继承后，它们可以既有不同的数据类型或表现出不同的行为，这使得同一个属性和方法在不同的类中具有不同的语义。例如，当听到“Cut”这个单词时，理发师的行为是剪发，演员的行为表现是停止表演，不同的对象，所表现的行为是个一样的。

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

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语言中，使用成员方法对应于类对象的行为。

        定义成员方法的语法格式如下：

权限修饰符  返回值类型  方法名（参数类型  参数名）{

        ....                     //方法体

        return  返回值；

}

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

      如果在成员方法内定义一个变量，那么这个变量被称为局部变量。在实际上，方法中的形参也可以作为一个局部变量。

      局部变量是在方法被执行时创建，在方法执行结束时被销毁。局部变量在使用时必须进行赋值操作或被初始化，否者会出现编译错误 。

可以将局部变量的有效范围称为变量的作用域，局部变量的有效范围从该变量的声明开始到该变量的结束为止。

在相互不嵌套的作用域中，可以同时声明两个名称和类型相同的局部变量。

但是在相互嵌套的区域中不可以这样声明，如果将区域变量id在方法体的for循环中再次进行定义，编译器将会报错。

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

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

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

public Book getBook{
  return this;//返回Book类的本类对象
}

在Java中，对象是通过类创建出来的，因此，在程序设计时，最重要的就是类的设计。
        假设要在程序中描述一个学校所有学生信息，可以先设置一个学生类(Student)，在这个类中定义两个属性name、age分别表示学生的姓名和年龄，定一个方法introduce()表示学生做自我介绍。具体如下：

public class Student {
        String name;      //定义一个姓名属性

        int age;               //定义一个年龄属性

        public void introduce() {
                //方法中打印属性name和age的值

                System.out.println("大家好，我叫" + name+ ",我今年" + age + "岁!");

        }

}

用户使用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中，当一个对象成为垃圾后仍会占用内存空间，时间一长，就会导致内存空间不足。针对这种情况，Java中引入了垃圾回收机制。

      一个对象在称为垃圾后会暂时保存内存中，当这样的垃圾堆积到一定程度时，Java虚拟机会启动垃圾回收器将这些垃圾对象从内存中释放。

     某些对象不是通过new操作符在内存中获取存储空间的，这种对象无法被垃圾回收机制识别。在Java中，提供了一个finalizer()方法

1.getClass（）方法
         getClass（）方法是Object类定义的方法，它会返回对象执行时的Class实力，然后使用此实例调用getName（）方法可以取得类的名称。语法如下：

getClass（）.getname（）；

         可以将 getClass（）方法与toString（）方法联合使用。

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

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

子类对象赋值给父类引用
Animal a=new Dong（）；
自动类型转换

父类对象赋值给子类引用
Dog a=（Dog）new Animal（）；
强制类型转换

class Bird {}
class Pigeon extends Bird{}
public class Demo4 {
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  Bird bird = new Pigeon();//某只鸽子是一只鸟
  Pigeon pigeon = (Pigeon) bird;//某只鸟是一只鸽子（要进行强制类型转换）
 } 
}

final修饰变量——不能被改变（常量）

        final关键字用于变量声明，一旦该变量被设定，就不可以在改变该变量的值，final关键字定义的变量必须在声明时对其进行赋值操作

语法：Final double Pi=3.14；

可以防止子类修改父类的定义与现实方法，执行效率高于非final方法

语法：private final void test（）{

...//省略一些程序代码

}

        final修饰方法—— 不能被重写

使用final类可以使该类不被任何类继承，并且不允许其他人对这个类进行任何改动

语法：final 类名{}

        Final修饰类——不能 被继承

一般将父类定义为抽象类，需要使用这个父类进行继承与多态处理。
抽象方法

修饰符 abstract 返回参数 方法名（传入参数）；
注释：没有方法体，要用abstract来修饰

public abstract void methodName（）；
抽象类 有抽象方法的类一定是抽象类
修饰符 abstract class 类名{
}

         当父类为抽象类子类为普通类时，要继承父类必须重写父类中的所有方法，不然会报错，或者将子类改为抽象类

接口：所有方法都是抽象方法且没有方法体
         Java语言中每个类只能继承一个父类，但是每个类可以实现多个接口，所以出现了接口。

修饰符 interface 接口名{
}

        实现 implements

        Java语言每个类可以实现多个接口

修饰符 class 类名 implements 接口1，接口2，接口3，...{
}

        一个类继承一个父类的同时再实现一个接口：

修饰符 class 类名 extends 父类名 implements 接口名{

}

注释：先继承再实现

        一个接口可以继承另一个接口 ：

interface intf1{}

interface intf2 extends intf1{}//接口继承接口

如果一个抽象类中的所有方法都是抽象的，则可以将这个类用另外一中方式来定义，即接口 。接口是由常量和抽象方法组成的特殊类，时对抽象类的进一步抽象。
在定义接口时，需要使用interface关键词来声明，其语法格式如下：

[public] interface 接口名 [extends 接口1，接口2...]{
      [public] [static] [final] 数据类型 常量名 = 常量值；

      [public] [abstract] 返回值 抽象方法名(参数列表)；

} 

        在上面的语法中，一个接口可以有多个父接口，它们之间用逗号隔开。一个类只能有一个父类，而一个类可以实现多个接口。接口中的变量默认使用“public static final”来修饰，即全局常量；接口定义的方法默认“public abstract”来修饰，即抽象方法。如果接口声明为public，则接口中的变量和方法全部为public。
        由于接口中的方法都是抽象方法，因此不能通过实例化对象的方式来调用接口中的方法。此时需要定义一个类，并使用implements关键字实现接口中所有的方法。一个类可以在继承的同时实现多个接口，在implements子句中用逗号隔开。接口的实现类声明格式如下:

[修饰符] class <类名> [extends <超类名>] [implements <接口1> ,<接口2>,......]

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

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

2.随意点击一个文件，里面的src文件中的是Java文件，bin文件中是class文件

1.新建一个项目，然后右击src，选择new、Package。

2.弹出“新建Java包”New Java Package对话框，在“名称”Name文本框中输入的包名Package1，然后点击完成Finish.

3.在eclipse中创建类时，可以在新建立的包上右击选择新建new命令，作业新建的类就会保存在该包中。另外还可以在新建类时同时修改包名，就可以创建两个不同的包和类.

import关键字的语法如下：

import com.mr.*;        //导入com.mr包中的所有类

import com.mr.Math        //导入com.mr包中的Math类

        在使用import关键字时，可以指定类的完整描述，如果为了使用包中更多的类，可以在使用import关键字指定时在包指定后加上*，这表示可以在程序中使用该包中的所有类。

        import关键字除了导入包外，还可以导入静态成员，导入静态成员可以使编程更为方便。

package com.mr;
import static java.lang.Math.max;//导入静态成员方法
import static java.lang.System.out;//导入静态成员变量
public class Test3 {
 
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  out.println("1和4的较大值为："+max(1,4));//主方法中可以直接使用这些静态成员
 }
 
}

成员内部类的语法：

class OuterClass{        //外部类

        class InnerClass{        //内部类

        }

}

        在成员内部类中可以随意使用外部类的成员方法及成员变量，尽管这些类成员被修饰为private。

        内部类初始化方式与其他类的初始化方式相同，都是使用new关键字。

public class Car {//创建汽车类
 private String brand;//汽车品牌
 public Car(String brand) {//汽车类的构造方法，参数为汽车品牌
  this.brand = brand;//给汽车品牌赋值
 }
 class Engine{//发动机类（内部类）
  String model;//发动机型号
  public Engine(String model) {//发动机类的构造方法，参数为发动机型号
   this.model=model;//给发动机型号赋值
  }
  public void ignite() {//（发动机）点火方法
   System.out.println("发动机"+this.model+"点火");
  }
 }
 public void start() {//启动（汽车）方法
  System.out.println("启动"+this.brand);
 }
 public static void main(String[] args) {
  Car car=new Car("大众朗行");//创建汽车类对象，并为汽车品牌赋值
  car.start();//汽车类对象调用启动（汽车）方法
        //常见发动机类（内部类）对象，并为发动机型号赋值
  Car.Engine engine=car.new Engine("EA211");
  engine.ignite();//发动机类对象调用（发动机）点火方法
 }
}

成员内部类不止可以在外部类中使用，在其他类中也可以使用。在其他类中创建内部类对象的语法非常特殊，语法如下：

外部类 outer = new 外部类();

外部类.内部类 inner = outer.new 内部类();

匿名类是只在创建对象时才会编写类体的一种写法 。匿名类的特点是”现用现写“，其语法如下：

new 父类/父接口(){

        子类实现的内容

};

abstract class Dog{
 String Color;
 public abstract void move();
 public abstract void call();
}
public class Demo {
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  Dog maomao=new Dog() {
   public void move() {
    System.out.println("四条腿狂奔");
   }
   public void call() {
    System.out.println("嗷呜~");
   }
  };
  maomao.Color="灰色";
  maomao.move();
  maomao.call();
 }
}

使用匿名类时应该遵循以下原则：

1、匿名类不能写构造方法

2、匿名类不能定义静态的成员

3、如果匿名类创建的对象没有赋值给任何引用变量，会导致该对象用完一次就会被Java虚拟机销毁

异常抛出后，如果不做任何处理，程序就会被终止。例如，将一个字符串转换为整型。可以通过Integer类的 parseInt(方法来实现。但如果该字符串不是数字形式，parseInt)方法就会抛出异常，程序将在出现异常的位置终止，不再执行下面的语句。

Java语言的异常捕获结构有try、catch和finally3种部分组成。其中，try语句块存放的是可能发生异常的Java语句；catch语句块在try语句块之后，用来激发被捕获的异常；finally语句块是异常处理结构的最后执行部分，无论try语句块中的代码如何退出，都将执行finally语句块。语法如下：

try{
        //程序代码块

}

catch(Exceptiontype1 e){
        //对Exceptiontype1的处理

}

catch(Exceptiontype2 e){
        //对Exceptiontype2的处理

}

...

finally{
        //程序代码块

}

Java语言的异常捕获结构有try、catch和finally3种部分组成。其中，try语句块存放的是可能发生异常的Java语句；catch语句块在try语句块之后，用来激发被捕获的异常；finally语句块是异常处理结构的最后执行部分，无论try语句块中的代码如何退出，都将执行finally语句块。语法如下：

try{
        //程序代码块

}

catch(Exceptiontype1 e){
        //对Exceptiontype1的处理

}

catch(Exceptiontype2 e){
        //对Exceptiontype2的处理

}

...

finally{
        //程序代码块

}

其中在try代码块中编写可能发生异常的Java语句，catch代码块中编写针对异常进行处理的代码。当try代码块中的程序发生了异常，系统会将这个异常的信息封装成一个异常对象，并将这个对象传递给catch代码块。catch代码块需要一个参数指明它所能够接收的异常类型，这个参数的类型必须是Exception类或其子类。

//创建异常
public class MyException extends Exception{//创建自定义异常，继承Exception类
 public MyException(String message) {//构造方法
  super(message);//父类构造方法
 }
}

//使用异常
public class Tran {//创建类
 static int avg(int num1,int num2) throws MyException{//定义方法，抛出异常
  
  if (num1<0 ||num2<0) {                //判断方法中参数是否满足指定条件
   System.out.println("存在负数 ，无法计算");
   throw new MyException("存在负数 ，无法计算");//错误信息
  }
  if (num1>100 ||num2>100) {        //判断方法中参数是否满足指定条件
   System.out.println("大于一百 ，无法计算");//错误信息
  }
  return(num1+num2)/2;            //将参数的平均值返回
 }
 public static void main(String[] args) {    //主方法
  try {                //try语句块处理可能出现异常的代码
   int result=avg(-32,56);        //调用AVG（）方法
   System.out.println(result);    //将AVG（）方法的返回值输出
  }catch (MyException e) {    
   System.out.println(e);    //输出异常信息
  }
 }
 
}

从上述语法格式中可以看出，throws关键字需要写在方法声明的后面，throws后面需要声明方法中发生异常的类型，通常将这种做法称为方法声明抛出一个异常。

使用throws关键字将异常抛给上一级后，如果不想处理该异常，可以继续向上抛出，但最终要有能够处理该异常的代码。

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

"23.23"、"ABCDE"、"您好"

可以通过以下语法格式来声明字符串变量：

String str;

String:指定该变量为字符串类型

str：任意有效的标识符，表示字符串变量的名称

声明字符串变量s，代码如下：

String s;

在Java语言中，将字符串作为对象来处理，因此可以像创建其他类型对象一样来创建字符串对象。创建对象要使用类的构造方法。

1. String(char a[])
        该方法用一个字符数组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 中的一部分创建一个字符串对象。参数 ofset 表示开始截取字符串的位置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[] value)
该构造方法可分配一个新的 String 对象，使其表示字符数组参数中所有元素连接的结果。代码如下:

char a[]={'s','t','u','d','e','n','t'};

String s = new String(a);等价于   String s = new String("student");

使用”+“运算符可实现连接多个字符串的功能。”+“运算符可以连接多个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输出
 }
}

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

public class Test1{
 public static void main(String args[]) {
  int booktime=4;
  float practice=2.5f;
  //将字符串与整型、浮点型变量相连接，并将结果输出
  System.out.println("我每天花费"+booktime+"小时看书；"+practice+"小时上机练习");
 }
}

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

str.length();

其中，str为字符串对象。

获取字符串长度，代码如下：

String str = "We are students";

int size = str.length();

上段代码是将字符串 sr 的长度值给 in 型变量 size，此时变量 size 的值为 15，这表示 ngth方法返回的字符串的长度(包括字符串中的空格)。

String类提供了两种查找字符串的方法，即indexOf()与lastIndexOf()方法。这两种方法都允许在字符串中搜索指定条件的字符或字符串。indexOf()方法返回的是搜索的字符或字符串首次出现的位置。

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

indexOf(substr)

str：任意字符串对象
substr：要搜索的字符串
查找字符a 在字符串 str 中的索引位置，代码如下:

String str = "We are students";

int size = str.indexOf("a");        //变量 size 的值是3

        理解字符串的索引位置，要对字符串的下标有所了解。在 Java 语言中，String 对象是用数组表示的。字符串的下标是0~length0-1。

2. lastindexOf(String str)
该方法用于返回指定字符中最后一次出现的索引位置。当调用 Sting 类的 lastindexOf0方法时，会从当前字符串的开始位置检索参数字符串 ，并将最后一次出现。的聚引位置运回。如果没有检索到字符巾 str，该方法返回-1。语法如下：

str.lastIndexof(substr)

str：任意字符串对象
substr：要搜索的字符串

使用charAt()方法可将指定索引处的字符返回。

//获取指定索引号的字符

char charAt=str.charAt(3);

System.out.println(charAt);

通过String类的substring0方法可对字符串进行截取。substring0方法被两种不同的重载形式，来满足不同的需要。这些形式的共同点就是都利用字符串的下标进行截取，且应明确字符串下标是从0开始的。

1. substring(int beginlndex)
该方法返回的是从指定的索引位置开始截取直到该字符串结尾的子串。语法如下.:

str.substring(int beginlndex)

其中，beginIndex 指定从某一索引处开始截取字符串。

2. substring(int beginlndex,int endlndex)
该方法返回的是从字符串某一索引位置开始截取至某一索引位置结束的子串。语法如下:

substring(int beginindex, int endindex)

beginIndex:开始截取子字符串的索引位置。
endIndex:子字符串在整个字符串中的结束位置。

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

str.trim()

replace()方法可实现将指定的字符或字符串替换成新的字符或字符串，语法如下：

str.replace(CharSequence target,CharSequence replacement)

target:要替换的字符或字符串

replacement:用于替换原来字符串的内容

startsWit()方法与endsWith()方法分别用于判断字符串是否以指定的内容开始或结束。这两个方法的返回值都为 boolean类型。

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

str.startsWith(String prefix)

 prefix：作为前缀的字符串

2. endWith()方法
该方法用于判断当前字符串是否为以给定的字符串结束。语法如下：

str.endsWith(String suffix)

suffix：作为后缀的字符串

对字符对象进行不能简单地使用比较运算符“==”，因为比较运算符比较的是两个字符串的地址是否相同。即使两个字符串的内容相同，两个对象的内存地址也是不同的，使用比较运算符仍然会返回。

        要比较两个字符串内容是相同相等，应使用equals()方法和equalsIgnoreCase()方法 。

1. equals()方法
        如果两个字符串具有相同的字符和长度，则使用equals()方法进行比较时，返回true。否则false。语法如下：

str.equlas(String  otherstr)

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

compareTo()方法为按字典顺序比较两个字符串，该比较基于字符串中各个字符串的Unicode值，按照字典顺序将String对象表示的字符序列与参数字符串所表示的字符序列进行比较。语法如下：

str.compareTo(String otherstr)

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:限制的分割次数

在应用程序设计中，经常需要显示日期和时间。如果想输出满意的日期和时间格式化，一般需要编写大量的代码、经过各种算法才能实现。format()方法通过给定的特殊转换符作为参数来实现对日期和时间的格式化。

1. 日期格式化
先来看一个例子。返回一个月中的天数，代码如下：

Date date=new Date();//创建Date对象date

Stirng s=String.format("%te",date);//通过format()方法date进行格式化

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

格式化时间的转换符如图所示

3. 格式化常见的日期时间组合
格式化日期与时间组合的转换符定义了各种日期时间组合的格式，其中最常见的如图所示

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

public class Test2{
 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 j=0;j<10000;j++) {//利用for循环进行操作
   builder.append(j);//循环追加字符
  }
  endTime=System.currentTimeMillis();//更新操作后的时间
  time=endTime-starTime;//更新追加操作执行时间
  System.out.println("StringBuilder消耗时间："+time);//将操作时间输出
  }
 }

Integer类

Double类

Boolean类

Character类

Number类

数字格式化

Math类

Random类

BigInteger类

BigDecimal类

控制台输出字符

计时

Date 类用于表示日期时间，使用该类表示时间需要使用其构造方法创建对象，其构造方法及其说明如表所示。

例如，使用 Date 类的第 2种构造方法创建一个 Date 类的对象，代码如下:

long timeMillis = System.currentTimeMillis();        //当前系统时间所经历的毫秒数

Date date = new Date(timeMillis);

Date 类的常用方法及其说明如表 所示。

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

SHORT:完全为数字，如 12.13.2或3:30pm。
MEDIUM:较长，如 Jan 12,1952。
LONG:更长，如January 12,1952 或3:30:32pm。
FULL:完全指定，如 Tuesday、April 12、1952AD 或3:30:42pm PST。


        另外，使用 DateFormat 类还可以自定义日期时间的格式。要格式化一个当前语言环境下的日期,首先需要创建 DateFormat 类的一个对象，由于它是抽象类，因此可以使用其静态方getDateInstance()进行创建，语法如下:

DateFormat df = DateFormat.getDatelnstance();

使用 getDateInstance()方法获取的是所在国家或地区的标准日期格式。另外，DateFormat 类还提供了一些其他静态方法。例如，使用 getTimeInstance()方法可获取所在国家或地区的时间格式，使用getDateTimeInstance()方法可获取日期和时间格式。DateFormat 类的常用方法及其说明如表 所示:

例如，将当前日期按照DateFormat类默认格式输出:

DateFormat df = DateFormat.getlnstance();

System.out.println(df.format(new Date()));

结果如下：

2021/2/19上午9:59

输出长类型格式的当前时间:

DateFormat df = DateFormat.getTimelnstance(DateFormat.LONG);

System.out.println(df.format(new Date()));

结果如下：

CST 上午10:00:33

输出长类型格式的当前日期:

DateFormat df = DateFormat.getDatelnstance(DateFormat.LONG);

System.out.println(df.format(new Date()));

结果如下：

2021年2月19日

输出长类型格式的当前日期和时间:

DateFormat df = DateFormatgetDate Timelnstance(DateFormat.LONG,DateFormat.LONG);

System.out.println(df.format(new Date()));

结果如下：

2021年2月19日CST 上午10:01:12

SimpleDateFormat 类提供了 19 个格式化字符，可以让开发者随意编写日期格式，这19 个格式化字符如表 所示：

通常上一表中的字符出现的数量会影响数字的格式。例如，yyyy 表示 4 位年份，这样输入会示2021;yy 表示两位，这样输入就会显示为21;只有一个y的话，会按照 yyyy 显示;如果超过4个y，如yyyyyy，会在4位年份左侧补0，结果为02021。一些常用的日期时间格式如下表：

DateFormat 类提供的 Date parse(String source)方法可以将字符串转为其字面日期对应的 Date对象，整个过程相当于日期格式化的逆操作。

例如，将“2021-02-19”这个字符串转成 Date 对象，可以使用如下代码:

DateFormat sdf = new SimpleDateFormat("yyyy-MM-dd);.

Date date = sdf.parse("2021-02-19");

Calendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY OF_MONTH、HOUR等日历字段之间的转换提供了一些方法，并为操作日历字段(如获得下星期的日期)提供了一些方法。另外，该类还为实现包范围外的具体日历系统提供了其他字段和方法，这些字段和方法被定义为 protected。

        Calendar 提供了一个类方法 getInstance()，以获得此类型的一个通用的对象。Calendar 类的getInstance()方法返回一个 Calendar 对象，其日历字段已由当前日期和时间初始化，其使用方法如下:

Calendar rightNow = Calendar.getlnstance();

Calendar 类提供的常用字段及其说明如表所示:

Calendar 类提供的常用方法及其说明如表所示:

最后对 Calendar 类的使用做出几点总结:

c.set(CalendarDAY_OF_MONTH,0)获取的是上个月的最后一天，所以调用前需要将月份往后加一个月。
 Calendar.MONTH的第一个月是使用0记录的，所以在获得月份数字后要加1。年和日是从1开始记录的，不需要加 1。
Calendar.DAY OF WEEK 的第一天是周日，周一是第二天，周六是最后一天。

执行本地命令

查看内存