Java中成员变量与局部变量的区别、形式参数、匿名对象与封装

Java中成员变量与局部变量的区别、形式参数、匿名对象与封装

学习要循循渐进

---

---

一、成员变量与局部变量的区别

1、在类中定义的位置不同

成员变量：类中，但是在方法外
局部变量：定义在方法内部

2、在内存中的位置也不同

成员变量：在堆内存中
局部变量：在栈内存中

3、初始化值也不同

成员变量：系统会给予默认值
局部变量：没有系统给的默认值，必须在定义的时候赋值，亦或者在方法中使用之前赋值，然后才能使用。

4、生命周期不同

成员变量的生命周期：随着对象的创建而创建，随着对象的消失而消失
局部变量的生命周期：随着方法的调用而创建，随着方法的调用完毕而消失

注意：
（1）方法与方法之间里面的局部变量不能互相调用。
（2）局部变量可以和成员变量一样，在方法中使用的时候，采用就近原则

二、形式参数

1 、形式参数的问题：

(1)当形式参数是基本数据类型的时候,将来调用方法的时候传入的是常量值,或者是该类型的变量
(2)当形式参数是引用数据类型的时候，将来调用方法的时候传入的是该类对象的地址值
(3)当形式参数是基本数据类型的时候，在方法中对变量做修改，不会影响到外部实际的栈内存中的值。
(4)当形式参数是引用数据类型的时候，在方法中对变量做修改，会影响到外部实际的堆内存中的值。

2、举例：

package com.shujia.wxl.day08;
class Demo2 {
    public int getSum(int a,int b) {
        a=100;
        b=200;
        return a + b;
    }
}

class Student2{
    String name;
    public void speak(){
        System.out.println("我热爱学习");
    }
}

class StudentTest2{
    /**
     * 如果将来你看到一个方法的形式参数是一个类的类型，说明他是一个引用数据类型
     * 这里其实需要的是该类的对象
     * 调用的时候，把main方法中创建好的对象名传过来，实际上传的就是对象的地址值
     * @param s
     */
    public void function(Student2 s){ //Student2 s = new Student2();
        s.name = "小王";
        s.speak();
    }
}


public class XingShiCanShuDemo {
    public static void main(String[] args) {
        Demo2 d = new Demo2();
        int a = 10;
        int b = 20;
        System.out.println(d.getSum(a,b));
        System.out.println("a:"+a+",b:"+b);

        //要想调用function(),就必须创建StudentTest2对象
        StudentTest2 st2 = new StudentTest2();

        Student2 student2 = new Student2();
        System.out.println(student2.name);
        st2.function(student2);
        System.out.println(student2.name);
    }
}

三、匿名对象

1、匿名对象：

   就是没有名字对象

2、匿名对象的使用场景：

（1）调用方法的时候，仅仅调用一次的时候，可以使用匿名对象
 注意，当调用多次的时候，不适合,每次new的时候都是一个新的匿名对象，会频繁的在堆内存中开辟空间
 当匿名对象使用完毕之后，无法再使用第二次，就变成了一个垃圾（当栈中没有变量引用它的时候，判定是一个垃圾），等待被垃圾回收器回收。
（2）当方法的参数类型是一个类的时候，可以使用匿名对象调用方法。

package com.shujia.wxl.day08;
class Phone4{
    public void show(){
        System.out.println("手机可以打电话");
    }
}

class PhoneDemo{
    public void function(Phone4 p){
        p.show();
    }
}

public class AnonymousDemo {
    public static void main(String[] args) {
        //创建一个PhoneDemo对象
        PhoneDemo pd = new PhoneDemo();
        Phone4 phone = new Phone4();
        pd.function(phone);
        System.out.println("=============================");
        //当new完对象之后直接使用，没有用变量名接收的对象，称之为匿名对象
        new PhoneDemo().function(new Phone4());
        new PhoneDemo().function(new Phone4());


    }
}

四、封装

首先我们先定义一个学生类：

class Student3 {
    //定义成员变量
    String name;
    private int age;

    public void setAge(int a){
        if(a<0 || a>200){
            System.out.println("您要传入的年龄数据有误，请重新赋值");
        }else{
            age = a;
        }
    }

    //定义一个输出所有的成员变量
    public void show() {
        System.out.println("姓名：" + name);
        System.out.println("年龄：" + age);
    }

}


public class StudentDemo2 {
    public static void main(String[] args) {
        //创建一个学生对象
        Student3 s = new Student3();
        s.show();

        //给对象的成员变量赋值
        s.name = "王宇";
//        s.age = 18;
//        s.age = 10000;
//        s.setAge(10000);
        //age 在 com.shujia.wyh.day08.Student3 中是 private 访问控制
//        s.age = 10000; //由于我们在Student3类中name前面加了一个private关键字，不可以直接使用获取到成员变量，要想赋值，
                        //就必须使用我们提供的数据校验赋值方法
        s.setAge(10000);
        s.show();

    }
}

我们在定义一个学生类并使用的时候，发现了一个问题：

通过对象给成员变量赋值的时候，可以赋值一些非法的数据。
这样是不合理不符合现实生活的。我们应该在赋值之前，做一次判断，数据校验，
也就是对即将要赋值的数据做判断。

