面向对象【三大特性——封装】 Java代码演示

封装

封装性是面向对象编程的核心思想，指的就是将描述某种实体的数据和基于这些数的操作集合到一起，形成一个封装体，封装的思想保证了类内部数据结构的完整性，使用户无法轻易直接操作类的内部数据，这样降低了对内部数据的影响，提高了程序的安全性和可维护性。

封装的优点：

• 1. 良好的封装能够减少耦合。
• 2. 类内部的结构可以自由修改。
• 3. 可以对成员变量进行更精确的控制。
• 4. 隐藏信息，实现细节。

---

1.方法封装

代码演示：

public class Demo11ClassPackaging {

    public static void main(String[] args) {
        int[] array = { 5, 15, 25, 50, 100 };
		
		// 需要取最大值，直接调用方法
        int max = getMax(array);
        System.out.println(max);
    }

	// 方法块
    public static int getMax(int[] array) {
        int max = array[0];
        for (int i = 1; i < array.length; i++) {
            if (array[i] > max) {
                max = array[i];
            }
        }
        return max;
    }

}

需要取数组的最大值，直接调用方法得到。

---

---

2.private关键字也是一种封装

首先定义一个Person类，在定义person年龄的时候，无法阻止不合理的数值进来，但是private关键字将需要保护的成员变量进行修饰。

代码演示：

public class Person {

    String name;
    // int private age;
    int age;

    public void show() {
        System.out.println("This is KL, he is " + age + " years old.");
    }
}

然后我们在另一个类当中去调用该类

public class Demo12Person {

    public static void main(String[] args) {
        Person person = new Person();
        person.show();

        person.name = "kl";
        person.age = 20;
        person.show();

    }
}

代码运行结果如下：

This is KL, he is 0 years old.
This is KL, he is 20 years old.

注意：
一旦使用了private进行修饰，在本类当中仍然可以访问，但是超出本类就不可以直接访问。如上代码如果使用private关键字去修饰age，那么在另外一个类中调用则报错！！！从而提高了代码鹅蛋安全性。不可以直接访问，那就可以间接访问呗。

代码演示：

我们用private去修饰age，然后间接访问age。

public class Person {

    String name;
    private int age;
    // int age;

    public void show() {
        System.out.println("This is KL, he is " + age + " years old.");
    }
    // setAge成员方法，专门用于向age设置数据
    public void setAge(int num) {
        age = num;
    }

    // getAge方法专门用于获取age数据
    public int getAge() {
        return age;
    }
}
0

然后再另一个类中访问

public class Demo12Person {

    public static void main(String[] args) {
        Person person = new Person();
        // person.show();

        person.name = "kl";
        // person.age = 20;

        person.setAge(-20);
        person.setAge(40);
        person.show();

    }
}

代码运行结果：

数据不合理！
This is KL, he is 40 years old.

---

对于基本类型当中的boolean值，Getter方法一定要写成isXxx的形式，而setXxx规则不变。

下面我们使用private关键字来修饰boolean类型的变量。

代码演示：

public class Student {

    private String name;    // 姓名
    private int age;    // 年龄
    private boolean male;   // 是不是man

    public void setMale(boolean b) {
        male = b;
    }

    public boolean isMale()  {
        return male;
    }

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }
}

然后在另一个类当中去调用

public class Demo13ClassStudent {

    public static void main(String[] args) {
        Student stu = new Student();

        stu.setName("KL");
        stu.setAge(20);
        stu.setMale(true);

        System.out.println("He's name is " + stu.getName());
        System.out.println("He's age is " + stu.getAge());
        System.out.println("He's is a " + stu.isMale());
    }
    
}

代码的执行结果：

He's name is KL
He's age is 20
He's is a true

---

3.this关键字

当方法的局部变量和类的成员变量重名的时候，根据“就近原则”，优先使用局部变量。

如果需要本类当中的成员变量，需要使用this关键字。

格式：this.成员变量名

作用：this关键字解决了重名的问题

【重点】：通过谁调用的方法，谁就是this

代码演示:

public class Person {

    String name;

    public void sayHello(String name) {
        System.out.println(name + ", hello, I am " + this.name);
        System.out.println(this);
    }
}

public class Demo01Person {

    public static void main(String[] args) {
        Person person = new Person();

        person.name = "James";
        // Person类调用了sayHello方法，在该方法内部执行了this关键字，
        // 相当于Person类调用了this

        person.sayHello("KL");
        System.out.println(person);
    }
}

代码运行结果：

KL, hello, I am James
shuyv.day01.demo07Girl.Person@2ff4f00f
shuyv.day01.demo07Girl.Person@2ff4f00f

根据运行结果，发现地址哈希值相同，验证了该观点。通过谁调用的方法，谁就是this。