今天開始復習之后的內(nèi)容，復習到哪兒，算哪兒了，大致就是數(shù)組、java類和對象那一塊了。

Java 數(shù)組

什么是數(shù)組？

數(shù)組是有序的元素序列。
若將有限個類型相同的變量的集合命名，那么這個名稱為數(shù)組名。組成數(shù)組的各個變量稱為數(shù)組的分量，也稱為數(shù)組的元素，有時也稱為下標變量。
數(shù)組是用于儲存多個相同類型數(shù)據(jù)的集合。
在 編程語言中數(shù)組是重要的數(shù)據(jù)結(jié)構(gòu)之一。

數(shù)組的特點：

1、數(shù)組是相同數(shù)據(jù)類型元素的集合。
2、數(shù)組中的各元素的存儲是有先后順序的，它們在內(nèi)存中按照這個先后順序連續(xù)存放在一起。
3、數(shù)組存放的數(shù)據(jù)類型可以是任何數(shù)據(jù)類型，包括基本數(shù)據(jù)類型、引用類型、數(shù)組（也就是數(shù)組中套數(shù)組，二維數(shù)組，三維數(shù)組等）
4、數(shù)組長度一旦創(chuàng)建就不能修改，只能存放固定長度的數(shù)據(jù)，如果超過這個長度會報數(shù)組下標越界的erro。
其實數(shù)組本身就是一個對象，java中對象是存放在堆中的，所以數(shù)組對象是存放在堆中的。

數(shù)組優(yōu)缺點：

優(yōu)點：
1、數(shù)組根據(jù)下標訪問元素的效率非?？臁?br> 2、可以表示一組數(shù)據(jù)。
缺點：
1、數(shù)組長度固定，不能自動擴容。
2、只能存放單一的數(shù)據(jù)類型。
3、數(shù)組根據(jù)內(nèi)容查找元素效率比較低。需要逐個比較。
4、插入元素和刪除元素的效率比較低，因為可能要移動大量的元素。

數(shù)據(jù)基本語法：

1、聲明數(shù)組：
dataType[] arrayRefVar; // 首選的方法
或
dataType arrayRefVar[]; // 效果相同，但不是首選方法

int[] myList;         // 首選的方法

int myList[];         //  效果相同，但不是首選方法

2、聲明并創(chuàng)建數(shù)組：
int[] mylist = new int[5]; // 創(chuàng)建數(shù)組并聲明數(shù)組的長度。
int[] myArray = {1,2,3,4,5}; // 創(chuàng)建數(shù)組并初始化數(shù)據(jù)。
上實例吧！

public class ArrayStudy {
    public static void main(String[] args) {

        int[] mylist = new int[5];    // 創(chuàng)建數(shù)組并聲明數(shù)組的長度。
        // 因為數(shù)組沒有相對應的 add()等方法，所以只能通過下標去對數(shù)組添加、修改、查詢數(shù)據(jù)。
        mylist[0] = 1;
        mylist[1] = 2;
        mylist[2] = 3;
        mylist[3] = 4;
        mylist[4] = 5;
        System.out.print("mylist[0] = " + mylist[0] + "\t");
        System.out.print("mylist[1] = " + mylist[1] + "\t");
        System.out.print("mylist[2] = " + mylist[2] + "\t");
        System.out.print("mylist[3] = " + mylist[3] + "\t");
        System.out.print("mylist[4] = " + mylist[4] + "\n");
        // 查看數(shù)組長度 用length屬性去查看
        System.out.println("mylist.length = " + mylist.length);
        // 修改數(shù)組中的數(shù)組，通過下標去修改
        mylist[2] = 8;
        System.out.println("mylist[2]修改后的值 = " + mylist[2] );

        System.out.println();

        int[] myArray = {1,2,3,4,5};
        System.out.print("myArray[0] = " +myArray[0] + "\t");
        System.out.print("myArray[1] = " +myArray[1] + "\t");
        System.out.print("myArray[2] = " +myArray[2] + "\t");
        System.out.print("myArray[3] = " +myArray[3] + "\t");
        System.out.print("myArray[4] = " +myArray[4] + "\n");
        // 查詢數(shù)組長度
        System.out.println("查看myArray數(shù)組長度 = " + myArray.length);

        // 因為通過下標一個一個的取，比較不方便，如果長度很大呢？所以用到循環(huán)也叫遍歷
        for (int i = 0; i<myArray.length;i++){  // 或者i<= myArray.length - 1
            System.out.print(myArray[i] + "\t");
        }
        System.out.println();

        // 增強for循環(huán),這種方便些直接取值
        for (int i :myArray) {
            System.out.print(i + "\t");
        }
        System.out.println();

        // 求數(shù)組中的和
        int sum = 0;
        for (int num :myArray){
            sum += num;
        }
        System.out.println("對數(shù)組中的數(shù)據(jù)求和：" + sum);

    }
}

