這裡蒐索程式師資訊,查找有用的技術資料
當前位置:首頁 » 文件傳輸 » 類的訪問特性的說明
擴展閱讀
webinf下怎麼引入js 2023-08-31 21:54:13
堡壘機怎麼打開web 2023-08-31 21:54:11

類的訪問特性的說明

發布時間: 2022-09-24 23:41:04

『壹』 深入理解Java中為什麼內部類可以訪問外部類的成員

內部類簡介

雖然Java是一門相對比較簡單的編程語言,但是對於初學者, 還是有很多東西感覺雲里霧里,
理解的不是很清晰。內部類就是一個經常讓初學者感到迷惑的特性。 即使現在我自認為Java學的不錯了,
但是依然不是很清楚。其中一個疑惑就是為什麼內部類對象可以訪問外部類對象中的成員(包括成員變數和成員方法)?
早就想對內部類這個特性一探究竟了,今天終於抽出時間把它研究了一下。

內部類就是定義在一個類內部的類。定義在類內部的類有兩種情況:一種是被static關鍵字修飾的, 叫做靜態內部類,
另一種是不被static關鍵字修飾的, 就是普通內部類。 在下文中所提到的內部類都是指這種不被static關鍵字修飾的普通內部類。
靜態內部類雖然也定義在外部類的裡面, 但是它只是在形式上(寫法上)和外部類有關系,
其實在邏輯上和外部類並沒有直接的關系。而一般的內部類,不僅在形式上和外部類有關系(寫在外部類的裡面), 在邏輯上也和外部類有聯系。
這種邏輯上的關系可以總結為以下兩點:

1 內部類對象的創建依賴於外部類對象;

2 內部類對象持有指向外部類對象的引用。

上邊的第二條可以解釋為什麼在內部類中可以訪問外部類的成員。就是因為內部類對象持有外部類對象的引用。但是我們不禁要問, 為什麼會持有這個引用? 接著向下看, 答案在後面。

通過反編譯位元組碼獲得答案

在源代碼層面, 我們無法看到原因,因為Java為了語法的簡介, 省略了很多該寫的東西, 也就是說很多東西本來應該在源代碼中寫出, 但是為了簡介起見, 不必在源碼中寫出,編譯器在編譯時會加上一些代碼。 現在我們就看看Java的編譯器為我們加上了什麼?
首先建一個工程TestInnerClass用於測試。 在該工程中為了簡單起見, 沒有創建包, 所以源代碼直接在默認包中。在該工程中, 只有下面一個簡單的文件。

?

1
2
3
4
5
6
7
8
9

public class Outer {
int outerField = 0;

class Inner{
void InnerMethod(){
int i = outerField;
}
}
}

該文件很簡單, 就不用過多介紹了。 在外部類Outer中定義了內部類Inner, 並且在Inner的方法中訪問了Outer的成員變數outerField。
雖然這兩個類寫在同一個文件中, 但是編譯完成後, 還是生成各自的class文件:

這里我們的目的是探究內部類的行為, 所以只反編譯內部類的class文件Outer$Inner.class 。 在命令行中, 切換到工程的bin目錄, 輸入以下命令反編譯這個類文件:

?

1

javap -classpath . -v Outer$Inner

-classpath . 說明在當前目錄下尋找要反編譯的class文件
-v 加上這個參數輸出的信息比較全面。包括常量池和方法內的局部變數表, 行號, 訪問標志等等。
注意, 如果有包名的話, 要寫class文件的全限定名, 如:

?

1

javap -classpath . -v com..Outer$Inner

反編譯的輸出結果很多, 為了篇幅考慮, 在這里我們省略了常量池。 下面給出除了常量池之外的輸出信息。

?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

{
final Outer this$0;
flags: ACC_FINAL, ACC_SYNTHETIC

Outer$Inner(Outer);
flags:
Code:
stack=2, locals=2, args_size=2
0: aload_0
1: aload_1
2: putfield #10 // Field this$0:LOuter;
5: aload_0
6: invokespecial #12 // Method java/lang/Object."<init>":()V
9: return
LineNumberTable:
line 5: 0
LocalVariableTable:
Start Length Slot Name Signature
0 10 0 this LOuter$Inner;

void InnerMethod();
flags:
Code:
stack=1, locals=2, args_size=1
0: aload_0
1: getfield #10 // Field this$0:LOuter;
4: getfield #20 // Field Outer.outerField:I
7: istore_1
8: return
LineNumberTable:
line 7: 0
line 8: 8
LocalVariableTable:
Start Length Slot Name Signature
0 9 0 this LOuter$Inner;
8 1 1 i I
}</init>

