Java零基础(第十章)---》封装

🏀封装

🥅简单理解

❤️面向对象的首要特征：封装 。什么是封装？有什么用？
⭐️现实生活中有很多现实的例子都是封装的，例如：手机，电视机，笔记本电脑，照相机，这些都是外部有一个坚硬的壳儿。封装起来，保护内部的部件。保证内部的部件是安全的。另外封装了之后，对于我们使用者来说，我们是看不见内部的复杂结构的，我们也不需要关心内部有多么复杂，我们只需要操作外部壳儿上的几个按钮就可以完成操作。

 ⭐️封装有什么用呢？
             第一个作用：保证内部结构的安全。
             第二个作用：屏蔽复杂，暴露简单。            
  ⭐️在代码级别上，封装有什么用？
       一个类体当中的数据，假设封装之后，对于代码的调用人员来说，不需要关心代码的复杂实现，只需要通过一个简单的入口就可以访问了。另外，类体中安全级别较高的数据封装起来，外部人员不能随意访问，来保证数据的安全性。

❤️例1：不使用封装

⭐️Person表示人类：
每一个人都有年龄这样的属性：年龄age，int类型。
⭐️我这里先不使用封装机制，分析程序存在什么缺点？
Person类的age属性对外暴露，可以在外部程序中随意访问，导致了不安全。
⭐️怎么解决这个问题？
封装。

⭐️Person类

public class Person{
    // 实例变量(属性)
    int age; //age属性是暴露的，在外部程序中可以随意访问。导致了不安全。

}

⭐️PersonTest类

// 在外部程序中访问Person这个类型中的数据。
public class PersonTest{
    public static void main(String[] args){
//1. 创建Person对象
        Person p1 = new Person();
        // 访问人的年龄
        // 访问一个对象的属性，通常包括两种操作，一种是读数据，一种是改数据。
//2. 读数据
        System.out.println(p1.age); //读（get表示获取）

//3. 修改数据（set表示修改/设置）
        p1.age = 50;        
        //再次读取
        System.out.println(p1.age);

//4. 在PersonTest这个外部程序中目前是可以随意对age属性进行操作的。
        // 一个人的年龄值不应该为负数。
        p1.age = -100; //改（随意在这里对Person内部的数据进行访问，导致了不安全。）
        System.out.println("您的年龄值是：" + p1.age); //读
    }
}

❤️例2：使用封装

⭐️怎么进行封装，代码怎么实现？
第一步：属性私有化（使用private关键字进行修饰。）
第二步：对外提供简单的操作入口（get和set方法）。

⭐️例1：构造方法的个数

//构造方法、构造器、Constructor【构造函数】都是一个东西
// 只能用new来调用构造方法。
public class Student{
    String no;
    String name;

//1. 无参数的构造方法
    public Student(){
    }
//2. 有一个参数，下面两种定义一种就行，都是字符串
    public Student(String s){
        no = s;
    }
    /*
    public Student(String mingZi){
        name = mingZi;
    }
    */
//3. 两个参数
    public Student(String s1, String s2){
        no = s1;
        name = s2;
    }
}

//构造方法两个作用：创建对象和给属性赋值。
class StudentTest{
    public static void main(String[] args){
        Student s = new Student();
        Student s1 = new Student("100");
        Student s1 = new Student("100","200");
    }
}

⭐️例2：带有static和没有static怎么调用

（1）带有static的方法怎么调用？
通过“类名.”的方式访问。

（2）没有static的方法称为实例方法。（对象方法，对象级别的方法），对象被称为实例。
实例相关的有：实例变量、实例方法。
实例变量是对象变量。实例方法是对象方法。
实例相关的都需要先new对象，通过“**引用.**”的方式去访问。

（3）带static是类级别的行为；不带static是对象级别的行为

public class MethodTest{

    public static void main(String[] args){
//带有static的方法    
        MethodTest.doSome();
        //类名. 可以省略（在同一个类中。）
        doSome();
        
//不带有static的方法，先创建对象
        MethodTest mt = new MethodTest();
        // 通过"引用."的方式访问实例方法。
        mt.doOther();
    }    

//1. 带有static
    public static void doSome(){
        System.out.println("do some!");
    }

//2. 不带有static
    public void doOther(){
        System.out.println("do other....");
    }

}

⭐️例3：空指针异常

** （1）空指针异常导致的最本质的原因是？**
空引用访问“实例相关的数据”，会出现空指针异常。
实例相关的包括：实例变量 + 实例方法。

public class NullPointerTest{
    public static void main(String[] args){
        User u = new User();
        System.out.println(u.id); // 0
        u.doSome();

// 引用变成空null
        u = null;
        //id的访问，需要对象的存在；实列变量的引用
        //System.out.println(u.id); // 空指针异常
        //一个实例方法的调用也必须有对象的存在；实列方法的引用，需要对象的存在
        //u.doSome(); // 空指针异常。
    }
}

