《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:
是一个(权限修饰符)
可以修饰成员变量和成员方法
被其修饰的成员(只能)在（本类）中被访问
*/
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());
}
}