首先我們會看到, 第一行的信息如下:
?

1

final Outer this$0;

這句話的意思是, 在內部類Outer$Inner中, 存在一個名字為this$0 , 類型為Outer的成員變數, 並且這個變數是final的。
其實這個就是所謂的「在內部類對象中存在的指向外部類對象的引用」。但是我們在定義這個內部類的時候, 並沒有聲明它,
所以這個成員變數是編譯器加上的。

雖然編譯器在創建內部類時為它加上了一個指向外部類的引用, 但是這個引用是怎樣賦值的呢?畢竟必須先給他賦值,它才能指向外部類對象。下面我們把注意力轉移到構造函數上。 下面這段輸出是關於構造函數的信息。

?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

Outer$Inner(Outer);
flags:
Code:
stack=2, locals=2, args_size=2
0: aload_0
1: aload_1
2: putfield #10 // Field this$0:LOuter;
5: aload_0
6: invokespecial #12 // Method java/lang/Object."<init>":()V
9: return
LineNumberTable:
line 5: 0
LocalVariableTable:
Start Length Slot Name Signature
0 10 0 this LOuter$Inner;</init>

我們知道, 如果在一個類中, 不聲明構造方法的話, 編譯器會默認添加一個無參數的構造方法。 但是這句話在這里就行不通了, 因為我們明明看到, 這個構造函數有一個構造方法, 並且類型為Outer。 所以說,
編譯器會為內部類的構造方法添加一個參數, 參數的類型就是外部類的類型。
下面我們看看在構造參數中如何使用這個默認添加的參數。 我們來分析一下構造方法的位元組碼。 下面是每行位元組碼的意義:
aload_0 :
將局部變數表中的第一個引用變數載入到操作數棧。 這里有幾點需要說明。
局部變數表中的變數在方法執行前就已經初始化完成;局部變數表中的變數包括方法的參數;成員方法的局部變數表中的第一個變數永遠是this;操作數棧就是
執行當前代碼的棧。所以這句話的意思是: 將this引用從局部變數表載入到操作數棧。

aload_1:
將局部變數表中的第二個引用變數載入到操作數棧。 這里載入的變數就是構造方法中的Outer類型的參數。
putfield #10 // Field this$0:LOuter;
使用操作數棧頂端的引用變數為指定的成員變數賦值。 這里的意思是將外面傳入的Outer類型的參數賦給成員變數this$0 。
這一句putfield位元組碼就揭示了, 指向外部類對象的這個引用變數是如何賦值的。
下面幾句位元組碼和本文討論的話題無關, 只做簡單的介紹。 下面幾句位元組碼的含義是: 使用this引用調用父類(Object)的構造方法然後返回。
用我們比較熟悉的形式翻譯過來, 這個內部類和它的構造函數有點像這樣: (注意, 這里不符合Java的語法, 只是為了說明問題)

?

1
2
3
4
5
6
7
8

class Outer$Inner{
final Outer this$0;

public Outer$Inner(Outer outer){
this.this$0 = outer;
super();
}
}

說到這里, 可以推想到, 在調用內部類的構造器初始化內部類對象的時候, 編譯器默認也傳入外部類的引用。 調用形式有點像這樣: (注意, 這里不符合java的語法, 只是為了說明問題)
vcq9ysfP4M2stcShoyDU2sTasr//wOC1xLPJ1LGx5MG/b3V0ZXJGaWVsZKOsIM/Cw++NDQtcSjugo8YnI+Cgo8cHJlIGNsYXNzPQ=="brush:java;">
void InnerMethod();
flags:
Code:
stack=1, locals=2, args_size=1
0: aload_0
1: getfield #10 // Field this$0:LOuter;
4: getfield #20 // Field
Outer.outerField:I
7: istore_1
8: return
getfield #10 // Field this$0:LOuter;
將成員變數this$0載入到操作數棧上來
getfield #20 // Field Outer.outerField:I
使用上面載入的this$0引用, 將外部類的成員變數outerField載入到操作數棧
istore_1
將操作數棧頂端的int類型的值保存到局部變數表中的第二個變數上(注意, 第一個局部變數被this佔用,
第二個局部變數是i)。操作數棧頂端的int型變數就是上一步載入的outerField變數。 所以, 這句位元組碼的含義就是:
使用outerField為i賦值。
上面三步就是內部類中是如何通過指向外部類對象的引用, 來訪問外部類成員的。

