精华内容
下载资源
问答
  • Java内部与外部类之间参数传递

    万次阅读 2018-05-23 15:56:35
    转自 : http://wendal.net/404.html传入://匿名内部,只能访问final的本地变量及方法参数 public void addUser(final String name, String passwd, final String userType) { User user = null; if ("admin...

    转自 : http://wendal.net/404.html


    传入:

    //匿名内部类,只能访问final的本地变量及方法参数
    public void addUser(final String name, String passwd, final String userType) {
        User user = null;
        if ("admin".equal(userType))
            user = new AdminUser(name, passwd); //仅作演示.
        else
            user = new User(name, passwd);
        final User _user = user; //因为user变量不能设置为final,所以需要新加一个变量来中转
        Trans.run(new Atom(){
            public void run() {
                dao.insert(_user);
                if (log.isDebugEnable())
                    log.debugf("Add user id=%d, name=%s , type=%s", _user.getId(), name, userType);
            }
        });
    }
    

    传出(获取方法返回值等等):

    方法1 – 对象数组法 通过一个final的Object对象数组,存放需要的值

    public long countUser(final String userType) {
        final Object[] objs = new Object[1];
        Trans.run(new Atom(){
            public void run() {
                objs[0] = dao.count(User.class, Cnd.where('userType', '=', userType));
            }
        });
        return ((Number)objs[0]).longValue();
    }
    

    方法2 – ThreadLocal法 通过一个ThreadLocal来存放结果,这个ThreadLocal可以是静态的,供全app使用的

    private static final ThreadLocal re = new ThreadLocal(); //自行补上泛型Object
    public long countUser(final String userType) {
        Trans.run(new Atom(){
            public void run() {
                re.set(dao.count(User.class, Cnd.where('userType', '=', userType)));
            }
        });
        return ((Number)re.get()).longValue(); //严谨一点的话,应该将ThreadLocal置空
    }
    

    方法3 – Molecule法 Molecule类是Nutz内置的抽象类类,实现Runnable和Atom接口,添加了两个获取/设置值的方法.

    public long countUser(final String userType) {
        Molecule mole = new Molecule() { //需要自行补齐泛型
            public void run() {
                setObj(dao.count(User.class, Cnd.where('userType', '=', userType)));
            }
        };
        Trans.run(mole);
        return ((Number)mole.getObj()).longValue(); 
    }
    展开全文
  • java中的参数传递-值传递、引用传递

    千次阅读 2017-04-12 16:38:05
    参数是按值而不是按引用传递的说明 Java 应用程序有且仅有的一种参数传递机制,即按值传递。 在 Java 应用程序中永远不会传递对象,而只传递对象引用。因此是按引用传递对象。Java 应用程序按引用传递对象这一事实...

    参数是按值而不是按引用传递的说明 Java 应用程序有且仅有的一种参数传递机制,即按值传递。

    在 Java 应用程序中永远不会传递对象,而只传递对象引用。因此是按引用传递对象。Java 应用程序按引用传递对象这一事实并不意味着 Java 应用程序按引用传递参数。参数可以是对象引用,而 Java 应用程序是按值传递对象引用的。

     

    Java 应用程序中的变量可以为以下两种类型之一:引用类型或基本类型。当作为参数传递给一个方法时,处理这两种类型的方式是相同的。两种类型都是按值传递的;没有一种按引用传递。

     

    按值传递和按引用传递。按值传递意味着当将一个参数传递给一个函数时,函数接收的是原始值的一个副本。因此,如果函数修改了该参数,仅改变副本,而原始值保持不变。按引用传递意味着当将一个参数传递给一个函数时,函数接收的是原始值的内存地址,而不是值的副本。因此,如果函数修改了该参数,调用代码中的原始值也随之改变。

    1、对象是按引用传递的

    2、Java 应用程序有且仅有的一种参数传递机制,即按值传递

    3、按值传递意味着当将一个参数传递给一个函数时,函数接收的是原始值的一个副本

    4、按引用传递意味着当将一个参数传递给一个函数时,函数接收的是原始值的内存地址,而不是值的副本

    首先考试大来看看第一点:对象是按引用传递的

      确实,这一点我想大家没有任何疑问,例如:

      class Test01

      {

      public static void main(String[] args)

      {

      StringBuffer s= new StringBuffer("good");

      StringBuffer s2=s;

      s2.append(" afternoon.");

      System.out.println(s);

      }

      }

      对象s和s2指向的是内存中的同一个地址因此指向的也是同一个对象。

      如何解释“对象是按引用传递的”的呢?

      这里的意思是进行对象赋值操作是传递的是对象的引用,因此对象是按引用传递的,有问题吗?

      程序运行的输出是:

      good afternoon.

      这说明s2和s是同一个对象。

      这里有一点要澄清的是,这里的传对象其实也是传值,因为对象就是一个指针,这个赋值是指针之间的赋值,因此在java中就将它说成了传引用。(引用是什么?不就是地址吗?地址是什么,不过就是一个整数值)

      再看看下面的例子:

      class Test02

      {

      public static void main(String[] args)

      {

      int i=5;

      int i2=i;

      i2=6;

      System.out.println(i);

      }

      }

      程序的结果是什么?5!!!

      这说明什么,原始数据类型是按值传递的,这个按值传递也是指的是进行赋值时的行为下一个问题:Java 应用程序有且仅有的一种参数传递机制,即按值传递

      class Test03

      {

      public static void main(String[] args)

      {

      StringBuffer s= new StringBuffer("good");

      StringBuffer s2=new StringBuffer("bad");

      test(s,s2);

      System.out.println(s);//9

      System.out.println(s2);//10

      }

      static void test(StringBuffer s,StringBuffer s2) {

      System.out.println(s);//1

      System.out.println(s2);//2

      s2=s;//3

      s=new StringBuffer("new");//4

      System.out.println(s);//5

      System.out.println(s2);//6

      s.append("hah");//7

      s2.append("hah");//8

      }

      }

      程序的输出是:

      good

      bad

      new

      good

      goodhah

      bad

      考试大提示: 为什么输出是这样的?

      这里需要强调的是“参数传递机制”,它是与赋值语句时的传递机制的不同。

      我们看到1,2处的输出与我们的预计是完全匹配的

      3将s2指向s,4将s指向一个新的对象

      因此5的输出打印的是新创建的对象的内容,而6打印的原来的s的内容

      7和8两个地方修改对象内容,但是9和10的输出为什么是那样的呢?

      Java 应用程序有且仅有的一种参数传递机制,即按值传递。

    在这里画了一个图给大家分析:



    1.对象就是传引用

    2.原始类型就是传值

    3.String类型因为没有提供自身修改的函数,每次操作都是新生成一个String对象,所以要特殊对待。可以认为是传值。


    参考:http://www.cnblogs.com/perfy/archive/2012/10/16/2726039.html

    展开全文
  • Java中的参数传递

    万次阅读 多人点赞 2018-01-19 13:52:15
    传引用参数指的还是原来的那个引用,但是Java里面参数类型是对象时是复制了原来的引用到一块新的内存,两者之间没有关系 1:按值传递是什么 指的是在方法调用时,传递参数是按值的拷贝传递。示例如下: ...

    Java中没有真正的引用传递 只有值传递!

    传引用参数指的还是原来的那个引用,但是Java里面参数类型是对象时是复制了原来的引用到一块新的内存,两者之间没有关系

    1:按值传递是什么

    指的是在方法调用时,传递的参数是按值的拷贝传递。示例如下:

        public class TempTest {
            private void test1(int a){
            //做点事情
            }
            public static void main(String[] args) {
                TempTest t = new TempTest();
                int a = 3;
                t.test1(a);//这里传递的参数a就是按值传递
            }
        }

    按值传递重要特点:传递的是值的拷贝,也就是说传递后就互不相关了。

    示例如下:

        public class TempTest {
            private void test1(int a){
                a = 5;
                System.out.println("test1方法中的a="+a);
            }
            public static void main(String[] args) {
                TempTest t = new TempTest();
                int a = 3;
                t.test1(a);//传递后,test1方法对变量值的改变不影响这里的a
                System.out.println(”main方法中的a=”+a);
            }
        }

    运行结果是:
    test1方法中的a=5
    main方法中的a=3

    2:按引用传递是什么

    指的是在方法调用时,传递的参数是按引用进行传递,其实传递的引用的地址,也就是变量所对应的内存空间的地址。

    示例如下:

        public class TempTest {
            private void test1(A a){
            }
            public static void main(String[] args) {
                TempTest t = new TempTest();
                A a = new A();
                t.test1(a); //这里传递的参数a就是按引用传递
            }
        }
        class A{
            public int age = 0;
        }

    3:按引用传递的重要特点

    传递的是值的引用,也就是说传递前和传递后都指向同一个引用(也就是同一个内存空间)。

    示例如下:

        public class TempTest {
            private void test1(A a){
                a.age = 20;
                System.out.println("test1方法中的age="+a.age);
            }
            public static void main(String[] args) {
                TempTest t = new TempTest();
                A a = new A();
                a.age = 10;
                t.test1(a);
                System.out.println(”main方法中的age=”+a.age);
            }
        }
        class A{
            public int age = 0;
        }

    运行结果如下:
    test1方法中的age=20
    main方法中的age=20

    4:理解按引用传递的过程——内存分配示意图

    要想正确理解按引用传递的过程,就必须学会理解内存分配的过程,内存分配示意图可以辅助我们去理解这个过程。

    用上面的例子来进行分析:

    (1):运行开始,运行第8行,创建了一个A的实例,内存分配示意如下:
    这里写图片描述
    (2):运行第9行,是修改A实例里面的age的值,运行后内存分配示意如下:
    这里写图片描述

    (3):运行第10行,是把main方法中的变量a所引用的内存空间地址,按引用传递给test1方法中的a变量。请注意:这两个a变量是完全不同的,不要被名称相同所蒙蔽。

    内存分配示意如下:
    这里写图片描述
    由于是按引用传递,也就是传递的是内存空间的地址,所以传递完成后形成的新的内存示意图如下:
    这里写图片描述
    也就是说:是两个变量都指向同一个空间。

    (4):运行第3行,为test1方法中的变量a指向的A实例的age进行赋值,完成后形成的新的内存示意图如下:
    这里写图片描述
    此时A实例的age值的变化是由test1方法引起的

    (5):运行第4行,根据此时的内存示意图,输出test1方法中的age=20

    (6):运行第11行,根据此时的内存示意图,输出main方法中的age=20
    5:对上述例子的改变

    理解了上面的例子,可能有人会问,那么能不能让按照引用传递的值,相互不影响呢?就是test1方法里面的修改不影响到main方法里面呢?

    方法是在test1方法里面新new一个实例就可以了。改变成下面的例子,其中第3行为新加的:

        public class TempTest {
            private void test1(A a){
                a = new A();//新加的一行
                a.age = 20;
                System.out.println("test1方法中的age="+a.age);
            }
            public static void main(String[] args) {
                TempTest t = new TempTest();
                A a = new A();
                a.age = 10;
                t.test1(a);
                System.out.println(”main方法中的age=”+a.age);
            }
        }
        class A{
            public int age = 0;
        }

    运行结果为:
    test1方法中的age=20
    main方法中的age=10
    为什么这次的运行结果和前面的例子不一样呢,还是使用内存示意图来理解一下

    6:再次理解按引用传递

    (1):运行开始,运行第9行,创建了一个A的实例,内存分配示意如下:
    这里写图片描述
    (2):运行第10行,是修改A实例里面的age的值,运行后内存分配示意如下:
    这里写图片描述
    (3):运行第11行,是把main方法中的变量a所引用的内存空间地址,按引用传递给test1方法中的a变量。请注意:这两个a变量是完全不同的,不要被名称相同所蒙蔽。

    内存分配示意如下:
    ![这里写图片描述]
    由于是按引用传递,也就是传递的是内存空间的地址,所以传递完成后形成的新的内存示意图如下:

    这里写图片描述
    也就是说:是两个变量都指向同一个空间。

    (4):运行第3行,为test1方法中的变量a重新生成了新的A实例的,完成后形成的新的内存示意图如下:
    这里写图片描述
    (5):运行第4行,为test1方法中的变量a指向的新的A实例的age进行赋值,完成后形成的新的内存示意图如下:
    这里写图片描述
    注意:这个时候test1方法中的变量a的age被改变,而main方法中的是没有改变的。

    (6):运行第5行,根据此时的内存示意图,输出test1方法中的age=20

    (7):运行第12行,根据此时的内存示意图,输出main方法中的age=10

    7:说明

    (1):“在Java里面参数传递都是按值传递”这句话的意思是:按值传递是传递的值的拷贝,按引用传递其实传递的是引用的地址值,所以统称按值传递。

    (2):在Java里面只有基本类型和按照下面这种定义方式的String是按值传递,其它的都是按引用传递。就是直接使用双引号定义字符串方式:String str = “Java私塾”;

    展开全文
  • java main方法参数传递

    万次阅读 2017-06-22 14:35:01
    并且需要输入参数的时候就需要用到main的参数传递 首先main方法中传递的参数是String数组 我们直接打印这个数组是没有值得空数组 所以可以编辑其下的代码 package com; public class TestMain {
    一般情况下 我们的main方法是不需要参数传入的 但是如果在工作中需要我们写一些小的应用程序 并且以jar包的方式发给其他人员直接在dos界面使用
    并且需要输入参数的时候就需要用到main的参数传递

    首先main方法中传递的参数是String数组 我们直接打印这个数组是没有值得空数组
    所以可以编辑其下的代码
    package com;
    public class TestMain {
                public static void main(String[] args) {
                      System.out.println(args[0]);
            System.out.println(args[1]);
            System.out.println(args[2]);
    }
                
    }

    在项目中右击 点击run as 在出现的对话框中 选择 run configurations 然后在 Arguments 这个条目中
    配置Program arguments 的值  元素之间用空格分开  然后点击run
    如果我们在其中输入 1  2  3    run之后 Console窗口 运行结果为
    1
    2
    3
    这是在myeclipse中main方法中String数组参数传递的方式(这种方式用于程序员测试  一般操作人员没有ide 会在dos界面操作)



     开发人员先将程序打包成.jar的文件 然后 告诉人员参数的个数 及形式 然后就可以通过命令进行运行(此机器必须拥有运行环境)
    (打包的方式可以参考我的另外两篇文章 http://blog.csdn.net/docuxu/article/details/73469340或者 http://blog.csdn.net/docuxu/article/details/73163549)

    这个测试程序没有额外的依赖jar包 我选择不适用插件的方法直接用 也给大家没有插件的人方便

    命令如下


    需要注意的是 在所传的参数中 如果包含特殊字符必须用双引号包裹


    展开全文
  • Java与React Native之间传递参数

    万次阅读 2016-07-18 11:28:38
    Java与React Native之间传递参数React Native作为一种新型的前端开发语言,必然很强大,但难免也有JavaScript无法实现的功能,这就需要和原生语言进行交互。而交互的过程中无非是函数以及参数传递,官网上对于...
  • java类之间的数据传递

    千次阅读 2015-03-08 21:19:14
    虽然最开始学java的时候,就知道java类之间数据的传递,可能当时也懂,不过可能忘了,  刚好,用到了这个,然后只为将一个数据连续传到后两个。  方法,通过构造函数,或者通过set方法。  构造函数:  ...
  • JAVA接口作为参数传递

    万次阅读 多人点赞 2011-07-20 18:02:55
    可以将接口类型的参数作为方法参数,在实际是使用时可以将实现了接口的类传递给方法,后方法或按照重写的原则执行,实际调用的是实现中的方法代码体,这样便根据传进入的参数的不同而实现不同的功能。重要的是,当...
  • Fragment参数传递方法二 可以使用bundle进行参数传递、这样在两个Fragment跳转的时候就可以带上参数了、同样也可以传递一个复杂的对象 ft.hide(getActivity().getSupportFragmentManager().findFragmentByTag("...
  • java参数传递是值传递还是地址传递结论: 1、基本类型作为参数传递时,是传递值的拷贝,无论你怎么改变这个拷贝,原值是不会改变的 2、对象作为参数传递时,是把对象在内存中的地址拷贝了一份传给了参数。 ...
  • Java类之间的数据传递3中方法。

    千次阅读 2015-07-30 10:12:27
    2.如果是类之间传递变量有两种方法,假如A调用B的一个属性,B的长像如下: class B {  public static String x ="nice"; public static void main(String []arg) { } } A可这样写 2.1 clas
  • JAVA参数传递方式 (按值传递与引用传递区别)

    千次阅读 多人点赞 2018-09-30 22:58:30
    首先要明确的是JAVA中没有引用传递, 全部是按值调用 令大家所费解的 当对象引用作为参数时 函数为什么能修改真实的对象呢?这不是引用传递的特征吗? 尤其先学习C++再学习JAVA的同学(比如说我自己)会这样认为, 用...
  • 大家都很清楚,在同一个java web项目中servlet之间、servlet与jsp页面之间、jsp页面之间传值大家都很熟悉。最近在做项目中需要将参数从一个项目的servlet中传递到另外一个项目的servlet中,其中还有中文,这改怎么...
  • 原先开发了一个功能,由于是两个系统做交互,所以在参数传递这一块做的比较简陋,有安全性问题,需重新调整。 原先的实现方式是,在A系统做用户校验,校验成功之后,把用户信息直接加密拼接成一个url,然后直接...
  • 然后联想到javajava传递参数是通过什么方式呢?是值传递还是引用传递? 在网上查阅资料知:java传递参数只有值传递。当参数为普通类型时,传递的是值;当参数为引用类型时,传递的是对象的引用(即地址),都是...
  • 类之间传递参数

    千次阅读 2017-10-26 16:12:56
     3、当B在A中要使用时,自然要传一个参数才能构造,此时传递“this”作为参数,就相当于将B中的那个A的实例赋值了,  4,、由于C要在B中使用,同样的方法,将值又从B中传递到C中。  5,、传递值,或者...
  • java的方法参数传递方式有两种,按值传递和引用传递 1.按值传递 参数类型是int,long等基本数据类型(八大基本数据类型),参数传递的过程采用值拷贝的方式 代码片段1: public class Test { public static void ...
  • JAVA 方法的参数是按值传递还是引用传递
  • Java如何向线程传递参数

    千次阅读 2018-08-28 14:17:55
    由于线程的运行和结束是不可预料的,因此,在传递和返回数据时就无法象函数一样通过函数参数和return语句来返回数据。本文就以上原因介绍了几种用于向线程传递数据的方法. 欲先取之,必先予之。一般在使用线程时都....
  • 所谓参数传递就是用函数调用所给出的实参(实际参数)向函数定义所给出的形参(形式参数)设置初始值的过程。基本的有三种参数分别为: (1)传值:  (2)传址(即是传指针) (3)传引用 以上这些都...
  • java调用post 传递参数

    千次阅读 2019-09-23 13:10:11
    import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.io.OutputStreamWriter; import java.net.URL; import java.net.URLConnection; public...
  • Java与C之间传递数据

    千次阅读 2011-10-14 19:54:47
    介绍Java如何将数据传递给C和C回调Java的方法。 java传递数据给C,在C代码中进行处理数据,处理完数据后返回给java。C的回调是Java传递数据给C,C需要用到Java中的某个方法,就需要调用java的方法。 Android中使用...
  • java中对象作为参数传递给一个方法,到底是值传递,还是引用传递? pdd:所谓java只有按值传递:基本类型 值传递;引用类型,地址值传递,所以叫值传递。  当主函数的变量,对象(主本)传递到副函数时,传递的...
  • android-jni与java参数传递

    千次阅读 2012-05-09 19:05:57
    android-jni与java参数传递 =================================================================================================== 问题的来源: jni与java之间互传参数,有几个问题需要解决: 1、需要...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 311,232
精华内容 124,492
关键字:

java类之间参数传递

java 订阅