// 类 = 属性 + 方法；属性描述状态；方法描述行为动作
class User{
//1. 实例变量
    int id;

//2. 实例方法（对象相关的方法，对象级别的方法，应该是一个对象级别的行为。）
    // 方法模拟的是对象的行为动作。
    public void doSome(){
        System.out.println("do some!");
    }
}

🥅get方法和set方法

❤️封装的代码实现两步：
⭐️第一步：属性私有化
⭐️第二步：1个属性对外提供两个set和get方法。外部程序只能通过set方法修改，只能通过get方法读取，可以在set方法中设立关卡来保证数据的安全性。
❤️强调一下：
⭐️set和get方法都是实例方法，不能带static；
不带static的方法称为实例方法，实例方法的调用必须先new对象。 set和get方法写的时候有严格的规范要求：（大家要按照规矩来）

---

    set方法：
           public void set+属性名首字母大写(1个参数){
              xxx = 1个参数;
           }

     get方法：
             public 返回值类型 get+属性名首字母大写(无参){
                    return xxx;
             }

⭐️Person类

/*
   Person表示人类：
        每一个人都有年龄这样的属性：年龄age，int类型。        
   尝试封装一下；不再对外暴露复杂的数据，封装起来
   对外只提供简单的操作入口。
   优点：第一数据安全了。第二调用者也方便了。
*/
public class Person{
//1.第一步：变量私有化
    // private 表示私有的，被这个关键字修饰之后，该数据只能在本类中访问。
    // 出了这个类，age属性就无法访问了。私有的。
    private int age; // 每一个人年龄值不同，对象级别的属性。

    // 写一个方法专门来完成读。(get)
    // 写一个方法专门来完成写。(set)
    // get读年龄，set改年龄，这个读和改都是操作的一个对象的年龄。（没有对象何来年龄）
//2. 封装的第二步：提供公开的set方法和get方法作为操作入口。并且都不带static。都是实例方法。
    /*
        [修饰符列表] 返回值类型 方法名(形式参数列表){
        }

        注意：
            java开发规范中有要求，set方法和get方法要满足以下格式。
                get方法的要求：
                    public 返回值类型 get+属性名首字母大写(无参){
                        return xxx;
                    }
                set方法的要求：
                    public void set+属性名首字母大写(有1个参数){
                        xxx = 参数;
                    }

    */
    // get方法----读
    public int getAge(){
        return age;
    }

    // set方法----写
    public void setAge(int nianLing){
        // 能不能在这个位置上设置关卡！！！！
        if(nianLing < 0 || nianLing > 150){
            System.out.println("对不起，年龄值不合法，请重新赋值！");
            return; //直接终止程序的执行。
        }
        //程序能够执行到这里，说明年龄一定是合法的。
        age = nianLing;
    }

}

⭐️PersonTest02类

public class PersonTest02{
    public static void main(String[] args){
//1. 创建对象
        Person p1 = new Person();
        
//2. 通过“类名.”可以调用set和get方法吗？不行。
    // 只有方法修饰符列表中有static的时候，才能使用“类名.”的方式访问错误的。
        //Person.getAge();//err

//3.读调用getAge()方法
        System.out.println(p1.getAge()); //0

//4.改调用setAge()方法
        p1.setAge(20);
        System.out.println(p1.getAge()); //20

        p1.setAge(-100);//g更改失败，还是原来的值
        System.out.println(p1.getAge()); // 20

    }
}

🥅小试牛刀

定义“人”类，“人”类包括这些属性：姓名、性别、年龄等。使用封装的方式编写 程序，要求对年龄进行安全控制，合法的年龄范围为[0~100]，其他值表示不合法。

public class Test{
    public static void main(String[] args) {
        //先使用无参构造
        Person1 p = new Person1();
        p.setName("张三");
        p.setSex(true);
        p.setAge(18);
        //打印
        p.print();

        //调用有参构造
        Person1 p1 = new Person1("李四",false,22);
        p1.print();

    }
}

class Person1{
 //1.属性私有化
    private String name;
    private boolean sex;
    private int age;

    //构造方法
    public Person1() { //无参构造
    }

    public Person1(String name, boolean sex, int age) { //有参构造
        if(age <0 || age >100){
            System.out.println("年龄不合法，年龄置位0");
            age = 0; //不合法就让年龄变为0
        }
        this.name = name;
        this.sex = sex;
        this.age = age;
    }

 //2.getter and setter
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public boolean getSex() {
        return sex;
    }

    public void setSex(boolean sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if(age <0 || age >100){
            System.out.println("修改的年龄不合法，年龄置位0");
            this.age = 0; //不合法就让年龄变为0
            return;
        }
        this.age = age;
    }

    //打印方法
    public void print(){
        System.out.println("姓名："+this.getName()+"，"+"性别："+(this.getSex()?"男":"女")+"，"+"年龄："+this.getAge());
    }
}