2020.7.17

学习内容：

1.方法的参数传递 

方法的参数传递通常分为两种：值传递和引用传递。Java的传递只有值传递，因为不管用户传入的参数是基本类型还是引用类型，都是对原有值的复制

（1）传入的是基本类型

如果传入的是基本类型会在栈中分配内存，当按基本类型传递时，实参会多复制一份，因此，在方法内修改参数值时不影响原实参

package day01;
public class MethodDemo{
    private static int x=10;
    public static void main(String[] args) {
        MethodDemo demo = new MethodDemo();
        demo.getX(x);
        System.out.println("x="+x);
    }
    public void getX(int x) {
        x--;
    }
}

 x的值没有改变，因为当在方法结束之后，传入的x值会被垃圾回收，但是在方法内部确实是改变的

（2）引用类型传递

引用类型传递是在栈中声明，在堆中分配内存

package day01;
public class Demo{
    public static void main(String[] args) {
        P p = new P();
        p.name="张无忌";
        p.age=30;
        P p2=new P();
        p2.name="伍正云";
        p2.age=25;
        p.t();
        p2.t();    
    }
}
class P{
    String name;//姓名
    int age;//年龄
    public void t() {
        System.out.println("姓名:"+name+",age"+age);
    }
}

当通过  " 对象名  .  属性名 ” 实际上就是每一个对应的堆内存空间的属性。

只要存在了关键字 new ，Java就会开辟新的内存空间

每个对象中实际保存的只是属性，并没有方法，因为所有的方法都是每个对象共同拥有的，保存在全局代码区中。

栈内存保存的是对堆内存的引用地址，而堆内存中保存的是每一个对象所拥有的属性，全局代码区中保存的是所有类中的方法，表示公共调用

所谓的引用类型传递，就是一个堆内存空间，可以同时被多个栈内存所指向，类本身也是一样的，即一块堆内存可以同时被多个对象所同时指向

package day01;
public class Demo{
    public static void main(String[] args) {
        P p = new P();
        p.name="张无忌";
        p.age=30;
        P p2=p;
        p2.name="伍正云";
        p2.age=20;
        p.t();
    }
}
class P{
    String name;//姓名
    int age;//年龄
    public void t() {
        System.out.println("姓名:"+name+",age:"+age);
    }
}

p的属性被p2给修改了，这是因为一个堆内存空间可以同时被多个栈内存所指向，从而引发的结果

package day01;
public class Demo{
    public static void main(String[] args) {
        //创建对象
        Demo demo=new Demo();
        P p = new P();
        p.age=20;
        //调用getX方法
        demo.getX(p);
        //打印p.age
        System.out.println(p.age);
    }
    public void getX(P p) {
        p.age=45;
    }
}
class P{
    String name;//姓名
    int age;//年龄
    public void t() {
        System.out.println("姓名:"+name+",age:"+age);
    }
}

2.方法递归 

所谓方法递归，是指方法调用自身，当然，递归不会无休止地调用下去，它必然有一个出口，当满足条件时程序也就结束了。

要想使用递归，必须满足以下两个条件

1. 必须满足一个结束的条件
2. 方法调用自身 

使用递归实现 n 的阶乘：

package day01;
public class JieCheng{
    public static void main(String[] args) {
        JieCheng j=new JieCheng();
        long i=j.f(5);
        System.out.println(i);
}
    public long f(int n) {
        if(n==1) {        //满足结束条件
            return 1;
        }
        return n*f(n-1);  //调用自身
        }
    }

注意：不要过多使用递归，否则会影响性能问题

3.类的属性  

属性具体表现在两个方面：一个是成员属性，成员属性也称之为全局变量；另一个是局部变量

（1）成员属性（全局变量)

成员属性定义在类中，而在方法的外面，它的范围归整个类所共享

在全局变量中，基本类型都会有一个默认值，整型变量的默认值是0，浮点型的默认值是0.0，布尔类型的默认值是false，引用类型的默认值是null

不能直接访问或修改属性，因为这样的访问和修改是极其危险的，所以通常会对属性进行封装，使用getXXX得到属性值，使用setXXX来设置属性

package day01;
public class Person{
    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name=name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age=age;
    }
    public static void main(String[] args) {
        Person p=new Person();
        p.setName("小明");
        p.setAge(18);
        p.getName();
        p.getAge();
        System.out.println(p.name+","+p.age);
    }
}

 （2）局部变量

局部变量定义在方法内部，局部变量的作用范围到方法尾结束

 遇到的问题：

堆和栈的概念不清

https://blog.csdn.net/majunzhu/article/details/90671738

明天要学习的内容：

this 关键字，变量的作用域和生存期，使用枚举