《java入门第一季》之面向对象（private关键字与封装概念的初探）

/*
	定义一个学生类：
		成员变量：name，age
		成员方法：show()方法
		
	在使用这个案例的过程中，发现了一个问题：
		通过对象去给成员变量赋值，可以赋值一些非法的数据。例如：name你赋值了一个30整型数据
		这是不合理的。
		应该是这个样子的：在赋值之前，先对数据进行判断是什么样的类型。
		判断到底在哪里做比较合适呢?
		StudentDemo类是一个测试类，测试类一般(只创建对象，调用方法。)	
		所以，这个判断应该定义在Student类中完成。
		而我们在成员变量的位置可不可以进行数据判断呢?
		是不可以的，因为做数据校验，必须要依靠一些逻辑语句。
		逻辑语句是应该定义在方法中的，所以，我们最终决定在Student类中提供一个方法setAge()
		来对数据进行校验。
	
	按照前面的分析，我们给出了一个方法进行校验。
	但是呢，它偏偏不调用方法来赋值，还是直接赋值了，
	这样方法就没有起到作用。
	要求你必须使用方法去给成员变量赋初值，而不能直接调用成员变量赋值。
	怎么去强制要求不能直接使用成员变量?
		针对这种情况，Java就提供了一个关键字 private
		
	private:私有的。可以修饰成员变量和成员方法。
		注意：被private修饰的成员只能在本类中访问。
		
	其实写到现在讲解的是一个封装的思想。
	封装：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。这个公共往往是提供方法的方式
*/
class Student {
	//姓名
	String name;
	//年龄
	private int age;//只能通过本类调用，且只能通过本类方法来赋值，不可以直接赋值。
	
	//写一个方法对数据进行校验
	/*
		返回值类型：void
		参数列表：int a
	*/
	public void setAge(int a) {
		if(a < 0 || age > 120) {
			System.out.println("你给的年龄有问题");
		}else {
			age = a;
		}
	}
	
	
	//show()方法,显示所有成员变量值
	public void show() {
		System.out.println("姓名："+name);
		System.out.println("年龄："+age);
	}
}

class StudentDemo {
	public static void main(String[] args) {
		//创建学生对象
		Student s = new Student();
		s.show();//引用类型的数据是有默认值的
		System.out.println("--------------");
		
		//给成员变量赋值
		s.name = "林青霞";
		//s.age = 27;//定义了age为private这个语句就会报错。因为private为私有变量,私有的成分只能在本类中对他操作。
		s.setAge(27);
		s.show();
		System.out.println("--------------");
		
		//给age赋值
		//s.age = -27; //这个数据是不合理的，报错
		//通过方法给值
		s.setAge(-34);//因为有校验，所以根本赋不了值
		s.show();//这里输出正确的年龄和姓名，按照上边已经赋值的27输出。
		System.out.println("--------------");
	}
}
结果如下：

接着再进一步了解private：

/*
	private:
		是一个(权限修饰符)
		可以修饰成员变量和成员方法
		被其修饰的成员(只能)在（本类）中被访问
*/
class Demo {
	//int num = 10;
	//用private修饰
	private int num = 10;
	
	public void show() {
		System.out.println(num);//被private修饰的num变量只能在本类中访问，这是合法的
	}
	
	private void method() {//method方法被private修饰了
		System.out.println("method");
	}
	
	public void function() {
		method();//被private修饰的method()方法，只能在本类中访问，这是合法的
	}
}

class PrivateDemo {
	public static void main(String[] args) {
		Demo d = new Demo();
		//不能访问私有的成员变量，只能在那个类中被访问，报错。不能直接访问，但是可以间接地通过调用该类中的其他方法对其调用
		//System.out.println(d.num);
		d.show();//对象调用方法   10
		//不能访问私有的成员方法，因为private修饰了，只能在那个类中被访问，报错。不能直接访问，但是可以间接地通过调用该类中的其他方法对其调用
		//d.method();
		d.function();//对象调用function方法，间接地调用method。让function方法调用实现在该类中被private修饰的method()方法
	}
}

接着用一个实例显示整个过程加深印象：

/*
	封装和private的应用：
		A:把成员变量用private修饰
		B:提供对应的getXxx()(get值要有返回值)和setXxx()(set值不需要返回值)方法
*/
//定义学生类
class Student {
	//姓名
	private String name;
	//年龄
	private int age;
	
	//姓名获取值
	public String getName() {
		return name;
	}
	
	//姓名设置值
	public void setName(String n) {
		name = n;
	}
	
	//年龄获取值
	public int getAge() {
		return age;//该age来自于成员变量的值
	}
	
	//年龄赋值
	public void setAge(int a) {
		age = a;//这里给成员变量赋值
	}
}

//测试类
class StudentTest {
	public static void main(String[] args) {
		//创建学生对象
		Student s = new Student();
		
		//使用成员变量
		//错误：被私有修饰了，外界不能直接访问了，报错输出：name可以在Student中访问private
		//System.out.println(s.name+"---"+s.age);
		System.out.println(s.getName()+"---"+s.getAge());//null  0
		
		//给成员变量赋值，被私有修饰了，外界不能直接访问了。报错name可以在Student中访问private
		//s.name = "林青霞";
		//s.age = 27;
		//通过方法给赋值
		s.setName("林青霞");//通过对象调用方法，到该方法中去给（该类中）的成员变量赋值是正确的。
		s.setAge(27);
		System.out.println(s.getName()+"---"+s.getAge());
	}
}

谢谢关注，留下您的见解、指正与批评。

下一集为java中的this关键字......