包及权限配置&java存储机理绘制

包及权限配置

包的声明和导入

//声明
package aa.bb.cc;
public class A{;}
class B{;}
//即在java输出目录aa.bb.cc中放入编译后的A.class和B.class文件

//使用其他包中的类的两种方式
//第一种：导入，import 包名.类名|接口名|*;
import aa.bb.cc.A;
//第二种：使用类的全名，即"包名.类名"
aa.bb.cc.A a =new aa.bb.cc.A();

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12

注：

1. 必须用声明（package）包的形式将类放入指定包中，必须用导入（import）包/类的形式使用包中的类
2. 一个Java源文件只能声明一个包，且声明语句必须作为源文件的第一条指令
3. 通常，功能相关密切的类、接口才能被放在同一包中
4. 一个.java文件可包含多个import语句，但只能导入public权限的类或接口，一个.java文件只有一个public类，且该类名与文件名要相同
5. 导入时不会导入子包，如要导入java.util包中的Scanner，用import java.*无法实现

从不同包中导入相同的类

从不同包中可以导入相同的类，但使用时必须用全名

//源文件一：A.java
package X;
public class A{
  public int x;
}

//源文件二：A.java
package Y;
public class A{
  public String s;
}

//源文件三：A.java
package Z;
//import X.A; import Y.A;   //这种导入方式将产生编译错
import X.*; import Y.*;   //正确
public class A{
  int x;
  public static void main(String[] args){
    A a = new A();    a.x = 10;         //正确，此A为Z包中的A
    Z.A a1 = new Z.A();  a1.x  = 10;    //正确，此A为Z包中的A
    X.A b = new Z.A();  b.x  = 5;       //正确，此A为X包中的A
    Y.A c = new Z.A();  c.s  = "abc";   //正确，此A为Y包中的A
  }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25

静态导入

JDK1.5版新增静态导入，可导入类/接口中的所有或特定静态成员，格式如下：

1. import static <包名>.类名.*;
2. import static <包名>.类名.<成员名>;

导入成员后，可以不加类名，直接使用成员

//源文件：A.java
package X;
public class A{
  public static int a;
  public static void f(int x){ System.out.print(" x=" + x); }
  public static void f(int x,int y){ System.out.print(" x=" + x + " y=" + y); }
}

//源文件：B.java
import static java.lang.Math.PI;
import static X.A.*;//在导入静态成员方法时，不能加参数，如import static X.A.f;
class B{
  public static void main(String[] args){
    f(1);  f(2,3);  a = 10;
    System.out.print(" a=" + a + " PI=" + PI);
  }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17

访问权限

1. 类的访问权限有两种：public和缺省

   • 缺省：只能被该类所属包中的类访问，不能被其他包中的类访问
   • public：访问不受包限制

2. 类中成员的访问权限有四种：private、缺省、protected和public

   • private：仅能被该类自己访问，其他任何类都不能访问该成员
   • 缺省：只有包内的类才可访问
   • protected：允许包中的类和包外的子类访问
   • public：对访问无限制

   修饰符	同一类	同一包	不同包的子类	所有类
   public	√	√	√	√
   protected	√	√	√
   缺省	√	√
   private	√

3. 无关系的两个类跨包访问只能访问其包中的public类的public成员

栗子：

假设某药企需要开发一个信息管理系统，其中药品价格涉及四种：成本价、出厂价、代理价、销售价，均由药厂的市场部决定。药品销售涉及直营店、代理商、普通药店三类客户。为安全起见，指定如下策略：

1. 市场部可以控制上述四种价格；
2. 厂家直营店只能看到出厂价、代理价和销售价；
3. 代理商只能看到代理价和销售价；
4. 普通药店只能看到销售价。

请设计一组包和市场部、直营店、代理商、普通药店等四个类，并完成类及其成员的权限配置。

package com.yq;
public class 市场部{
  private double 成本价;
  double 出厂价;
  protected double 代理价;
  public double 销售价;
}

package com.yq;
public class 直营店{;}//同包

package com.yq.dl;
public class 代理商 extends com.yq.市场部{;}//不同包的子类
//注：子类不一定要求在父包的子包中，只要包名不同即可

package com.yq.yd;
public class 普通药店{;}//不同包

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17

java存储机理绘制规则

1. 栈：存放函数中定义的所有变量
2. 堆：存放所有创建出来的对象
3. 方法区：存放类的定义
4. 三者的联系：在函数中new出对象，对象的引用名在栈中，指向堆中创建出的对象，每个对象都附加一个指向其所属类型（即方法区）的指针

注：

• 栈从main函数开始创建
• 对象存于堆中，对象的引用存于栈中，即引用指向堆中创建的对象
• 栈空间的数据被系统自动管理，在函数调用时自动创建数据空间，在函数运行结束时自动释放数据空间
• 对象中的实例变量存于堆中，函数中的变量存于栈中
• 方法区中的静态变量直接赋值，实例变量只是声明，在创建对象后在堆中赋值
• 对象未赋值为null，int型为0，String型为""
• 如果是基本型直接填值，如果是引用型则通过指针指向一个对象
• 画图用实线虚线不讲究，书中用的是虚线

int[] a = new int[5];//显式调用new操作，其中a存于栈空间，a引用的对象存于堆空间
int[] b = {1,2,3,4};//隐式调用new操作，其中b存于栈空间，b引用的对象存于堆空间
String s = "abc";//隐式调用new操作，其中s存于栈空间，"abc"存于堆空间

• 1
• 2
• 3

栗子：

class T{
 static int x;
  String[][] s;
  T(int a){x = a;}
  T(){s = new String[][]{new String[3],{"aaa","bbb"}};}
}

• 1
• 2
• 3
• 4
• 5
• 6

依次执行下列两条语句：T a=new T(5); T b=new T();请画出相关数据在栈、堆、方法区中的内存示意图

原文章：https://blog.csdn.net/qq_46469137/article/details/112151722