Java语法：包、权限修饰符

最新推荐文章于 2024-11-04 22:26:34 发布

wenre_5897

最新推荐文章于 2024-11-04 22:26:34 发布

阅读量359

点赞数 1

分类专栏： Java基础文章标签： java 开发语言

本文链接：https://blog.csdn.net/weixin_58618735/article/details/128436329

版权

Java基础专栏收录该内容

67 篇文章 3 订阅

订阅专栏

一.包

1.包是什么？

包是用来分别类的管理各种不同的类的，类似于文件夹、创建包利于程序的管理和维护。
创建包的语法格式：

package 公司域名倒写.技术名称
package com.app.javabean
public class Student{
}

包名的建议是全部英文小写，且具备意义
创建包语句必须在第一行，一般idea工具会帮助创建。

2.导包

相同包下的类可以直接访问，但是不同包下的类必须导包，才可以访问使用。

假如一个类中需要用到不同包下相同类名的类时，那么默认只能导入一个类，另一个类要使用包名访问。

导包的语法格式：

import 包名.类名

例子：

package Demo;
//学生类：用于测试不同包的类需要导包后才能使用

public class Student {
    public static String name = "使用不同包下相同类名的student类";
}

package packagetest;
//老师类：用于测试相同的包下类，可以直接使用
public class Teacher {
    public static String name = "相同包下的类";
}

package packagetest;

import Demo.Student;

import java.util.Scanner;

public class PackageDemo {
    public static void main(String[] args) {
        System.out.println(Teacher.name);
        // 1、同一个包下的类，可以直接互相访问。
        System.out.println(Student.name);
        // 2、不同包下的类，必须先导包才可以访问。
        Scanner sc = new Scanner(System.in);
        //3.调用Java写好的api也是需要导包
        System.out.println(Demo.Student.name);
        /*
            4、如果这个类中使用不同包下相同类名的类，
            此时默认只能导入一个类的包，另一个类要使用包名访问。
         */
    }
}

二、权限修饰符

1.权限修饰符是什么？

权限修饰符：是用来控制一个成员能够被访问的范围。

可以修饰成员变量、方法、构造器、内部类，不同权限修饰符，修饰的成员能够被访问的范围也会受到限制。

2.权限修饰符的分类和作用范围

权限修饰符有四种：

private

缺省

protected

public

作用范围从小到大：private —> 缺省 —> protected —> public

修饰符	同一个类中	同一个包中其他类	不同包下的子类	不同包下的无关类
private	ok
缺省	ok	ok
protected	ok	ok	ok
public	ok	ok	ok	ok

package modifier;
/**
 本类：父类——>定义全部的权限修饰符修饰的成员
 目标：理解权限修饰符，将成员修饰后的作用范围
 */
public class Fu {
    private void privateMethod(){
        System.out.println("private修饰的成员");
    }
    void method(){
        System.out.println("缺省（无修饰）的成员");
    }
    private void protectedMethod(){
        System.out.println("protected修饰的成员");
    }
    public void publicMethod(){
        System.out.println("public修饰的成员");
    }

    public static void main(String[] args) {
        Fu f = new Fu();
        f.privateMethod();
        f.method();
        f.protectedMethod();
        f.publicMethod();
    }
}

package modifier;

public class PurviewModifierTest {
    public static void main(String[] args) {
        Fu f = new Fu();
        f.method();
        f.publicMethod();
//        f.protectedMethod();   报错

                /*
            结论：private修饰的成员，在同包下的其他类中无法访问，
            缺省、protected、public修饰的成员都可以访问
         */
    }
}

package modifier;

public class Zi extends Fu {
    public static void main(String[] args) {
        // 在其他包下的子类中测试所有权限修饰符，修饰后的作用范围
        Zi z = new Zi();    // 因为子类继承了父类，所以使用子类的构造器来构建对象

        /*
            结论：private、缺省修饰的成员，在其他包下的子类中无法访问，
            protected、public修饰的成员都可以访问
         */
        // z.privateMethod();      // 报错
        // z.method();             // 报错
        z.publicMethod();

        System.out.println("-----------");

        // 注意点！！子类继承了父类，不要使用父类的构造器来构建对象
        Fu f = new Fu();
        // f.privateMethod();      // 报错
        // f.method();             // 报错
        // f.protectedMethod();    // 报错
        f.publicMethod();
    }
}

package modifier;

/**
 其他包下的无关类
 目标：理解权限修饰符，将成员修饰后的作用范围
 */
public class unrelated {
    public static void main(String[] args) {
        // 在其他包下的无关类中测试所有权限修饰符，修饰后的作用范围
        Fu f = new Fu();

        /*
            结论：private、缺省、protected修饰的成员在其他包下的无关类中，都无法访问，
            只有public修饰的成员可以访问
         */
        // f.privateMethod();      // 报错
        // f.method();             // 报错
        // f.protectedMethod();    // 报错
        f.publicMethod();
    }
}