四、Java面向对象三大特征之一——封装

目录

1.定义

2.优点

3.封装在java中的体现

4.private关键字的使用

5.java中的访问控制修饰符

6.this关键字的使用

7.构造方法：专门用来创建对象的方法

8.一个类的标准结构（java bean）

9.static关键字

10.final关键字的四种用法

---

1.定义

封装就是把过程和数据包装起来，对数据的访问只能通过已定义的接口严格控制。使用者不能够随机的访问其中的数据，实现了对关键信息的隐藏和保护。

2.优点

（1）我们只需关心内部的实现代码，而不用关心使用者如何调用。

（2）让程序更容易理解与维护，也加强了程序的安全性。

（3）良好的封装能够减少耦合。

3.封装在java中的体现

（1）方法的定义：只需传参然后接受返回值，无需关心中间过程的实现。

（2）类中成员变量的私有化——private关键字（只允许在类内部直接访问）

4.private关键字的使用

（1）首先我们给上面的学生类成员变量都加上private关键字。

    private int stuNo;//学号
    private String stuName;//姓名
    private int stuAge;//年龄
    private int stuGrade;//成绩

（2）此时我们再在外部直接调用这些属性，显然，编译器提示我们这些属性已变为私有路径，外部程序不能直接访问。

（3）此时我们需要给外部的调用程序提供接口，来对这些属性进行操作。我们以学生姓名为例：

    //获取姓名
    public String getStuName(){
        return stuName;
    }
    //修改姓名
    public void setStuName(String stuName){
        this.stuName = stuName;
    }

（4）我们再次通过这些接口来操作属性，此时便可实现姓名的修改。

student1.setStuName("张三");

注：一般对类中的每个私有化属性，都应该有相对应的getter，setter方法。

5.java中的访问控制修饰符

（1）public（公共）：包内及包外的任何类（包括子类和普通类）均可以访问；

（2）protected（受保护）：包内的任何类及包外那些继承了该类的子类才能访问，protected重点突出继承；

（3）default（默认，可不加修饰符）：包内的任何类（包括继承了此类的子类）都可以访问它，而对于包外的任何类都不能访问它（包括包外继承了此类的子类）。default重点突出包；

（4）private（私有）： 用private修饰的类、类属变量及方法，只有本类可以访问，而包内包外的任何类均不能访问它。

6.this关键字的使用

（1）在上面的例子中，我们注意到修改姓名的setter方法中出现了一个this关键字。

    //修改姓名
    public void setStuName(String stuName){
        this.stuName = stuName;
    }

（2）我们注意到，传入的参数名和成员变量名是一样的。若此时不加this，根据就近原则，等号前的stuName默认为参数中的stuName，即给自己赋值。此时引入this关键字，来区分这种重名的问题。this代表了该类中的成员变量。

（3）一般来说，在使用成员变量时，尽量加上this关键字，以避免因自己疏忽而造成的重名无效赋值的错误。

7.构造方法：专门用来创建对象的方法

（1）在我们用new 来创建对象的时候，其实就是在调用构造方法。之前创建学生类的时候并没有写构造方法，但依然能够创建一个属性为默认值的学生类。其实是因为在编写类时不写构造方法，系统会默认赠送一个没有任何参数的空构造方法。

此处需要注意的是，构造方法的格式：不能产生返回值（默认为void），且方法名与类必须相同。

（2）下面创建一个带参的构造方法，此时系统检测到有构造方法，就不会再赠送默认的构造方法。

    //带四个参数的构造方法
    public Student(int stuNo,String stuName,int stuAge,int stuGrade){
        this.stuNo = stuNo;
        this.stuName = stuName;
        this.stuAge = stuAge;
        this.stuGrade = stuGrade;
    };

（3）在主方法中用此构造方法创建一个类

        //根据模板实例化一个学生student2
        Student student2 = new Student(2,"王五",25,89);

（4）需要注意的是：构造方法是可以重载的，我们可以在一个类中定义多个构造方法方便使用。

    //无参构造方法
    public Student(){};
    //带一个参数的构造方法
    public Student(String stuName){
        this.stuName = stuName;
    };
    //带四个参数的构造方法
    public Student(int stuNo,String stuName,int stuAge,int stuGrade){
        this.stuNo = stuNo;
        this.stuName = stuName;
        this.stuAge = stuAge;
        this.stuGrade = stuGrade;
    };

 8.一个类的标准结构（java bean）

