【javaSE】面向对象程序三大特性之封装（二）-阿里云开发者社区

注意事项

import 和 C++ 的 #include 差别很大. C++ 必须 #include 来引入其他文件内容, 但是 Java 不需要.import 只是为了写代码的时候更方便. import 更类似于 C++ 的 namespace 和 using

自定义包

基本规则

1、在文件的最上方加上一个 package 语句指定该代码在哪个包中.

2、包名需要尽量指定成唯一的名字, 通常会用公司的域名的颠倒形式(例如 com.bit.demo1 ).

3、包名要和代码路径相匹配. 例如创建 com.bit.demo1 的包, 那么会存在一个对应的路径 com/bit/demo1 来存储代码.

4、如果一个类没有 package 语句, 则该类被放到一个默认包中.

操作步骤

步骤一

1. 在 IDEA 中先新建一个包: 右键 src -> 新建 -> 包

步骤二

2. 在弹出的对话框中输入包名, 例如 com.bit.demo1

步骤三

3. 在包中创建类, 右键包名 -> 新建 -> 类, 然后输入类名即可.

步骤四

4. 此时可以看到我们的磁盘上的目录结构已经被 IDEA 自动创建出来了

步骤五

5. 同时我们也看到了, 在新创建的 Test.java 文件的最上方, 就出现了一个 package 语句

包的访问权限控制举例

比如：当Computer类位于com.bit.demo1包中，TestComputer位置com.bit.demo2包中：

package com.bit.demo1;
public class Computer {
    private String cpu; // cpu
    private String memory; // 内存
    public String screen; // 屏幕
    String brand; // 品牌---->default属性
    public Computer(String brand, String cpu, String memory, String screen) {
        this.brand = brand;
        this.cpu = cpu;
        this.memory = memory;
        this.screen = screen;
    }
    public void Boot(){
        System.out.println("开机~~~");
    }
    public void PowerOff(){
        System.out.println("关机~~~");
    }
    public void SurfInternet(){
        System.out.println("上网~~~");
    }
}

但我们进行访问时

package com.bite.demo2;
import com.bite.demo1.Computer;
public class TestComputer {
    public static void main(String[] args) {
        Computer p = new Computer("HW", "i7", "8G", "13*14");
        System.out.println(p.screen);
        // System.out.println(p.cpu); // 报错：cup是私有的，不允许被其他类访问
        // System.out.println(p.brand); // 报错：brand是default，不允许被其他包中的类访问
    }
}
// 注意：如果去掉Computer类之前的public修饰符，代码也会编译失败

常见的包

1. java.lang:系统常用基础类(String、Object),此包从JDK1.1后自动导入。

2. java.lang.reflect:java 反射编程包;

3. java.net:进行网络编程开发包。

4. java.sql:进行数据库开发的支持包。

5. java.util:是java提供的工具程序包。(集合类等) 非常重要

6. java.io:I/O编程开发包。

static成员

再谈学生类

使用前文中介绍的学生类实例化三个对象s1、s2、s3，每个对象都有自己特有的名字、性别，年龄，学分绩点等成员信息，这些信息就是对不同学生来进行描述的，如下所示：

public class Student{
        // ...
    public static void main(String[] args) {
        Student s1 = new Student("Li leilei", "男", 18, 3.8);
        Student s2 = new Student("Han MeiMei", "女", 19, 4.0);
        Student s3 = new Student("Jim", "男", 18, 2.6);
    }
}

假设三个同学是同一个班的，那么他们上课肯定是在同一个教室，那既然在同一个教室，那能否给类中再加一个成员变量，来保存同学上课时的教室呢？

答案是不行的

之前在Student类中定义的成员变量，每个对象中都会包含一份(称之为实例变量)，因为需要使用这些信息来描述具体的学生。而现在要表示学生上课的教室，这个教室的属性并不需要每个学生对象中都存储一份，而是需要让所有的学生来共享。在Java中，被static修饰的成员，称之为静态成员，也可以称为类成员，其不属于某个具体的对象，是所有对象所共享的

那我们应该怎么解决呢？这就涉及到我接下来要讲的static修饰的成员变量了

static修饰成员变量

static修饰的成员变量，称为静态成员变量，静态成员变量最大的特性：不属于某个具体的对象，是所有对象所共享的

静态成员变量特性

1. 不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中

2. 既可以通过对象访问，也可以通过类名访问，但一般更推荐使用类名访问

3. 类变量存储在方法区当中

4. 生命周期伴随类的一生(即：随类的加载而创建，随类的卸载而销毁)

public class Student {
    public String name;
    public String gender;
    public int age;
    public double score;
    public static String classRoom = "Bit110";
    // ...
    public static void main(String[] args) {
// 静态成员变量可以直接通过类名访问
        System.out.println(Student.classRoom);
        Student s1 = new Student("Li leilei", "男", 18, 3.8);
        Student s2 = new Student("Han MeiMei", "女", 19, 4.0);
        Student s3 = new Student("Jim", "男", 18, 2.6);
// 也可以通过对象访问：但是classRoom是三个对象共享的
        System.out.println(s1.classRoom);
        System.out.println(s2.classRoom);
        System.out.println(s3.classRoom);
    }
}

经过调试后我们会发现，静态成员变量并没有存储到某个具体的对象中。

static修饰成员方法

我们在前面讲过一般类中的数据成员都设置为private，而成员方法设置为public，那设置之后，Student类中classRoom属性如何在类外访问呢？

Java中，被static修饰的成员方法称为静态成员方法，是类的方法，不是某个对象所特有的。静态成员一般是通过静态方法来访问的

比如

