精华内容
下载资源
问答
  • Java函数调用

    千次阅读 2019-09-26 19:44:23
    函数调用 举例说明Java中函数的调用 public class test { public static void main(String[] args) { int i = 0; func(i); i = i++; System.out.println(i); String str = "hello wo...

    函数调用

    举例说明Java中函数的调用

    public class test {
        public static void main(String[] args) {
            int i = 0;
            func(i);
            i = i++;
            System.out.println(i);
    
            String str = "hello world";
            char[] arr = {'g', 'o', 'o', 'd'};
            func(str, arr);
            System.out.println(str);//"hello world"
            System.out.println(arr);//'g','a','o','d'
    
            /**
             * arr =>存储的是数组的地址
             * arr[i]访问arr指向的数组的第i号位元素的值
             * @param
             */
    
    }
    
        private static void func(String str,char[]arr) {
            str="i love china!";
            arr[1]='a';
        }
        private static void func(int i){
            i++;
        }
    }
    

    注释:func属于被调用函数,而main则为主函数(调用方函数),通过判断被调用函数改的是形参变量本身还是通过引用变量改的是它所指向的内存,即能判定出是否影响实参的值!
    如上例所示:被调用函数(func)中String str所改变的是str本身,所有str中的“hello world”并不受影响,但char[]arr 则是改变它所指向的内存(arr[]这个数组1号位元素所存储的值 ‘o’)所以打印出来则为‘g’,‘a’,‘o’,‘d’。

    举出两个简单的例子,加深对上述说法的理解

    eg:a,b交换变量与arr[i],arr[j]交换变量

    public class test {
        public static void main(String[] args) {
            int a = 10;
            int b = 20;
            int i=0;
            int j=0;
            swap(a, b);
            System.out.println(a+" "+b);
    
            int []intArr={10,20};
            swap(intArr,i=0,j=1);
            System.out.println(intArr[i]+" "+intArr[j]);
        }
        private static void swap(int []intArr, int i,int j) {
            int temp=intArr[i];
            intArr[i]=intArr[j];
            intArr[j]=temp;
        }
            private static void swap(int a,int b) {
                    int temp=a;
                    a=b;
                    b=temp;
    
                    }
        }
    

    打印结果为:
    10 20
    20 10

    函数调用实现二分搜索

    public class test {
        public static void main(String[] args) {
            Scanner in=new Scanner(System.in);
            int []arr=new int[11];
            Random rd=new Random();
            for (int i = 0; i < arr.length; i++) {
                arr[i]=rd.nextInt(100);
            }
            System.out.println(Arrays.toString(arr));
            Arrays.sort(arr);
            int index=-1;
    
            index=binarySearch(arr,11);
            System.out.println(index);
        }
    
        /**
         * 有序数列得二分查找算法
         * @param arr
         * @param data
         * @return
         */
        private static int binarySearch(int[] arr,int data) {
            //先定义二分搜索需要的变量
            int left = 0;
            int right = arr.length - 1;
            int middle = 0;
            //开启一个循环,计算middle值和data相比较,判断3中不同情况
            while (left <= right) {
                middle = (left + right) / 2;
                if (arr[middle] == data) {
                    return middle;
                } else if (arr[middle] > data) {
                    right = middle - 1;
                } else {
                    left = middle + 1;
                }
            }
            //没有找到  返回-1
                return -1;
            }
        }
    
    展开全文
  • JAVA函数调用流程

    2018-01-27 19:37:26
    JAVA函数调用流程 转载: https://my.oschina.net/kailuncen/blog/915043 IDEA查看class文件字节码 转载: http://blog.csdn.net/u013076044/article/details/70194922

    JAVA函数调用流程

    转载: https://my.oschina.net/kailuncen/blog/915043

    IDEA查看class文件字节码

    转载: http://blog.csdn.net/u013076044/article/details/70194922

    展开全文
  • 经常需要进行动态调试栈回溯,查看Java函数的调用流程,Android的smali动态调试又不是很方便,因此使用Android的Java Hook的方法,打印Java函数调用堆栈信息辅助静态分析。package com.xposedd...

    本文博客链接:http://blog.csdn.net/QQ1084283172/article/details/79378374

    在进行Android逆向分析的时候,经常需要进行动态调试栈回溯,查看Java函数的调用流程,Android的smali动态调试又不是很方便,因此使用Android的Java Hook的方法,打印Java函数调用堆栈信息辅助静态分析。

    package com.xposeddemo;
    
    import java.util.Map;
    
    import android.util.Log;
    import de.robv.android.xposed.IXposedHookLoadPackage;
    import de.robv.android.xposed.XC_MethodHook;
    import de.robv.android.xposed.XposedBridge;
    import de.robv.android.xposed.XposedHelpers;
    import de.robv.android.xposed.callbacks.XC_LoadPackage.LoadPackageParam;
    
    public class Module implements IXposedHookLoadPackage {
    
    	@Override
    	public void handleLoadPackage(LoadPackageParam lpparam) throws Throwable {
    		// 判断是否是要Hook的包名
    		if (lpparam.packageName.equals("com.lenovo.anyshare.gps")){
    			XposedBridge.log("Loaded App:" + lpparam.packageName);
    			
    			// 查找要Hook的函数(需要打印堆栈调用的目标函数)
    			XposedHelpers.findAndHookMethod(
    					"com.lenovo.anyshare.frv", // 被Hook函数所在的类com.lenovo.anyshare.frv
    					lpparam.classLoader, 
    					"a",     // 被Hook函数的名称a
    					new XC_MethodHook(){
    						@Override
    						protected void beforeHookedMethod(MethodHookParam param)
    								throws Throwable {
    							// Hook函数之前执行的代码
    							
    							//传入参数1
    							//XposedBridge.log("beforeHookedMethod userName:" + param.args[0]); 
    						}
    						
    						@Override
    						protected void afterHookedMethod(MethodHookParam param)
    								throws Throwable {
    							// Hook函数之后执行的代码
    							
    							//函数返回值
    							//XposedBridge.log("afterHookedMethod result:" + param.getResult());
    							
    							// 函数调用完成之后打印堆栈调用的信息
    							// 方法一:
    							Log.i("Dump Stack: ", "---------------start----------------");
    							Throwable ex = new Throwable();
    							StackTraceElement[] stackElements = ex.getStackTrace();
    							if (stackElements != null) {
    								for (int i = 0; i < stackElements.length; i++) {
    									
    									Log.i("Dump Stack"+i+": ", stackElements[i].getClassName()
    											+"----"+stackElements[i].getFileName()
    											+"----" + stackElements[i].getLineNumber()
    											+"----" +stackElements[i].getMethodName());
    								}
    							} 
    							Log.i("Dump Stack: ", "---------------over----------------");
    							
    							// 方法二:
    							new Exception().printStackTrace(); // 直接干脆
    							
    							// 方法三:
    							Thread.dumpStack(); // 直接暴力
    							
    							// 方法四:
    							 // 打印调用堆栈: http://blog.csdn.net/jk38687587/article/details/51752436
    			                RuntimeException e = new RuntimeException("<Start dump Stack !>");
    			                e.fillInStackTrace();
    			                Log.i("<Dump Stack>:", "++++++++++++", e);
    
    							// 方法五:
    							// Thread类的getAllStackTraces()方法获取虚拟机中所有线程的StackTraceElement对象,可以查看堆栈
    							for (Map.Entry<Thread, StackTraceElement[]> stackTrace:Thread.getAllStackTraces().entrySet())
    							{
    								Thread thread = (Thread) stackTrace.getKey();
    								StackTraceElement[] stack = (StackTraceElement[]) stackTrace.getValue();
    								
    								// 进行过滤
    								if (thread.equals(Thread.currentThread())) {
    									continue;
    								}
    								
    								Log.i("[Dump Stack]","**********Thread name:" + thread.getName()+"**********");
    								int index = 0;
    								for (StackTraceElement stackTraceElement : stack) {
    									
    									Log.i("[Dump Stack]"+index+": ", stackTraceElement.getClassName()
    											+"----"+stackTraceElement.getFileName()
    											+"----" + stackTraceElement.getLineNumber()
    											+"----" +stackTraceElement.getMethodName());
    									}
    									// 增加序列号
    									index++;
    								}
    								Log.i("[Dump Stack]","********************* over **********************");
    						}
    					});
    			
    			//查找要Hook的函数
    //			XposedHelpers.findAndHookMethod(
    //					"com.lenovo.anyshare.frw", // 被Hook函数所在的类com.lenovo.anyshare.frv
    //					lpparam.classLoader, 
    //					"b",     // 被Hook函数的名称b
    //					int.class,
    //					new XC_MethodHook(){
    //						@Override
    //						protected void beforeHookedMethod(MethodHookParam param)
    //								throws Throwable {
    //							// Hook函数之前执行的代码
    //							
    //							//传入参数1
    //							XposedBridge.log("beforeHookedMethod com.lenovo.anyshare.frw--b--StpSocket: " + param.args[0]); 
    //						}
    //						
    //						@Override
    //						protected void afterHookedMethod(MethodHookParam param)
    //								throws Throwable {
    //							// Hook函数之后执行的代码
    //							
    //							//函数返回值
    //							//XposedBridge.log("afterHookedMethod result:" + param.getResult());
    //							
    //							XposedBridge.log("com.lenovo.anyshare.frw--b---StpSocket---Dump Stack: "+"---------------start----------------");
    //							Throwable ex = new Throwable();
    //							StackTraceElement[] stackElements = ex.getStackTrace();
    //							if (stackElements != null) {
    //								for (int i = 0; i < stackElements.length; i++) {
    //									
    //									XposedBridge.log("Dump Stack---StpSocket"+i+": "+stackElements[i].getClassName()
    //											+"----"+stackElements[i].getFileName()
    //											+"----" + stackElements[i].getLineNumber()
    //											+"----" +stackElements[i].getMethodName());
    //								}
    //								
    //								XposedBridge.log("com.lenovo.anyshare.frw--b---StpSocket---Dump Stack: "+"---------------over----------------");
    //							} 
    //						}
    //					});
    			
    //			XposedHelpers.findAndHookMethod(
    //					"com.lenovo.anyshare.frw", // 被Hook函数所在的类com.lenovo.anyshare.frv
    //					lpparam.classLoader, 
    //					"a",     // 被Hook函数的名称a
    //					int.class,
    //					new XC_MethodHook(){
    //						@Override
    //						protected void beforeHookedMethod(MethodHookParam param)
    //								throws Throwable {
    //							// Hook函数之前执行的代码
    //							
    //							//传入参数1
    //							XposedBridge.log("beforeHookedMethod com.lenovo.anyshare.frw--a--ServerSocket:" + param.args[0]); 
    //						}
    //						
    //						@Override
    //						protected void afterHookedMethod(MethodHookParam param)
    //								throws Throwable {
    //							// Hook函数之后执行的代码
    //							
    //							//函数返回值
    //							//XposedBridge.log("afterHookedMethod result:" + param.getResult());
    //							
    //							XposedBridge.log("com.lenovo.anyshare.frw--a--ServerSocket--Dump Stack: "+"---------------start----------------");
    //							Throwable ex = new Throwable();
    //							StackTraceElement[] stackElements = ex.getStackTrace();
    //							if (stackElements != null) {
    //								for (int i = 0; i < stackElements.length; i++) {
    //									
    //									XposedBridge.log("Dump Stack--ServerSocket"+i+": "+stackElements[i].getClassName()
    //											+"----"+stackElements[i].getFileName()
    //											+"----" + stackElements[i].getLineNumber()
    //											+"----" +stackElements[i].getMethodName());
    //								}
    //								
    //								XposedBridge.log("com.lenovo.anyshare.frw--a--ServerSocket--Dump Stack: "+"---------------over----------------");
    //							} 
    //						}
    //					});
    		}
    	
    	}
    }
    	
    /**
     * Look up a method and place a hook on it. The last argument must be the callback for the hook.
     * @see #findMethodExact(Class, String, Object...)
     */
    /*针对非静态方法的Hook
    public static XC_MethodHook.Unhook findAndHookMethod(Class<?> clazz, String methodName, Object... parameterTypesAndCallback) {
    	if (parameterTypesAndCallback.length == 0 || !(parameterTypesAndCallback[parameterTypesAndCallback.length-1] instanceof XC_MethodHook))
    		throw new IllegalArgumentException("no callback defined");
    
    	XC_MethodHook callback = (XC_MethodHook) parameterTypesAndCallback[parameterTypesAndCallback.length-1];
    	Method m = findMethodExact(clazz, methodName, getParameterClasses(clazz.getClassLoader(), parameterTypesAndCallback));
    
    	return XposedBridge.hookMethod(m, callback);
    }*/
    
    /** @see #findAndHookMethod(Class, String, Object...) */
    /*针对静态方法的Hook
     public static XC_MethodHook.Unhook findAndHookMethod(String className, ClassLoader classLoader, String methodName, Object... parameterTypesAndCallback) {
    	return findAndHookMethod(findClass(className, classLoader), methodName, parameterTypesAndCallback);
    }*/

    展开全文
  • 相信选择语句跟循环大家已经很熟悉了,今天我们说方法的调用,方法的调用是在一个叫方法调用栈的机制上的,规则是先进后出,意思是说先执行的方法后结束,一个程序最先执行的方法是main()方法,是由JAVA虚拟机(JVM)...

    控制程序流程的方法有3种,1.方法的调用 2.选择语句(if else)3.循环(while,do_while,for等),

    相信选择语句跟循环大家已经很熟悉了,今天我们说方法的调用,方法的调用是在一个叫方法调用栈的机制上的,规则是先进后出,意思是说先执行的方法后结束,一个程序最先执行的方法是main()方法,是由JAVA虚拟机(JVM)执行的,因此main()是最后结束的。如果一个JAVA程序是多线程的,那么它可以有多个调用栈这在后面进行讲解。

    一个方法被调用时,会被放在调用栈的顶部,直到方法结束,当方法执行时,会发生三种情况。1.方法返回一个值。2.方法不返回一个值。(void)3.方法抛出一个异常给调用者。

    怎么书写一个方法呢?

    方法书签{

    方法实例

    }

    一个方法分为“方法签名”跟“方法实例”两块

    方法书签:public static void main(String [] args)

    方法签名又分为访问修饰符:public,可选修饰符static,返回值void,方法名main,形式参数列表(String[]

    args)。

    一个方法签名包括一个形式参数列表,它声明传递到方法中的数据的类型(实际上声明了一个变量),注意一个方法可以有多个形式参数用“,”隔开,调用的时候实际参数(传递给方法的参数)必须顺序个数相同,但是只能有一个返回值,这是电子科大研究生都要搞错的问题。

    在JAVA方法调用的时候,是把实际参数的数据复制给形式参数,这种过程叫做按值调用,也是唯一的,因为JAVA中不能按引用调用或者按指针调用,这种情况下实际参数不是复制给形式参数的。

    方法的重载,JAVA中允许方法的重载,当一个类有两个或者多个同名但是有不同参数列表的方法时,就是方法的重载。不同参数列表有三种情况:1.参数个数2.参数类型3.参数顺序。方法具有相同名字,听起来不是那么重要的,但是方法重载在JAVA以及其他编程语言中使用是比较频繁的。

    构造器,构造器就是构造方法,作用是为了创建对象,构造方法有两大特点1.无返回类型,无返回值2.构造方法必须与类名相同

    。构造可以写也可以不写,不写的话编译器会为我们默认一个构造方法,如果写了就按照我们所写的构造方法来,注意构造方法也是方法,可以实现方法的重载,可以对属性赋值。我们知道内存分为4个部分,堆,栈,数据段和代码段。而构造方法对属性初始化可以分为4个步骤,1.在堆中划分空间2.在此空间划分属性3.对属性初始化4.然后再执行在构造方法所写的代码。

    构造器中this的使用,this有两个作用,一个是this.:

    代表当前对象,调用当前对象的属性和行为。第二格就是在一个类中调用其他构造器this(参数),但是这句代码只能在构造器的第一句。

    方法的调用跟C语言一样。方法名(实际参数)

    展开全文
  • * Java函数调用按值传递 */ public class ValuePassTest { public static void main(String[] args) { Date d1 = new Date("1 Apr 98"); nextDateUpdate(d1); System.out.println("d1
  • Java函数调用

    千次阅读 2015-05-17 10:46:33
    Java函数调用栈就是Java虚拟机栈,它是线程私有的,与线程一同被创建,用于存储栈帧。 栈帧随着方法的调用而创建,随着方法的结束而销毁。可以说栈帧是方法的抽象。 于是,可以通过打印出Java虚拟机栈中的栈帧...
  • } } 结果:2 1)Java里数据分为值类型和引用类型,数组是引用类型,即本质上是传递了数组的地址,所以,当被调用函数里传入的数组发生变化,主函数里的数组也在变化。 2)当在方法中申明变量为值类型,则变量名和...
  • 本文是网友KailunTalk文章的精简版, 他从字节码的角度解释了Java 函数调用中传递参数的方式, 充分体现了一个程序员深度挖掘,了解底层的精神, 原文地址:https://my.oschina.net/kailuncen/blog/915043 ...
  • JAVA对象函数的执行过程如下: 1.编译器查看对象的声明类型和方法名。  根据方法名和声明类型在基类的public方法和本对象的方法中寻找合适的方法接口。 2.编译器查看参数类型 从1过程中筛选的函数,找到参数...
  • 1、传递的是不可变对象的引用 以String为例: void func(String s){ s+="asd"; System.out.println(s);...由于java中的引用传递和值传递传递的都是一个copy,即String定义的s的引用对象和func函数中的参数s...
  • Java函数调用时参数合法性检查时机

    千次阅读 2017-02-27 17:32:00
    java开发过程中,我们时常需要调用自己或者别人的方法,在调用方法时不可避免一个问题,那就是参数问题。 我们调用方法时常需要传入参数,这时就...求调用者在调用函数前先检查参数的非空等,而是在函数内对非空等进
  • 关于Java函数调用的一点体会

    千次阅读 2010-03-10 16:33:00
    从上面的代码可以看出,两种处理方法的不同主要体现在:一个是使用临时变量存储函数返回的结果,而另一个是直接使用函数调用的返回值 那么它们之间有什么区别呢?   原来,对于第一种方法,函数只调用了一...
  • Java函数调用过程-编译期-运行期

    千次阅读 2011-08-04 10:06:52
    程序运行结果是:子类 在Java中程序对象中函数处理的过程是: 编译器在选择在运行期将被调用的方法时,所做的第一件事就是在肯定能找到该方法的范围内挑选。编译器将在包含了具有恰当名字的方法的最小闭合范围内进行...
  • JAVA通过调用数据库函数调用存储过程 下面将举一个通过数据库函数来调用存储过程: 创建数据库函数存储过程 CREATE OR REPLACE FUNCTION stu_proc ( v_id IN NUMBER ) RETURN VARCHAR2 IS v_name ...
  • Java函数调用

    万次阅读 2018-03-30 23:04:10
    package hello; public class Hello { public static void main(String[] args) { // TODO Auto-...//给sum函数里a,b赋值 System.out.println("a,b最大是"+x); sayHello("zz");...
  • java构造函数调用构造函数

    千次阅读 2014-04-26 15:01:57
    一个类可包含多个构造函数,在java中一个构造函数可以
  • 调用函数方法:对象名.函数名需要实例化对象,后调用2.自定义32313133353236313431303231363533e4b893e5b19e31333365663433函数:结构为:[方法修饰符] ([]){方法体}有以下几种函数:方法有2种修饰符1)有public、...
  • java 打印函数调用

    千次阅读 2015-11-18 19:37:32
    有时候需要跟一些代码的调用流程,这时候打印函数调用栈就非常好用。 java.util.Map ts = Thread.getAllStackTraces(); StackTraceElement[] ste = ts.get(Thread.currentThread()); for ...
  • Java函数重载问题,编写两个函数,计算圆和长方形面积,构成重载,并且在main函数调用
  • Java构造函数调用顺序问题

    千次阅读 2017-06-07 19:18:15
    java构造代码调用顺序研究。
  • Java的构造函数调用

    千次阅读 2017-03-03 13:20:20
    如果类没有定义构造函数Java编译器就会给类生成一个构造函数(无参的)。如果类定义了构造函数,无论是有参的构造函数还是无参的构造函数,编译器都不会在为再为类生成构造函数。 当子类调用构造函数的时候,...
  • 我的二维数组具体的个数在键盘输入,怎么在输入n和m的值后调用函数,谢谢![图片](https://img-ask.csdn.net/upload/201703/22/1490151078_791611.jpg)
  • Java构造函数调用顺序

    千次阅读 2015-04-27 21:46:40
    使用super调用父类构造器的语句必须...如果父类没有不带参数的构造器,并且在子类的构造器中又没有显式地调用父类的构造器,则java编译器将报告错误 父类: public class Parents { private int age; private Strin
  • Js调用Java函数实例

    2019-12-02 22:05:47
    Js调用Java函数 利用Webview在程序中显示map框架,当触发map中的事件时调用Jscript代码,并在Js中反过来调用Java的函数,实现简单的互动以及变量传递等功能。 Java部分 Webview 设置: //AndroidtoJS类对象映射到js...
  • Android Java打印函数调用

    千次阅读 2013-06-19 16:59:12
    Java中打印函数调用栈,在method中添加如下一行: new Exception().printStackTrace(); 这样,在logcat中可以看到: W/System.err( 290): java.lang.Exception W/System.err( 290): at ...
  • JAVA函数递归调用问题

    2015-01-20 16:08:53
    /** 计算5! */ public class Function { static int i=5,sum=1; public static void print(){ sum=sum*i; i--; if(i>1) {print(); System.out.println("****** "+sum); } else ...
  • JNI调用java函数

    2019-03-14 17:05:00
    假设Java回调接口如下,JNI如何回调这么接口呢? public interface Listener ...首先获取虚拟机指针,JNI_OnLoad系统自动调用JavaVM* javaVM = nullptr; jint JNI_OnLoad(JavaVM *vm, void *reserved) { JNIEnv ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 39,147
精华内容 15,658
关键字:

java函数调用

java 订阅