问题又来了，我们应该在哪里定义这个判断逻辑呢？

StudentDemo2是一个测试类
一般情况下，测试类负责创建对象并使用对象的地方，在这里定义判断逻辑是不合适的。
所以我们这里应该定义在Student3类中。
又因为，我们在定义成员变量的时候无法加入逻辑判断。
所以，我们在成员方法中定义。
因为做数据判断的时候，加的是一些逻辑判断语句，肯定不是只有一条。
我们应该在Student3类中提供一个方法来数据校验。
按照我们的想法，在类中提供了一个数值校验的方法，
如果符合就成功赋值，反之则不赋值。
但是，谁规定了我定义了方法就一定会被使用呢，如果我还是用之前的获取成员变量的方式进行赋值，问题依旧存在那么我们给出的方法意义就不是很大了。
实际上，我们应该定义了一个方法后，让调用必须使用我们的方法进行赋值，并且不能让调用者直接获取到我们成员变量。

怎么去强制要求不直接获取成员变量呢？

针对这样的情况，java就提供了一个关键字：private
private： 私有的。
其实说到现在，就是为了引出一个思想：封装
封装：其实就是隐藏对象的属性和相关的实现细节，仅仅对外提供公共的访问方式

接下来看一个案例，具体的实现是如何的

package com.shujia.wxl.day08;

/*
        规范定义一个类的标准版本1.0
            1、将成员变量使用private修饰
            2、提供公共getXxx()和setXxx()
            3、提供一个方法打印所有的成员变量值（先自己定义，后面我们会学习新的方法替代）
 */
public class Teacher {
    //定义成员变量
    private String name;
    private int age;

    //提供公共的getXxx()和setXxx()方法
    public void setName(String s) {
        name = s;
    }

    public String getName() {
        return name;
    }

    public void setAge(int a) {
        age = a;
    }

    public int getAge(){
        return age;
    }

    //提供一个方法打印所有的成员变量值
    public void show() {
        System.out.println("姓名：" + name + ",年龄：" + age);
    }
}

class TeacherTest{
    public static void main(String[] args){
        //创建一个老师对象
        Teacher t1 = new Teacher();
        //使用成员变量
        //不能直接获取，因为它们都被private修饰了
//        System.out.println(t1.name+"---"+t1.age);
        //通过公共的方法来获取成员变量
        System.out.println(t1.getName()+"---"+t1.getAge());

        //给成员变量赋值
        t1.setName("刘志城");
        t1.setAge(18);
        System.out.println(t1.getName()+"---"+t1.getAge());
        t1.show();

    }
}

五、this关键字

我们还是先定义一个类用来讲解

package com.shujia.wxl.day08;

/*
      定义一个医生类：

      回想一下我们之前定义变量的时候，提过一个规范：见名之意。
      我们根据见名之意的规范来重新定义形参的名字，运行后发现结果不对，值没有赋上。
 */

class Doctor {
    private String name;
    private int age;
    private String gender;

    public void setName(String name) {

//我们还说过，局部变量的使用原则：就近原则
//我们这里的name采用就近原则后发现，使用的都是形参的变量名name，
没有使用成员变量中name.
//我们理想上应该是将传进来的name赋值给调用该方法对象中的成员变量name
//Doctor.name = name;直接通过类名.成员变量的方式目前是不行，
我们还没有说过类似的用法，所以这个是有问题的
//如果这个Doctor对象存在的话，它是不是就表示了一个医生对象
//如果有一个东西可以代表是当前调用该方法的对象就好了
//java提供了一个关键字：this
//this在方法中使用的时候，就代表着调用该方法的对象
//既然都是一个对象了，我们学过对象.成员变量

// Doctor.name = name;
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setAge(int i) {
        age = i;
    }

    public int getAge() {
        return age;
    }

    public void setGender(String s) {
        gender = s;
    }

    public String getGender() {
        return gender;
    }

    //提供一个公共的方法
    public void show() {
        System.out.println("姓名：" + name + ",年龄：" + age + ",性别：" + gender);
    }

}

public class DoctorDemo {
    public static void main(String[] args) {
        //创建一个医生对象
        Doctor d = new Doctor();

        d.setName("wxl");
        d.setAge(18);
        d.setGender("男");
        d.show();
    }
}

为了方便大家理解我们再创建一个医生类

package com.shujia.wxl.day08;

/*
        定义一个标准类的2.0版本
            成员变量：被private修饰
            成员方法：getXxx()和setXxx()，其中setXxx(..)形参的名字与成员变量名字一致，使用this关键字赋值
                    show()
 */
class Doctor2 {
    private String name;
    private int age;
    private String gender;

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name; //其实这里隐藏了一个this，但是我们也可以不写，因为就近原则取的就是对象的成员变量
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public String getGender() {
        return gender;
    }

    public void show() {
        System.out.println("姓名：" + name + ",年龄：" + age + ",性别：" + gender);
    }

}

public class DoctorDemo2 {
    public static void main(String[] args) {
        //创建一个医生对象
        Doctor2 d = new Doctor2();

        //给成员变量进行赋值
        d.setName("明旺");
        d.setAge(18);
        d.setGender("男");

        d.show();

    }
}

并且附上内存图，this究竟在内存的什么地方？