xiabiaoyuejie.jpg

實際項目中用到的數(shù)組不是很多，面試的時候可能會問一些排序的問題，自己找時間練習下就好了，而且只有初級的工程師才會被問到吧！中級和高級問到的概率不是很大。有但是不多，主要的都是關注技術，能否適合公司的項目。

數(shù)組排序算法

Java中常用的數(shù)組排序算法，有冒泡排序、快速排序、選擇排序、插入排序、希爾算法、并歸排序算法、堆排序算法
1、冒泡排序
冒泡排序是一種簡單的排序算法。它重復地走訪過要排序的數(shù)列，一次比較兩個元素，如果他們的順序錯誤就把他們交換過來。走訪數(shù)列的工作是重復地進行直到?jīng)]有再需要交換，也就是說該數(shù)列已經(jīng)排序完成。這個算法的名字由來是因為越小的元素會經(jīng)由交換慢慢“浮”到數(shù)列的頂端，也就是輕泡上浮。

public class ArraySortStudy {
    public static void main(String[] args) {

        int temp;
        int[] arr = {8,5,9,6,1,3,4,2,7};
        for (int i =0;i< arr.length;i++){
            for (int j=0;j<arr.length-1-i;j++){
                if (arr[j] > arr[j + 1]){ // arr[0] = 8 ; arr[1] = 5; 8 > 5 true
                    temp = arr[j]; // temp = arr[0] 8 temp賦值 = 8；
                    arr[j] = arr[j + 1]; // arr[0] = arr[0+1] arr[1] 因為arr[0] 等于8 所以要后移，所以下標+1
                    arr[j + 1] = temp; // arr[0+1] = 8; 數(shù)字大的往后移了一個下標，把大的值賦給arr[j + 1]
                }
            }
        }

        for (int i :arr){
            System.out.print(i + "\t");
        }
        System.out.println();
    }
}

可以優(yōu)化，自己去優(yōu)化，可以寫個方法封裝下。

冒泡.gif

冒泡靜態(tài).png

2、選擇排序

public class ArraySortStudy {
    public static void main(String[] args) {

        int temp;
        int[] arr = {8,5,9,6,1,3,4,2,7};
        for (int i =0;i< arr.length;i++){
            for (int j=i+1;j<arr.length;j++){
                if (arr[i] > arr[j]){
                    temp = arr[j];  // temp = 5
                    arr[j] = arr[i]; // arr[j] = 8
                    arr[i] = temp; // arr[i] = 5
                }
            }
        }

        for (int i :arr){
            System.out.print(i + "\t");
        }
        System.out.println();
    }
}

其余的排序可以自行去練習。

多維數(shù)組

多維數(shù)組就是數(shù)組中嵌套數(shù)組。
語法：
type[][] typeName = new type[typeLength1][typeLength2];
例如：
String[][] str = new String[3][4];
int[][] a = new int[2][3];

String[][] s = new String[2][];
s[0] = new String[2];
s[1] = new String[3];
s[0][0] = new String("Good");
s[0][1] = new String("Luck");
s[1][0] = new String("to");
s[1][1] = new String("you");
s[1][2] = new String("!");

Arrays 類

