Java基础入门菜鸟学习第十六天——Java面向对象（十）

java面向对象——封装

4.8封装

4.8.1封装的定义

• 封装，顾名思义，就是打包，在Java中封装是面向对象方法的重要原则，就是把对象的属性和操作结合为一个独立的整体，并尽可能隐藏对象的内部实现细节
• 类层面上的封装：使用对象做事，将一个类封装起来之后，通过创建的对象就可以调用其中的属性以及方法。

4.8.2实现封装的修饰符

• 在Java中通过关键字public、protect、默认的default、private
  

4.8.3属性的封装

这里只用private关键字来演示，其他修饰符写法一样

代码演示：

public class Person{
    //属性的封装， private修饰成员变量，封装后是对象的私有属性
    private String name;
    private int age;
    public Person(){
        
	}
	public void info(){
		System.out.println(name+"Person.info()"+age);
    }
    //方法的封装
	public void setName(String name){
		this.name=name;
	}
	public String getName(){
		return this.name;
	}
	public void setAge(int age){
		if(age>0&&age<=150){
			this.age=age;
		}
    }
}
public class PersonTest{
	public static void main(String[] args){
		//创建person对象
		Person p=new Person();
        p.setName("张三");
        p.setAge(1000);
		p.info();
        System.out.println(p.getName());
	}
}        

//执行结果：
张三Person.info()0
张三

• 通过不同的修饰符去修饰当前属性，导致某些属性外部的可见性降低，甚至外部不能随意修改以及获取。
• 要注意当将属性的可见性减低之后，内部一定要暴露出来你需要暴露的访问和修改的方式。
• 当属性访问权限降低之后，如果要访问以及修改当前属性，需要通过类中内部定义的方法实现，也就意味着可操作性空间进行了提升。我们可以在方法内部对于数据进行一些列的判定以及干扰

4.8.4构造器的封装

代码演示：

public class Single{
    //构造器方法的封装，不能通过new对象来调用
	private Single(){
        System.out.println();
	}
/*让外部能够调用当前该方法获取到当前类的对象*/
	public static Single getInstance(){
		return new Single();
	}
}
public class TestSingle{
	public static void main(String[] args){
        Single s=new Single();//编译出错，封装了构造器
		Single s=Single.getInstance();
        System.out.println(s);
	}
} 

执行结果：
你好！
com.pxcoder.myproject4.Single@15db9742

归纳：

• 构造器封装之后虽然无法产生对象，但是在一定程度上是有必要的。比如对于Math类而言，由于内部所有方法都是static静态的，那么它将构造器私有就是为了防止外部创建实例对象。
• 一般情况下对于构造器的封装都是有意义的，后期的单例模式、后期的一些工具类的创建都会将构造器私有起来。本质上构造器是否私有，构造器是否封装是有当前类所处的角色事先就定义好了。

封装练习：

public class Arrays {
	//定义一个int类型的data数组
	private int[] datas;
	//数组的索引（数据的添加位置）
	private int index;
	public Arrays() {
		//给属性赋值
		datas=new int[4];
		index=0;
	}
	//给Arrays对象中添加元素
	public void add(int value) {
		if(index>=datas.length) {
			resize();
		}
		datas[index]=value;
		index++;
	}
	private void resize() {
		int[] newdatas=new int[datas.length*2];
		for(int i=0;i<index;i++) {
			newdatas[i]=datas[i];
		}
		datas=newdatas;
	}
	public String toString() {
		String prefix="arr[";
		String content="";
		for(int i=0;i<index;i++) {
			content+=datas[i]+"\t";
		}
		String sffix="]";
		String ret=prefix+content+sffix;
		return ret;
	}
	public int getLength() {
		return this.index;
	}
}
public class ArrayTest {
	public static void main(String[] args) {
		Arrays a=new Arrays();
		a.add(20);
		a.add(20);
		a.add(39);
		a.add(40);
		a.add(60);
		System.out.println(a);
		System.out.println(a.getLength());
	}
}

执行结果：
arr[20	20	39	40	60	]
5

4.8.5封装的作用

• 方法封装就是将一些核心的业务逻辑隐藏起来，外部不可见，让内部更加安全，外部的调用复杂度也会相应减低，提高了可控性的目的。例如：对于上述代码而言扩容的方法resize无须外界访问，内部自己确定合适调用以及调用的方式以及扩容的大小。

• 提高了代码的可复用性和可维护性