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