面向对象(5)：封装：private关键字、公共的setXxx()和getXxx()方法

面向对象(5)：封装

例1、show方法表示打印全部成员变量

//定义一个学生类
 class Student02{
    //定义学生类中的成员变量
    String name;
    int age;
    //定义学生类中的成员方法
    //show方法表示打印出所有的成员变量，切记！
    public void show(){
        System.out.println("姓名："+name+"，年龄："+age);
    }
}

//定义一个测试类
public class Test88 {
    public static void main(String[] args) {
        //创建学生对象
        Student02 cc = new Student02();
        //调用学生类中的show方法
        cc.show(); //因为未赋值，输出为是null和0

        //给成员变量赋值
        cc.name = "伟神";
        cc.age = 18;
        //再次调用成员方法show
        cc.show();
    }
}

        执行结果：
                姓名：null，年龄：0
                姓名：伟神，年龄：18

                Process finished with exit code 0

例2、当给年龄赋值10000，再调用方法，不影响程序运行，但是10000岁不符合现实，这时候就需要加入判断；

这个判断就是，再添加一个成员方法，来控制着年龄

//定义一个学生类
 class Student02{
    //定义学生类中的成员变量
    String name;
    int age;

    //添加一个判断方法
    public void setAge(int x){
        if(x>0 && x<=100){
            age = x;    //如果满足条件，就将x赋值给age
        }else{
            System.out.println("年龄输入有误");
        }
    }
    //定义学生类中的成员方法
    //show方法表示打印出所有的成员变量，切记！
    public void show(){
        System.out.println("姓名："+name+"，年龄："+age);
    }
}

//定义一个测试类
public class Test88 {
    public static void main(String[] args) {
        //创建学生对象
        Student02 cc = new Student02();
        //调用学生类中的show方法
        //因为未赋值，输出为是null和0
        cc.show();

        //给成员变量赋值
        cc.name = "伟神";
        cc.age = 18;
        //再次调用成员方法show
        cc.show();
        System.out.println("=====================");
        //假如我们给年龄赋值10000
        //调用判断的方法，直接将参数写成10000即可
        cc.setAge(10000);
        cc.show();
        System.out.println("======================");
        //假如给年龄赋值98
        cc.setAge(98);
        cc.show();
    }
}

        执行结果如下：
                姓名：null，年龄：0
                姓名：伟神，年龄：18
                =====================
                年龄输入有误
                姓名：伟神，年龄：18
                ======================
                姓名：伟神，年龄：98

                Process finished with exit code 0

3、通过例1、例2，虽然我们加入了一个方法传参的形式去给成员变量进行赋值，并且在赋值的时候进行判断；
但是呢，我偏偏不使用定义的方法，就使用对象名.成员变量的形式去赋值，依旧可以赋值一些不合理的值；

​ 如果有一个办法可以让外界不能直接访问到成员变量就好了，这样想要进行对成员变量赋值，就不能通过对象名.成员变量的形式去赋值，只能通过我们定义的方法去赋值。
这样的方法，java提供了一个关键字给我们使用，这个关键字叫做：private（私有的）

使用private修饰的成员变量，在其他类中不能直接访问

通过例1、例2，主要引出一个思想：面向对象的三大特征之一：封装

4、封装

封装的步骤：
第一：
（1）创建一个类
（2）在类中定义成员变量 private String name;
（3）定义公共的setXxx()方法，括号里需要写形参
（4）定义公共的getXxx()方法
（5）定义一个show方法
第二：
（1）创建一个测试类，输入main方法
（2）创建学生对象
（3）调用公共的setName()方法并赋值，在括号内赋值
（4）调用show方法

1、封装的含义：实际上就是隐藏对象的属性和相关实现细节，仅仅对外提供公共的（public）访问的方式
2、封装的好处：
		①隐藏实现细节，提供公共的访问方式
		②提高了代码的复用性
		③提高安全性
3、封装原则：
		①将不需要对外提供的内容都隐藏起来
		②把属性隐藏，提供公共方法对其访问
4、封装中的private关键字介绍：
        ①是一个权限修饰符
        ②可以修饰成员变量和成员方法
        ③被private修饰的成员只在本类中才能访问

//定义一个人类
class Person{
    /*
    定义成员变量（之前的做法）
    String name;
    int age;
     */
//学过了private,在以后定义成员变量的时候，
// 前面必须加上private，这是规范
    private String name;
    private int age;

//我们需要提供一个公共的方法，可以让外界可以获取到成员变量，以及对成员变量可以赋值

//先对name来说，定义一个公共的方法，让外界其他类可以对name进行赋值
    public void setName(String n){  //setName这个名字是统一的
        name = n;
    }
//对name来说，需要提供一个公共的方法，让外界可以获取到name
    public String getName(){  //外界调用getName的时候，可以接收一个String的值
        return name;          //接收的String的值，就是name
    }
//上面创建的公共set和get方法，可以让外界对成员变量name,进行赋值和取值

    //根据上面，同理，age也是如此
    public void setAge(int a){
        age = a;
    }
    public int getAge(){
        return age;
    }

    //此外，还有提供一个方法，来输出打印所有的成员变量
    public void show(){
        System.out.println("姓名："+name+"，年龄："+age);
    }
}
        //这样，一个标准规范的类就写好了

//定义一个测试类
public class PrivateDemo {
    public static void main(String[] args) {
        //创建Person对象
        Person x = new Person();
        //被private修饰的成员变量无法直接被访问，写x.name;是错误的
        //只能调用公共的方法进行获取(暂未赋值)
        String name = x.getName();
            int age = x.getAge();
        System.out.println(name+"======"+age);

        //调用公共的方法对成员变量进行赋值
        //之前做法是 x.name ="伟爷";
        x.setName("伟爷");
        x.setAge(18);
        //然后调用show方法
        x.show();

        /*
        如果在人类中再定义一个方法fun被private修饰
            private void fun(){
                System.out.println("嘤嘤嘤");
            }
            这个fun方法在PrivateDemo中也是无法访问的，
            但是如果将fun放进show中，是可以被访问到的，最后会打印出：嘤嘤嘤
            public void show(){
                    fun();
                    System.out.println("姓名："+name+"，年龄："+age);
            }
         */
    }
}

            执行结果如下：
                    null======0
                    姓名：伟爷，年龄：18

                    Process finished with exit code 0