java接口 作为函数参数传递。。。。怎么传递值？

Posted 2023-04-30

public interface NVectorADT

public NVectorADT plus ( NVectorADT y ) ;
public NVectorADT minus ( NVectorADT y ) ;
public NVectorADT mult ( NVectorADT y ) ;
public NVectorADT divby ( NVectorADT y ) ;
public double sum( ) ;
public NVectorADT s q r t ( ) ;
public int s i z e ( ) ;
public double [ ] getAsArray ( ) ;
public boolean equa l s ( NVectorADT y ) ;

这是接口

public class DVector implements NVectorADT

....DVector是实现接口的类

。。。。。。

public class DVectorTest extends TestCase
DVectorTest是测试类
下面是测试类中的加法的那个函数，接口和测试类是老师给的
要编写DVector类
我不明白 的是
public void testPlus()

int n = 100;
double[] arr = new double[n];
double[] arr2 = new double[n];
double[] arr3 = new double[n];
for( int i = 0; i < n; ++i )

arr[i] = i;
arr2[i] = i*3;
arr3[i] = arr[i] + arr2[i];

DVector dv = new DVector(arr);
DVector dv2 = new DVector(arr2);
DVector dv3 = new DVector(arr3);
NVectorADT dv4 = dv.plus(dv2);////////////////////这块，参数dv2在接口中是接口类型的在这怎么是DVector类型的，如果是接口类型的怎么传递参数arr2...................................................................................................如果写成DVector dv2;
有dv2.arr......
如果写成NVectorADT dv2;
就没有dv2.arr。。。。。
接口中那样写，，，那在DVector中怎么实现
谢谢
assertTrue(dv3.equals(dv4));

没有数组就没有成员，实现不了相加。。

但是我感觉我的那个程序比较麻烦，实现接口的类要多一个私有的成员 数组，但是接口里没有
在接口函数参数是接口类型的，到实现他的类中的函数参数，如果也是接口类型的就不会有它的私有的成员，也就是一个数组。。。。。？

你后面的表述确实有点不清晰，你问了NVectorADT dv4 = dv.plus(dv2)这个东西，参数dv2是一个DVector类型的，而接口中定义的dv2应该是NVectorADT的，因为DVector实现了NVectorADT这个接口，其实我们可以有一个很不准确的理解：DVector是NVectorADT的子类，所以DVector类型的也就是NVectorADT类型，就好像我们说DVector类型也是Object类型一样。但是这个说法不准确，但是可以这样理解。
下来就是你问参数的传递问题，你问参数在接口里面是怎么传递的，我觉得你理解错，接口就相当于一个规范，里面不存在什么传递值之说，值的传递是在实现类里面。
也就是你只要实现接口过后，就可以暂时不用去管它了，你只需要看你的实现类厘米的方法就行了。
要是对你有帮助，不要忘了采纳哟，呵呵 参考技术A 你好，很高兴为你解答。
这种用法是Java的接口回调。
接口回调是多态的另一种体现。接口回调是指：
可以把使用实现了某一接口的类创建的对象的引用赋给该接口声明的接口变量，那么该接口变量就可以调用被类实现的接口的方法。实际上，当接口变量调用被类实现的接口中的方法时，就是通知相应的对象调用接口的方法，这一过程称为对象功能的接口回调。
class Student implements People
publicvoid peopleList()
System.out.println("I’m a student.");


class Teacher implements People
publicvoid peopleList()
System.out.println("I’m a teacher.");


publicstaticvoid main(String args[])
a = new Student(); // 实例化，接口变量中存放对象的引用
a.peopleList(); // 接口回调
a = new Teacher(); // 实例化，接口变量中存放对象的引用
a.peopleList(); // 接口回调

参考技术B 要什么参数你传什么啊。你可以把arr arr2 arr 3 设成DVector 的成员变量，然后把DVector 传过去，通过DVector 就能得到你的arr arr2 arr 3。

关于Java对象作为参数传递是传值还是传引用的问题

前言

