java的封装性

目的

限制在类的外部对类内部成员进行访问，只通过公共接口来访问类的成员数据。
屏蔽细节：这是程序设计的基本思想，便于程序功能的扩展和程序的维护。

封装类

大多数变量都是私有的，变量通过他们自己类的方法修改，一个类只向其它类公开一部分成员（通常是方法）作为接口；
若变量或方法为公有，它就是接口的一部分，其它类可以访问它；若为私有，它是实现的一部分，只有类自己的成员可以访问它。

访问控制符

Java通过访问控制来实现封装性，访问控制通过4个访问修饰符实现。

default（默认）
public（公共）
protected（保护）
private（私有）

访问修饰符限定了被修饰者的可见性。

类的访问控制

类的权限有两种：

默认（修饰符为空），该类只能被自身所在的包中的类使用。
public，该类能被所有包中的类使用。

如果在一个源程序文件中，声明了若干个类的话，只能有一个类的权限关键字是public。这个类的名字应该和程序文件同名，main方法也应该在这个类中，否则程序无法执行。

public：在任何地方，只要能访问到该类，即可访问到该成员。
protected：该成员允许同一个包或该类的扩展子类访问。 
默认：该成员只能由同一个包中的其它类访问。
private：类中的该成员只能由该类自己的成员调用，而无法被该类以外的其它类访问。

声明局部变量不能包含访问权限修饰符，否则编译时将检查出错。

封装性的设计原则

基本思想：提供对外的通讯方式，封装内部的实现机制。

增加内部实现部分的可替换性；
减小类之间的耦合关系，方便模块划分；
容易保证类内部数据间的一致性，从而提高软件的可靠性。

基本原则：

类常常是public；
成员变量常常是private；
构造方法一般是public；
方法“getter”与“setter”是 public；
其它方法需要根据实际的需要而定。

私有化构造方法

这是一种设计模式——单例模式

类的封装性不止体现在对属性的封装，还可以对方法进行封装，这里我们看一下对构造方法的封装。

对属性封装可以防止其他类随意修改一个类的成员变量，那为什么要对构造方法进行封装？

我们知道对象在实例化时会调用类的构造方法，如果将构造方法私有化（隐藏起来），则外部无法实例化对象，而此时若在内部实例化对象，并提供一个方法将该实例返回出去，则其他类中也可以获取到这个实例，这样可以保证一个类在内存中对象的唯一性。

总体来说，想要保证对象的唯一性，要做到：

1.避免其他类过多的建立该类对象，先禁止其他类建立该类对象

2.为了让其他类访问到该类对象，只好在本类中实例化一个对象

3.为了方便其他类对自定义对象的访问，可以对外提供一些访问方式

对应于代码实现：

1.构造方法私有化

2.在类中创建一个本类对象

3.提供方法可以获取到该对象

代码：

class Singleton{  
    private Singleton(){        //构造方法实例化  
    }  
    public void print(){  
        System.out.println("Hello World!");  
    }  
}  
public class SingletonDemo{  
    public static void main(String[] args){  
        Singleton s1 = null;  //声明对象  
    }  
}  

此时，外部SingletonDemo类只能声明对象，无法实例化对象，所以我们需要在Singleton类内部实例化对象。

class Singleton{  
    Singleton instance = new Singleton();  //在内部实例化对象  
    private Singleton(){        //构造方法实例化  
    }  
    public void print(){  
        System.out.println("Hello World!");  
    }  
}  
public class SingletonDemo{  
    public static void main(String[] args){  
        Singleton s1 = null;  //声明对象  
    }  
}  

此时要考虑外部SingletonDemo类如何获取内部生成的instance对象，这样外部就可以直接通过该对象实例化了。
如果在没有实例化对象的时候获得instance对象，则要将instance声明为static类型，因为static声明的变量，可以直接通过类名.属性进行访问 。

class Singleton{  
    static Singleton instance = new Singleton(); //在内部实例化对象  
    private Singleton(){        //构造方法实例化  
    }  
    public void print(){  
        System.out.println("Hello World!");  
    }  
}  
public class SingletonDemo{  
    public static void main(String[] args){  
        Singleton s1 = null;  //声明对象  
        s1 = Singleton.instance;  
        s1.print();  
    }  
}  

输出结果：
Hello World！
此时结果已经出来，但是正常情况下，属性应该要进行封装，所以我们将instance封装后，并提供getInstance()方法对外返回instance代码如下：

代码：

class Singleton{  
    private static Singleton instance = new Singleton();  //在内部实例化对象  
    public static Singleton getInstance(){  
        return instance;  
    }  
    private Singleton(){        //构造方法实例化  
    }  
    public void print(){  
        System.out.println("Hello World!");  
    }  
}  
public class SingletonDemo{  
    public static void main(String[] args){  
        Singleton s1 = null;  //声明对象  
        s1 = Singleton.getInstance();  
        s1.print();  
    }  
}  

这样完整的代码就写出来了，而这代码就是Java中的单例设计模式的一种写法
如果不希望一个类产生很多对象，就需要使用单例设计模式，这种模式的应用有很多，比如打印机在打印的时候只能创建一个打印实例，不然会造成内存浪费逻辑混乱；又如如在Windows中就只能打开一个任务管理器。如果不使用单例机制对窗口对象进行唯一化，将弹出多个窗口，如果这些窗口显示的内容完全一致，则是重复对象，浪费内存资源；如果这些窗口显示的内容不一致，则意味着在某一瞬间系统有多个状态，逻辑混乱。
单例模式的核心是构造方法的私有化（即在入口处限制了对象的实例化），之后在类的内部实例化对象，并通过静态方法返回实例化对象的引用。

——参考http://blog.csdn.net/tomcmd/article/details/48810669