day10_包和访问权限

一、包和访问权限

1.1包

包是Java程序组织文件的一种方式，实质就是文件夹。

包的作用：

1、方便管理大型软件系统中数目众多的类。

2、相同名称的类可以放到不同的包中解决了命名冲突的问题。

基本用法

例如：package com.offcn.test 系统自动建立三个文件夹，结构如下：

com

offcn

test

该文件中所定义的类都在test文件夹下。

示例代码

package com.offcn.finaltest;

JDK中的包

1、java.lang包含一些Java语言的核心类，如String、Math、Integer 、System和Thread，提供常用功能。工具类，如集合、日期等。

3、java.io 包含能提供多种输入/输出功能的类。

4、java.net包含执行与网络相关的操作的类。

5、java.awt包含构成抽象窗口工具集的多个类，这些类用来创建和管理应用程序的图形用户界面（GUI）。

import语句

如果将一个类放入包中，则使用该类时，必须使用该类的全名

（例如com.offcn.Student）,Java编译器才能找到该类。如果在文件中多次使用Student，则每次都要使用类全名，比较麻烦。

解决方式：使用import语句

import com.offcn.Student，引入该类，以后每次使用Student类，只需使用类名即可，无需只用类全名。

import的多导入

import com.offcn.*;引入该包下所有类。

使用import语句应该注意的几点：

1、import语句定义在package语句后

2、java.lang包是默认被导入的，该包下所有类都可以直接使用。

3、包的导入不是迭代的，也就是当使用com.offcn.*时只会导入该包下的所有类，如果该包下有文件夹a，则a下的所有类不会被导入。

4、同一个包下的类，不需要导入。

示例代码

package com.offcn.b;
​
import com.offcn.a.Student; //导入
//import java.util.Random;
import java.util.*;  // 导入java.util包下的所有类
​
public class Test {
    // 要使用 com.offcn.a 下的Student
    public static void main(String[] args) {
        /*
        com.offcn.a.Student stu = new com.offcn.a.Student();
        stu.study();
        */
        Student stu = new Student();
        stu.study();
        
        /*
        java.util.Random r = new java.util.Random();
        int x = r.nextInt();
        System.out.println(x);
        */
        Random r = new Random();
        int x = r.nextInt();
        System.out.println(x);
    }
}

---

1.2静态导入（了解）

1、静态导入是JDK5.0开始引入的特性。

2、要使用静态成员（方法和变量）我们必须给出提供这个静态成员的类,使用静态导入可以使被导入类的静态变量和静态方法在当前类直接可见，使用这些静态成员无需再给出他们的类名。

public class Common {
​
    public static final int AGE = 10;
    public static void output() { 
        System.out.println("Hello World!"); 
    } 
​
}

不使用静态导入 前面加入了导入语句，将Common类导入，使用其中的静态成员变量和静态方法时需要加上类名。

import com.offcn.Common; 
public class Test { 
    public static void main(String[] args) {
        int a = Common.AGE; 
        System.out.println(a); 
        Common.output(); 
    } 
}

使用静态导入

静态导入的语法是： import static 包名.类名.静态成员变量; import static 包名.类名.静态成员函数;

import static com.offcn.Common.AGE; 
import static com.offcn.Common.output; 
public class Test { 
     public static void main(String[] args) { 
          int a = AGE; 
          System.out.println(a); 
          output(); 
     } 
}

---

1.3 权限修饰符

概述

在Java中提供了四种访问权限，使用不同的访问权限修饰符修饰时，被修饰的内容会有不同的访问权限，

• public：公共的。

• protected：受保护的

• default：默认的

• private：私有的

不同权限的访问能力

	public	protected	default（空的）	private
同一类中	√	√	√	√
同一包中(子类与无关类)	√	√	√
不同包的子类	√	√
不同包中的无关类	√

可见，public具有最大权限。private则是最小权限。

编写代码时，如果没有特殊的考虑，建议这样使用权限：

• 成员变量使用private ，隐藏细节。

• 构造方法使用public ，方便创建对象。

• 成员方法使用public ，方便调用方法。

小贴士：不加权限修饰符，其访问能力与default修饰符相同

示例代码

public class Demo01 {
    private int aa = 1;       // 私有的  
    int bb = 2;               // 默认的
    protected int cc = 3;     // 受保护的
    public int dd = 4;        // 公共的   
 
    public void test1(){  // 本类中访问，都可以
        System.out.println(aa);
        System.out.println(bb);
        System.out.println(cc);
        System.out.println(dd);
    }
}
​
public class Demo02 extends Demo01 {  // 同包子类
     public void test(){
         //System.out.println(aa);  // 不能访问私有的
         System.out.println(bb);
         System.out.println(cc);
         System.out.println(dd);
     }
}
​
public class Demo03 extends Demo01{ // 不同包子类
    public void test(){
        //System.out.println(aa);
        //System.out.println(bb);  // 不同包中，default的也不能访问
        System.out.println(cc);
        System.out.println(dd);
    }
}
​
public class Demo04 {  // 不同包类
    public static void main(String[] args) {
        Demo01 demo = new Demo01();
        //System.out.println(demo.aa);
        //System.out.println(demo.bb);
        //System.out.println(demo.cc); 
        System.out.println(demo.dd);
    }
}