【MMBBi的Java之路】类和对象的理解（三）-封装和static
前言
本篇博客的主要内容是承接上一篇内容（类和对象的理解（二）-this引用和对象的构造方法）主要内容为封装的概念和static修饰符的作用。
本篇主要是需要搞懂，我们平时写java代码，前面加的public和static究竟是干什么用的。
封装
封装的概念
我们都知道，免息对象有三大特征，封装 继承 多态 （不知道的现在知道了），而在我们的类和对象里，主要研究的就是封装的特性。
封装简单的来说就是套上壳屏蔽里面的细节，只留下接口供用户使用和交互。
举一个简单的例子，我们现在使用的电脑，他内部有主板，CPU，显卡，内存条等配件，这些一般都是在笔记本内部或者机箱里面，我们主要是通过主板提供的各种接口，链接键盘 鼠标 显示器等进行交互。
封装就是将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。
访问限定符
那么如何实现封装哪？ 我们主要是通过访问修饰限定符来进行封装操作的，下面就开始了解访问修饰限定符的内容了。但是再说访问限定修饰符之前，我们需要先了解包的概念和内容。
包的概念
在面向对象体系中，提出了一个软件包的概念，即：为了更好的管理类，把多个类收集在一起成为一组，称为软件包
包其实就类似于我们电脑上的文件夹的概念，比如我们可能会有一个照片的文件夹，打开照片的文件夹，里面又会对哪一天拍的照片进行分类，或者会对照片内容进行分类，会有风景照片，人物照片，美食照片等内容。
包是对类、接口等的封装机制的体现，是一种对类或者接口等的很好的组织方式。
导入包中的类
其实java已经提供了很多现成的包供我们使用，这个就类似于C语言中的头文件。
我们在C语言中想使用printf函数需要导入stdio.h的头文件，而在java中也差不多，如果想使用java中给我们准备好的类，就需要先导入java给我们提供的包。
一般我们使用import来导入java中的包，比如我们想要获取一个时间戳。
import java.util.Date;
public class Test {
public static void main(String[] args) {
Date date = new Date();//这里使用的Date类是java中提供的Date类。
//获得一个毫秒级的时间戳。
System.out.println(date.getTime());
}
}
这里看第一行代码，impor是导入包的关键字，java.util是包名，Date是类名，这个Date类不是我之前写的Date类（我这个项目文件中有我自己写的Date类，详情可以见我前两篇博客），是java中自带的类。
这里也体现出了包的另一个作用：
在同一个工程中允许存在相同名称的类，只要处在不同的包中即可。
我们可以使用impor java.util.*来导入其他类。
C语言中，我们想使用它的库函数，必须要引用头文件，然而有时候可能我只会用到那个头文件里的一个库函数，但是引用只会会把其他的库函数也包含在内，java中我们可以指定引用。就比如java.util.Date，是之引用Date类。当然也可以全部引用就是用java.util.*来引用。
但是我们更建议显式的指定要导入的类名. 否则还是容易出现冲突的情况.
import java.util.*;
import java.sql.*;
public class Test {
public static void main(String[] args) {
// util 和 sql 中都存在一个 Date 这样的类, 此时就会出现歧义, 编译出错
Date date = new Date();
System.out.println(date.getTime());
}
}
这个时候想使用就必须使用完整的类名。
import java.util.*;
import java.sql.*;
public class Test {
public static void main(String[] args) {
java.util.Date date = new java.util.Date();
System.out.println(date.getTime());
}
}
注意：不能把impro当成C++中的#include来理解，import 和 C++ 的 #include 差别很大. C++ 必须 #include 来引入其他文件内容, 但是 Java 不需要.。
import 只是为了写代码的时候更方便. import 更类似于 C++ 的 namespace 和 using
自定义包
方法可以自定义，类也可以自定义。那么我们的包当然也可以自定义。
自定义包有几个基本规则：
1：在文件的最上方加上一个 package 语句指定该代码在哪个包中.
2：包名需要尽量指定成唯一的名字, 通常会用域名的颠倒形式(例如 com.baidu.www )
3：包名要和代码路径相匹配. 例如创建 com.baidu.www的包, 那么会存在一个对应的路径 com/baidu/www 来存储代码。
4：如果一个类没有 package 语句, 则该类被放到一个默认包中。
在IDAE中自定义包：
右键src文件夹，新建（new) - 包（packag）-在弹出的对话框中输入包名, 例如 com.baidu.www
然后看我们的磁盘目录，创建了三个文件夹，com里面有baidu，baidu里面有www
然后我们在www里新建一个类，可以看到最上方出现了一个package语句。
那么包就暂时先说到这里，回到我们的访问限定符。
访问限定符
Java中主要通过类和访问权限来实现封装：类可以将数据以及封装数据的方法结合在一起，更符合人类对事物的认
知，而访问权限用来控制方法或者字段能否直接在类外使用。
Java中提供了四种访问限定符：分别是privat default protected 和public
目前我们见到的代码，public的权限是最高的，任何地方都可以访问。
defaul是我们什么都不写的时候，默认的权限，在同一个包中都可以使用，但是在其他的包里就无法使用。
private是权限最低的，只能在同一个包里的同一个类中使用，其他地方无法使用。
至于protected主要是在继承的时候使用，感兴趣的可以到这里仔细了解，对现阶段不需要了解（还没写出来，预留一个链接位置）
下面看代码。
package com.baidu.www;
public class Phone {
private String cpu; //cpu
private String memory;//内存
public String screen;//屏幕
String brand;//品牌 -什么都不加，默认default属性。
public Phone(String cpu, String memory, String screen, String brand) {
this.cpu = cpu;
this.memory = memory;
this.screen = screen;
this.brand = brand;
}
}
class TestPhone {
public static void main(String[] args) {
Phone iPone14 = new Phone("A16", "8G", "三星", "苹果");
System.out.println(iPone14.brand);//default权限，只能在本包中访问。
System.out.println(iPone14.screen);//public权限，项目中任何地方都可以访问。
System.out.println(iPone14.cpu);// error private权限，只能在本类中使用。
System.out.println(iPone14.memory);//error private权限，只能在本类中使用。
}
}
一般情况下成员变量设置为private，成员方法设置为public。
static成员（重要）
static的作用
我们先来看一个简单的学生类
public class Student {
public String name;
public String gender;
public int age;
public Student(String name, String gender, int age) {
this.name = name;
this.gender = gender;
this.age = age;
}
public static void main(String[] args) {
Student s1 = new Student("张三", "男", 20);
Student s2 = new Student("李四", "女", 19);
Student s3 = new Student("王五", "男", 21);
}
}
假设三个同学是同一个班的，那么他们上课肯定是在同一个教室，那既然在同一个教室，那能否给类中再加一个成员变量，来保存同学上课时的教室呢？答案是不行的。
在Student类中定义的成员变量，每个对象中都会包含一份，因为需要使用这些信息来描述具体的学生。而现在要表示学生上课的教室，这个教室的属性并不需要每个学生对象中都存储一份，而是需要让所有的学生来共享。
在Java中，被static修饰的成员，称之为静态成员，也可以称为类成员，其不属于某个具体的对象，是所有对象所共享的。
static修饰成员变量
static修饰的成员变量，称为静态成员变量，静态成员变量最大的特性：不属于某个具体的对象，是所有对象所共享的。
【静态成员变量特性】
1.不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中
2.既可以通过对象访问，也可以通过类名访问，但一般更推荐使用类名访问
3. 类变量存储在方法区当中
4. 生命周期伴随类的一生(即：随类的加载而创建，随类的卸载而销毁)
public class Student {
public String name;
public String gender;
public int age;
//static修饰的成员变量
public static String classRoom = "404";//教室名
public Student(String name, String gender, int age) {
this.name = name;
this.gender = gender;
this.age = age;
}
public static void main(String[] args) {
//通过类命访问
System.out.println(Student.classRoom);
Student s1 = new Student("张三", "男", 20);
Student s2 = new Student("李四", "女", 19);
Student s3 = new Student("王五", "男", 21);
//通过对象名访问 但是classRoom是三个对象共享的
System.out.println(s1.classRoom);
System.out.println(s2.classRoom);
System.out.println(s3.classRoom);
}
}
调试一下可以看到，classRoom并没有在s1 s2 s3任意一个对象中。
static修饰成员方法
一般类中的数据成员都设置为private，而成员方法设置为public。那设置之后，Student类中classRoom属性如何在类外访问呢？
public class Student {
private String name;
private String gender;
private int age;
private static String classRoom = "404";
public Student(String name, String gender, int age) {
this.name = name;
this.gender = gender;
this.age = age;
}
public static void main(String[] args) {
System.out.println(Student.classRoom);
Student s1 = new Student("张三", "男", 20);
Student s2 = new Student("李四", "女", 19);
Student s3 = new Student("王五", "男", 21);
System.out.println(s1.classRoom);
System.out.println(s2.classRoom);
System.out.println(s3.classRoom);
}
}
Java中，被static修饰的成员方法称为静态成员方法，是类的方法，不是某个对象所特有的。静态成员一般是通过静态方法来访问的。
public class Student {
//.....
private static String classRoom = "404";
//.....
public static String getClassRoom() {
return classRoom;
}
public class Main {
public static void main(String[] args) {
System.out.println(Student.getClassRoom());
}
}
【静态方法特性】
1.不属于某个具体的对象，是类方法
2.可以通过对象调用，也可以通过类名.静态方法名(…)方式调用，更推荐使用后者
3.不能在静态方法中访问任何非静态成员变量
public static String getClassRoom() {
age += 1;//error
System.out.println(this);//error
return classRoom;
}
4.静态方法中不能调用任何非静态方法，因为非静态方法有this参数，在静态方法中调用时候无法传递this引用.
public String doClassRoom() {
return classRoom;
}
public static String getClassRoom() {
doClassRoom();//error
return classRoom;
}
5.
静态方法无法重写，不能用来实现多态(这里需要了解多态才能理解这些，这里暂时不做赘述)。
static变量初始化
静态成员变量一般不会放在构造方法中来初始化，构造方法中初始化的是与对象相关的实例属性。
静态成员变量的初始化分为两种：就地初始化 默认初始化 提供get和set方法 和 静态代码块初始化。
就地初始化就是定义的时候直接给一个初始的值。
public class Student {
//.....
private static String classRoom = "404";
//.....
}
默认初始化就是我们在创建静态成员变量的时候如果什么值都不赋，java会默认给一个初始值，一般整形都是0，String类型是null。
get和set方法初始化可以通过编译器来生成。
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
静态代码块初始化这里因为篇幅有限，可以到下一篇博客进行了解（链接（现在还没写，等写了更新。））
#总结
封装:就是将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行 交互
包：可以先理解为我们操作系统中常见的文件夹的概念。
访问限定符：用来给类的成员和方法设置权限，实现封装。
static修饰符：被static修饰的成员，是所有对象所共享的。只能通过静态成员方法访问。(重要)
【静态成员变量特性】
1.不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中
2.既可以通过对象访问，也可以通过类名访问，但一般更推荐使用类名访问
3. 类变量存储在方法区当中
4. 生命周期伴随类的一生(即：随类的加载而创建，随类的卸载而销毁)
【静态方法特性】
1.不属于某个具体的对象，是类方法
2.可以通过对象调用，也可以通过类名.静态方法名(…)方式调用，更推荐使用后者
3.不能在静态方法中访问任何非静态成员变量
4.静态方法中不能调用任何非静态方法，因为非静态方法有this参数，在静态方法中调用时候无法传递this引用.
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