public class Student{
    // ...
    private static String classRoom = "Bit306";
    // ...
    public static String getClassRoom(){
        return classRoom;
    }
}
public class TestStudent {
    public static void main(String[] args) {
        System.out.println(Student.getClassRoom());
    }
}

输出：Bit306

静态方法特性

1. 不属于某个具体的对象，是类方法

2. 可以通过对象调用，也可以通过类名.静态方法名(...)方式调用，更推荐使用后者

3. 不能在静态方法中访问任何非静态成员变量

    public static String getClassRoom(){
        System.out.println(this);
        return classRoom;
    } 
    // 编译失败：Error:(35, 28) java: 无法从静态上下文中引用非静态 变量 this
public static String getClassRoom(){
        age += 1;
        return classRoom;
        }
        // 编译失败：Error:(35, 9) java: 无法从静态上下文中引用非静态 变量 age

4. 静态方法中不能调用任何非静态方法，因为非静态方法有this参数，在静态方法中调用时候无法传递this引用

public static String getClassRoom(){
    doClass();
    return classRoom;
} 
// 编译报错：Error:(35, 9) java: 无法从静态上下文中引用非静态 方法 doClass()

5. 静态方法无法重写，不能用来实现多态

static成员变量初始化

注意：静态成员变量一般不会放在构造方法中来初始化，构造方法中初始化的是与对象相关的实例属性

静态成员变量的初始化分为两种：就地初始化 和 静态代码块初始化

就地初始化

public class Student{
    private String name;
    private String gender;
    private int age;
    private double score;
    private static String classRoom = "Bit110";
    // ...
}

静态代码块初始化

这里我们有涉及了一个新的知识点——代码块，那什么是代码块呢，请看下文

代码块

代码块概念以及分类

使用 {} 定义的一段代码称为代码块。根据代码块定义的位置以及关键字，又可分为以下四种：

普通代码块

构造块

静态块

同步代码块（后续讲解多线程部分再谈）

普通代码块

普通代码块：定义在方法中的代码块

public class Main{
    public static void main(String[] args) {
    { //直接使用{}定义，普通方法块
    int x = 10 ;
    System.out.println("x1 = " +x);
    } 
    int x = 100 ;
    System.out.println("x2 = " +x);
    }
} 
// 执行结果
x1 = 10
x2 = 100

这种用法较少见

构造代码块

构造块：定义在类中的代码块(不加修饰符)。也叫：实例代码块。构造代码块一般用于初始化实例成员变量。

构造如下

public class Student{
    //实例成员变量
    private String name;
    private String gender;
    private int age;
    private double score;
    public Student() {
        System.out.println("I am Student init()!");
    }
    //实例代码块
    {
        this.name = "bit";
        this.age = 12;
        this.gender = "man";
        System.out.println("I am instance init()!");
    }
    public void show(){
        System.out.println("name: "+name+" age: "+age+" sex: "+gender);
    }
}

使用如下

public class Main {
    public static void main(String[] args) {
        Student stu = new Student();
        stu.show();
    }
}

结果如下

静态代码块

使用static定义的代码块称为静态代码块。一般用于初始化静态成员变量。

public class Student{
    private String name;
    private String gender;
    private int age;
    private double score;
    private static String classRoom;
    //实例代码块
    {
        this.name = "bit";
        this.age = 12;
        this.gender = "man";
        System.out.println("I am instance init()!");
    } 
    // 静态代码块
    static {
        classRoom = "bit306";
        System.out.println("I am static init()!");
    }
    public Student(){
        System.out.println("I am Student init()!");
    }
    public static void main(String[] args) {
        Student s1 = new Student();
        Student s2 = new Student();
    }
}

注意事项

1、静态代码块不管生成多少个对象，其只会执行一次

2、静态成员变量是类的属性，因此是在JVM加载类时开辟空间并初始化的

3、如果一个类中包含多个静态代码块，在编译代码时，编译器会按照定义的先后次序依次执行(合并)

4、实例代码块只有在创建对象时才会执行

对象的打印

public class Person {
    String name;
    String gender;
    int age;
    public Person(String name, String gender, int age) {
        this.name = name;
        this.gender = gender;
        this.age = age;
    }
    public static void main(String[] args) {
        Person person = new Person("Jim","男", 18);
        System.out.println(person);
    }
}

// 打印结果：day20210829.Person@1b6d3586

如果想要默认打印对象中的属性该如何处理呢？答案：重写toString方法即可

public class Person {
    String name;
    String gender;
    int age;
    public Person(String name, String gender, int age) {
        this.name = name;
        this.gender = gender;
        this.age = age;
    } @
            Override
    public String toString() {
        return "[" + name + "," + gender + "," + age + "]";
    }
    public static void main(String[] args) {
        Person person = new Person("Jim","男", 18);
        System.out.println(person);
    }
}

如果自己不重写就会调用系统的toString，也就是上面所示，如果重写，就调用自己的。

总结

关于《面向对象程序三大特性之封装》就讲解到这儿，欢迎各位留言交流以及批评指正，如果文章对您有帮助或者觉得作者写的还不错可以点一下关注，点赞，收藏支持一下。

【javaSE】面向对象程序三大特性之封装（二）

注意事项

自定义包

基本规则

操作步骤

步骤一

步骤二

步骤三

步骤四

步骤五

包的访问权限控制举例

常见的包

static成员

再谈学生类

static修饰成员变量

静态成员变量特性

static修饰成员方法

静态方法特性

static成员变量初始化

就地初始化

静态代码块初始化

代码块

代码块概念以及分类

普通代码块

构造代码块

静态代码块

注意事项

对象的打印

总结

热门文章

最新文章

相关课程

相关电子书

相关实验场景