文章寫到這里, 相信讀者對整個原理就會有一個清晰的認識了。 下面做一下總結:
本文通過反編譯內部類的位元組碼, 說明了內部類是如何訪問外部類對象的成員的,除此之外, 我們也對編譯器的行為有了一些了解, 編譯器在編譯時會自動加上一些邏輯, 這正是我們感覺困惑的原因。

關於內部類如何訪問外部類的成員, 分析之後其實也很簡單, 主要是通過以下幾步做到的:
1 編譯器自動為內部類添加一個成員變數, 這個成員變數的類型和外部類的類型相同, 這個成員變數就是指向外部類對象的引用;
2 編譯器自動為內部類的構造方法添加一個參數, 參數的類型是外部類的類型, 在構造方法內部使用這個參數為1中添加的成員變數賦值;
3 在調用內部類的構造函數初始化內部類對象時, 會默認傳入外部類的引用。

『貳』 Java,詳細說明類是如何定義的,解釋類的特性及它的要素

public class Test{//一個類首先要有定義類名,這里Test就是我定義的類名
//然後還有屬性
private String name;//私有屬性,只能被該類中成員訪問
int age;//預設屬性,默認的,可被同一個包中類訪問
protected char sex;//保護屬性,可以被同包的類和子類訪問
public String address;//公開屬性,可以被所有類訪問
//接著定義方法
public void setName(String name){
this.name = name;

}
public String getName(){
return name;
}

//無參數構造函數,若沒有定義任何構造函數,則系統自動定義該方法
public Test(){
super();//這行代碼可以不寫,系統會自動調用。
}

//有參數構造函數,若定義此方法,則系統不會主動定義無參數構造方法
public Test(int age,char sex,String address){
this.age =age;

this.sex = sex;

this.address = address;

}

//main方法,控制台輸出的入口,在javaSe中要運行java代碼,必須放入main方法中
public static void main(String [] args){
Test test = new Test(11,N,"無家可歸");

test.setName("無名");

System.out.println("sex="+test.getName());
System.out.println("age="+test.age);
}
}

//一個java文件中必須有且只有一個public 類
//絕大多數的類都是Object類的子類,若定義一個類沒有繼承任何類,默認繼承Objec類
//類包括屬性,方法,構造函數,mian函數
//特性:繼承,多態,封裝。

『叄』 什麼是訪問控制符有哪些訪問控制符哪些可以用來修飾類哪些用來修飾域和方法試述不同訪問控制符的作用

一,非訪問修飾符。

1, 抽象類:
凡是用abstract修飾符修飾的類被稱為抽象類。抽象類就是沒有具體對象的概念類。
抽象類是一種經過優化的概念組織方式:把共同特點抽象出來;其後在描述和處理某一種具體對象時,就只需描述不同的特殊之處。這種組織方式使得所有的概念層次分明,簡潔洗練,非常符合人們日常的思維習慣。
由於抽象類是它的所有子類的公共屬性的集合,所以使用抽象類的一個優點就是可以充分利用這些公共屬性來提高開發和維護程序的效率。
值得一提的是,面向對象技術是要用更接近於人類思維方式的方法來處理實際問題,抽象類的設立就是這種思想的具體體現之一,它是模仿人類的思維模式的產物。

2,最終類:
如果一個類被final修飾符所修飾和限定,說明這個類不可能有子類。
被定義為final的類通常是一些有固定作用、用來完成某種標准功能的類。如Java系統定義好的用來實現網路功能的InterAddress、Socket等類都是final類。
abstract和final修飾符不能同時修飾一個類,因為abstract類自身沒有具體對象,需要派生出子類後在創建子類的對象;而final類不可能有子類。這樣放在一起修飾就沒有意義了。

3,有些類的修飾符也可以用來修飾類中的域或方法:

