当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性吗？为什么，能不能详细解释下

1. package com.itheima;
   
2. 
   
3. public class Demo {
   
4. 
   
5.         public static void main(String[] args)
   
6.         {
   
7.                 Person p1= new Person();
   
8.                 Person p2= new Person("zhangsan", 24);
   
9.                 System.out.println("p1原"+p1);
   
10.                 System.out.println("p2原"+p2);
    
11.                
    
12.                 change(p1, new String("王五"));
    
13.                 change(p2, 28);
    
14.                 System.out.println("p1新"+p1);
    
15.                 System.out.println("p2新"+p2);
    
16.         }
    
17.        
    
18.         private static void change(Person p, String name)
    
19.         {
    
20.                 p.setName(name);       
    
21.         }
    
22.         private static void change(Person p, int age)
    
23.         {
    
24.                 p.setAge(age);       
    
25.         }
    
26. 
    
27. }
    
28. class Person
    
29. {
    
30.         Person(){}
    
31.         Person(String name, int age)
    
32.         {
    
33.                 this.name= name;
    
34.                 this.age= age;
    
35.         }
    
36.         private String name;
    
37.         private int age;
    
38.         public String getName() {
    
39.                 return name;
    
40.         }
    
41.         public void setName(String name) {
    
42.                 this.name = name;
    
43.         }
    
44.         public int getAge() {
    
45.                 return age;
    
46.         }
    
47.         public void setAge(int age) {
    
48.                 this.age = age;
    
49.         }
    
50.         @Override
    
51.         public String toString() {
    
52.                 return "Person [name=" + name + ", age=" + age + "]";
    
53.         }
    
54.        
    
55. }

复制代码

谢谢了  运行看到结果了  精辟

基础知识很扎实

肯定可以啊。

只要对象中提供有修改属性的方法，而且权限足够，就能修改

当做参数被传递！对象的属相不会被改变！因为对象在被创建时，属性已经确定！被改变的只是，对象的变量！

1. class MoringDemo
   
2. {
   
3.         public static void init(Person p){
   
4.                 p.setName("lisi");
   
5.                 p.setAge(15);
   
6.                 System.out.println("init方法中Person的属性值：："+p.getName()+"--->>>"+p.getAge());//①
   
7.         }
   
8.         public static void main(String[] args)
   
9.         {
   
10.                 Person p = new Person("zhangsan",10);
    
11.                 init(p);
    
12.                 System.out.println("调用init方法后Person的属性值：："+p.getName()+"--->>>"+p.getAge());//②
    
13.         }
    
14. }
    
15. class Person
    
16. {
    
17.         private String name;
    
18.         private int age;
    
19.         Person(String name,int age){
    
20.                 this.name = name;
    
21.                 this.age = age;
    
22.         }
    
23.         public void setName(String name){
    
24.                 this.name = name;
    
25.         }
    
26.         public void setAge(int age){
    
27.                 this.age = age;
    
28.         }
    
29.         public String getName(){
    
30.                 return name;
    
31.         }
    
32.         public int getAge(){
    
33.                 return age;
    
34.         }
    
35. }

复制代码

①和②输出结果是一致的，可以看到调用init方法后，Perosn的属性值被该变了。
为什么呢？因为改变的是引用变量p的指向，这个改变是始终有效的。