一文搞懂Java類和對象
簡介
Java類是Java編程語言的基本構建塊。Java類是用于創建對象以及定義數據類型和方法的模板。Java類對象應該具有基本的類屬性。本文將通過代碼示例解釋Java類的工作原理。
什么是Java類？
Java類是面向對象編程語言的基本概念。Java類是用戶定義的模板或藍圖，其中定義了對象、數據成員和方法，以及構建特定對象類型的一組指令。同一Java類的變量和方法對于所有類對象都是通用的。
在Java中，class關鍵字用于定義Java類。
如何定義Java類？
語法：
class <class-name>
{
[data members]
[method];
}代碼示例：
class MyClass {
int x = 5; //數據成員
void fun() {
System.out.println("This is method");
}
}Java類的三個主要組成部分是什么？
1) Java中的類變量是什么？
變量是用于存儲值的保留內存位置。換句話說，當我們想要存儲任何值并給它命名時，該值在內存中占據了一個保留空間，這稱為變量。
變量具有任何位于內存中的值。
語法：
<access specifier> <data type> <variable name> = <value>;如何聲明變量？
代碼示例：
int x; (int 是數據類型，x 是變量名)
int y;
int x , y;
int x = 4 , y = 5;
byte p = 65;
double pi = 3.1415;
char q = 's';Java中不同類型的變量是什么？
1. Java中的局部變量
在方法、構造函數和塊中聲明的變量稱為局部變量。它在方法、構造函數、塊創建后創建，類看不到局部變量，也無法訪問它。它的作用范圍有限，因為它僅在方法內部使用。
例如，我們首先創建一個類和一個方法，然后在方法內部聲明兩個局部變量。
public class LocalVariableExm {
void message() { //這是一個方法
int p; //局部變量的聲明
int x = 10; //局部變量的聲明與初始化
}
}
Java中的靜態變量
靜態變量是一種非常重要的變量類型。我們使用 static 關鍵字與變量一起使用，因此稱為靜態變量。靜態變量在類內部、方法、構造函數和塊外部聲明。靜態變量屬于類而不是對象，存儲在靜態內存中。其默認值為0，我們可以通過類名調用靜態變量，因此無需為靜態變量創建對象。
例如，首先我們創建一個類，并在方法外部聲明了三個變量，其中兩個是靜態變量。
public class StaticVariableExm {
int p;
static int q = 10; // 靜態變量并初始化
static int r; // 靜態變量聲明
void message() {
}
}
Java中的實例變量
實例變量在類中聲明，但在方法、構造函數或塊外部。它的作用范圍最廣，因為它在類中全局可見。當對象創建時，實例變量也被創建。在實例變量被創建時，它在堆內存中占據空間，并通過對象調用，默認值為0。
例如，首先我們創建一個類，并在方法外部聲明了兩個實例變量。
public class InstanceVariableExm {
int a; // 實例變量的聲明
int b = 10; // 實例變量的聲明與初始化
void message() {
}
}
2) 什么是Java中的構造函數？
構造函數就像Java中的一個特殊方法，用于初始化Java類的對象。構造函數對于每個Java類都非常重要。如果我們不聲明構造函數，編譯器會創建一個Java類的默認構造函數。
構造函數必須與Java類同名。它沒有返回類型。
Java中的不同類型的構造函數是什么？
默認構造函數
默認構造函數沒有參數，如果我們不聲明構造函數，編譯器會自動創建該Java類的默認構造函數。
語法：
<class-name>() {}以下程序創建了一個默認構造函數并輸出消息。完整程序如下：
public class DefaultConstructor {
DefaultConstructor() {
System.out.println("This is default constructor example");
}
public static void main(String args[]) {
DefaultConstructor d = new DefaultConstructor();
}
}
什么是 Java 類中的數據成員？
數據成員是在每次創建對象時分配內存空間的那些成員。數據成員通常用于存儲特定的值。
語法
數據類型 v1,v2,v3,……vn;
class DataMember
{
int v1,v2,v3;
float f1,f2;
}
什么是 Java 類中的訪問修飾符？
訪問修飾符用于確定 Java 類、數據成員、方法或構造函數的可訪問性（作用域）。通過訪問修飾符，我們可以設置 Java 類、變量和方法的訪問級別。
有哪些不同類型的訪問修飾符？
Java 中有四種訪問修飾符：
- public
- private
- protected
- default（默認）
下表列出了訪問修飾符：
| 訪問修飾符 | 關鍵詞 |
|---|---|
| 公共訪問修飾符 | public |
| 私有訪問修飾符 | private |
| 受保護訪問修飾符 | protected |
| 默認訪問修飾符 | 無關鍵詞 |
1) 公共訪問修飾符
公共訪問修飾符在所有地方都可以訪問。它具有所有修飾符中最廣泛的作用域。在公共類中聲明的變量、方法和構造函數對 Java 程序中的任何類都是可見的，無論這些類是在同一個包中還是在不同包中。
完整程序如下所示：
步驟 1. 首先，我們創建一個 Java 類 PublicExample，其中我們聲明方法 show()：
public class PublicExample {
public void show() {
System.out.println("Public access modifier example");
}
}
步驟 2. 接著，我們創建一個名為 PublicAccess 的類，在其中調用 PublicExample 類的方法：
public class PublicAccess {
public static void main(String args[]) {
PublicExample obj = new PublicExample();
obj.show();
}
}
2) 私有訪問修飾符
私有訪問修飾符只能在類內訪問，不能在類外訪問。聲明為私有的數據成員、方法或構造函數受到嚴格控制。私有訪問修飾符不能在類外部訪問。
除了嵌套類外，Java 類不能被聲明為私有。
完整程序如下所示：
步驟 1. 首先，我們創建一個 Java 類 PrivateExample，在其中聲明私有方法 run()：
public class PrivateExample{
private void run() {
System.out.println("Scooter is running");
}
}
步驟 2. 接著，我們創建一個 PrivateAccess 類，在其中調用 PrivateExample 類的方法：
public class PrivateAccess{
public static void main(String args[]) {
PrivateExample s = new PrivateExample();
s.run(); // 編譯時錯誤
}
}
注意： 在這個例子中，我們創建了兩個 Java 類 PrivateExample 和 PrivateAccess。PrivateExample 包含私有方法 run()。如果我們嘗試在類外部訪問私有方法，將會產生編譯時錯誤。
3) 受保護的訪問修飾符
受保護的訪問修飾符可在包內和包外通過繼承訪問。
受保護的訪問修飾符可以應用于變量、方法和構造函數，但不能應用于 Java 類。父類中的變量、方法和構造函數被聲明為受保護，可以在其他包中的子類中訪問。
完整程序如下所示：
步驟 1. 首先，我們在 pack1 包中創建一個公有的 Java 類 ProtectedExample，其中聲明一個受保護的方法 display()：
package pack1;
public class ProtectedExample{
protected void display() {
System.out.println("Protected access modifier example");
}
}
步驟 2. 接著，我們在 pack2 包中創建一個公有的 Java 類 ProtectedAccess，并調用 ProtectedExample 類的方法：
package pack2;
import pack1.*;
public class ProtectedAccess extends ProtectedExample{
public static void main(String args[]) {
ProtectedAccess p = new ProtectedAccess();
p.display();
}
}
4) 默認訪問修飾符
當我們不使用任何修飾符時，它被視為 Java 中的默認訪問修飾符。默認訪問修飾符僅在包內可訪問。
任何 Java 類、變量、方法和構造函數的默認訪問修飾符，僅在同一包中的類可以訪問。默認訪問修飾符不用于接口中的變量和方法。
完整程序如下所示。
package pack1;
class DefaultExample {
void msg() {
System.out.println("默認訪問修飾符示例");
}
}步驟 1：首先，我們在包 pack1 中創建一個名為 DefaultExample 的默認 Java 類，并聲明一個方法 msg()：
步驟 2：其次，我們在包 pack2 中創建一個名為 DefaultAccess 的默認 Java 類，其中調用 DefaultClass 類的方法：
package pack2;
import pack1.*;
class DefaultAccess{
public static void main(String args[]) {
DefaultClass d = new DefaultClass(); // 編譯時錯誤
r.msg(); // 編譯時錯誤
}
}注意：在這個示例中，我們創建了兩個 Java 類 DefaultClass 和 DefaultAccess。 DefaultClass 是一個默認的 Java 類，無法在包外訪問。因此，它會產生編譯時錯誤。
Java 中有多少種類型的類？
Java 中有三種主要類型的類：
- 抽象 Java 類
- 嵌套 Java 類
- 最終 Java 類
- 單例 Java 類
1) 什么是 Java 中的抽象類？
在了解抽象 Java 類之前，我們應該了解 Java 中的抽象。
抽象
在 Java 中，抽象是一種向用戶隱藏實現細節的過程，并僅向用戶提供功能。例如，當我們想在計算器中計算一些數據時，我們使用其按鍵，但不知道它是如何在內部工作的。
因此，當我們在任何類中使用抽象關鍵字時，該類稱為抽象 Java 類。它僅向用戶提供必要的內容，并隱藏內部過程。
抽象 Java 類可以有抽象方法和非抽象方法。如果一個類有一個抽象方法，則該類必須是抽象 Java 類。如果我們想使用抽象類，它必須被擴展并實現其方法。如果我們擴展一個抽象 Java 類，我們必須為其中的所有抽象方法提供實現。
完整程序如下所示。
abstract class AbstractClass {
abstract void work();
}步驟 1：首先，我們創建一個名為 Employee 的抽象 Java 類，其中聲明一個名為 work() 的抽象方法。
步驟 2：其次，我們創建一個名為 WomanEmployee 的公共 Java 類，在其中訪問方法 work()，其實現由 WomanEmployee 類給出。
public class AbstractClass2 extends AbstractClass{
void work() {
System.out.println("抽象類示例");
}
public static void main(String args[]) {
AbstractClass p = new AbstractClass2();
p.work();
}
}2) 什么是嵌套 Java 類？
Java 編程語言允許您在一個類內定義另一個類。我們使用嵌套類來將類和接口在一個地方進行邏輯分組。這可以提高可讀性和可維護性，并且可以訪問外部類的所有成員（公共、私有、受保護）。
語法
class OuterClass{
......
class InnerClass{
// 嵌套 Java 類
}
}嵌套類在 Java 中的優點
- 嵌套 Java 類顯示一種特殊類型的關系；它可以訪問外部類的所有成員，包括私有成員。
- 嵌套 Java 類主要用于使我們的程序更具可讀性和可維護性，因為它將類和接口在一個地方進行邏輯分組。
- 嵌套類需要寫的代碼更少。
嵌套類的類型
- 非靜態嵌套類
- 靜態嵌套類
非靜態嵌套類在 Java 中也稱為內部類。
Java 中的成員內部類
成員內部類是在類內部但在方法外部創建的。它是一個非靜態內部類。在 Java 中創建內部成員類很簡單。我們只需在類內編寫一個類。內部類可以是私有的，一旦我們將內部類聲明為私有，就無法從外部類的對象訪問它。
語法
class Outer{
class Inner {
// 成員內部類
}
}完整程序如下所示。
public class MemberClassExample {
private int data = 30;
class MemberClassInner {
void msg() {
System.out.println("data is " + data);
}
}
public static void main(String args[]) {
MemberClassExample obj = new MemberClassExample();
MemberClassExample.MemberClassInner in = obj.new MemberClassInner();
in.msg();
}
}注意：在示例中，我們在內部成員類中創建了一個 display() 方法，它訪問外部類的私有數據成員。
Java 中的匿名內部類
沒有名稱的類稱為 Java 中的匿名內部類。它必須在我們需要覆蓋類和接口的方法時使用。
我們可以同時聲明和初始化它們。完整程序如下所示。
public class AnonoymousClassExample {
public static void main(String[] args) {
AnonoymousDemo a = new AnonoymousDemo() {
public void message() {
System.out.println("匿名內部類示例");
}
}; // 匿名類體在此關閉
// a 包含匿名子類 AnonoymousClassExample 的對象。
a.message();
}
}
class AnonoymousDemo {
public void message() {
System.out.println("消息");
}
}Java 中的局部內部類
在方法內部創建的 Java 類稱為局部內部類 Java；如果我們想調用局部內部類的方法，那么我們必須在方法內部初始化這個類。
完整程序如下所示。
public class LocalInnerClassExample {
private int data = 30;
void display() {
class Local {
void msg() {
System.out.println(data);
}
}
Local l = new Local();
l.msg();
}
public static void main(String args[]) {
LocalInnerClassExample obj = new LocalInnerClassExample();
obj.display();
}
}Java 中的靜態嵌套類
靜態類不能訪問非靜態數據成員和方法。它可以訪問外部類的靜態成員，無論是私有、公共還是受保護的，并且只能通過外部類名稱訪問。當在另一個 Java 類內部創建靜態類時，它稱為靜態嵌套類。
語法
class Outer{
static NestedClass {
// 靜態嵌套類
}
}完整程序如下所示。
public class StaticNestedClassExample {
static int age = 30;
static class StaticClassAccess {
void display() {
System.out.println("員工年齡是 " + age);
}
}
public static void main(String args[]) {
StaticNestedClassExample.StaticClassAccess obj = new StaticNestedClassExample.StaticClassAccess();
obj.display();
}
}3) 什么是最終類？
最終類在 Java 中是一個不可更改的類。它不能被擴展，也不能作為基類。使用最終類的主要目的是為了不讓其他類繼承它。
當我們不希望其他類繼承時，我們將類聲明為最終類；這是定義常量的好方法。完整程序如下所示。
final class FinalClassExample {
void display() {
System.out.println("最終類示例");
}
}
// 編譯時錯誤
class NewClass extends FinalClassExample { } // 無法擴展最終類上面的代碼會導致編譯時錯誤，表示無法擴展最終類。
4) 什么是單例類？
單例類是設計模式中的一種模式，它確保一個類僅有一個實例，并提供全局訪問。它主要用于控制對共享資源的訪問。
完整程序如下所示。
class Singleton {
private static Singleton instance = new Singleton(); // 唯一實例
private Singleton() { } // 私有構造函數
public static Singleton getInstance() {
return instance;
}
public void display() {
System.out.println("單例類示例");
}
}
public class SingletonExample {
public static void main(String args[]) {
Singleton s = Singleton.getInstance();
s.display();
}
}3) 最終 Java 類
當我們在任何類前使用 final 時，它被稱為最終 Java 類。最終類不能被繼承。如果任何類被聲明為最終的，那么它的所有方法也隱式地被聲明為最終的。
語法
final class <類名> {
// 代碼
}
完整程序如下：
final class FinalClassExample {
}
class Manager extends FinalClassExample { // 編譯時錯誤
void work() {
System.out.println("努力工作");
}
public static void main(String args[]) {
Manager m1 = new Manager();
m1.work();
}
}
注意
在這個例子中，我們創建了一個名為 FinalClassExample 的最終 Java 類和另一個名為 Manager 的 Java 類。我們嘗試繼承這個最終類，但程序在編譯時出現錯誤。
4) 單例 Java 類
在面向對象編程中，單例類是指在任何時候只能有一個對象的類。單例通常控制對資源的訪問，例如數據庫連接或套接字。其目的是創建一個對象的單一實例，這些對象在運行時創建成本高昂，并盡量重用同一個對象。這些對象主要是不可變的。
實現單例類需要遵循一些基本規則。
- 構造函數應該是私有的。
- 聲明一個該類的靜態變量對象。
- 聲明一個靜態方法以返回實例。
完整程序如下。
步驟 1
首先，我們創建一個名為 SingletonClassExample 的單例類。
public class SingletonClassExample {
private static SingletonClassExample singleton = new SingletonClassExample();
public static SingletonClassExample getInstance() {
return singleton;
}
protected static void demoMethod() {
System.out.println("單例的 demoMethod");
}
}
步驟 2
其次，我們創建一個名為 SingletonDemo 的公共類以訪問單例類。
public class SingletonDemo {
public static void main(String[] args) {
SingletonClassExample tmp = SingletonClassExample.getInstance();
tmp.demoMethod();
}
}
總結
在本教程中，我們學習了各種 Java 類以及如何在 Java 程序中使用它們。
若你想提升Java技能，可關注我們的Java培訓課程。
