成員變數和成員方法如何去訪問

㈠ php 類中 通過成員方法訪問成員變數有什麼好處,我知道是爭對於安全性，但不能解釋怎麼個安全法，

將成員變數私有化，並使用公有介面去訪問，是為了保證數據的正確性，保證對象能夠正常工作。

對象有兩個作用，一是保存數據，二是擁有操作數據的方法。對象就是一個黑盒子，隱藏數據操作細節，而我們可以輕松地處理和取得數據，不需要了解內部的處理過程。對象的數據只由它自己去處理，沒有外部干涉，這樣的數據是安全的可信任的。

如果我們能夠任意改變對象的數據，就是對其密封性的破壞。在"外力"的作用下，對象擁有的數據類型和值發生改變，很可能會影響其內部的處理過程，嚴重時會發生錯誤。

示例一：

classDivision{
public$a;
public$b;
publicfunction__construct($a,$b){
if($b==0)
thrownewException('divisionbyzero!');
$this->a=$a;
$this->b=$b;
}
publicfunctionrun(){return$this->a/$this->b;}
}
$a=newDivision(5,5);
$a->b=0;
$a->run();//出錯了，因為除數被設為了0

在上例中，雖然構造函數對傳入的變數經行了過濾，但由於變數是公有的，用戶「不小心」更改了$b的值，造成了程序異常。

使用函數來訪問變數，可以對變數經行預處理，防止用戶傳入了不合法的值。這就像是在對象的前面加上了一道「防火牆」，保證程序正常地工作。

示例二：

classA{
publicfunctioncall(){echo'A->call()iscalling!';}
}
classB{
private$_a;
publicfunctionsetA(A$a){
if(!is_callable($a,'call'))
thrownewException('A->call()isnotcallable!');
$this->_a=$a;
}
publicfunctioncall(){
if($this->_a)
$this->_a->call();
}
}

在上例中，屬性$a是私有的，只能通過setA()方法來設置。setA()方法中使用了PHP的「類型提示」功能，這就要求傳入的參數必須是A的實例。在函數中的代碼又檢查了$a對象是否含有可以調用的$a->call()方法，如果失敗就會拋出異常。從而保證了傳入變數的正確性。

希望能幫到您~也希望能夠及時採納~

㈡ java如何訪問類的成員變數和方法

如果變數和方法是靜態的就直接 類名.變數名 或 類名.方法名
非靜態的話,本類中訪問直接 this.變數名 或者 this.方法名 ,外部其它類如果要調用的話就需要先創造出該類然後再 .變數名 或 .方法名

㈢ 成員變數和成員方法的存取限有哪些

在學習java的過程中，我寫類經常會用到public，private 和protected
的，我的基本經驗就是一般類的成員變數都是用private，
方法用public，類內部用的方法用protected，如果是存在子類的，那我就會把父類中的成員變數變為protected。（其餘的看具體實際情況而定）

不過在一些公司的筆試題中，他們會要求你具體的寫出像public這些訪問限定符的作用域。其實，平常我都沒去系統的考慮這些訪問限定符的作用域，特別是包內包外的情況，OK，筆試不行了。

這是java基本的知識，也是公司看重的，那沒辦法啦，我的腦袋記不住東西，那我只能把這些東西寫下來方便自己溫故知新。

注意:
可以把默認，也就是沒加任何訪問限定符，理解為"包訪問"，在子類中不能直接訪問，但在同包中的類卻可以訪問

如果你看到這里還不是很了解上面的表，或者是很久就沒看書了，忘記了上面的表的內容的意義，那下面的例子就是幫助你溫故知新的好東東。

例如，有一個包demo中的類P，它有一個 private 成員變數data， 一個public
默認構造方法， 一個public 訪問方法getData()，
一個protected修改方法setData()，還有一個默認訪問方式的輔助方法print()。

package demo;

