Java学习笔记42——封装 private关键字

/*
            定义一个学生类：
                成员变量：姓名，年龄
                成员方法：show()

            我们在正常开发的过程中，发现一个问题：
                我们通过对象.变量名的形式给成员变量进行赋值，在赋值年龄的时候
                我们居然可以赋值一些不合理的数据，比如我赋值10000
                根据现实实际情况来看，年龄赋值10000是不合理。
                想一想，如果我们在赋值的时候，加一个判断，校验一下，如果
                合理，就允许赋值，如果不合理，就不允许赋值。
                那么，我们在哪里加入判断比较合适呢？
                StudentDemo1是一个测试类，测试类中一般情况下，只允许创建对象，调用方法或者访问成员变量

                所以，我们把添加判断的逻辑代码放到Student2类中
                而我们的类中有成员变量，成员方法。
                成员变量上只能是定义成员变量，加不了判断。
                我们经过考虑后决定，另外写一个成员方法，来为年龄进行赋值，在赋值的时候加入判断

                虽然我们加入了一个方法传参的形式去给成员变量进行赋值，并且在赋值的时候进行判断
                但是呢，我偏偏不使用定义的方法，就使用对象名.成员变量的形式去赋值，依旧可以赋值一些
                不合理的值。如果有一个办法可以让外界不能直接的访问到成员变量就好了，这样如果想要
                进行对成员变量赋值，就不能通过对象名.成员变量的形式去赋值，只能通过我们定义的方法
                去赋值。
                有这样的方法，java替我们考虑到了这样的情况，提供了一个关键字给我们使用
                这个关键字叫做：private

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

                说到现在的案例，主要引出一个思想：面向对象的三大特征之一-----封装

                封装：
                    实际上就是隐藏对象的属性和相关实现细节，仅仅对外提供公共的访问的方式。


 */
class Student2 {
    //定义成员变量
    String name;
    private int age;

    public void setAge(int x){
        if(x>0 & x<=100){
            age = x;
        }else {
            System.out.println("输入的年龄有误");
        }

    }

    //输出打印该对象的所有成员变量
    public void show() {
        System.out.println("姓名：" + name + ",年龄：" + age);
    }
}


public class StudentDemo1 {
    public static void main(String[] args) {
        //创建Student2的对象
        Student2 s1 = new Student2();
        s1.show();
        //给对象的成员变量进行赋值
        s1.name = "李玉伟";
//        s1.age = 18;
        s1.show();

//        s1.age = 10000;
        s1.setAge(100);
        s1.show();


    }
}

/*
        封装：
            是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
        好处：
            隐藏实现细节，提供公共的访问方式
            提高了代码的复用性
            提高安全性。
        封装原则：
            将不需要对外提供的内容都隐藏起来。
            把属性隐藏，提供公共方法对其访问。

        封装中的private关键字介绍：
            1、是一个权限修饰符。
            2、可以修饰成员(成员变量和成员方法)
            3、被private修饰的成员只在本类中才能访问。


        练习：
            随机找身边的一个事物，定义一个类
            成员变量用private修饰，提供公共的getXxx()和setXxx()方法
            以及提供一个可以输出所有成员变量的show()方法
            然后定义一个测试类，去创建对象使用看看


 */
class Person {
    private String name;
    private int age;

    public void setName(String s) {
        name = s;
    }

    public String getName() {
        return name;
    }

    public void setAge(int i) {
        age = i;
    }

    public int getAge() {
        return age;
    }

    //提供一个方法可以输出打印所有的成员变量
    public void show() {
        //被private修饰的成员方法，只能在本类中进行访问
        fun2();
        System.out.println("姓名：" + name + ",年龄：" + age);
    }

    private void fun2() {
        System.out.println("这是一个被private修饰的成员方法");
    }



}


public class PrivateDemo1 {
    public static void main(String[] args) {
        //创建Person对象
        Person p1 = new Person();

        //因为成员变量都被private私有的关键字修饰了，所以在其他类中访问不到。
//        p1.name;
//        p1.age;
        //只用调用公共方法进行获取
        String name = p1.getName();
        int age = p1.getAge();
        System.out.println(name + "---" + age);

        //通过公共的方法对成员变量进行赋值
        p1.setName("刘梦云");
        p1.setAge(18);
        p1.show();

        //被private修饰成员方法，在其他类中也是不可以被访问的。
//        p1.fun2();

    }
}