　　在Java中，当对象作为参数传递时，究竟传递的是对象的值，还是对象的引用，这是一个饱受争议的话题。若传的是值，那么函数接收的只是实参的一个副本，函数对形参的操作并不会对实参产生影响；若传的是引用，那么此时对形参的操作则会影响到实参。 
　　首先我们来看一句代码：

Object obj = new Object();

这句话的意思是：创建一个Object对象，再创建一个名为obj的引用，让这个引用指向这个对象，如下图所示：

在有了上面的基础之后，我们便来看下面这组在网上很流行的例子：

 

基本数据类型作为参数传递：

例1：

public class test {
    public static void main(String[] args) {
        int i = 1;
        System.out.println("before change, i = "+i);
        change(i);
        System.out.println("after change, i = "+i);
    }
    public static void change(int i){
        i = 5;
    }
}

 

 这个例子不难理解，当基本数据类型（Boolean，byte，char，String，int，Long，float，double）作为参数传递时，传递的是实参值的副本，即传的是值，无论在函数中怎么操作这个副本，实参的值是不会被改变的。所以以上代码执行的结果是： 
　　 

　before change, i = 1 
　after change, i = 1 

 

对象作为参数传递：

　　在下面的例２中，我们把StringBuffer对象作为参数传递到change函数。 
　　 
　　例2：

public class test {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer("Hello ");
        System.out.println("before change, sb is "+sb.toString());
        change(sb);
        System.out.println("after change, sb is "+sb.toString());
    }
    public static void change(StringBuffer stringBuffer){
        stringBuffer.append("world !");
    }
}

为了方便推理出结论，我们先直接看程序的运行结果： 
　　 

　　before change, sb is Hello 
　　after change, sb is Hello world ! 

　　 
　　从输出结果中我们可以发现，sb所指向的对象的值被改变了，那么是否我们可以推论出，在Java中，当对象作为参数传递时，传递的是该对象的引用呢？我们再来看下面这个例子： 

public class test {
    public static void main(String[] args) {
        StringBuffer sb = new StringBuffer("Hello ");
        System.out.println("before change, sb is "+sb.toString());
        change(sb);
        System.out.println("after change, sb is "+sb.toString());
    }
    public static void change(StringBuffer stringBuffer){
        stringBuffer = new StringBuffer("Hi ");
        stringBuffer.append("world !");
    }
}

如果上面的推论是正确的，即Java中对象作为参数传递，实际传递的是该对象的引用，那么在调用change函数之后，原对象的值应该是会改变的，变为“Hi world ！”，但是，当我们运行程序后，结果却是如下所示： 
　　 

　　before change, sb is Hello 
　　after change, sb is Hello 

　　 
　　原对象的值并没有被改变，这与上面的推论相矛盾！为什么在Java中，当对象作为参数传递时，有的时候实参被改变了，而有的时候实参并未被改变呢？下面让我们来分析一下其中的原因： 
　　从文章的开头我们知道，当执行StringBuffer sb = new StringBuffer(“Hello “)时，我们创建了一个指向新建对象“new StringBuffer(“Hello “)”的引用“sb”，如下图所示： 

 

在例2中，当我们调用change函数后，实际上，形参stringBuffer也指向了实参sb所指向的对象，即： 

 

那么当我们执行stringBuffer.append(“world !”)后，便通过对象的引用“stringBuffer”修改了对象的值，使之变成了“Hello world ！”，即： 

 

但是，在例3中的change函数中，我们又新建了一个对象“new StringBuffer(“Hi “)”（这实际上在内存中开辟了一块在原对象地址之外的新区域），这让形参stringBuffer实际指向了这个新建的对象，并将新对象的值设置为“Hi world ！”，例三中stringBuffer的值已经被改变为了Hi world，但是因为值没有被return返回赋值给sb对象，所以sb对象并没有被改变，所以输出的任然是hello，即：

 

那么我们就不难理解，为何在执行完change函数之后，实参的值仍为“Hello”了。 
　　

结论

　　综上所述，我们可以得出结论：在Java中，当对象作为参数传递时，实际上传递的是一份“引用的拷贝”。 （实际传递的是对象的引用）

 

转载自：https://blog.csdn.net/xiangwanpeng/article/details/52454479