成员变量和成员方法如何去访问

㈠ 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.

所以在这里看出，匿名内部类有了自己的实现。其实很简单，使用匿名内部类是因为我这地方需要有点什么特殊的实现，所以我就在这地方把具体实现也给了出来了。然后我就在这地方获取它的实例，调用它的方法。
接口的方式，只要把父类换成接口就行了，没必要给出代码了。

使用匿名内部类时我们不要忘了我们的目的，我们只是在这地方想对某个类有特殊的实现。而不要想得太多，在匿名内部编写其它的方法。在匿名内部类中编写的自己的方法是不可见的。此种做法是毫无意义的，当然一般也不会这么做。在这里只是告诉初学者对于匿名内部类不要想的太多，而要这么想：匿名内部类就是重写父类或接口的方法。

匿名内部类是没有名字的，所以我们没办法获得其类型，而只能把它当作超类或接口类型来使用。