我理解javascript语言的以下属性:
var bar = 1;
var foo = bar;
bar = "something entirely different";
// foo is still 1
但是,当尝试将此逻辑应用于对象时,它似乎采取不同的行为:
var bar = {};
bar.prop = 1;
var foo = bar;
bar.prop = "something entirely different";
// foo.prop now changes to "something entirely different"
// but...
bar = "no longer an object";
// now foo remains an object with the prop property
有人能告诉我发生了什么以及为什么会有区别？
这个程序输出6作为输出,但当我取消注释第9行时,输出为5.为什么？我认为ba不应该改变,应该保持在主要的5.
1 class C1{
2 int a=5;
3 public static void main(String args[]){
4 C1 b=new C1();
5 m1(b);
6 System.out.println(b.a);
7 }
8 static void m1(C1 c){
9 //c=new C1();
10 c.a=6;
11 }
12 }
我知道在Java中,一切都是通过价值传递的.但对于对象,它是传递的对象的引用值.这意味着有时候一个对象可以通过参数进行更改,这就是为什么人们说,永远不要修改参数.
但在下面的代码中,会发生一些不同的事情. 当你回到时,sin changeIt()不会改变main():
public class TestClass {
static String str = "Hello World";
public static void changeIt( String s ) {
s = "Good bye world";
}
public static void main( String[] args ) {
changeIt( str );
System.out.println( str );
}
}
我猜 - 我想要确认 - 当你说它s = "something"是相同或相当于说String s = new String("something").这是为什么s不改变？它是否在本地分配了一个全新的对象,一旦退出就会被丢弃changeIt()？
我仍然是java的初学者,我有一个关于传递参数的有效方法的问题.在方法中传入对象时,传递对象的某些部分或者根本不重要是否更有效？例如,假设我有一个Person对象,它有几个属性(名称,高度,性别,位置,hairColor等),我有一个方法需要处理其中两个属性.当我将信息传递给方法时,它是否会节省我的内存,处理时间等,只传递所需的信息(如名称和位置),还是仅仅传递整个人物对象？
是:
public void getNamePlace(String name, String location){
\\\\work here
}
任何不同的效率方面:
public void getNamePlace(Person person){
\\\\work here and get the name location in the method
}
非常感谢您的帮助.我很抱歉,如果这是一个愚蠢的问题,但我正在努力找出解决这个问题的最佳心态.谢谢.
ps我正在考虑方法调用本身.它是如何工作的.孤立地是:
public void getNamePlace(String name,String Location) - >传递的位数和使用的内存比 - > public void getNamePlace(Person person)
如果使用函数调用函数Call-by-Reference,则对函数内部变量所做的任何更改都会立即影响调用者.因为Call-by-Sharing,它在功能结束时受到影响.
问题1: Java是否使用Call-by-Sharing而不是Call-by-Reference？
问题2:我认为,Call-by-Sharing不同于Call-by-Reference 只,而多线程.它的创建只是为了减少在某些其他线程中使用时值的并发重写; 提供一致性.我对吗？
我在我的 main 中制作了一个对象Recipe recipeOne = new Recipe("Pepperoni Pizza");
该对象是此处定义和构造的对象数组的实例！
public class Recipe implements Cloneable{
String Name;
final int INGREDIENT_ARRAY_MAX = 10;
Ingredient Recipe[] = new Ingredient[INGREDIENT_ARRAY_MAX];
public Recipe(String name){
Name = name;
}
所以我想用这条线制作这个对象的深层副本Recipe ressippi = (Recipe) recipe.clone();，它把我发送到这里！
public Object clone(){
Recipe cloneRec = new Recipe(Name);
return cloneRec;
}
我知道这目前是一个浅拷贝，因为该方法只传递引用，所以如果我尝试对我的新对象（它是recipeOne 的克隆）进行名称更改...它将更改它们的两个名称。显然我不希望这样，我对此很迷茫，有人可以帮忙吗？
编辑：@Rohit Jain
我的 Recipe 类和 Ingredient 类（菜谱数组保存的对象）都有 toString 方法，并且 Recipe 调用配料，以便以漂亮的小格式将其全部打印出来。当我在我的“recipeOne”对象（称为意大利辣香肠披萨的那个）上调用它时，我得到“意大利辣香肠披萨：1.0 磅面团，8.0 盎司酱汁，10.0 盎司奶酪”
然后我继续创建 ressippi 对象并将其设置为recipeOne 的克隆，所以从这里开始一切都很好...然后我将 ressippi 的名称更改为“Pineapple Pizza”，打印效果很好，但它不打印recipeOne 的 3 个成分对象存储，这是它应该做的！
为什么以下代码可能？(这只是我在处理其他代码时想出的一个例子)
public String getLogIdentifierFromFile(final File file) {
//this.file = null; //Gives compiler error as obviously expected
nullify(file);
return "";
}
public void nullify(Object object) {
object = null;
}
我怎样才能确保final顶级函数实际上有效？这次是我制作nullify方法,但它也可以是我的方法需要调用的任何人的代码.
我一直在测试一些不同的方法来将数组项与常数相乘.
我已经产生了不同的结果,这取决于我如何遍历数组并且我无法理解这一点(我对Java很新,并且仍然关注事物的传递或引用).
测试1
int[] array = {1, 2, 3, 4};
for (int number : array)
{
number *= 2;
}
导致未修改的数组项:
{1, 2, 3, 4}
它似乎number不是实际的数组项,而是一个int用它的值初始化的新项.那是对的吗？
测试2
我认为通过使用一个Object数组可能会起作用,假设它number是对实际数组项的引用.以下是我使用的测试Integer而不是int:
Integer[] array = {1, 2, 3, 4};
for (Integer number : array)
{
number *= 2;
}
同样,导致数组项未经修改:
{1, 2, 3, 4}
测试3
经过一些头部刮擦后,我尝试了一种不同的循环方法,如下所示:
int[] array = {1, 2, 3, 4};
for (int i = 0; i < array.length; i ++)
{ …有人可以解释一下这段代码吗？
public void getSupplierByZipCode(
@WebParam(name = "zip", targetNamespace = "http://www.webservicex.net/")
String zip,
@WebParam(name = "GetSupplierByZipCodeResult", targetNamespace = "http://www.webservicex.net/", mode = WebParam.Mode.OUT)
Holder<Boolean> getSupplierByZipCodeResult,
@WebParam(name = "SupplierDataLists", targetNamespace = "http://www.webservicex.net/", mode = WebParam.Mode.OUT)
Holder<SupplierDataList> supplierDataLists);
我以前从未见过HolderJava.什么是Holder<Boolean>和Holder<SupplierDataList>功能？他们喜欢输出吗？我需要这个功能的供应商数据清单.
我总是理解静态变量在引用时共享一个实例.我想对此进行测试,但结果与我预期的不同.
static Integer counter = 0;
static Integer test = counter;
public static void main(String args[]) {
counter++;
System.out.println("counter: " + counter);
System.out.println("test: " + test);
}
输出:
柜台:1
测试:0
由于test引用counter我认为,当我增加counter那么test将自动以及递增.但是,似乎test是0从某个地方引用,问题是,在哪里？