正文
java代码怎么看调用 java代码怎么看调用过的文件
提示：扫一扫查出行【扫一扫了解最新限行尾号】
复制提示
java中怎么查看哪调用了当前的方法?
需要开发环境的支持，你安装一个eclipse, 然后选中方法名，点右键，选“open call hierarchy”，
或者按快捷键“Ctrl+Alt+H”，Eclipse就会显示出这个方法被哪些方法调用，最终产生一个调用关系树。
相关问答
Q1: 在java 中 父类定义的静态方法 子类 调用时候 如何 知道 是哪个子类调用的
1)父类构造函数
java中当调用某个类的构造方法的时候，系统总会调用父类的非静态初始化块进行初始化，这个调用是隐式的，而且父类的静态初始化代码
块总是会被执行，接着调用父类的一个或者多个构造器执行初始化，这个调用也可以通过super进行显式调用。
例如：
父类代码如下：
public class Creature {//父类
{//非静态代码块
System.out.println("creature的非静态代码块正在执行");
}
public Creature(){
System.out.println("creature的构造函数正在执行");
}
}
子类代码如下：
public class Animal extends Creature {
{
System.out.println("animal的初始化代码块正在执行");
}
public Animal(){
System.out.println("animal的构造方法正在执行");
}
public static void main(String[] args){
Animal a = new Animal() ;
}
}
则运行程序后的结果为：
creature的非静态代码块正在执行
creature的构造函数正在执行
animal的初始化代码块正在执行
animal的构造方法正在执行
从结果中可以看出：调用某个类的构造方法的时候总是会先执行父类的非静态代码块，然后执行父类的构造方法，最后才是执行当前类的。
非静态代码块和构造方法。执行过程中有先后顺序。
若果想要显式调用父类的构造方法则可以使用super()，来调用，但是super关键字和this关键字都必须放在构造放的第一行，而且只能使用第一个。
注：super用于显式调用父类的构造器，this可以显式调用本类中的重载的构造器。
2）访问子类对象的实例变量
子类的方法可以访问父类中的实例变量，这是因为子类继承父类就会获得父类中的成员变量和方法，但是父类方法不能访问子类的实例变量，因为父类根本无法知道它将被哪个类继承，它的子类将会增加怎么样的成员变量。但是，在极端的情况下，父类也可以访问子类中的变量。
例如：
父类代码如下：
public class Base {//父类
private int i = 2 ;
public Base(){
this.display() ;
}
public void display(){
System.out.println(i);
}
}
子类中代码如下：
public class Derived extends Base {
private int i = 22 ;
public Derived(){
i = 222 ;
}
public void display(){
System.out.println(i);
}
}
测试用例如下：
public class Test {
public static void main(String[] args) {
new Derived() ;
}
}
程序的执行结果为：
调用new Derived() ;创建Derived
实例的时候，系统会为Derived对象分配内存空间，Derived会有两个i实例变量，会分配两个空间来保存i的值。分配完空间以后i的值为0
，如果有引用类型则引用类型的值为null。接下来程序在执行Derived的构造器之前会执行Base的构造器，表面上看Base的构造器中只有
一行代码，但是在父类中定义i的时候执行的初始值2，因此经过编译之后，该构造方法中应该包含如下两行代码：
i =2 ;
this.display() ;
程序先将Base中的i赋值为2，然后执行display方法。此处有一个关键字this，this到底代表谁呢？表面上看this代表的是Base的当前实例，但是实际上代码是放在Derived的构造器中的，所以this最终代表的是Derived的当前实例（编译类型是Base而实际引用一个Derived对象），所以如果在父类的构造方法中直接输出System.out.println(this.i) ;则输出的结果为2。但是调用this.display()方法，此时调用的是子类中重写的display方法，输出的变量i也是子类中的i，但是此时子类中的变量i还没有赋值，所以输出结果为0。
为了详细的看清楚this变量到底代表什么实例，我们将Base的构造方法修改如下：
public Base(){
System.out.println(this.i);
System.out.println(this.getClass());
this.display() ;
}
再次运行程序，结果为：
2
class edu.qichao.chapter2.Derived
可以看到this代表的是Derived的实例，但是编译的时候类型为Base，所以输出this.i的值为2。
3）调用被子类重写的方法
默认情况下，子类可以调用父类的方法，但是父类不能调用子类的方法，因为父类不知道它将被哪个子类继承，也不知道子类将增加怎么
样的方法。
例如：
父类Animal的代码如下：
public class Animal {
private String desc ;
public Animal(){
this.desc = getDesc() ;
}
public String getDesc(){
return "Animal" ;
}
public String toString(){
return desc ;
}
}
子类Wolf的代码如下：
public class Wolf extends Animal {
private String name ;
private double weight ;
public Wolf(String name , double weight){
this.name = name ;
this.weight = weight ;
}
public String getDesc(){
return "Wolf[name=" + name + ",weight=" + weight + "]" ;
}
public static void main(String[] args){
System.out.println(new Wolf("灰太狼" , 3));
}
}
程序的运行结果为：
Wolf[name=null,weight=0.0]
在main方法中通过new Wolf("灰太狼" , 3)；来创建一个Wolf的实例，子类会隐式调用父类的构造方法，在父类构造方法中初始化desc变量this.desc = getDesc() ;此处需要注意this变量，虽然这个this放在Animal的构造放中，但是是在Wolf的构造方法中调用父类的构造方法，所以this编译时类型为Animal，运行时类型为Wolf，此处调用的getDesc方法是子类Wolf的方法，但是子类中的name和weight变量都没有初始化，默认为null和0.0.所以程序的最终结果为：Wolf[name=null,weight=0.0]
4）继承成员变量和成员方法的区别
java中队成员变量的继承和成员方法的继承是不同的。
例如：
父类代码如下：
public class Base {
int count = 2 ;
public void display(){
System.out.println(this.count);
}
}
子类代码如下：
public class Derived extends Base {
int count = 20 ;
@Override
public void display(){
System.out.println(this.count);
}
}
测试用例如下：
public class Test {
public static void main(String[] args) {
Base b = new Base() ;
System.out.println(b.count);
b.display() ;
System.out.println("-----------------");
Derived d = new Derived() ;
System.out.println(d.count);
d.display() ;
System.out.println("-----------------");
Base bd = new Derived() ;
System.out.println(bd.count);
bd.display() ;
System.out.println("-----------------");
Base d2b = d ;
System.out.println(d2b.count);
}
}
程序运行结果为：
2
2
-----------------
20
20
-----------------
2
20
-----------------
2
Q2: .请简述如何在Java代码与XML文件中调用布局资源文件
步骤：
1、在存放使用资源的res文件夹下的layout文件夹内新建一个XML布局文件，如命名为：page1.xml。
2、在存放资、代码的文件夹下下找到MainActivity.java，双击打开，在onCreate的方法内添加关联代码。
Q3: java中的函数调用怎么理解？
函数调用可以理解为：
你想去买一样东西，这时，可能会叫你的秘书去帮你买它。
您的秘书可能不熟悉市场，这时她委任采购部门去帮她购买你需要的东西。
不好意思，昨天有事匆忙留下一段，还有一段没有完成。。。
在JAVA中怎么使用 什么时候能用到？
我就大致的回答一下吧。如果不合心意，还请谅解！
OOP强调低耦合，高内聚。单一职责原则。还有许多模式以及原则，使你的系统富有弹性，易于扩展，修改，维护。
内聚就是一个模块内各个元素彼此结合的紧密程度，高内聚就是一个模块内各个元素彼此结合的紧密程度高。
所谓高内聚是指一个软件模块是由相关性很强的代码组成，只负责一项任务，也就是常说的单一责任原则。
耦合：一个软件结构内不同模块之间互连程度的度量(耦合性也叫块间联系。指软件系统结构中各模块间相互联系紧密程度的一种度量。模块之间联系越紧密，其耦合性就越强，模块的独立性则越差，模块间耦合的高低取决于模块间接口的复杂性，调用的方式以及传递的信息。) 对于低耦合，粗浅的理解是：
一个完整的系统，模块与模块之间，尽可能的使其独立存在。
也就是说，让每个模块，尽可能的独立完成某个特定的子功能。
模块与模块之间的接口，尽量的少而简单。
如果某两个模块间的关系比较复杂的话，最好首先考虑进一步的模块划分。
这样有利于修改和组合。[1]
引用：
代码的话，我就不多说了。自己估量估量，就知道是怎么回事了。
Q4: java中可不可以判断那个class调用的我？
可以参考以下java代码怎么看调用的代码java代码怎么看调用，在被调用java代码怎么看调用的函数中增加一个记录调用的方法java代码怎么看调用，记录调用方的信息
public void testMethod(){
Test1 t1 = new Test1();
t1.my();
}
public static void main(String[] args) {
Test t = new Test();
t.testMethod();
}
class Test1{ public void my(){
String tag = this.getMyGrandpaStackTrace();
System.err.println(String.format("调用我的人是:%s", tag));
}
public String getMyGrandpaStackTrace(){
StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
StackTraceElement father = stackTrace[1];
StackTraceElement log = stackTrace[2];
String tag = null; for (int i = 1; i stackTrace.length; i++) {
StackTraceElement e = stackTrace[i]; if (!e.getClassName().equals(log.getClassName())) {
tag = e.getClassName() + "." + e.getMethodName(); break;
}
} if (tag == null) {
tag = log.getClassName() + "." + log.getMethodName();
}
System.err.println(String.format("My father is %s.%s", father.getClassName() ,father.getMethodName()));
System.err.println(String.format("My grandpa is %s",tag)); return tag;
}
}
java代码怎么看调用的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于java代码怎么看调用过的文件、java代码怎么看调用的信息别忘了在本站进行查找喔。
