JAVA 面向对象 隐藏和封装

本页面更新日期: 2016年07月22日

前言

在前面程序中,经常出现通过某个对象直接访问其成员变量的情况.
这可能引起一些潜在问题,比如将某个 Person 的 age 成员变量直接设为 1000.
这在语法上没有任何问题, 但显然违背了当前的自然规律. 人怎么可能活到 1000岁 - - . (就现在的科学来讲)
Java也考虑到了这种情况, 为你提供了 类和对象的成员变量进行封装的方法,来保护成员变量不被恶意修改.

理解封装

封装(Encapsulation)是面向对象的三大特征之一.(另外两个是继承和多态, 以后会讲到)
它指的是将对象的状态信息隐藏在对应内部.
不允许外部程序直接访问对象内部信息.
而是通过该类所提供的方法来实现对内部信息的操作和访问.

封装是面向对象编程语言对客观世界的模拟
在客观世界里, 对象的状态信息都是被隐藏在对象内部.
外界无法直接操作和修改.
就如刚刚说的 Person 对象的 age 变量, 只能随着岁月的流逝, age 才会增加.
通常不能随意修改 Person 对象的 age.
对一个类或对象实现良好的封装, 可以实现以下目的.

  • 隐藏类的实现细节.
  • 让使用者只能通过事先预定的方法来访问数据, 从而可以在该方法里加入控制逻辑,限制对成员变量的不合理访问.
  • 可进行数据检查, 从而有利于保证对象信息的完整性.
  • 便于修改,提高代码的可维护性.

为了实现良好的封装, 需要从两个方面考虑.

  • 将对象的成员变量和实现细节隐藏起来, 不允许外部直接访问.
  • 把方法暴露出来, 让方法来控制对这些成员变量进行安全的访问和操作.

因此, 封装实际上有两个方面的含义:
把该隐藏的隐藏起来.
把该暴露的暴露出来.
这两个方面都需要通过使用 Java 提供的访问控制符来实现.

使用访问控制符

Java 提供了 3 个访问控制符.

  • private
  • protected
  • public

它们分别代表了 3 个 访问控制级别.
另外还有一个不加任何访问控制符的访问控制级别.
所以一共 4 个访问控制级别.
Java 的访问控制级别由小到大如下图所示:

这里写图片描述

上图的 4 个访问控制级别中. default 并没有对应的访问控制符.
当你不使用任何访问控制符来修饰类或类成员时, 系统默认使用该访问控制级别.
这 4 个访问控制级别的详细介绍如下:

  • private(当前类访问权限): 如果类里的一个成员(包括成员变量 / 方法 / 和构造器等)使用 private 访问控制符来修饰. 则这个成员只能在当前类的内部被访问. 很显然, 这个访问控制符用于修饰成员变量最合适. 使用它来修饰成员变量就可以把成员变量隐藏在该类的内部.
  • default(包访问权限):如果类里的一个成员(包括成员变量 / 方法 / 和构造器等) 或者一个外部类不使用任何访问控制修饰符,就称它是包访问权限的. 什么是包? 以后会讲到. default 访问控制的成员或外部类可以被相同包下的其它类访问.
  • protected(子类访问权限): 如果一个成员(包括成员变量 / 方法 / 和构造器等)使用 protected 访问控制符修饰, 那么这个成员既可以被同一个包中的其它类访问, 也可以被不同包中的子类访问. 在通常情况下, 如果使用 protected 来修饰一个方法, 通常是希望其子类来重写这个方法. 关于父类 / 子类 我以后会讲到.
  • public(公共访问权限): 这是一个最宽松的访问控制级别.如果一个成员(包括成员变量 / 方法 / 和构造器等) 或者一个外部类使用 public 访问控制符修饰, 那么这个成员或外部类就可以被所有类访问,不管访问类和被访问类是否处于同一个包中, 是否具有父子继承关系.

