Java 中的對象

1. 對象

Java 中的一切都是對象。

更準確地說，Java 中很少有不是對象的東西。例如，原始類型。但這是一個相當罕見的例外。

那麼什麼是對象呢？

對像是將數據與處理數據的方法組合在一起的實體。當我們說“數據”時，當然是指變量。

對象的變量稱為它的“數據”或“狀態”。

一個對象的方法被稱為它的“行為”。通常僅使用對象的方法來更改對象的狀態（變量）。直接更改對象的變量（不使用其方法）被認為是錯誤的形式。

每個對象，以及每個變量，都有一個類型。該類型在創建對象時確定一次，以後不能更改。一個對象的類型就是它的類。

每個對像都有自己的實例變量（字段）副本。如果在類中聲明了一個非靜態 int a 變量，並且您的程序創建了該類的 10 個對象，那麼每個對像都會有自己的 int a 變量。

與對象交互

使用對象最方便的方法是將對它的引用存儲在一個變量中，然後調用該變量的方法。這對你來說很熟悉：

variable.method()

其中variable是存儲對象引用的變量，method是該類的方法。

如果你想引用一個對象的字段（變量），那麼你還需要使用點運算符：

variable.field

其中variable是存儲對象引用的變量，field是實例變量（字段）。

2.new操作員

要創建某個類的對象，需要使用new運算符。通常，創建對象的過程如下：

Class variable = new Class(arguments);

其中Class是變量的類名variable以及要創建的對象的類名。Andvariable 是一個變量，它存儲對創建的對象的引用。Andarguments是傳遞給構造函數的以逗號分隔的參數列表的佔位符。

可以傳遞的具體參數列表由編寫該類的程序員決定。

您以前創建過對象，甚至使用過這個特定的構造。你沒有忘記，我希望？

Scanner console = new Scanner(System.in);
int x = console.nextInt();

Scanner console— 這將創建一個console類型為Scanner. — 這會創建一個新對象。並且賦值運算符將變量設置為等於對新創建對象的引用。new Scanner(System.in)Scannerconsole

在第二行中，我們使用存儲對象引用的變量調用對象nextInt()的方法。ScannerconsoleScanner

對象創建示例：

String s = new String("Hello");

Scanner console = new Scanner("");

int[] data = new int[10];

創建的對象稱為類的對像或類的實例，而類稱為對象的類。例如，s變量存儲對類實例的引用String。

3.引入類

我想您已經看到使用其他程序員編寫的類是多麼方便。但是如何編寫自己的類呢？

您如何知道何時何地需要自己的課程以及如何製作課程？

當程序員想在程序中引入新實體時，他們通常會創建自己的類。這聽起來令人困惑嗎？然後我會嘗試解釋，但我將從很遠的地方開始。

數據組

稍微簡化一下，我們可以說 Java 中的對像是一塊內存，其中包含類中聲明的變量（實例字段）。或者，換句話說，變量組合成一個組。

假設您的程序需要存儲100點的坐標並需要一種方法將它們顯示在屏幕上。這可以使用數組來完成。例如，像這樣：

class Solution
{
   public static void printPoints(int[] x, int[] y, int[] color)
   {
     for (int i = 0; i < x.length; i++)
       System.out.println("Color of (" + x[i] + ", " + y[i] + ") = " + color[i]);
   }

   public static void main(String[] args)
   {
     int[] x = new int[100];
     int[] y = new int[100];
     int[] color = new int[100];
     printPoints(x, y, color);
   }
}

如果我們有一個單一的類型來存儲關於一個點的所有信息，那就更方便了：x, y, color。如果 Java 中不存在這樣的類型，您可以自己創建它。

為此，我們將為一個Point類編寫代碼：

public class Point
{
   public int x;
   public int y;
   public int color;
}

現在上面的代碼可以重寫為：

class Solution
{
   public static void printPoints(Point[] points)
   {
     for (int i = 0; i < points.length; i++)
       System.out.println("Color of (" + points[i].x + ", " + point[i].y + ") = " + points[i].color);
   }

   public static void main(String[] args)
   {
     Point[] data = new Point[100];
     for (int i = 0; i < data.length; i++)
       data[i] = new Point();
     printPoints(data);
   }
}

現在讓我們在Point類中添加一個方法來顯示有關對象的信息：

public class Point
{
   public int x;
   public int y;
   public int color;
   public void print()
   {
     System.out.println("Color of (" + x + ", " + y + ") = " + color);
   }
}

現在Solution類看起來像這樣：

class Solution
{
   public static void printPoints(Point[] points)
   {
     for (int i = 0; i < points.length; i++)
       points[i].print();
   }

   public static void main(String[] args)
   {
     Point[] data = new Point[100];
     for (int i = 0; i < data.length; i++)
       data[i] = new Point();
     printPoints(data);
   }
}

我們巧妙地將點的坐標和顏色信息Point以及顯示點狀態的方法隱藏在類中。

類是管理程序複雜性的一種方式。當一個大程序被分解成許多小類時，它變得不那麼複雜。

4. 可變對象與不可變對象

曾幾何時，我們研究了 Java 中的常量，得出了一個不太令人欣慰的結論。常量可讓您保護變量不被更改，但它們無法阻止對其引用的對象進行更改。

為了解決這個問題，Java 想出了常量對象。或者，它們更常被稱為不可變對象。

順便說一下，你已經知道這樣一個類，它的對像不能被改變：String。對String像在創建後將永遠保持不變。Java 的創造者是如何做到這一點的？

首先，String類的所有變量都是隱藏的，即聲明的private。

其次，您不能繼承該類String：它的類聲明包含修飾符final。

第三，也是最有趣的是，該類的所有方法String，理論上您希望更改現有對象，實際上並沒有更改它，而是返回一個新對象。

例如，該toUpperCase()方法使字符串中的所有字母大寫。但是它並沒有改變調用該方法的對象，而是返回一個由String大寫字母組成的新對象：

String text = "This is a very important message";
String message = text.toUpperCase();

這是執行此代碼後內存中的內容：

所以請隨意將您的字符串傳遞給任何方法：沒有人會更改它們。