包与封装(Java)

2402_86350741

687人浏览 · 2025-09-25 15:52:52

2402_86350741 · 2025-09-25 15:52:52 发布

还在被Java的包与封装搞得晕头转向？这篇“扫盲帖”将带你彻底搞懂它们，体验醍醐灌顶的瞬间。

跟着作者的节奏，体验文章中的每一个瞬间！

包

包的定义

包是Java中一个组织类的方式，用于防止类名冲突和提高代码的可读性。包允许将类组织在一个层次结构中，类似于文件系统中的目录~~

看下面的代码，我们可以直接通过对类使用java.util.Date导入这个java.util这个包中的Date类

public class PackageDemo {

    public static void main(String[] args) {
        java.util.Date date = new java.util.Date();
    }

}

我们也可以通过import引包~~

import java.util.Date;

public class PackageDemo {

    public static void main(String[] args) {
        Date date  = new Date();
        System.out.println(date);
    }

}

如果使用java.util包中的其他类，也可以通过以下这种方式导入包，这种*就相当于把util包中所有类

都导进来了

import java.util.*;

public class PackageDemo {

    public static void main(String[] args) {
        Date date  = new Date();
        System.out.println(date);
    }

}

但是这种方式有可能会发生冲突~~

由于sql和util中都有Date这个类，这样Java就不知道要导入哪个包中的类了~~~

这种情况下只能使用完整的类名

自定义包

我们也可以自定义创建包~~

这个package就是你创建的包~

package Test;

public class Test {
    
    
    
}

封装

定义：

封装就是将属性和方法捆绑到一个类中。同时，通过控制访问权限来隐藏对象内部的实现的细节，只对外暴露优先的、安全的接口、让外部程序可以与之交互，无需关心其内部实现的细节~~

让我们看一段代码~~ 无法对类中被private修饰的属性进行访问~~这也就实现了封装~~

那我们应该怎么处理，让其可以访问

package Test;

class Person{
    private String name;
    private int age;


    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;
    }
}


public class Test {
    
    public static void main(String[] args) {
        Person person = new Person();
        person.setName("你好");
        person.setAge(18);
        System.out.println(person.getAge());
        System.out.println(person.getName());
    }

}

通过设置set和get方法，进而间接地对被private修饰的成员变量进行访问~~

访问限定符

Java中主要通过类和访问权限来实现封装~~类可以将数据以及封装数据的方法结合在一起~~

而访问权限用来控制方法或者字段能否直接在类外使用~~

让我们对访问限定符进行解析~

看上图~~public相对来说比较简单，我这里就不再讲述了~~

让我们看看private的限定符

private

package Demo;

public class Person{
    private int b = 10;


    private static void test2(){
        System.out.println("test");
    }

}

class Test {

    private static int a = 10;

    private static void test1(){
        System.out.println("test");
    }

    public static void main(String[] args) {
        Person p = new Person();
//      同一包中的同一类被private修饰的可以被访问
        System.out.println(a);
//      同一包中不同类被private修饰的不可以被访问
        System.out.println(p.b);
//      同一包中的同一类被private修饰的可以被访问
        test1();
//      同一包中不同类被private修饰的不可以被访问
        p.test2();
    }
}

从以上报错，我们可以看出我们不能直接在类外访问被private修饰的属性和方法，但是我们可以在类外间接的访问被private修饰的属性和方法~通过调用set和get方法~~

package Demo1;

import Demo.Person;


class Test{


    public void test(){
        Person p = new Person();
//      不同包中的非子类是不能访问被private修饰的属性
        p.b
    }
}

public class Student extends Person {


    public static void main(String[] args) {

        Student s = new Student();
//      不同包中的子类，不可以访问被protected修饰的属性
        System.out.println(s.b);
    }

}

让我们想想我们是否可以在接口中的方法使用private，其实是不能的，因为接口中的方法默认是抽象方法，抽象方法要被不同类实现，与private设计规则相违背~~ 所以是不能的~~

protected

看下面这两个代码

package Demo;

public class Person {

    protected int age = 10;


    public static void main(String[] args) {
//      同一包中的同一类，被portected修饰的可以被访问
        Person p = new Person();
        System.out.println(p.age);
    }
}

class Test{

    public static void main(String[] args) {
//      不同包中的不同类，被protected修饰的可以被访问
        Person p = new Person();
        System.out.println(p.age);
    }
}

package Demo1;

import Demo.Person;


class Test{


    public void test(){
        Person p = new Person();
//      不同包中的非子类是不能访问被protected修饰的属性
        p.age
    }
}

public class Student extends Person {


    public static void main(String[] args) {

        Student s = new Student();
//      不同包中的子类，可以访问被protected修饰的属性
        System.out.println(s.age);
    }
    
}

default

没有被任何访问限定符修饰的就是default

package Demo;

public class Person{
    int b = 10;


    void test2(){
        System.out.println("test");
    }

}

class Test1 {

    int a = 10;

    void test1() {
        System.out.println("test");
    }

    public static void main(String[] args) {

        Test1 t = new Test1();
//      同一类，被default修饰的可以被访问
        System.out.println(t.a);

        Person p = new Person();
//      不同类，被default修饰的可以被访问
        System.out.println(p.b);

    }
}