通过上面的解释不难发现, 访问控制符用于控制一个类的成员是否可以被其它类访问.
对于局部变量而言, 其作用域就是它所在的方法, 不可能被其它类访问, 因此不能使用访问控制符来修饰.

对于外部类而言,它也可以使用访问控制符修饰,但外部类只能有两种访问控制级别

  • public
  • 和默认 (default)

因为外部类没有处于任何类的内部, 也就没有其所在类的内部 / 所在类的子类 两个范围, 因此 private 和 protected 访问控制符对外部类没有任何意义.

外部类可以使用 public 和 包访问控制权限.
使用 public 修饰的外部类可以被所有类使用.
如声明变量 / 创建实例.
不使用任何访问控制符修饰的外部类只能被同一个包中的其它类使用.

小插曲: 如果一个 Java 源文件里定义的所有类都没有使用 public 修饰, 则这个 Java 源文件的文件名可以是一切合法的文件名.
但如果一个 Java 源文件里定义了一个 public 修饰的类, 则这个源文件的文件名必需与public 修饰的类的类名相同.

明白了访问控制符的用法后, 下面通过使用合理的访问控制符来定义一个 Person 类, 这个 Person 类实现了良好的封装.

public class Person
{
  //使用 private 修饰成员变量, 将这些成员变量隐藏起来
  private String name;
  private int age;
  //提供方法来操作 name 成员变量
  public void setName(String name)
  {
    //执行合理性验证,要求用户名必需在 2~6 位之间.
    if(name.length() > 6 || name.length() < 2)
    {
      System.out.println("您设置的人名不符合要求!");
      return;
    }
    else
    {
      this.name = name;
    }
  }
  //提供方法来操作 age 成员变量
  public void setAge(int age)
  {
    //执行合理性验证,要求用户年龄必须在 0~100 之间
    if(age > 100 || age < 0)
    {
      System.out.println("您设置的年龄不合法!");
      return;
    }
    else
    {
      this.age = age;
    }
  }
}

定义了上面的 Person 类之后, 该类的 name 和 age 两个成员变量只有在 Person 类的内部 才可以操作和访问.
在 Person 类之外只能通过其对应的 setter 和 getter 方法来操作和访问它们.

小知识:
Java 类里实例变量的 setter 和 getter 方法有非常重要的意义.
例如, 某个类里包含了一个名为 abc 的实例变量, 则其对应的 setter 和 getter 方法名为 setAbc() 和 getAbc()
即将原实例变量名的首字母大写, 并在前面分别增加 set 和 get 动词.
就变成了 setter 和 getter 方法名.
如果一个 Java 类的每个实例变量都被使用 private 修饰, 并为每个实例变量都提供了 public 修饰的 setter 和 getter 方法, 那么这个类就是一个 符合 JavaBean规范的类.
因此, JavaBean 总是一个封装良好的类.

下面程序在 main()方法中创建一个 Person 对象, 并尝试操作和访问该对象的 age 和 name 两个实例变量.

public class PersonTest
{
  public static void main(String[] args)
  {
    Person p = new Person();
    //因为 age 成员变量已被隐藏, 所以下面语句将会出现编译错误
    // p.age = 1000;
    //下面语句不会出现错误, 但运行时将会得到违规提示
    //同时程序不会修改 age 成员变量
    p.setAge(1000);
    //访问 p 的 age 成员变量也必需通过其对应的 getter 方法
    //因为上面从未成功设置 p 的 age 成员变量, 故此处会输出 0
    System.out.println(p.getAge());
    //下面成功修改 p 的 age 成员变量
    p.setAge(30);
    //因为上面成功设置了 p 的 age 成员变量, 故此处输出 30
    Sytem.out.println(p.getAge());
    //不能直接操作 p 的 name 成员变量, 只能通过其对应的 setter 方法
    //因为 "孙悟空" 字符串长度满足 2~6 的要求, 所以可以成功设置
    p.setName("孙悟空");
    System.out.println(p.getName());
  }
}

