精华内容
下载资源
问答
  • 我的书在c中说如果嵌套函数throw数据类型与catch参数不匹配,那么调用函数将被终止 . 但是我的代码不会这样做 . 相反,它只是跳过抛出的异常,就好像它甚至没有被抛出一样 . 这是我应该说清楚的代码片段 .#include#...

    所以我使用throw语句和嵌套前面描述的函数的另一个函数声明并定义了一个函数 . 我的书在c中说如果嵌套函数throw数据类型与catch参数不匹配,那么调用函数将被终止 . 但是我的代码不会这样做 . 相反,它只是跳过抛出的异常,就好像它甚至没有被抛出一样 . 这是我应该说清楚的代码片段 .

    #include

    #include

    using namespace std;

    void setlength(double w)

    {

    if (w >= 0)

    {

    cout << "We're good";

    }

    else if (w > -5 && w < 0)

    {

    string sample = "Hello";

    throw sample;

    }

    }

    void setwaidth(double w)

    {

    try

    {

    setlength(-3);

    cout << "OK";

    }

    catch (int a)

    {

    cout << "Error has occurred";

    }

    if (w >= 0)

    {

    cout << "We're good";

    }

    else if (w > -5 && w < 0)

    {

    string sample= "Hello";

    throw sample;

    }

    }

    int main()

    {

    try

    {

    setwaidth(-3);

    cout << "OK";

    }

    catch (string a)

    {

    cout << a;

    }

    }

    这只显示Hello,但不应该中止,因为-3在setlength的else if语句中,数据类型为string,但catch具有int数据类型 .

    展开全文
  • Java语言基础组成—函数Java语言由8个模块构成,分别为:关键字、标识符(包名、类名、接口名、常量名、变量名等)、注释、常量和变量、运算符、语句、函数、数组。本片主要介绍Java中的函数函数Java中最小的功能...

    Java语言基础组成—函数

    Java语言由8个模块构成,分别为:关键字、标识符(包名、类名、接口名、常量名、变量名等)、注释、常量和变量、运算符、语句、函数、数组。

    本片主要介绍Java中的函数,函数是Java中最小的功能单元。

    1.函数的定义

    1)定义:指在类中的具有特定功能的一段独立小程序,也称为方法。

    2) 格式:

    修饰符 返回值类型 函数名(参数类型 形式参数1,参数类型 形式参数2, ... )

    {

    执行语句;

    return 返回值;

    }

    返回值类型:函数运行后的结果的数据类型。

    参数类型:是形式参数的数据类型。

    实际参数:传递给形式参数的具体数值。

    return:用于结束函数。

    返回值:该值会返回给调用者。

    3) 范例

    //计算任意整数*3+5的结果

    class FunctionDemo{

    public static void main(String[] args){

    int x=4;

    System.out.println(x*3+5);

    int y=6;

    System.out.println(y*3+5);

    }

    }

    发现以上的运算,因为获取不同数据的运算结果,代码出现了重复。

    为了提高代码的复用性,对代码进行抽取。

    将这个部分定义成一个独立的功能,方便使用。

    Java中对功能的定义是通过函数的形式来体现的。

    即需要定义一个功能:完成任意整数*3+5的值。

    public static int getResult(int num){

    return num*3+5;

    }

    因此,上面的代码就可以简写为:

    public class FuntionDemo{

    public static void main(String[] args){

    int x=getResult(4);

    int y=getResult(6);

    System.out.println("x="+x+",y="+y);

    }

    }

    public static int getResult(int num){

    return num*3+5;

    }

    //该程序运行结果为:x=17,y=23

    2.函数的特点

    1) 定义函数可以将功能代码进行封装。

    2) 便于对该功能进行复用。

    3) 函数只有被调用才会执行。

    4) 函数的出现提高了代码的复用性。

    5) 当函数没有具体返回值的情况,返回值类型用关键字void标识,即void代表的是函数没有具体返回值,那么该函数中的return语句如果在最后一行可以省略不写,该功能也不能在输出语句中输出,在功能中可以输出,函数直接调用。

    6) 注意写法格式:

    函数只能调用函数,不可以在函数内部定义函数(函数是平级的,谁也不包含谁)。

    定义函数时,函数的结果应该返回给调用者,交由调用者处理。

    7) 例子说明:直接打印结果,不返回值(注意对应第五个特点)

    public class FuntionDemo{

    public static void main(String[] args){

    getResult(5);

    }

    public static void getResult(int num){

    System.out.println(num*3+5);

    return; //return可以省略不写。

    }

    }

    //该程序运行结果为:20

    3.函数的应用

    1) 如何定义一个函数?

    *1* 既然函数是一个独立的功能,那么先明确该功能的运算结果是什么。

    *2* 再明确在定义该功能的过程中是否需要未知的内容参与运算。

    *3* 定义函数时只需完成相对应的功能,将结果返回给调用者,调用者怎么使用是调用者的事情。

    2)实例说明

    这里以简单的加法运算为例,主要介绍函数的应用,对于函数的特点体现不是特别明确。

    *1* 需求:定义一个功能,完成3+4的运算,并将结果返回给调用者。

    *2* 思路:1.明确该功能的运算结果:是一个整数的和,即明确函数的返回值类型。

    2.再明确在定义该功能的过程中没有未知的内容参与运算,即明确函数的参数列表(参数类型和参数个数)。

    *3* 程序实现:

    class FunctionDemo2{

    public static void main(String[] args){

    int sum=getAdd();

    System.out.println("sum="+sum);

    }

    public static int getAdd(){

    return 3+4;

    }

    }

    *4* 结果分析:该程序运行结果为:sum=7

    以上函数的功能,结果是固定的,无扩展性。

    为方便用户需求,由用户来指定加数和被加数,这样功能才有意义。

    *1* 需求:定义一个功能,完成任意两个整数加法的运算,并将结果返回给调用者。

    *2* 思路:

    功能的结果是一个整数,即返回值类型为int。

    有两个未知内容参与运算,类型为int。

    *3* 程序实现:

    class FunctionDemo2{

    public static void main(String[] args){

    int sum=getAdd(3,5);

    System.out.println("sum="+sum);

    int sum=getAdd(6,6);

    System.out.println("sum="+sum);

    public static int getAdd(int a int b){

    return a+b;

    }

    }

    *4* 结果分析:该程序运行结果为:sum=8

    sum=12

    3)函数的具体应用实例(一)

    *1* 需求:判断两个数是否相等。

    *2* 思路:

    功能的结果是一个boolean型变量,即返回值类型为boolean。

    有两个未知内容参与运算,类型为int。

    *3* 程序实现:

    class FunctionDemo{

    public static void main(String[] args){

    compare(3,5);

    System.out.println(compare(3,5));

    }

    public static boolean compare(int a,int b){

    return (a==b)?true:false;

    }

    }

    *4* 结果分析:该程序运行结果为:flase

    4)函数的具体应用实例(二)

    *1* 需求:输出两个整数中的最大值。

    *2* 思路:

    功能的结果是int型变量,即返回值类型为int。

    有两个未知内容参与运算,类型为int。

    *3* 程序实现:

    class FunctionDemo{

    public static void main(String[] args){

    getMax(3,5);

    System.out.println(getMax(3,5));

    }

    public static int getMax(int a,int b){

    return (a>b)?a:b;

    }

    }

    *4* 结果分析:该程序运行结果为:5

    4)函数的具体应用实例(三)

    *1* 需求:定义一个功能,用于打印矩形。

    *2* 思路:

    功能的结果直接打印,所以返回值类型是void。

    有两个未知内容(矩形的行和列)参与运算,类型为int。

    *3* 程序实现:

    class FunctionDemo{

    public static void main(String[] args){

    draw(2,4);

    printHr();

    draw(3,6);

    printHr();

    }

    public static void draw(int row,int col){ //实现矩形的打印功能

    for(int x=0;x

    for(int y=0;y

    System.out.print("*");

    }

    System.out.println();

    }

    }

    public static void printHr(){ //将每个矩形分割开

    System.out.println("----------------------");

    }

    }

    *4* 结果分析:该程序运行结果为:

    ****

    ****

    ----------------------

    ******

    ******

    ******

    ----------------------

    4.函数的重载

    1) 重载的概念

    在同一个类中,允许存在一个以上的同名函数,只要它们的参数个数或者参数类型不同即可。。

    2) 重载的特点

    与返回值类型无关,只看参数列表。

    3) 重载的好处

    方便于阅读,优化了程序设计。

    4) 重载示例

    *1*返回任意两个小数的和

    int add(double a,double b){return a+b;}

    *2*返回任意两个整数的和

    int add(int a,int b){return a+b;}

    *3*返回任意三个整数的和

    int add(int a,int b,int c){return a+b+c;}

    5) 重载的应用(什么时候用重载)

    当定义的功能相同,但参与运算的未知内容不同时,通过参数列表的不同来区分多个同名函数。

    6)重载应用实例

    class FunctionOverload {

    public static void main(String[] args) {

    int x=add(3,6);

    System.out.println(x);

    int y=add(3,6,7);

    System.out.println(y);

    }

    //定义一个加法运算,获取两个整数的和。

    public static int add(int a, int b){

    return a+b;

    }

    //定义一个加法运算,获取三个整数的和。

    public static int add(int a, int b,int c){

    return a+b+c;

    }

    }

    //该程序运行结果为:9

    16

    展开全文
  • 函数嵌套调用性能好还是分开写性能好?下午突然想到一个问题:* 形式如下的两种方法,哪一种的效率更高一点?第一种:A=fun1(args1[]);B=fun2(A,args2[]);C.fun3(B);123第二种:C.fun3(fun2(fun1(args1[]),args2[]))...

    函数嵌套调用性能好还是分开写性能好?

    下午突然想到一个问题:

    * 形式如下的两种方法,哪一种的效率更高一点?

    第一种:

    A=fun1(args1[]);

    B=fun2(A,args2[]);

    C.fun3(B);

    1

    2

    3

    第二种:

    C.fun3(fun2(fun1(args1[]),args2[]));

    1

    也就是说,一段结果相同的代码,是将中间使用的函数嵌套起来写性能更好还是分开写性能更高呢?

    这里假定变量不会再被后面的代码使用,不存在复用的问题,同时,也将可读性问题暂放一边,仅仅从性能角度考虑。

    直觉上,应当是第二种形式的性能更高一些,减少了中间变量存储,但是我还是有一点迷惑:函数调用时系统要保存现场,对各种变量在栈中进行保存,调用完了还要恢复现场,恢复各种上一个方法中的值,第二种形式是不是在这方面消耗了更多性能呢?毕竟在第二种形式中,刚想调用fun3,发现还要调用fun2,刚想调用fun2,发现还必须先调用fun1。

    本着先敲一敲看看的想法,我用java写了一个测试代码(放到文章最后面),从javap反编译的中间代码上能看出上面两个问题的答案:

    第一种形式:

    第二种形式:

    从代码上,可以看出,第一种形式的确会多保存两个临时变量,多了成对的两个命令’astore’、’aload’从寄存器中存读变量。

    而第二种形式在编译成中间代码之后,函数的调用顺序也变成了fun1->fun2->fun3,而且没有中间变量。

    后来我又想了想,其实第一种形式和第二种形式函数调用对栈的影响次数是一样的,即便第二种函数切换频繁,在机器层面也是按部就班地做,性能上应当相同。

    结论:

    第二种形式在性能上更优

    题外话:

    在看反编译的中间代码时我发现,即便普通的字符串拼接,到了java字节码的层次,也是通过StringBuilder完成的,也就是说简单的字符串拼接,性能上应当和使用StringBuilder一样,字符串拼接在这里不会形成性能瓶颈,但是也有例外。

    比如,我在下面的测试代码里用的那样,在for循环中循环字符串拼接,这个时候会反复调用StringBuilder的toString方法,导致产生大量的String挤占堆空间,结果我的测试代码就显示OOM了,所以如果要使用以下代码请调节循环次数。

    从1中可以看出,其实我测试代码有问题,本来想找个耗时的操作区分两种形式代码的性能,所以使用了String的拼接,结果循环次数一多就OOM,也就是说我没从实践中真实测得两种形式代码的差别(即便循环次数少的情况下,多次测量结果也是千奇百怪,我怀疑系统对程序的调度影响了耗时)

    以下我写的测试代码:

    public class AnyIdeaTestFirst{

    /**

    * 静态内部类,用于返回一个记录方法耗时和字符串的集合

    */

    static class Iner{

    String s;

    long time;

    public String getS() {

    return s;

    }

    public void setS(String s) {

    this.s = s;

    }

    public long getTime() {

    return time;

    }

    public void setTime(long time) {

    this.time = time;

    }

    }

    public static Iner fun1(String a){

    long timeBefore=System.currentTimeMillis();

    for(int i=0;i<50;i++){

    a+=a;

    }

    Iner iner=new Iner();

    iner.setS(a);

    long timeAfter=System.currentTimeMillis();

    iner.setTime(timeAfter);

    System.out.println("fun1 after:"+(timeAfter-timeBefore));

    return iner;

    }

    public static Iner fun2(Iner iner,String a){

    long timeBefore=System.currentTimeMillis();

    System.out.println("进入fun2,与退出fun1之间的时间差:"+(timeBefore-iner.getTime()));

    for(int i=0;i<30;i++){

    iner.setS(a);;

    }

    long timeAfter=System.currentTimeMillis();

    iner.setTime(timeAfter);

    System.out.println("fun1 after:"+(timeAfter-timeBefore));

    return iner;

    }

    public static void fun3(Iner iner){

    long timeBefore=System.currentTimeMillis();

    System.out.println("进入fun3,与退出fun2之间的时间差:"+(timeBefore-iner.getTime()));

    }

    public static void main(String []args){

    System.gc();

    System.out.println("方法一开始-------------------------------"+System.currentTimeMillis());

    Iner iner1=fun1("a");

    Iner iner2=fun2(iner1,"b");

    fun3(iner2);

    System.out.println("方法一结束--------------------------------"+System.currentTimeMillis());

    System.out.println("方法二开始--------------------------------"+System.currentTimeMillis());

    fun3(fun2(fun1("c"),"d"));

    System.out.println("方法二结束--------------------------------"+System.currentTimeMillis());

    }

    }

    ---------------------

    作者:lqadam

    来源:CSDN

    原文:https://blog.csdn.net/lqadam/article/details/53395019

    版权声明:本文为博主原创文章,转载请附上博文链接!

    展开全文
  • Java script的嵌套函数、递归函数

    千次阅读 2015-05-01 19:45:21
    script的嵌套函数、递归函数" title="Java script的嵌套函数、递归函数" style="margin:0px; padding:0px; border:0px; list-style:none"> 2.递归函数 script的嵌套函数、递归函数" title="Java script的嵌套...
    1.嵌套函数:
    Java <wbr>script的嵌套函数、递归函数

    2.递归函数
    Java <wbr>script的嵌套函数、递归函数
    展开全文
  • publicabstractclassSensorextendsThread{publicstaticvoidmain(String[]args){//需要在main函数里面初始化5个sensor,并且分别建立5个线程//Sensor必须是抽象类,建立5个sensor的时候编...public abstract class ...
  • Python函数定义、匿名函数、嵌套函数、闭包、装饰器函数核心理解函数也是对象,可以把函数赋予变量可以把函数当作参数,传入另一个函数中可以在函数里定义函数,函数嵌套函数的返回值也可以是函数对象,闭包1....
  • 函数嵌套函数嵌套就是在函数内调用了其他函数名称空间与作用域名称空间:就是存放名字与值绑定关系的地方名称空间分类:1,内置名称空间:存放python解释器自带的名字,在解释器启动时生效,关闭就失效2,全局名称...
  • scala 函数中嵌套函数 Scala中的嵌套函数 (Nested functions in Scala) A nested function is defined as a function which is defined inside the definition of another function. Programming languages like c, ...
  • 在数据可用之前,传递给getLocations()的函数将不会被调用,因此在设置之前返回“国家”将无济于事。您需要执行的方法是让传递给geocoder.getLocations()的函数实际完成返回值所需的任何操作。像这样:function ...
  • 本地 local 本地使用,在函数缩进中,代表着本地缩进封闭 enclosing 在嵌套函数中使用,全局 global 任何地方都能使用,模块的顶层内置 Builtin 内置,比如 int,内置函数等。1.1 作用域的范围 与 搜索次序...
  • Created by Wang, Jerry, last modified on Dec 24, 2015
  • 一、函数对象(精髓:可以把函数当成变量去用)函数对象指的是函数可以被当做’数据’来处理,具体可以分为四个方面的使用。def func():# func指向函数体内存地址print('from func')1、可以赋值f=funcprint(f,func)# f...
  • 我想了解构造函数是如何工作的,...下面是我在做什么一个简单的例子:什么时候在嵌套类中调用构造函数(Java)private class Person{private String name;private Address unitedStates;private Address unitedKingdo...
  • ExampleIf you want to create an instance of an inner nested class you need to provide a class object of the enclosing class as an extra parameter with Class#getDeclaredConstructor.public class Enclosi...
  • 我想知道是否有任何构造函数涉及到内部类。例如,考虑下面给出的代码片段class MyOuter{private int x= 10;class MyInner{void dostuff(){System.out.println("The value of x is"+x);}}}在另一个Java文件中,我为...
  • 详解Java 中的嵌套类与内部类在Java中,可以在一个类内部定义另一个类,这种类称为嵌套类(nested class)。嵌套类有两种类型:静态嵌套类和非静态嵌套类。静态嵌套类较少使用,非静态嵌套类使用较多,也就是常说的...
  • Java方法的嵌套与递归调用本文关键字:方法、嵌套、递归、经典问题一、方法的嵌套1. 概念解读方法嵌套的概念其实比较好理解,就是在调用方法的过程中又遇到了方法的调用,在刚开始接触的时候虽然在逻辑上能够理解为...
  • 我不认为您可以无需创建自己的自定义模式(这对于嵌套结构来说是不平凡的),但是下面的例子可能非常接近,而不用这样做.首先,定义一个抽象bean作为外部bean的模板(我的示例使用一个Car作为外部bean,一个Engine作为内部...
  • Java允许类的嵌套定义。这里将讲解如何在一个类中嵌套定义另一个类。嵌套内部类Java允许我们在类的内部定义一个类。如果这个类是没有static修饰符,那么这样一个嵌套在内部的类称为内部类(inner class)。内部类被...
  • dayName函数是一个带有私有变量的闭包 . 您可以访问该数组varreturn names[number];内部功能 . 将Number传递给名称以声明要捕获的数组中的哪个值 .从本质上讲,这就是正在发生的事情var dayName = function(number) ...
  • C++不支持嵌套函数(像Pascal,Java等都支持),这给编程带来很大麻烦。 使用嵌套函数相对于全局函数有很多好处: 嵌套函数只在外层函数中有效,防止将函数作为全局函数而污染全局函数空间,使全局函数数量膨胀 ...
  • 1.函数简化fun plus(args1:Int,args2:Int):Int {return args1+args2}fun plus(args1:Int,args2:Int):Int = args1+args22.命名参数,参数默认值,位置参数/*** 命名参数,位置参数调用的时候有个主意事项,位置参数必须...
  • java中的实现:常规的逻辑判断(开关)(用在最外层),一层一层的往外传递,每层使用逻辑判断...以上是常规也是最底层的方式,其他是否有可以直接跳出多层嵌套函数的方法我也不是很清楚,感觉应该有,找到了之...
  • 我在以下位置阅读有关新功能的信息:http : //www.javaworld.com/article/2078836/java-se/love-and-hate-for-java-8.html我看到了下面的示例:使用匿名类:button.addActionListener(new ActionListener() {public ...
  • 我们平时写if,switch或for语句是常有的事儿,也一定写过多层if或for语句嵌套的情况...1 尽早终止函数或返回数据如果符合某个条件下可以直接终止函数,则应该将这个条件放在第一位。我们来看看下面的例子。if(condi...
  • 5、嵌套函数

    2019-01-25 11:05:18
    ...java" def change_name2(): name = "linux" print("第3层打印", name) change_name2() # 调用内层函数 print("第2层打印", name) change_name(...
  • 比较Java的内部类和JavaScript的闭包根据维基百科的定义: In programming languages, a closure (also lexical closure or function closure) is a technique for implementing lexically scoped name binding in a ...
  • 我遇到了一个读取文本文件并对其进行分析的代码库。 我对使用异常的方式感到困惑。 单独的类... error()函数也有一个异常处理程序,可能导致嵌套异常! 在基本的try和catch应该足够的情况下进行这种异常...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,324
精华内容 529
关键字:

java嵌套函数

java 订阅