java面向对象的三大特征之封装

面向对象的三大特征
*封装性
*继承性
*多态性

封装性
1.对于事物来说，看不到复杂的一面，只能看到简单的一面。复杂性封装，
对外提供简单的操作入口。例如照相机的实现原理非常复杂，对于使用者来
说却非常的方便简单
2.封装之后才会形成真正的对象，真正的独立体
3.封装就意味着以后的程序可以重复使用，并且这个事物应该适应性强，在
任何场合都可以使用
4.封装之后，对于事物本身，提高了安全性

封装的步骤
1.所有属性私有化，使用private关键字进行修饰，private表示私有的，
修饰的所有数据只能在本类中访问

2.对外提供简单的操作入口，也就是说以后外部程序想要访问age属性，必须
通过这些简单的入口进行访问
*对外提供两个公开的方法，set和get
*想修改age属性，调用set方法
*想读取age属性，调用get方法

3.set方法命名规范
public void set属性名首字母大写（形参）｛
｝
public viod setAge(int a){
age=a;
}

4.get方法命名规范
public 数据类型 get属性名首字母大写（）｛
｝
public int getAge(){
return age;
}
属性的访问形式
1.读取属性值：get
2.修改属性值：set

*setter 和 getter方法没有static关键字
*有static关键字修饰的方法怎么调用：类名.方法名（实参）
*没有static关键字修饰的方法怎么调用：引用.方法名（实参）
*一键封装：Alt+shift+s

package encapsulation;

public class Encapsulation {
	//属性私有化
	private int age;
//	public void setAge(int age) {
//		age=age;//java遵循就近原则，这里其实并没有给age赋值，这里的age都是局部变量age
//	}
	
	//setter
	public void setAge(int a) {
		if(a<0 || a>100) {
			System.out.println("您输入的年龄不合法！");
			return;
		}
		age=a;
	}
	//getter
	public int getAge() {
		
		return age;
	}
	public static void main(String[] args) {
		// TODO 自动生成的方法存根

		
	}

}

举个例子：
这是一个地址类

package instance;

public class Address {
	int number;
	String city;
	String street;
}

这是一个学生类

package instance;

public class Student {
	
		int age = 20;
		int number;
		boolean sex;
		//Address是一种饮引用型数据类型，addr是一个实例变量
		Address addr;
		
}

所有学生都有学号信息
但每一个学生的学号都不同
所以要访问这个学号必须先创建对象，通过对象去访问学号信息
学号信息不能直接通过’类’去访问，所以这种成员变量被叫做：实例变量/对象变量
如果不创建对象，这个number变量的内存空间是不存在的，只有创建了对象，这个number变量才会有内存空间
在java语言中，程序员不能直接操作对内存，java中没有指针

这是关于封装的使用

package instance;
/*
 	面向对象的三大特征
 		*封装
 		*继承
 		*多态
 	面向对象的方式开发软件
 		*面向对象的分析：OOA
 		*面向对象的设计：OOD
 		*面向对象的编程：OOP
 	什么是类
 		对象之间具有共同特征，抽象总结出一个模板，这个模板称为类
 		类描述的是状态+动作
 		状态——>一个类的属性
 		动作——>一个类的方法
 	什么是对象（实例/instance）
 		现实世界实际存在
 	
 	类-【实例化】->对象
 	对象-【抽象】->类
 */

import encapsulation.Encapsulation;

/*
 	类的定义
 		语法结构：
 			[修饰符列表] class 类名{
 				//属性；
 				int age;
 				int numbel;
 				boolean sex;
 				String address;
 				方法；
 			}
 */
public class Instance {
	// 定义一个类，起名学生

	public static void main(String[] args) {
		// new用来创建对象，在JVM堆内存中开辟空间
		/*
		 * 方法区内存：class字节码文件 栈内存：方法压栈，局部变量 堆内存：new的对象
		 */
		Student s = new Student();// S是局部变量【引用】，new Student是一个学生对象
		// 引用是保存了对象地址的的变量
		/*
		 * 访问实例变量的语法格式 读取数据：引用.变量名 修改数据：引用.变量名 = 值
		 */
		int stunum = s.number;
		int stuage = s.age;
		boolean stusex = s.sex;
		Address a = new Address();// a也是局部变量
		s.addr = a;
		// System.out.println(stusex);
		// s.age = 16;
		System.out.println(stuage);
		System.out.println(s.age);
		s.age = 16;
		System.out.println(stuage);
		System.out.println(s.age);
		stuage = s.age;
		System.out.println(stuage);
		System.out.println(s.age);
		s.age = 17;
		System.out.println(stuage);
		System.out.println(s.age);

		// 对象的嵌套使用【跨文件】
		System.out.println(s.addr);
		System.out.println(s.addr.city);
		System.out.println(a.city);

		// 对象的嵌套使用【本文件】
		home shao = new home();
		bed huihui = new bed();// 类名 引用
		shao.mianJi = 200.345;
		shao.weiZhi = "Ordes";
		shao.bedd = huihui;
		// huhui = shao.bedd;
		huihui.tiJi = 234.234;
		huihui.caiZhi = "mutou";
		System.out.println(shao.bedd.caiZhi);
		System.out.println(huihui.tiJi);
		System.out.println(shao.mianJi);
		shao.bedd = new bed();// 引用.变量名
		bed huhu = new bed();
		shao.bedd = huhu;
		huhu.tiJi = 30.67;
		System.out.println(huihui.tiJi);
		System.out.println(huihui.caiZhi);
		System.out.println(shao.bedd.tiJi);// 空指针
		System.out.println(shao.bedd.caiZhi);// 空指针
		System.out.println(huhu.tiJi);
		
		//面向对象的封装性
		Encapsulation syh = new Encapsulation();
		//编译报错，该age不可视
		//私有的属性不能在外部直接访问，这就是封装
		//System.out.print(syh.age);
		System.out.println(syh.getAge());
		//修改
		syh.setAge(100);
		//读取
		System.out.println(syh.getAge());
	}
}

class home {
	double mianJi;
	String weiZhi;
	bed bedd;
}

class bed {
	double tiJi;
	String caiZhi;
}