封装
封装性是面向对象编程的核心思想,指的就是将描述某种实体的数据和基于这些数的操作集合到一起,形成一个封装体,封装的思想保证了类内部数据结构的完整性,使用户无法轻易直接操作类的内部数据,这样降低了对内部数据的影响,提高了程序的安全性和可维护性。
封装的优点:
- 良好的封装能够减少耦合。
- 类内部的结构可以自由修改。
- 可以对成员变量进行更精确的控制。
- 隐藏信息,实现细节。
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。