(1) 域:是類和對象的靜態屬性,定義域的操作就是說明變數或創建對象的操作。

<1> 靜態域:
用static修飾符修飾的域是僅屬於類的靜態域。靜態域是類中每個對象共享的域。他們是類的域,不屬於任何一個類的具體對象。是一個公共的存儲單元,任何一個類的對象訪問它時,取到的都是相同的數值。

<2> 靜態初始化器:
靜態初始化器是由關鍵字static引導的一對大括弧括起的語句組。作用是:在載入時,初始化類的靜態域。
與構造函數相同,他們都是用來完成初始化的工作,但是靜態初始化器與構造函數有三點不同:
①構造函數是對每個新創建的對象初始化,而靜態初始化器是對類自身進行初始化。
②構造函數是在用new運算符產生新對象時由系統自動執行,而靜態初始化器則是在它所屬的類載入到內存時由系統調用執行。
③不同於構造函數,靜態初始化器不是方法,沒有方法名、返回值和參數列表。

<3> 最終域:
用final修飾的域,實際上就是Java中的常量。
用final修飾符說明常量時,需要注意以下幾點:
①需要說明常量的數據類型。
②需要同時指出常量的具體取值。
③因為所有類對象的常量成員,其數值都固定一致,為了節省空間,常量通常聲明為static。

<4> 易失域:
如果一個域被volatile修飾符所修飾,說明這個域可能同時被幾個線程所控制和修改,即這個域不僅僅被當前程序所掌握,在運行過程中可能在其他未知的程序操作影響和改變該域的取值。在使用當中應該特別注意。
通常,volatile用來修飾接受外部輸入的域。如表示當前時間的變數將系統的後台線程隨時修改,以保證程序中取到的總是最新的當前系統時間,所以可以把它定義為易失域。

(2)方法:是類的動態屬性,標志了類所具有的功能和操作。小括弧是方法的標志。

<1> 抽象方法:
修飾符abstract修飾的抽象方法是一種僅有方法頭,而沒有具體的方法體和操作實現的方法。使用抽象方法的目的是使所有的子類,對外都呈現一個相同名字的方法,是一個統一的介面。所有的抽象方法,都必須存在於抽象類之中。

<2> 靜態方法:
用static修飾符修飾的方法,是屬於整個類的類方法,不用的是對象或實例的方法。調用這種方法時,應該使用類名作前綴;這種方法在內存中的代碼段將隨著類的定義而分配和裝載,不被任何一個對象專有;只能處理屬於整個類的成員變數。

<3> 最終方法:
用final修飾符修飾的類方法。功能和內部語句不能再更改的方法,不能再被繼承。
注意:所有已被private修飾符限定為私有的方法,以及所有包含在final類中的方法,都被預設地認為是final的。

<4> 本地方法:
用native修飾符聲明其他語言書寫方法體並具體實現方法功能的特殊的方法。這里的其他語言包括C/C++/FROTRAN/匯編等。由於native的方法的方法體使用其他語言在程序外部寫成,所以所有的native方法都沒有方法體,而用一個分號代替。

<5> 同步方法:
如果synchronized修飾的方法是一個類的方法(即static的方法),那麼在被調用執行前,將把系統類Class中對應當前類的對象加鎖。如果synchronized修飾的是一個對象的方法(未用static修飾的方法),則這個方法在被調用執行前,將把當前對象加鎖。Synchronized修飾符主要用於多線程共存的程序中的協調和同步。

二,訪問控制符。
訪問控制符是一組限定類、域或方法是否可以被程序里的其他部分訪問和調用的修飾符。類的訪問控制符只有一個public,域和方法的訪問控制符有四個,分別是public、private、protected、private protected,另外還有一種沒有定義專門的訪問控制符的預設情況。

1, 公有訪問控制符public:
Java的類是通過包的概念來組織的,包氏類的一個鬆散的集合。處於同一個包中的類可以不需要任何說明而方便的互相訪問和引用,而對於不同包中的類,則不行。但當一個類被聲明為public時,他就具有了被其他包中的類訪問的可能性,只要這些其他包中的類在程序中使用import語句引入public類,就可以訪問和引用這個類。
類中被設定為public的方法是這個類對外的介面部分,避免了程序的其他部分直接去操作類內的數據,這實際就是數據封裝思想的體現。
每個Java程序的主類都必須是public類,也是基於相同的原因。
用public修飾的類的域稱為公共域。如果公共域屬於公共類,則它能被所有的其他類所引用。public修飾符會造成安全性的數據封裝性下降,所以一般應減少public域的使用。

