面向对象--封装

软件开发追求的境界：高内聚，低耦合。

高内聚：尽可能把模块的内部数据，功能实现细节隐藏在模块内部独立完成，不允许外部直接干预

低耦合：仅暴露少量的方法给外部使用

封装是面向对象的三大特征之一，它指的是将对象的状态信息隐藏在对象内部，不允许外部程序直接访问对象内部信息，通过该类所提供的方法来实现对内部信息的操作和访问。

理解封装

对一个类或对象实现良好的封装，可以实现以下目的：

1），隐藏类的实现细节

2），让使用者只能通过实现预定的方法来访问数据，从而可以在该方法里加入控制逻辑，限制对属性的不合理访问

3），还可以进行数据检查，有利于保证对象信息的完整性

4），便于修改，提高代码的可维护性

为了实现良好的封装，需要从2个方面来考虑：

1），把对象的属性和实现细节隐藏起来，不允许外部直接访问

2），把方法暴露出来，让方法来控制对这些属性进行安全的访问和操作

因此，封装实际上有两个方面的含义，把该隐藏的隐藏起来，把该暴露的暴露出来。

去餐馆吃饭，我们只要能吃到菜就OK了，至于这个厨师长啥样，单眼皮还是双眼皮，怎么做的菜，用了什么牌子的地沟油，我们都没必要知道。我们使用的电脑其实就是体现了封

装的思想，它里面什么网卡，声卡是怎么插放的，怎么设计的，我们不要知道，我们只需打开电脑就可以用了。这就如同找一个人来修电脑，只需要知道修好了还是没修好。至于

他怎么修的可以不用了解。可是封装好了，外界怎么使用呢？（向外暴露一些简单的入口，供使用）         

方法是类中最小的封装体，那么类也一样是一种封装形式，有写方法需要暴露出去，有些就不用。

使用访问控制符

Java提供了4个访问控制符，private，default，protected，public，从左到右访问控制级别由小到大。

1），private（当前类访问权限）：本类内部可以访问，不能继承到子类

/**
 * private访问控制符
 * 
 * @author LinkinPark
 *
 */
public class Linkin
{
	private String name;

	private String getName()
	{
		return name;
	}

	public static void main(String[] args)
	{
		Linkin linkin = new Linkin();
		System.out.println(linkin.name);
		System.out.println(linkin.getName());
	}

}

class LinkinTest
{

	public static void main(String[] args)
	{
		Linkin linkin = new Linkin();
		// name属性，getName方法用private修饰，只能在自己类中被访问
		// 下面2行代码报错，编译不错。
		System.out.println(linkin.name);
		System.out.println(linkin.getName());
	}
}

2），default（包访问权限）：本类内部可以访问，同包其他类也可以访问，同包可继承

/**
 * default访问控制符
 * 
 * @author LinkinPark
 *
 */
public class Linkin
{
	String name;

	String getName()
	{
		return name;
	}

	public static void main(String[] args)
	{
		Linkin linkin = new Linkin();
		System.out.println(linkin.name);
		System.out.println(linkin.getName());
	}

}

class LinkinTest
{

	public static void main(String[] args)
	{
		Linkin linkin = new Linkin();
		// name属性，getName方法用default修饰，可以被同一个包中其他类访问
		System.out.println(linkin.name);
		System.out.println(linkin.getName());
	}
}

3），protected（子类访问权限）：本类内部可以访问，不同包的子类也可以访问，同包其他类也可以访问，能继承到子类

/**
 * protected访问控制符
 * 
 * @author LinkinPark
 *
 */
public class Linkin
{
	protected String name;

	protected String getName()
	{
		return name;
	}

	public static void main(String[] args)
	{
		Linkin linkin = new Linkin();
		System.out.println(linkin.name);
		System.out.println(linkin.getName());
	}

}

public class LinkinTest extends Linkin
{

	public void test()
	{
		// name属性，getName方法用protected修饰，可以被不同包中的其子类访问
		System.out.println(name);
		System.out.println(getName());
	}

}

4），public（公共访问权限）：任何地方都可以访问，能继承到子类。public就不举例子了，那里都可以访问，满世界都可以访问。

修饰符	类内部	同一个包	子类	任何地方
private	√
default	√	√
protected	√	√	√
public	√	√	√	√

关于访问控制符的使用，存在以下原则：

1，类中的绝大部门属性都应该使用private修饰，只有一些static修饰的，类似全局变量的属性，才使用public

2，如果某个类主要用作其他类的父类，那么应该使用protected来修饰这个类的方法

3，希望暴露给其他类调用的方法使用public来修饰。如果一个java源文件里定义了一个public修饰的类，则这个源文件的文件名必须与public修饰的类的类名相同

一个类常常就是一个小的模块，应该只让这个模块公开必须让外界知道的内容，而隐藏其他的一些内容。

进行程序设计时，应尽量避免一个模块直接操作或访问另一个模块的数据，模块设计追求高内聚，低耦合。

关于访问控制符的使用，存在如下几条基本原则：

1），类里的绝大部分属性都应该使用private修饰，至于一些static修饰的，类似全局变量的属性，才可能考虑使用public修饰。

2），如果某个类主要用做其他类的父类，该类里包含的大部分方法可能仅希望被其他子类重写，而不想被外界直接调用，则应该使用protected修饰这些方法。

3），希望暴露出来给其他类自由调用的方法应该使用public修饰。因此，类的构造器通过使用public修饰，从而允许在其他地方创建该类的实例。

因为外部类通常都希望被其他类自由使用，所以大部分外部类都使用public修饰。

JavaBean

一个类必须有一个参数为空的构造方法，所有的字段必须使用private修饰；并向外提供get方法和set方法。

若字段的第二个字母是小写的，把第一个字母变成大的，再加上get或者set作为前缀。

若第二个字母是大写的，就保持原样再加上get/set。boolean 类型的变量没有getXX,只有 isXX。

/**
 * JavaBean实例
 * 
 * @author LinkinPark
 *
 */
public class JavaBean
{
	// 使用private修饰，将这些属性隐藏起来，要是想修改这个类的属性，提供get和set方法
	private String name;
	private int age;

	public JavaBean()
	{

	}

	public String getName()
	{
		return name;
	}

	public void setName(String name)
	{
		// 在这里还可以加入自己的逻辑判断
		if ("LinkinPark".equals(name))
		{
			System.out.println("不可以的，林肯公园是偶的名字，不能随便拿来赋值");
			return;
		}
		else
		{
			this.name = name;
		}
	}

	public int getAge()
	{
		return age;
	}

	public void setAge(int age)
	{
		// 保证自己写的类的属性不要出现与实际情况不符的情况
		if (age > 100 || age < 0)
		{
			System.out.println("");
		}
		else
		{
			this.age = age;
		}
	}
}