（1）所有的成员变量都要使用private关键字修饰

（2）为每一个成员变量编写一对Getter/setter方法

（3）编写一个无参数的构造方法

（4）编写一个全参数的构造方法

下面创建一个标准的学生类：

public class Student {

    private int stuNo;//学号
    private String stuName;//姓名
    private int stuAge;//年龄
    private int stuGrade;//成绩

    //无参构造方法
    public Student(){};
    //带参数的构造方法
    public Student(int stuNo,String stuName,int stuAge,int stuGrade){
        this.stuNo = stuNo;
        this.stuName = stuName;
        this.stuAge = stuAge;
        this.stuGrade = stuGrade;
    };

    //getter/setter方法
    public int getStuNo() {
        return stuNo;
    }

    public void setStuNo(int stuNo) {
        this.stuNo = stuNo;
    }

    public String getStuName() {
        return stuName;
    }

    public void setStuName(String stuName) {
        this.stuName = stuName;
    }

    public int getStuAge() {
        return stuAge;
    }

    public void setStuAge(int stuAge) {
        this.stuAge = stuAge;
    }

    public int getStuGrade() {
        return stuGrade;
    }

    public void setStuGrade(int stuGrade) {
        this.stuGrade = stuGrade;
    }
}

9.static关键字

（1）定义

被 static 修饰的成员属于类，不属于单个此类的对象，被类中所有对象所共享，一般通过类名直接调用。

一个类中静态的内容总是优先于非静态。

（2）应用场景

①修饰成员变量和成员方法

②静态代码块

public class Student {
    //设为静态变量，每次创建对象时自动加1
    private static int stuNo;//学号

    private String name;//年龄

    //若不是私有成员，调用时直接【类名.变量名】，无需实例化
    public static String ban;
    
    //静态代码块：只有该类第一次使用时执行
    static {
        System.out.println("静态代码块执行");
    }
    //普通代码块：每次实例化对象都执行
    {
        System.out.println("普通代码块执行");
    }

    //构造方法
    public Student(){}
    public Student(String name) {
        this.name = name;
        Student.stuNo += 1;//每次创建一个学生对象学号加1
    }

    //getter和setter方法
    //包含静态变量的方法必须为静态方法
    public static int getStuNo() {
        return stuNo;
    }

    public static void setStuNo(int stuNo) {
        //静态变量调用
        Student.stuNo = stuNo;
    }

    public String getName() {
        return name;
    }

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

    public static void main(String[] args) {

        //调用静态常量（变量调用同样）
        System.out.println(Student.ban);

        //调用静态方法
        Student.setStuNo(3);//当前学号为3

        //创建两个个学生
        Student student1 = new Student("张三");
        System.out.println(student1.getName()+"学号为："+Student.getStuNo());
        Student student2 = new Student("李四");
        System.out.println(student2.getName()+"学号为："+Student.getStuNo());

    }

    结果为：
    
    静态代码块执行
    高三一班
    普通代码块执行
    张三学号为：4
    普通代码块执行
    李四学号为：5

③修饰类(只能修饰内部类，其实质也是静态成员属性，只不过该属性也是一个类)

④*静态导包(用来导入类中的静态资源，1.5之后的新特性)

（3）内存示意图：静态属性和方法都是保存在方法区的静态区中的，与堆中的对象没有关系。

 10.final关键字的四种用法

（1）修饰类：断子绝孙

①final关键字修饰的类不能有任何子类，但是可以继承父类。

②final关键字修饰的类所有成员方法都不可重写（没儿子来重写）。

（2）修饰方法：最终方法，不可改变

①final关键字修饰的方法为最终方法，不能被覆盖重写。

②final关键字与abstract关键字不能同时使用，因为矛盾（abstract一定要被覆盖重写）。

（3）修饰成员变量：一次赋值，终身不变

①final关键字修饰的成员变量不再有默认值，必须手动赋值。

②final关键字修饰的成员变量只能直接赋值或者通过构造方法赋值，不再有getter，setter方法。

（4）修饰局部变量：一次赋值，终身不变

    注意：对基本数据类型，不可变是指变量数据不可改变；

               对引用数据类型，不可变是指变量地址不可改变。