持续创作，加速成长！这是我参与「掘金日新计划 · 6 月更文挑战」的第6天，点击查看活动详情

成员变量和局部变量区别

变量根据定义位置的不同，我们给变量起了不同的名字。如下图所示：

在类中的位置不同 重点

成员变量：类中，方法外局部变量：方法中或者方法声明上(形式参数)
作用范围不一样 重点

成员变量：类中局部变量：方法中
初始化值的不同 重点

成员变量：有默认值局部变量：没有默认值。必须先定义，赋值，最后使用
在内存中的位置不同 了解

成员变量：堆内存局部变量：栈内存
生命周期不同 了解

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

封装

封装概述

面向对象有很多设计上的语法是需要大家掌握的，接下来我们需要学习面向对象的三大特征中的封装。

面向对象编程语言是对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界无法直接操作和修改。封装可以被认为是一个保护屏障，防止该类的代码和数据被其他类随意访问。要访问该类的数据，必须通过指定的方式。适当的封装可以让代码更容易理解与维护，也加强了代码的安全性。

例如：之前我们定义的方法，实际上也是一种封装，我们是把功能代码封装在了方法中，然后必须通过调用该方法来执行功能。

为什么要封装

假如我们现在定义一个People类。代码如下：

public class People {
    // 实例成员变量,属于对象的
    // 合理隐藏
    public String name ;
    public int age  ;
}

之前我们已经知道对象可以直接访问这些实例成员变量。那么就会出现以下情况：

public class TestPeople {
    public static void main(String[] args){
        // 创建一个人对象 
        People p = new People();
        p.name = "古力娜扎";
        p.age = -100; // 很显然这个数据注入是存在问题的，年龄不可能是负数
    }
}

上面年龄age直接注入数据是不合理的，说明age不应该直接就被访问，应该把age封装起来，以便不能被直接访问。那么如何进行封装呢？

封装原则

封装是为了让代码的功能更加的安全，让细节被进一步的隐藏起来。原则上应该合理隐藏，合理暴露。

按照规范:我们需要将成员变量(属性)隐藏起来，若需要访问某个成员变量，暴露公共方法对其访问。

封装的步骤

1.使用 private 关键字来修饰成员变量。表示成员变量不能被直接访问。

2.使用public修饰方法，提供对应的一对用public修饰的 getXxx方法、setXxx 方法来暴露成员变量的访问。

注意：public关键字是公开访问权限，private关键字是隐藏访问权限。

封装的操作

private修饰成员变量

private的含义

private是一个权限修饰符，代表最小权限，是私有的含义。
可以修饰成员变量和成员方法。
被private修饰后的成员变量和成员方法，只在本类中才能访问。

private的使用格式

private 数据类型 变量名；

使用 private 修饰成员变量，代码如下：

public class People {
    private String name;
    private int age;
}

public修饰getter和setter方法

public的含义

public是一个权限修饰符，代表最大权限，是公开权限的含义。
可以修饰成员变量和成员方法。
被public修饰后的成员变量和成员方法，可以在任何类中访问。

private的使用格式

private 数据类型 变量名；

使用public修饰成员方法，代码如下：

1.提供 getXxx方法 / setXxx 方法（我们也称呼getXxx方法 / setXxx 方法是getter和setter方法），可以通过getter和setter方法来暴露成员变量的访问，然后可以在setAge方法中过滤掉非法的年龄，代码如下：

public class People {
    private String name;
    private int age;
    private String addr;

    public void setName(String n) {
        name = n;
    }

    public String getName() {
        return name;
    }
    
    public String getAddr() {
        return addr;
    }

    public void setAddr(String ar) {
        addr = ar;
    }

    public void setAge(int a) {
        if(a > 0 && a <200){
            age = a;
        }else{
            System.out.println("年龄非法！");
        }
        
    }

    public int getAge() {
        return age;
    }
}

接下来我们通过代码进行测试

public class TestPeople {
    public static void main(String[] args){
        // 创建一个人对象 
        People p = new People();
        // p.age = -100;//这里代码会出现编译错误，因为age被private修饰了，只能通过setAge访问修改
        // p.setAge(-10); // 提示年龄非法
        p.setAge(19); 
        p.setName("张曼玉");
        p.setAddr("香港")
        System.out.pritnln(p.getAge());// 输出年龄：19
        System.out.pritnln(p.getName());// 输出：张曼玉
        System.out.pritnln(p.getAddr());// 输出：香港
    }
}

从上面代码可以看出：

成员变量age一旦私有以后，其他类就不能直接访问成员变量了，必须通过setAge来修改，通过getAge来访问。这样就实现了安全性，值得注意的是开发的时候，我们并不一定会在setAge中做参数的校验，因为可以在界面上提前校验用户输入的数据是否合法，但是即便如此，成员变量私有和提供配套的getter和setter方法已经成为Java设计的一种规范，建议大家都这样设计自己的代码。

封装小结

1.从上述代码中可以看出，成员变量使用private修饰以后，就不可以在其他类中访问了。

2.提供成套的被public修饰的setter和方getter法可以暴露对私有成员变量的修改以及获取值。

3.封装就是合理的进行隐藏，合理的进行暴露，按照规范我们会对成员变量进行私有，而对方法进行暴露。

this关键字

this修饰的变量用于指代成员变量，其主要作用是（区分局部变量和成员变量的重名问题）

方法的形参如果与成员变量同名，不带this修饰的变量指的是形参，而不是成员变量
方法的形参没有与成员变量同名，不带this修饰的变量指的是成员变量

public class Student {
    private String name;
    private int age;

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void show() {
        System.out.println(name + "," + age);
    }
}

this内存原理

this代表当前调用方法的引用，哪个对象调用的方法，this就代表哪一个对象
示例代码：

public class StudentDemo {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("林青霞");
        Student s2 = new Student();
        s2.setName("张曼玉");
    }
}

图解：

封装思想

封装概述是面向对象三大特征之一（封装，继承，多态）是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界是无法直接操作的
封装原则将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问成员变量private，提供对应的getXxx()/setXxx()方法
封装好处通过方法来控制成员变量的操作，提高了代码的安全性

java 变量&封装