java.util.Arrays 類能方便地操作數(shù)組，它提供的所有方法都是靜態(tài)的。
具有以下功能：
給數(shù)組賦值：通過 fill 方法。
對數(shù)組排序：通過 sort 方法,按升序。
比較數(shù)組：通過 equals 方法比較數(shù)組中元素值是否相等。
查找數(shù)組元素：通過 binarySearch 方法能對排序好的數(shù)組進行二分查找法操作。
通過 sort 方法,按升序：

        int[] brr = {8,5,9,6,1,3,4,2,7};
        Arrays.sort(brr);
        for (int b : brr){
            System.out.print(b + "\t");
        }
        System.out.println();

1   2   3   4   5   6   7   8   9   

Process finished with exit code 0

Java 對象和類

對象：對象是類的一個實例（對象不是找個女朋友），有狀態(tài)和行為。例如，一條狗是一個對象，它的狀態(tài)有：顏色、名字、品種；行為有：搖尾巴、叫、吃等。
類：類是一個模板，它描述一類對象的行為和狀態(tài)。
總體來說 類就是一類的統(tǒng)稱比如人，分中國人、外國人，男人、女人統(tǒng)稱，對象就比如具體的某個人，他有行為能力，比如跑步、吃飯等。

一個類中包含描述信息，和函數(shù)也叫方法，就是行為，能做什么，我們希望寫這個方法去做什么？是有動作的。
類：訪問關鍵字 class 類名{}
函數(shù)：訪問關鍵字 返回值類型 方法名稱(參數(shù)列表){} 需要在類中定義。
例如:

public class Person{
String p_name;
String p_age;

public static void main(String[] args){ // 程序入口，static靜態(tài)
  // 在主函數(shù)main函數(shù)中調(diào)用函數(shù)
  printName();
}

// 自定義函數(shù)
public static void printName(){
  System.out.println("張三李四王二麻子");
}
}

張三李四王二麻子

Process finished with exit code 0

一個類可以包含以下類型變量：
局部變量：在方法、構(gòu)造方法或者語句塊中定義的變量被稱為局部變量。變量聲明和初始化都是在方法中，方法結(jié)束后，變量就會自動銷毀。
成員變量：成員變量是定義在類中，方法體之外的變量。這種變量在創(chuàng)建對象的時候?qū)嵗?。成員變量可以被類中方法、構(gòu)造方法和特定類的語句塊訪問。
類變量：類變量也聲明在類中，方法體之外，但必須聲明為 static 類型。

一個類可以擁有多個方法，在上面的例子中可以加入：eat()、run()、sleep() 等方法。

public class Person {
    // 成員變量  類中的所有方法都可以使用
    String p_name;
    // 成員變量
    String p_age;
    // 這是類變量，也叫靜態(tài)變量，private是私有的
    private static String p_addr = "北京市";

    public static void main(String[] args){ // 程序入口，static靜態(tài)
        // 在主函數(shù)main函數(shù)中調(diào)用函數(shù)
        printName();
        eat();
        run();
        sleep();
    }

    // 自定義函數(shù)
    public static void printName(){
        // 靜態(tài)變量屬于類，直接用類.變量名 調(diào)用  Person.p_addr
        System.out.println("張三李四王二麻子" + "   地址：" + Person.p_addr);
    }

    public static void eat(){
        // 局部變量，方法執(zhí)行完，生命周期結(jié)束，會被回收
        String str = "外賣到了";
        System.out.println(str + "開始吃飯");

    }

    public static void run(){
        System.out.println("睡覺之前去跑幾公里");
    }

    public static void sleep(){
        System.out.println("跑步回來，洗完澡，開始睡覺");
    }


}

張三李四王二麻子   地址：北京市
外賣到了開始吃飯
睡覺之前去跑幾公里
跑步回來，洗完澡，開始睡覺

Process finished with exit code 0

構(gòu)造方法

每個類都有構(gòu)造方法。如果沒有顯式地為類定義構(gòu)造方法，Java 編譯器將會為該類提供一個默認構(gòu)造方法。
在創(chuàng)建一個對象的時候，至少要調(diào)用一個構(gòu)造方法。構(gòu)造方法的名稱必須與類同名，一個類可以有多個構(gòu)造方法。

public class Puppy{
    public Puppy(){
    }
 
