java变量同名_Java中如何访问同名的方法或变量 ？

/*

类变量：又叫静态变量，这种变量属于类，通过类名就可以访问类变量。

实例变量：属于类的实例即对象，通过对象可以访问实例变量，但是不能通过类名访问实例变量。

静态方法：方法属于类，通过对象访问实例方法，不能通过类名访问实例方法。

隐藏：B隐藏了A的变量或者方法，那么，B不能访问A被隐藏的变量或方法，但是，将B转换成A后，可以访问A被隐藏的变量或方法。

覆盖：B覆盖了A的变量或者方法，那么，B不能够访问A被覆盖的变量或方法，将B转换成A后，同样不能访问A被覆盖的变量或方法。

Java中方法和变量在继承时的覆盖与隐藏规则如下：

父类的实例变量和类变量能被子类的同名变量隐藏。

父类的静态方法被子类的同名静态方法隐藏。

父类的实例方法被子类的同名实例方法覆盖。

不能用子类的静态方法隐藏父类中同样标识的实例方法，否则编译器将会报错。

不能用子类的实例方法覆盖父类中同样标识的静态方法，否则编译器会报错。

最终方法(带关键字final的方法)不能被覆盖。

变量只会被隐藏，不会被覆盖，无论她是实例变量还是静态变量。而且，子类的静态变量可以隐藏父类的实例变量，子类的实例变量可以隐藏父类的静态变量。

*/

public class AccessMethod

{

public static void main(String[] args)

{

//先测试继承时变量的覆盖于隐藏问题

System.out.println("在继承关系中，同名变量的覆盖与隐藏的执行内容如下:");

ChildClass child = new ChildClass();

System.out.println("\t创建了ChildClass对象，ChildClass的属性信息如下：");

System.out.println("name:" + child.name + "; age:" + child.age + "; var:" + child.classVar);

//将ChildClass类型转换成parentClass对象

ParentClass parent = child;

System.out.println("将创建的ChildClass对象赋值给ParentClass对象，其属性信息如下：");

System.out.println("name:" + parent.name + "; age:" + parent.age + "; var:" + parent.classVar);

System.out.println("子类可以访问父类被隐藏的实例变量name:" + child.getParentName());

System.out.println("子类可以访问父类被隐藏的实例变量age:" + child.getParentAge());

System.out.println("子类可以访问父类被隐藏的静态变量var:" + child.getParentVar());

System.out.println("\n<>------------------>>\n");

//再测试继承时方法的覆盖与隐藏问题

System.out.println("在继承关系中，同名方法的覆盖与隐藏的执行内容如下：");

child.getName();//实例方法

child.getClassVar();//静态方法

parent.getName();//实例方法

parent.getClassVar();//静态方法

}

}

class ParentClass

{

public static String classVar = "父类的字符串类变量";

public static int age = 50;//类变量，ParentClass年龄

public String name = "ParentClass";//实例变量，ParentClass的名字

//静态方法，获取ParentClass的类别

public static String getClassVar()

{

//静态方法中操作的只能是类变量，静态变量

System.out.println("ParentClass的getClassVar()方法被调用！");

return classVar;

}

//静态方法，获取ParentClass的年龄

public static int getAge()

{

//静态方法中操作的只能是类变量，静态变量

System.out.println("ParentClass的getAge)方法被调用！");

return age;

}

//实例方法，获取ParentClass的名字

public String getName()

{

//实例方法中操作的可以是实例变量，也可以是类变量

System.out.println("ParentClass的getName()方法被调用了！");

return this.name;

}

//final方法，将ParentClass的年龄减1

public final int getPreviousAge()

{

System.out.println("ParentClass的getPreviousAge()方法被调用！");

return --age;

}

}

class ChildClass extends ParentClass

{

public static String classVar = "子类的字符串类变量";

public int age = 25;//实例变量，ChildClass的年龄，在ParentClass类是static的

public String name = "ChildClass";//实例变量，ChildClass的名字

//静态方法，获取ChildClass的类别

public static String getClassVar()

{

//静态方法中操作的只能是类变量，静态变量

System.out.println("ChildClass的getClassVar()方法被调用！");

return classVar;

}

//静态方法，获取父类的类别

public static String getParentVar()

{

//通过类名加“.”访问父类被隐藏的类变量

return ParentClass.classVar;

}

//实例方法，获取ChildClass的名字

public String getName()

{

System.out.println("ChildClass的getName()方法被调用！");

return this.name;

}

//实例方法，获取父类的名字

public String getParentName()

{

//通过super关键字父类中被隐藏的实例变量

return super.name;

}

//实例方法，获取父类的年龄

public int getParentAge()

{

return ParentClass.age;

}

}

/*

1.同名的实例方法被覆盖，同名的静态方法被隐藏。

Child类的getName()实例方法覆盖了Parent类的getName()实例方法；

Child类的getClassVar()静态方法隐藏了Parent类的getClassVar()静态方法。

2.隐藏和覆盖的区别在于：子类对象转换成父类对象后，能够访问父类被隐藏

的变量和方法，而不能访问父类被覆盖的变量和方法。

把child对象转换成Parent类的对象parent时，不能访问parent的getName()实例方法；

把child对象转换成Parent类的对象parent后，能够访问Parent的getClassVar()静态方法。

3.子类若需要访问父类中被隐藏的实例变量，需要使用super关键字。

Child类的getParentName()方法中就使用super.name访问Parent类的name实例变量。

4.子类若需要访问父类中被隐藏的类变量，需要使用父类的名字加点“.”来访问。

Child类的getParentAge()方法使用了ParentClass.age访问Parent类的age静态变量。

*/