现在你已经创建了两个类文件 一个是 Person , 一个是 PersonTest
如果你编译它们并直接运行 PersonTest 是会出错的, 原因是他俩并没有产生关联. 不过暂时你先看看代码的逻辑就行, 以后我们会讲到如何成功运行这俩个类.

观察上面程序可得出, PersonTest 类的 main() 方法bu可以直接修改 Person 对象的 name 和 age 两个实例变量.
只能通过各自对应的 setter 方法来操作这两个实例变量的值.
因为使用 setter 方法来操作 name 和 age 两个实例变量, 就允许程序员在setter 方法中增加自己的控制逻辑.
从而保证 Person 对象的 name 和 age 两个实例变量不会出现与实际不符的情形.

小知识:
一个类常常就是一个小的模块.
应该只让这个模块公开必需让外界知道的内容.
隐藏其他一切内容.
进行程序设计时, 应尽量避免让一个模块直接操作和访问另一个模块的数据.
模块设计追求高内聚(尽可能把模块的内部数据 / 功能实现 细节隐藏在模块内部独立完成, 不允许外部直接干预)
低耦合(仅暴露少量的方法给外部使用)
正如日常常见的内存条, 内存里的数据及其实现细节被完全隐藏在内存条里.
外部设备(如主板)
只能通过内存条的金手指(提供一些方法供外部调用)来和内存条进行交互.

关于访问控制符的使用, 如下几个原则你要知道.

  • 类里的绝大部分成员变量都应该使用 private 修饰, 只有一些 static 修饰的 / 类似全局变量的成员变量, 才考虑使用 public 修饰. 除此之外, 有些方法只用于辅助实现该类的其它方法, 这些方法被称为工具方法,工具方法也应该使用 private 修饰.
  • 如果某个类主要用作其它类的父类, 该类里包含的大部分方法可能仅希望被子类重写, 而不想被外界直接调用, 则应该使用 protected 修饰这些方法.
  • 希望暴露出来给其它类自由调用的方法应该使用 public 修饰. 因此, 类的构造器通常使用 public 修饰, 从而允许在其它地方创建该类的实例. 因为外部类通常都希望被其他类自由使用. 所以, 大部分外部类都使用 public 修饰.

小提示:
在教学当中, 有些代码示例可能并未进行良好的封装, 当你自己开发项目时, 请尽量注意. 我只是为了演示某个知识点而故意偷点懒.嘿嘿嘿.

本页内容版权归属为原作者,如有侵犯您的权益,请通知我们删除。
上一篇文章分析过DroidPlugin对Activity的处理过程,不得不为对DroidPlugin的工程师们钦佩不已,那么是不是Service可以像Activity的处理过程一样来处理呢?前面讲过每一个代理进程只是预定义了一个Service,如果某一个插件中有多个Service,那岂不是某一个时刻只能有一个Service运行呢?由此可以判定可能Service的处理和Activity不一样。 一方面:平时使用Activity主要是用于展示界面和用户交互,Activity的生命周期可能受用户控制,当用户操作

IntentService使用及源码分析 - 2016-07-23 14:07:58

IntentService使用及源码分析 转载请注明 原博客地址: http://blog.csdn.net/gdutxiaoxu/article/details/52000680 本篇博客主要简介一下三个问题: 什么是IntentService? 怎样使用IntentService IntentSerice()源码分析 1)什么是IntentService? 我们知道Service和Activity一样是Android的四大组件之一,Service简称为后台服务,具有较高的优先级别。我们平时在Activ

Android——ListView控件 - 2016-07-23 14:07:54