    public Puppy(String name){
        // 這個構(gòu)造器僅有一個參數(shù)：name
    }
}

創(chuàng)建對象

對象是根據(jù)類創(chuàng)建的。在Java中，使用關鍵字 new 來創(chuàng)建一個新的對象。創(chuàng)建對象需要以下三步：
聲明：聲明一個對象，包括對象名稱和對象類型。
實例化：使用關鍵字 new 來創(chuàng)建一個對象。
初始化：使用 new 創(chuàng)建對象時，會調(diào)用構(gòu)造方法初始化對象。

public class Puppy{
   public Puppy(String name){
      //這個構(gòu)造器僅有一個參數(shù)：name
      System.out.println("小狗的名字是 : " + name ); 
   }
   public static void main(String[] args){
      // 下面的語句將創(chuàng)建一個Puppy對象
      Puppy myPuppy = new Puppy( "tommy" );
   }
}

訪問實例變量和方法

通過已創(chuàng)建的對象來訪問成員變量和成員方法:

/* 實例化對象 */
Object referenceVariable = new Constructor();
/* 訪問類中的變量 */
referenceVariable.variableName;
/* 訪問類中的方法 */
referenceVariable.methodName();

public class Person {
    // 成員變量  類中的所有方法都可以使用
    String p_name;
    // 成員變量
    String p_age;
    // 這是類變量，也叫靜態(tài)變量，private是私有的
    private static String p_addr = "北京市";

    // 自定義函數(shù)
    public static void printName(String name,String age){
        // 靜態(tài)變量屬于類，直接用類.變量名 調(diào)用  Person.p_addr
        System.out.println("姓名：" + name + " 年齡：" + age + "   地址：" + Person.p_addr);
    }

    public static void eat(){
        // 局部變量，方法執(zhí)行完，生命周期結(jié)束，會被回收
        String str = "外賣到了";
        System.out.println(str + "開始吃飯");

    }

    public static void run(){
        System.out.println("睡覺之前去跑幾公里");
    }

    public static void sleep(){
        System.out.println("跑步回來，洗完澡，開始睡覺");
    }


}

public class TestMain {
    public static void main(String[] args){ // 程序入口，static靜態(tài)
        // 創(chuàng)建對象
        Person person = new Person();
        // 為類中的屬性進行賦值
        person.p_age = "28";
        person.p_name = "張三";

        // 通過創(chuàng)建的對象調(diào)用類中的方法
        person.printName(person.p_age,person.p_name);
        person.eat();
        person.run();
        person.sleep();
    }
}

姓名：28 年齡：張三   地址：北京市
外賣到了開始吃飯
睡覺之前去跑幾公里
跑步回來，洗完澡，開始睡覺

Process finished with exit code 0

• 一個源文件中只能有一個 public 類
• 一個源文件可以有多個非 public 類
• 源文件的名稱應該和 public 類的類名保持一致。例如：源文件中 public 類的類名是 Employee，那么源文件應該命名為Employee.java。
• 如果一個類定義在某個包中，那么 package 語句應該在源文件的首行。
• 如果源文件包含 import 語句，那么應該放在 package 語句和類定義之間。如果沒有 package 語句，那么 import 語句應該在源文件中最前面。
• import 語句和 package 語句對源文件中定義的所有類都有效。在同一源文件中，不能給不同的類不同的包聲明。

類有若干種訪問級別，并且類也分不同的類型：抽象類和 final 類等。這些將在訪問控制章節(jié)介紹。

除了上面提到的幾種類型，Java 還有一些特殊的類，如：內(nèi)部類、匿名類。

Java 包

包主要用來對類和接口進行分類。當開發(fā) Java 程序時，可能編寫成百上千的類，因此很有必要對類和接口進行分類。

import 語句

在 Java 中，如果給出一個完整的限定名，包括包名、類名，那么 Java 編譯器就可以很容易地定位到源代碼或者類。import 語句就是用來提供一個合理的路徑，使得編譯器可以找到某個類。
例如，下面的命令行將會命令編譯器載入 java_installation/java/io 路徑下的所有類

import java.util.Random;// 導入的包