2, 預設訪問控制符:
預設訪問控制權規定,該類只能被同一個包中的類訪問和引用,而不可以被其他包中的類使用,這種訪問特性又稱為包訪問性。
同樣道理,類內的域或方法如果美育訪問控制符來限定,也就具有包訪問性。
簡單說,定義在同一個程序中的所有類屬於一個包。

3,私有訪問控制符private :
用private修飾得域或方法只能被該類自身所訪問和修改,而且不能被任何其他類(包括該類的子類)來獲取和引用。private修飾符用來聲明那些類的私有成員,它提供了最高的保護級別。

4,保護訪問控制符protected :
用protected修飾的成員變數可以被三種類所引用:該類自身、與它在同一個包中的其它類、在其他包中的該類的子類。使用protected修飾符的主要作用是允許其他包中該類的子類來訪問父類的特定屬性。

5,私有保護訪問控制符 private protected :
用private protected修飾的成員變數可以被兩種類訪問和引用,一種是該類本身,一種是該類的所有子類。把同一個包內的非子類排除在可訪問的范圍之外,使得成員變數更專於具有明確繼承關系的類,而不是鬆散地組合在一起的包。

『肆』 c#中請說明類的三大特性,並舉例說明類的繼承和多態。

以控制項來說

封裝:你用那些控制項,只需要調用具體的屬性和方法,對怎麼呈現的根本不需要了解,這就是封裝
繼承:有個Control基類,封裝了常用的方法和屬性,所有控制項都是繼承自它,而且都會有這些屬性和方法,這就是繼承
多態:Control類是繼承自object,object有個ToString()方法,但是你每個控制項調用一次就會知道,輸出字元串是不一樣的,因為它們內部重寫(override)了ToString()方法.每個控制項還有很多同名,但不同參數或者不同返回值的方法(重載),這就是多態

『伍』 有關java中package之間類的調用問題

java有public、private、protected和預設訪問修飾符
你這里沒有修飾,就是默認的預設訪問
預設訪問控制權規定,該類只能被同一個包中的類訪問和引用,而不可以被其他包中的類使用,這種訪問特性又稱為包訪問性
建議你去看看各種修飾符的訪問許可權 能更好的理解

『陸』 類的預設訪問特性

private
public

『柒』 java中類成員的訪問修飾符有哪些

一:訪問修飾符:
1.省略訪問修飾符
具有默認的訪問特性,即具有包訪問特性,只能被同一個包中的類使用。
2.public訪問修飾符
用於說明類和類的成員的訪問許可權。這種類叫公有類。在一個文件中只能有一個public類型的類。
例如:Rect和UseImport兩個類,分別在兩個不同的包中。順便回顧一下不同類要用import導入。(哎,一直就沒記住)
//Rect.java
pacakage
my;
public
class
Rect
{
private
int
a,b;
public
void
init(int
len,int
width)
{
a=len;
b=width;
}
public
int
area()
{
return
a*b;
}
}
//UseImport.java
import.my.*;//導入my
包的所有類
public
class
UseImport
{
public
static
void
main(string[]
args)
{
Rect
x=new
Rect();
x.init(2,3);
System.out.println("矩形面積為:"+x.area());
}
}
3.private
用private修飾的類成員成為私有成員,只能在聲明該成員的類中使用,不能在類外使用。一般通過本類中公有方法進行訪問。
4.protected
protected修飾的類成員為保護成員,可以被三種類使用,分別是該類本身,該類的所有子類,該類同包的其他類,該類的子類。
5.private
protected
私有保護成員。可被兩種類使用。分別是:該類本身和該類的所有子類。
二:特徵修飾符
1.abstract:抽象
修飾類為抽象類,修飾方法為抽象方法。只要類中有抽象方法,就必須定義為抽象類。抽象方法只能聲明,不能實現。但是可以在其子類中對抽象方法進行實現。抽象類中也可以包含非抽象方法。
2.final:最終
修飾的類為終止類,不能有子類。修飾變數為終止變數,只可賦值一次。修飾方法為終止方法,不能在子類中更改。如Socket、ServerSocket等都是final類,防止黑客派生子類進行破壞。同時,final與abstract是相互矛盾的。
3.static:靜態
靜態成員無需通過對象調用,可以直接通過類名直接調用。
public
class
RectArea//輸出6

