01.Java 基础 - 封装

基本概念

Java 面向对象有三大特性：封装、继承、多态。而封装与继承基本上是为多态服务的。

封装（Encapsulation）：就是把对象的属性和操作（或服务）结合为一个独立的整体，并尽可能隐藏对象内部的实现细节。通俗来讲就是私有化类的成员变量，并提供公共方法来访问这些成员变量。

数据隐藏：一个成员变量声明为私有成员，那么它不能通过外部类直接访问，从而将成员变量隐藏在类的内部。基于这个原因，封装也被称为数据隐藏。

---

JavaBean

JavaBean 是一种规范，它规定了一种良好封装的规范，只要符合该规范的类都称作JavaBean。

它具有以下特点：

• 数据成员（对象成员）必须由 private 修饰。

• 为每个对象成员都提供 public 的 setter /getter 方法

• setter/getter 的原型必须为：

public void set 成员名(成员类型 arg);
public 成员类型 get 成员名();

---

实例探究

1.未封装&封装

首先我们来看未封装的成员变量：

class Person{
    // 将成员的访问权限设置为 public，这也为意味这谁都访问到它
    public String name;
    public int age;
}

public class Test{
    public static void main(String[] args) {
        Person person = new Person();

        //通过类，我们可以直接操作成员变量
        person.name ="kobe";
        person.age =1000;

        //直接获得成员变量的值
        System.out.println(person.name+"-"+person.age);
    }
}

下面我们对上面的类进行封装：

class Person {
    //1.将成员变量私有化，这样一来外部就不能直接访问到它们
    private String name;
    private int age;

    //2.提供公共的方法来操作成员变量
    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 class Test {
    public static void main(String[] args) {
        Person person = new Person();

        // 不能直接访问成员变量，而是通过提供的公共方法来设置/获取成员变量的值
        person.setName("kobe");
        person.setAge(1000);
        System.out.println(person.getName() + "-" + person.getAge());
    }
}

到目前为止我们看到封装与未封装对象的大概区别了：

• 对于未封装的对象我们直接访问/设置其成员变量

• 而对于封装的对象我们需要通过提供的公共方法（如 getter/setter）来操作成员变量

---

2.封装控制对象

如果仅仅只是这样，封装似乎也没有什么作用，接下来我们看看如何通过封装实现对对象的控制：

class Person {
    private String name;
    private int age;
    private int city;

    //对于 name 的控制，直接取消了 setter 方法，这样外部只能访问，而不能设置 name 的值
    public String getName() {
        // 直接返回值
        return "kobe";
    }

    public int getAge() {
        return age;
    }

    // 有两个 setter 方法，可以接收 int，String 类型的参数
    public void setAge(int age) {
        this.age = age;
    }

    public void setAge(String age) {
        // 对参数值进行验证，默认只能输入数字
        if(age.matches("[0-9]")){
            this.age = Integer.valueOf(age);
        }else{
            System.out.println("Error：年龄只能为数字");
        }
    }

    // 在日常开发，我们一般会将文字转换成编码在数据库存储，因此在存储调用时就要做转换
    public String getCity() {
        switch (city) {
        case 001:
            return "北京";
        default:
            return "上海";
        }
    }

    public void setCity(String city) {
        if("北京".equals(city)){
            this.city = 001;
        }else if("上海".equals(city)){
            this.city = 002;
        }else{
            System.out.println("Error：没有找到该城市");
        }
    }
}

public class Test {
    public static void main(String[] args) {
        Person person = new Person();
        person.setAge("a"); //Error：年龄只能为数字
        person.setAge(1000); //既可以接收 String 类型，也可以接收 int 类型
        person.setCity("广州"); //Error：没有找到该城市
        person.setCity("北京"); //此时已经被转换成 001 存储了    

        //在访问 city 成员变量时，001 又被转换成 北京 显示
        System.out.println(person.getName()+"-"+person.getAge()+"-"+person.getCity());
    }
}

通过以上的代码，我们大致可以总结出封装的作用：

• 良好的封装能够减少耦合。

• 类内部的结构可以自由修改。

• 可以对成员进行更精确的控制。

• 隐藏信息，实现细节。

---

参考

• http://www.cnblogs.com/chenssy/p/3351835.html