public class P{

private int data;

public P(){

setData(0);

}

public int getData(){

return data;

}

protected void setData(int v){

data = v;

}

void print(){

System.out.println("used!")

}

}

本類的不用說了，在本類裡面才不管什麼訪問限定符呢。

如有類Q，擴展了P，所以可以調用P的默認構造方法、訪問方法getData()和修改方法setData()。但類Q不能直接訪問P的成員變數data，輔助方法print()也不行（可以把默認，也就是沒加任何訪問限定符，理解為"包訪問"，在子類中不能直接訪問，但在同包中的類卻可以訪問）。

import demo.P

public class Q extends P{

public Q(){

super();
<---------------------------Q可以訪問父類的默認構造方法

}

public Q(int v){

setData(v);
<------------------------Q可以訪問父類的protected的方法

}

public String toString(){

int v = getData();
<--------------------Q可以訪問父類的public的方法

return
String.valueOf(v);

}

public void invalid1(){

data =
12;
<---------------------------Q不能直接訪問父類的private數據域

}

public void invalid2(){

print();
<-------------------------------Q不能直接訪問父類默認許可權的方法

}

}

對於默認訪問,只有當2個類在同一個包中的時候,才可以互訪對方的默認訪問許可權的成員。因此，由於類Q並不是包
demo 的一部分，它不可以訪問P的輔助方法print()。

現在考慮包 demo 中的類R。R的方法可以調用P中 public 的默認構造方法和訪問方法
getData()，protected 的修改方法 setData()，以及默認訪問許可權的輔助方法 print()。然而，類R不能直接訪問P的 private
成員變數data。

package demo;

public class R{

private P p;

public R(){

p = new P();
<--------------------------R 可以訪問P的默認構造方法

}

public void set(int v){

p.setData(v);
<---------------------------R可以訪問P的protected的方法

}

public int get(){

return p.getData();
<---------------------R可以訪問P的public的方法

}

public void use(){

p.print();
<-------------------------------R可以訪問P的默認許可權的方法

}

public void invalid1(){

p.data = 12;
<------------------------- R不能直接訪問P的private的數據域

}

}

下面考慮類S，它既不是demo包的一部分，也沒有直接或者間接地擴展自類P。所以，類S僅僅可以調用P中的
public 訪問許可權的默認構造方法和訪問方法getData()。

import demo.P;

public class S{

private P p;

public S(){

p = new P();
<-------------------------------S可以訪問P的public的默認構造方法

}

public int get(){

return p.getData();
<------------------------S可以訪問P的public的方法

}

public void invalid1(int v){

p.setData(v);
<------------------------------S不能訪問P的protected的方法

}

public void invalid2(){

p.data =
12;
<-------------------------------S不能直接訪問P的private的數據域

}

public void invalid3(){

p.print();
<------------------------------- S不能直接訪問P的默認許可權的方法

}

}

上面三個類是分別對應作用域子類、包內和外部三種情況的。

㈣ 怎麼訪問超類的超類的成員變數

給你舉個例子吧：訪問超類私有成員變數和非私有成員變數的方法是不同的，私有的需要通過反射，非私有的可以直接訪問。
public class Clazz extends Father {

public static void main(String[] args) throws Exception {
Clazz zz = new Clazz();
String pub = zz.publicc;// 共有屬性和方法直接訪問
System.out.println(pub);
zz.pubMethod();

Class cla = Class.forName("com.bd.Father");
Method mes = cla.getDeclaredMethod("privMethod", new Class[] {});
mes.setAccessible(true);
mes.invoke(new Father());//訪問私有方法
Field fie = cla.getDeclaredField("privatee");
fie.setAccessible(true);
String privatee = (String)fie.get(new Father());
System.out.print(privatee);//訪問私有屬性
}
}

class Father {
private String privatee = "私有屬性";

public String publicc = "共有屬性";

private void privMethod() {
System.out.println("私有方法");
}

public void pubMethod() {
System.out.println("共有方法");
}
}
結果：
共有屬性
共有方法
私有方法
私有屬性