本篇介绍ListView控件,这是Android中比较重要也比较复杂的控件,这里只谈到使用ViewHolder机制优化即可。 一、ListView简介 ListView是Android系统中显示列表的控件,每个ListView都可以包含很多个列表项。 二、ListView的使用 概念不多说,直接来介绍使用方法。 ListView中比较复杂的是数据适配器,其作用是把复杂的数据(数组、链表、数据库、集合等)填充在指定视图界面,是连接数据源和视图界面的桥梁。常见的Android原生的适配器有ArrayAdapt
HTTP请求报文: 一个HTTP请求报文由四个部分组成:请求行、请求头部、空行、请求数据 1.请求行   请求行由请求 方法字段、URL字段和HTTP协议版本字段 3个字段组成,它们用空格分隔。比如 GET /data/info.html HTTP/1.1 方法字段就是HTTP使用的请求方法,比如常见的GET/POST 其中HTTP协议版本有两种:HTTP1.0/HTTP1.1 可以这样区别: HTTP1.0对于每个连接都的建立一次连接一次只能传送一个请求和响应,请求就会关闭,HTTP1.0没有Host字

gradle多渠道打包 - 2016-07-23 14:07:48

E文不好的童鞋,例如我,翻译文章的过程里没有愉悦的感受,只有2行老泪;但最终有一丝成就感也算是安慰了。所以我会去尊重那些翻译IT技术文章的大拿们,他们就是千千万万个亚里士多德和吴启明,他们是E文不好的童鞋的传教士,阿门,当然我不是大拿。 废话少说,先看一篇例子:在 http://ghui.me/post/2015/03/create-several-variants/  。 然后来看这篇翻译,扫清例子中一部分未知的知识。原文在 http://tools.android.com/tech-docs/new-b
前言 本文主要讲解Telephony中Phone相关的知识,主要想讲明白三件事情: Phone是什么? Phone从哪里来? Phone有什么作用? 1. Phone是什么 1.1 Phone是一个接口 Phone.java (frameworks\opt\telephony\src\java\com\android\internal\telephony) public interface Phone { //包含了大量的register/unregister的方法。(监听能力) void registe

Android混淆心得 - 2016-07-23 14:07:36

最近在做Android应用的混淆,踩了一些坑,这里记录分享下个人的心得。 混淆介绍 首先先简单说一下什么是混淆和混淆的作用,其实这个搜索下可以找到一堆官方的说法等等,这里简单口语叙述一下,混淆就是把代码替换成a、b、c基本字母组成的代码,比如一个方法名为:function(),混淆后可能会被替换成a()。 混淆的好处: 代码混淆后阅读性降低,反编译后破译程序难度提高 混淆后字节数减少,减少了应用了体积 前者只能说有一点作用,后者则需要看代码的数量 当然不能忽视混淆的缺点: 混淆后,测试不充分可能导致某些功
[编写高质量iOS代码的52个有效方法](二)对象 参考书籍:《Effective Objective-C 2.0》 【英】 Matt Galloway 先睹为快 6.理解“属性”这一概念 7.在对象内部尽量直接访问实例变量 8.理解“对象等同性”这一概念 9.以“类簇模式”隐藏实现细节 10.在既有类中使用关联对象存放自定义数据 目录 编写高质量iOS代码的52个有效方法二对象 先睹为快 目录 第6条理解属性这一概念 第7条在对象内部尽量直接访问实例变量 第8条理解对象等同性这一概念 第9条以类簇模式隐
插件其实是Apk安装包,如果要使用必须先要安装和解析,以便知道插件Apk的相关信息。而从Demo中我们知道插件的安装和卸载是通过调用PluginManager的installPackage()和deletePackage()来实现的。就先从PluginManager.installPackage()开始分析插件Apk的安装过程。 第一步:PluginManager. getInstance().installPackage(apkPath,flag); 此函数中只是调用了mPluginManager.in
分享截屏已经是很多游戏应用必备的功能了,找到了一个国内的插件,虽然用起来还行,但是,还是想吐槽下,跟老外的插件比,真的有差距啊有差距啊有差距啊,啊啊啊。 ShareSDK的官方网站:http://www.mob.com/,使用插件需要注册账号获得key,不过,至少现在是免费的。 我的Unity版本是5.3,xcode版本是7.2,ShareSDK版本是2.7.4 Unity sdk下载地址:https://github.com/MobClub/New-Unity-For-ShareSDK 新建一个简单的工