12
{
public
static
void
main(String[]
args)
{
System.out.println(area(2,3));
System.out.println(area(3,4));
}
static
void
area(int
a,int
b)
{
return
a*b;
}
}
4.native
用native修飾的為本地方法。它修飾的方法在程序外部使用其他編程語言編寫。(這個步驟比較多,所以就木有繼續研究了)
5.synchronized
修飾的方法為同步方法。

『捌』 類的特性

封裝性
將數據和操作封裝為一個有機的整體,由於類中私有成員都是隱藏的,只向外部提供有限的介面,所以能夠保證內部的高內聚性和與外部的低耦合性。用者不必了解具體的實現細節,而只是要通過外部介面,以特定的訪問許可權來使用類的成員,能夠增強安全性和簡化編程。 繼承性
繼承性更符合認知規律,使程序更易於理解,同時節省不必要的重復代碼。 多態性
同一操作作用於不同對象,可以有不同的解釋,產生不同的執行結果。在運行時,可以通過指向基類的指針,來調用實現派生類中的方法。 在C++、C#語言中,class和struct都可以定義一個類,它們的區別如下: C#中,class是引用類型,繼承自System.Object類;struct是值類型,繼承自System.ValueType類,不具多態性。但是注意,System.ValueType是個引用類型。 從職能觀點來看,class表現為行為;而struct常用於存儲數據。 class支持繼承,可以繼承自類和介面;而struct沒有繼承性,struct不能從class繼承,也不能作為class的基類,但struct支持介面繼承。 class可以聲明無參構造函數,可以聲明析構函數;而struct只能聲明帶參數構造函數,且不能聲明析構函數。因此,struct沒有自定義的默認無參構造函數,默認無參構造器只是簡單地把所有值初始化為它們的0等價值。 Java/C#中,實例化時,class要使用new關鍵字;而struct可以不使用new關鍵字,如果不以new來實例化struct,則其所有的欄位將處於未分配狀態,直到所有欄位完成初始化,否則引用未賦值的欄位會導致編譯錯誤。 class可以實現抽象類(abstract),可以聲明抽象函數;而struct為抽象,也不能聲明抽象函數。 class可以聲明protected成員、virtual成員、sealed成員和override成員;而struct不可以,但是值得注意的是,struct可以重載System.Object的3個虛方法,Equals()、ToString()和 GetHashTable()。 class的對象復制分為淺拷貝和深拷貝,必須經過特別的方法來完成復制;而struct創建的對象復制簡單,可以直接以等號連接即可。 class實例由垃圾回收機制來保證內存的回收處理;而struct變數使用完後立即自動解除內存分配。 作為參數傳遞時,class變數是以按址方式傳遞;而struct變數是以按值方式傳遞的。 我們可以簡單的理解,class是一個可以動的機器,有行為,有多態,有繼承;而struct就是個零件箱,組合了不同結構的零件。其實,class和struct最本質的區別就在於class是引用類型,內存分配於託管堆;而struct是值類型,內存分配於線程的堆棧上。由此差異,導致了上述所有的不同點。所以只有深刻的理解內存分配的相關內容,才能更好的駕馭。
當然,使用class基本可以替代struct的任何場合,class後來居上。雖然在某些方面struct有性能方面的優勢,但是在面向對象編程里,基本是class橫行的天下。
那麼,有人不免會提出,既然class幾乎可以完全替代struct來實現所有的功能,那麼struct還有存在的必要嗎?答案是,至少在以下情況下,鑒於性能上的考慮,我們應該考慮使用struct來代替class: 實現一個主要用於存儲數據的結構時,可以考慮struct。 struct變數佔有堆棧的空間,因此只適用於數據量相對小的場合。 struct數組具有更高的效率。

『玖』 如何訪問類的私有特性(屬性)

2種辦法
1:封裝私有屬性
2:構造函數中使用(當前類中)。
私有屬性外部是不允許訪問的,最好的辦法是使用封裝,將其轉變為公共屬性後拋出,在屬性構建方法中操作私有屬性