㈤ 如何在一個類中訪問其他類的成員變數

如果成員變數是靜態的，那麼直接在A類中通過「B.變數名稱」的形式即可。
如果成員變數是動態的，需要在B類中創建變數的set和get方法，之後在A類中：
B b =new B();進行B類實例化
b.setName("zhangsan");//賦值
b.getName();獲取到成員變數值。

㈥ Java中封裝private的變數通過成員方法或者get set 方法訪問,那如何訪問成員方法呢

成員方法用訪問修飾符控制訪問許可權，只供內部使用的方法聲明為private，供外部調用的方法聲明為public，供本包和子類訪問的方法聲明為protected，只供本包訪問的方法不加訪問修飾符。

㈦ 成員變數和成員方法的訪問的控制修飾符有哪些

public
private
protected
預設

㈧ Java,對對象的成員變數一不直接訪問，而是通過成員方法怎麼理解

應該是就是為了可以做出一個標記，從而可以實現java域變數的封裝性和安全性。

1. 如果直接將成員變數設置為public許可權，那麼對於該成員變數的訪問和修改的控制就不再是由封裝它的對象來控制的，而是由調用它的類來控制，這樣首先破壞了java面向對象的封裝性。

2. 其次，如果不採用這樣一種標記手段，那麼程序員何時何地修改域變數的值也很難控制和排查，從而影響安全性。為了解決這兩個問題，人們約定成一種習慣，也就是get和set方法來對域變數進行管理。

㈨ 成員變數和成員方法的訪問控制修飾符有哪些

一共分四種，開放性有小到大 ：public>defualt>protect>private
public：可以認為沒有限制訪問
defualt：同一個包中可訪問（類中不寫默認為次修飾符）
protect：本類以及所有子類可訪問
private：本類內可訪問

㈩ java 匿名內部類中的成員變數和成員方法如何調用

使用匿名內部類課使代碼更加簡潔、緊湊，模塊化程度更高。內部類能夠訪問外部內的一切成員變數和方法，包括私有的，而實現介面或繼承類做不到。然而這個不是我說的重點，我說的很簡單，就是匿名內部類的兩種實現方式：第一種，繼承一個類，重寫其方法；第二種，實現一個介面（可以是多個），實現其方法。
public class TestAnonymousInterClass{
public static void main(String args[]){
TestAnonymousInterClass test=new TestAnonymousInterClass();
test.show();
}
//在這個方法中構造了一個匿名內部類
private void show(){
Out anonyInter=new Out(){// 獲取匿名內部類實例

void show(){//重寫父類的方法
System.out.println("this is Anonymous InterClass showing.");
}
};
anonyInter.show();// 調用其方法
}
}

// 這是一個已經存在的類，匿名內部類通過重寫其方法，將會獲得另外的實現
class Out{
void show(){
System.out.println("this is Out showing.");
}
}
程序運行的輸出結果為：

this is Anonymous InterClass showing.

所以在這里看出，匿名內部類有了自己的實現。其實很簡單，使用匿名內部類是因為我這地方需要有點什麼特殊的實現，所以我就在這地方把具體實現也給了出來了。然後我就在這地方獲取它的實例，調用它的方法。
介面的方式，只要把父類換成介面就行了，沒必要給出代碼了。

使用匿名內部類時我們不要忘了我們的目的，我們只是在這地方想對某個類有特殊的實現。而不要想得太多，在匿名內部編寫其它的方法。在匿名內部類中編寫的自己的方法是不可見的。此種做法是毫無意義的，當然一般也不會這么做。在這里只是告訴初學者對於匿名內部類不要想的太多，而要這么想：匿名內部類就是重寫父類或介面的方法。

匿名內部類是沒有名字的，所以我們沒辦法獲得其類型，而只能把它當作超類或介面類型來使用。