public class TestMain {
    public static void main(String[] args){ // 程序入口，static靜態(tài)

        // 創(chuàng)建Random對象，需要導包不然報錯
        Random r = new Random(); 
        // 打印生成的隨機數(shù)
        System.out.println(r.nextInt(10));
    }
}

2

Process finished with exit code 0

Java 修飾符

Java語言提供了很多修飾符，主要分為以下兩類：
訪問修飾符
非訪問修飾符
修飾符用來定義類、方法或者變量，通常放在語句的最前端。

訪問控制修飾符

Java中，可以使用訪問控制符來保護對類、變量、方法和構(gòu)造方法的訪問。Java 支持 4 種不同的訪問權限。
default (即默認，什么也不寫）: 在同一包內(nèi)可見，不使用任何修飾符。使用對象：類、接口、變量、方法。
private : 在同一類內(nèi)可見。使用對象：變量、方法。 注意：不能修飾類（外部類）
public : 對所有類可見。使用對象：類、接口、變量、方法
protected:對同一包內(nèi)的類和所有子類可見。使用對象：變量、方法。 注意：不能修飾類（外部類）。

訪問.jpg

非訪問修飾符

為了實現(xiàn)一些其他的功能，Java 也提供了許多非訪問修飾符。
static 修飾符，用來修飾類方法和類變量。
final 修飾符，用來修飾類、方法和變量，final 修飾的類不能夠被繼承，修飾的方法不能被繼承類重新定義，修飾的變量為常量，是不可修改的。
abstract 修飾符，用來創(chuàng)建抽象類和抽象方法。
synchronized 和 volatile 修飾符，主要用于線程的編程。

static 修飾符
靜態(tài)變量：
static 關鍵字用來聲明獨立于對象的靜態(tài)變量，無論一個類實例化多少對象，它的靜態(tài)變量只有一份拷貝。 靜態(tài)變量也被稱為類變量。局部變量不能被聲明為 static 變量。
靜態(tài)方法：
static 關鍵字用來聲明獨立于對象的靜態(tài)方法。靜態(tài)方法不能使用類的非靜態(tài)變量。靜態(tài)方法從參數(shù)列表得到數(shù)據(jù)，然后計算這些數(shù)據(jù)。

final 修飾符

final 表示"最后的、最終的"含義，變量一旦賦值后，不能被重新賦值。被 final 修飾的實例變量必須顯式指定初始值。一般用做常量。

abstract 修飾符

抽象類：
抽象類不能用來實例化對象，聲明抽象類的唯一目的是為了將來對該類進行擴充。
一個類不能同時被 abstract 和 final 修飾。如果一個類包含抽象方法，那么該類一定要聲明為抽象類，否則將出現(xiàn)編譯錯誤。

abstract class Caravan{
   private double price;
   private String model;
   private String year;
   public abstract void goFast(); //抽象方法
   public abstract void changeColor();
}

抽象方法
抽象方法是一種沒有任何實現(xiàn)的方法，該方法的具體實現(xiàn)由子類提供。
抽象方法不能被聲明成 final 和 static。
任何繼承抽象類的子類必須實現(xiàn)父類的所有抽象方法，除非該子類也是抽象類。
如果一個類包含若干個抽象方法，那么該類必須聲明為抽象類。抽象類可以不包含抽象方法。

public abstract class SuperClass{
    abstract void m(); //抽象方法
}
 
class SubClass extends SuperClass{
     //實現(xiàn)抽象方法
      void m(){
          .........
      }
}

synchronized 修飾符

synchronized 關鍵字聲明的方法同一時間只能被一個線程訪問。synchronized 修飾符可以應用于四個訪問修飾符。

public synchronized void showDetails(){
.......
}

用于多線程。

transient 修飾符

序列化的對象包含被 transient 修飾的實例變量時，java 虛擬機(JVM)跳過該特定的變量。
該修飾符包含在定義變量的語句中，用來預處理類和變量的數(shù)據(jù)類型。

public transient int limit = 55;   // 不會持久化
public int b; // 持久化

volatile 修飾符

volatile 修飾的成員變量在每次被線程訪問時，都強制從共享內(nèi)存中重新讀取該成員變量的值。而且，當成員變量發(fā)生變化時，會強制線程將變化值回寫到共享內(nèi)存。這樣在任何時刻，兩個不同的線程總是看到某個成員變量的同一個值。
一個 volatile 對象引用可能是 null。

public class MyRunnable implements Runnable
{
    private volatile boolean active;
    public void run()
    {
        active = true;
        while (active) // 第一行
        {
            // 代碼
        }
    }
    public void stop()
    {
        active = false; // 第二行
    }
}

接下來介紹下常用的Java內(nèi)置類：

Java String 類

字符串廣泛應用 在 Java 編程中，在 Java 中字符串屬于對象，Java 提供了 String 類來創(chuàng)建和操作字符串。

創(chuàng)建字符串

// 用構(gòu)造函數(shù)創(chuàng)建字符串：
String str2=new String("Runoob");
// String 創(chuàng)建的字符串存儲在公共池中，而 new 創(chuàng)建的字符串對象在堆上：
String s1 = "Runoob";              // String 直接創(chuàng)建
String s2 = "Runoob";              // String 直接創(chuàng)建
String s3 = s1;                    // 相同引用
String s4 = new String("Runoob");   // String 對象創(chuàng)建
String s5 = new String("Runoob");   // String 對象創(chuàng)建

注意:String 類是不可改變的，所以你一旦創(chuàng)建了 String 對象，那它的值就無法改變了。

字符串長度

public class StringDemo {
    public static void main(String args[]) {
        String site = "www.baidu.com";
        int len = site.length();
        System.out.println( "百度地址長度: " + len );
   }
}

public class StringDemo {
    public static void main(String[] args) {

        String url = "www.baidu.com";
        // 打印字符串長度
        System.out.println(url.length());
        // 字符串是否包含匹配的字符串
        System.out.println(url.contains("ba"));
        // 在字符串后面拼接addr
        System.out.println(url.concat("addr"));
        // 字符串轉(zhuǎn)換成大寫
        System.out.println(url.toUpperCase());

    }
}

String有很多方法，操作字符串的時候需要可以自己去看下API。

創(chuàng)建格式化字符串

我們知道輸出格式化數(shù)字可以使用 printf() 和 format() 方法。
String 類使用靜態(tài)方法 format() 返回一個String 對象而不是 PrintStream 對象。
String 類的靜態(tài)方法 format() 能用來創(chuàng)建可復用的格式化字符串，而不僅僅是用于一次打印輸出。

System.out.printf("浮點型變量的值為 " +
                  "%f, 整型變量的值為 " +
                  " %d, 字符串變量的值為 " +
                  "is %s", floatVar, intVar, stringVar);

String fs;
fs = String.format("浮點型變量的值為 " +
                   "%f, 整型變量的值為 " +
                   " %d, 字符串變量的值為 " +
                   " %s", floatVar, intVar, stringVar);

Java StringBuffer 和 StringBuilder 類

當對字符串進行修改的時候，需要使用 StringBuffer 和 StringBuilder 類。
String 類不同的是，StringBuffer 和 StringBuilder 類的對象能夠被多次的修改，并且不產(chǎn)生新的未使用對象。
在使用 StringBuffer 類時，每次都會對 StringBuffer 對象本身進行操作，而不是生成新的對象，所以如果需要對字符串進行修改推薦使用 StringBuffer。
StringBuilder 類在 Java 5 中被提出，它和 StringBuffer 之間的最大不同在于 StringBuilder 的方法不是線程安全的（不能同步訪問）。
由于 StringBuilder 相較于 StringBuffer 有速度優(yōu)勢，所以多數(shù)情況下建議使用 StringBuilder 類。

public class RunoobTest{
    public static void main(String args[]){
        StringBuilder sb = new StringBuilder(10);
        sb.append("Runoob..");
        System.out.println(sb);  
        sb.append("!");
        System.out.println(sb); 
        sb.insert(8, "Java");
        System.out.println(sb); 
        sb.delete(5,8);
        System.out.println(sb);  
    }
}

StringBuffer .jpg

StringBuffer 2.jpg

Java Number & Math 類

一般地，當需要使用數(shù)字的時候，我們通常使用內(nèi)置數(shù)據(jù)類型，如：byte、int、long、double 等。
然而，在實際開發(fā)過程中，我們經(jīng)常會遇到需要使用對象，而不是內(nèi)置數(shù)據(jù)類型的情形。為了解決這個問題，Java 語言為每一個內(nèi)置數(shù)據(jù)類型提供了對應的包裝類。
所有的包裝類（Integer、Long、Byte、Double、Float、Short）都是抽象類 Number 的子類。

包裝類.jpg

public class Test{
 
   public static void main(String[] args){
      Integer x = 5;
      x =  x + 10;
      System.out.println(x); 
   }
}

15

Java Math 類

Java 的 Math 包含了用于執(zhí)行基本數(shù)學運算的屬性和方法，如初等指數(shù)、對數(shù)、平方根和三角函數(shù)。
Math 的方法都被定義為 static 形式，通過 Math 類可以在主函數(shù)中直接調(diào)用。

public class Test {  
    public static void main (String []args)  
    {  
        System.out.println("90 度的正弦值：" + Math.sin(Math.PI/2));  
        System.out.println("0度的余弦值：" + Math.cos(0));  
        System.out.println("60度的正切值：" + Math.tan(Math.PI/3));  
        System.out.println("1的反正切值： " + Math.atan(1));  
        System.out.println("π/2的角度值：" + Math.toDegrees(Math.PI/2));  
        System.out.println(Math.PI);  
    }  
}

90 度的正弦值：1.0
0度的余弦值：1.0
60度的正切值：1.7320508075688767
1的反正切值： 0.7853981633974483
π/2的角度值：90.0
3.141592653589793

Java Character 類

Character 類用于對單個字符進行操作。
Character 類在對象中包裝一個基本類型 char 的值。

char ch = 'a';
 
// Unicode 字符表示形式
char uniChar = '\u039A'; 
 
// 字符數(shù)組
char[] charArray ={ 'a', 'b', 'c', 'd', 'e' };

然而，在實際開發(fā)過程中，我們經(jīng)常會遇到需要使用對象，而不是內(nèi)置數(shù)據(jù)類型的情況。為了解決這個問題，Java語言為內(nèi)置數(shù)據(jù)類型char提供了包裝類Character類。
Character類提供了一系列方法來操縱字符。你可以使用Character的構(gòu)造方法創(chuàng)建一個Character類對象，例如：

Character ch = new Character('a');
// 原始字符 'a' 裝箱到 Character 對象 ch 中
Character ch = 'a';
 
// 原始字符 'x' 用 test 方法裝箱
// 返回拆箱的值到 'c'
char c = test('x');

轉(zhuǎn)義序列

前面有反斜杠（\）的字符代表轉(zhuǎn)義字符，它對編譯器來說是有特殊含義的。

轉(zhuǎn)義字符.jpg

public class Test {
 
   public static void main(String[] args) {
      String str = "你好";
      System.out.println(str  + "你好" + "\t");
      System.out.println(str  + "你好" + "\n");
      System.out.println(str  + "你好" + "\r");
   }
}

Java 日期時間

java.util 包提供了 Date 類來封裝當前的日期和時間。 Date 類提供兩個構(gòu)造函數(shù)來實例化 Date 對象。
第一個構(gòu)造函數(shù)使用當前日期和時間來初始化對象。

// Date( )
// Date(long millisec)

import java.util.Date;
  
public class DateDemo {
   public static void main(String[] args) {
       // 初始化 Date 對象
       Date date = new Date();
        
       // 使用 toString() 函數(shù)顯示日期時間
       System.out.println(date.toString());

      // SimpleDateFormat 格式化日期
      SimpleDateFormat ft = new SimpleDateFormat ("yyyy-MM-dd hh:mm:ss");
      System.out.println("當前時間為: " + ft.format(dNow));
   }
}

簡單介紹下這些類，需要的自己去查下對應的API就可以了。
本次就復習到這了，下次開始復習Java面向?qū)ο竽且粔K了。