Java寒假学习Day9:封装和隐藏

刚复习完递归，看了斐波那契数列，我和她的所有故事，都藏着f5和f8这两个无言的数字里。

package Methods;

public class FbnqTest {
	public static void main(String[] args) {
		FbnqTest test = new FbnqTest();
		System.out.println("about her");
		System.out.print(test.getFbnqLine(5));
		System.out.println(test.getFbnqLine(8));
	}
	
	public int getFbnqLine(int n) {
		if (n == 1|| n == 2) {
			return 1;
		}else{
			return getFbnqLine(n-1)+getFbnqLine(n-2);
		}
	}
}

我们程序设计追求“高内聚，低耦合”

高内聚 ：类的内部数据操作细节自己完成，不允许外部干涉

低耦合 ：仅对外暴露少量的方法用于使用

 隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可

维护性。通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。

①属性的封装

package PackageTest;

public class AnimalTest {
	
	public static void main(String[] args) {
		Animal a = new Animal();
		//无任何封装
		a.name = "huahua";
		a.age = 1;
		a.legs = 4;
		a.show();
		//尝试要求legs只能赋正偶数
		a.setLegs(4);//赋值成功，输入4
		a.setLegs(1);//赋值失败，输入0
		a.legs = 3;//依旧成功，可以随便赋值
		a.show();
		//要求必须用setLegs方法给legs赋值
		//更改Animal类的属性legs
		//更改为private int legs，外部没办法调用 想要调用必须用setLegs()方法
		a.legs = 3; //显然，报错了
		a.setLegs(3);//不报错
	}
}


class Animal{
	String name;
	int age;
	private int legs;
	
	public void setLegs(int l) {
		if(l>0&&l%2==0) {
			legs = l;
		}else {
			legs = 0;
		}
	}
	
	public void show() {
		System.out.println("name ="+name +"age ="+age+"legs ="+legs);
	}
}

②不对外暴露的私有方法

③单例模式

④其他封装等

Java 规定的四种权限：private<缺省(default)

类及类的内部结构：属性，方法，构造器，内部类

对于类来说：只能用public或缺省的

权限修饰符测试：

3.1.1.1包PackageTest下的测试

Order类

package PackageTest;

public class Order {
	private int orderPrivate;
	int orderDefault;
	public int orderPublic;
	
	private void OrderPrivate() {
		orderPrivate = 1;
		orderDefault = 2;
		orderPublic = 3;
	}
	void OrderDefault() {
		orderPrivate = 1;
		orderDefault = 2;
		orderPublic = 3;
	}
	public void OrderPublic() {
		orderPrivate = 1;
		orderDefault = 2;
		orderPublic = 3;
	}
}

测试结果：public,private，缺省在同一个类中，都能使用 

OrderTest类

package PackageTest;

public class OrderTest {
	public static void main(String[] args) {
		Order o = new Order();
		
//		o.orderPrivate = 1;  
//		The field Order.orderPrivate is not visible;
//		private权限下，别的类调用就报错：不可见
		o.orderDefault = 2;
		o.orderPublic = 3;
		
//		o.OrderPrivate();
//		The method OrderPrivate() from the type Order is not visible
		o.OrderDefault();
		o.OrderPublic();
	}
	
}

 测试结果：public,缺省在同一个包下都可以使用，private不行

3.1.1.2在包Package1中再次测试

package PackageTest1;

import javaStudy.PackageTest.Order;

public class OrderTest {
	public static void main(String[] args) {
		Order o = new Order();
		
//		o.orderPrivate = 1;  
//		The field Order.orderPrivate is not visible;
//		private权限下，别的类调用就报错：不可见
//		o.orderDefault = 2;
//		The field Order.orderDefault is not visible;
//		default权限下，别的包调用就报错：不可见
		o.orderPublic = 3;
		
//		o.OrderPrivate();
//		The method OrderPrivate() from the type Order is not visible
//		o.OrderDefault();
//		The method OrderDefault() from the type Order is not visible
		o.OrderPublic();
	}
	
}

测试结果：在不同包下，仅仅public权限依旧有效，其他全部失效

创建程序,在其中定义两个类：Person和PersonTest类。定义如下：
用setAge()设置人的合法年龄(0~130)，用getAge()返回人的年龄。
在PersonTest 类中实例化 Person类 的 对 象 b， 调 用 setAge()和
getAge()方法，体会Java的封装性。

Person

package PackageTest;

import javax.management.RuntimeErrorException;

public class Person {
	private int age;
	
	public void setAge(int i) {
		if(i<0||i>130) {
			throw new RuntimeException("age is out of bound");
		}else {
			age = i;
		}
	}
	
	public int getAge() {
		return age;
	}
}

 PersonTest

package PackageTest;

public class PersonTest {
	public static void main(String[] args) {
		Person p = new Person();
//		p.age = 130;编译不通过，age为private类型
		p.setAge(30);
		System.out.println(p.getAge());
		p.setAge(130);
	}
}