Java中的包与访问权限的控制

多人开发

在java中,可以将一个大型项目中的类分别独立出来,分门别类的存到文件里,再将这些文件一起编译运行,如此的程序代码将更易于维护。

多人开发的问题:如果多个开发人员共同开发一个项目的时候,则肯定会出现类名称相同的情况。那么这样一来就会非常麻烦。

相同的文件会出现覆盖的情况。

包的概念

package是在使用多个类或接口时,为了避免名称重复而采用的一种措施,直接在程序中加入package关键字即可。

包的定义格式:

package 包名称.子包名称;

package org.lxh.demo08.demo ;
public class Hello{
	public String getInfo(){
		return "Hello World!!!" ;
	}
};

定义包之后,实际上类的名称就是:包.类名称

为程序打包:

package org.lxh.demo08 ;	// 定义一个包
class Demo{
	public String getInfo(){
		return "Hello World!!!" ;
	}
};
public class PackageDemo01{
	public static void main(String args[]){
		System.out.println(new Demo().getInfo());
	}
};

程序编译:javac -d .  packageDemo01.java

所谓的包实际上就是一个文件夹,一个*.class文件要保存在一个文件夹之中。既然包本身就是一个文件夹,所以在java的编译指令中就提供了专门的打包编译命令,在编译时加上参数

打包编译:

javac -d . PackageDemo01.java

此时生成完*.calss之后,就可以直接访问了。

java org.lxh.demo08.PackageDemo01

如果在MyEclipse中更简单,直接在src下新建一个org.lxh.demo08的包,直接在包内声明包名,新建java文件即可。

包的导入:

当一个包的class文件需要使用另外一个包的class文件的时候就需要使用导入指令。

import语句

上面的程序,两个类是存放在同一个包中的,因此你代码与之前没有什么根本的不同,但是如果几个类存放在不同的包中,则在使用类的时候就必须通过import语句导入。

Demo.java

package org.lxh.demo08.a ;
class Demo{ //默认是default权限,是不能被外包的类所访问的
	public String getContent(){
		return "lx XXX" ;
	}
};

ImportDemo01.java

package org.lxh.demo08.b ;	// 放在不同的包中
import org.lxh.demo08.a.* ;	// 导入不同包中的Demo类
public class ImportDemo01{
	public static void main(String args[]){
		System.out.println(new Demo().getInfo()) ;
	}
};

如果使用DOS命令,应该先编译Demo.java类,之后再编译ImportDemo01.java,因为后者使用了前者的类进行操作。 发现编译时出现了错误,是因为Demo类没有加权限是默认的default权限,default权限的类是无法被不在同一包中的类所访问的。加上public才可以被外面的类所访问。

public class与class:

如果一个类声明为public class则文件名必须与类名称一致,而且在一个类中只能有一个public class,而如果使用class声明一个类,则文件名可以与类名称不一致,但是执行的时候必须执行生成的class文件名称。除了这些之外,public class和class在包的访问上有所限制,如果一个类只在本包中访问,不需要被外包访问,则直接声明成class即可,而如果一个类需要被外包访问,则必须声明成public class。而在一般的开发中对于一个*.java
文件中往往只定义一个类:public class。

以上的操作方式是明确的使用了包.类名称的方式导入的。如果要现在假设要导入一个包中的很多类,这样写肯定很麻烦。可以直接使用“*”的方式进行导入。

package org.lxh.demo08.b ;	// 放在不同的包中
import org.lxh.demo08.a.* ;	// 导入不同包中的Demo类
public class ImportDemo01{
	public static void main(String args[]){
		System.out.println(new Demo().getInfo()) ;
	}
};

问题:

以上的两种导入语句,哪种性能更高?

第一种:import org.lxh.demo08.a.* ;

第二种:package org.lxh.demo08.b ;

实际上两种的性能都是一样的,因为如果使用 * 的方式进行导入,是由JVM帮助用户判定需要导入的类,不需要的类是不会被加载进来的。

但是在导包的时候也要注意另外一个问题,如果导入不同包的同名类的时候就有可能出现不明确的信息。

package org.lxh.demo08.d ;
import org.lxh.demo08.a.* ;		// 包中存在Demo类
import org.lxh.demo08.c.* ;		// 包中存在Demo类
public class ImportDemo02{
	public static void main(String args[]){
		Demo d = new Demo() ;
		System.out.println(d.getInfo()) ;
	}
};

现在定义一个类导入两个包,两个包中都有一个Demo类,此时声明Demo对象的时候就会出现错误,是因为JVM无法区分调用的到底是哪个包中的类。所以如果出现这种情况的时候最好写入完整的“包.类名称”。修改代码如下所示即可。

package org.lxh.demo08.d ;
import org.lxh.demo08.a.* ;		// 包中存在Demo类
import org.lxh.demo08.c.* ;		// 包中存在Demo类
public class ImportDemo02{
	public static void main(String args[]){
		org.lxh.demo08.a.Demo d = new org.lxh.demo08.a.Demo() ;
		System.out.println(d.getInfo()) ;
	}
};

java.util.Arrays.sort()

当然在这些包中,也存在着大量的子包。

JAVA新特性——静态导入

在JDK1.5之后提供了静态导入的功能,什么叫静态导入?如果一个类中的方法全部是使用static声明的静态方法,则在导入的时候就可以直接使用“import static”的方式进行导入,导入的方式如下:

import static 包.类.*;

package org.lxh.demo08.e ;
public class Operate{							// 里面的方法全部都是static类型
	public static int add(int i,int j) {		// 加法操作
		return i + j ;
	}
	public static int sub(int i,int j) {		// 减法操作
		return i - j ;
	}
	public static int mul(int i,int j) {		// 乘法操作
		return i * j ;
	}
	public static int div(int i,int j) {		// 除法操作
		return i / j ;
	}
};

如果按照之前的import导入的话,则调用的时候肯定使用的是“类.方法()”

package org.lxh.demo08.f ;
import static org.lxh.demo08.e.Operate.* ;	// 静态导入
public class StaticImportDemo{
	public static void main(String args[]){
		System.out.println("3 + 3 = " + add(3,3)) ;	// 直接调用静态方法
		System.out.println("3 - 2 = " + sub(3,2)) ;	// 直接调用静态方法
		System.out.println("3 * 3 = " + mul(3,3)) ;	// 直接调用静态方法
		System.out.println("3 / 3 = " + div(3,3)) ;	// 直接调用静态方法
	}
};

静态导入后直接可以调用静态方法即可。

jar命令的使用——将类打包

直接输入jar即可:

JAR命令中的主要参数:

“C”:创建新的文档。

“V”:生成详细的输出信息。

“F”:指定存档的文件名。

package org.lxh.demo08.demo ;
public class Hello{
	public String getInfo(){
		return "Hello World!!!" ;
	}
};

将其打包编译:javac -d . Hello.java

将其打成jar包:jar -cvf my.jar org

表示将文件夹org 就是总文件夹 打包成my.jar

一个jar包如果要想使用的话,则必须配置classpath路径

set classpath= .;e:/XXXX/my.jar

在MyEclipse中直接导入jar包就可使用 import导入jar中的类了。

在实际的Java开发中往往把一些实用的工具类打成jar包交给用户使用。

包的总结:

1、包可以将很多的class文件分类的存放好,这样可以避免多人开发时,类文件重名的问题。

2、在实际的开发中,没有包的类基本上是不存在的,完整的类名称“包.类名称”。

3、如果导入了不同包的同名类的时候,可以直接通过完整的包.类名称避免重复。

4、JDK1.5之后提供了静态导入的功能,可以直接使用一个类的静态方法。

5、如果一个包中的全部类需交付用户使用。则要将其打成一个jar包。

访问控制权限及命名规范。

java中存在四种访问控制权限:

private 私有的访问权限。

default (默认)即不加任何声明的访问权限。

protected 受保护的访问权限。

public 公有的访问权限。

private:可以定义方法或者属性,定义的方法和属性不能被外部的类所访问(包括子类)。

default:可以在本包中的任意地方访问。

protected:保护,不同包中的非子类不能访问。

public:公共的,都可以访问,不受任何限制。

回顾总结:

当产生了一个类之后,为了保证类中的内容不被外部直接看到,则使用private关键字。

但是,如果现在两个有关系的类要进行属性相互访问的话就比较麻烦,之前只能使用setter/getter方法取得和设置,所以为了减少私有属性访问的麻烦,使用类内部类,但是内部类会破坏程序的结构。

为了让一个类的内容继续方便的使用,使用了继承的概念,但是在继承中private属性也是无法被子类看到的,所以此时,为了方便子类的操作,可以将属性进行protected封装,这样一来外部也无法直接看到(不同包)。

之后有了继承之后,既然有了父子关系,所以就可以使用向上或向下的转型操作,以完成多态性。,但是在开发中类与类之间的直接继承并不常见,而往往继承抽象类或实现接口,当若干个操作间需要解耦合的时候就可以使用接口完成。

既然有内部类,则如果一个接口或抽象类的子类只使用一次,则可以将其定义为匿名内部类。

开发中没有包的类是绝对不存在的。

封装—>继承—>多态

java命名规范:

类:所有单词的首字母大写。如:TestJava。

方法:第一个单词的首字母小写,之后每个单词的首字母大写,如:getInfo()。

属性:第一个单词的首字母小写,之后每个单词的首字母大写,如:studentName。

包:所有单词的首字母小写。如: hhxy.lx.pp

常量:所有单词的首字母大写,如:FLAG

时间: 2024-10-23 21:02:17

Java中的包与访问权限的控制的相关文章

关于如何在你的Web项目中实现对空间数据访问权限的控制(一)

Wednesday, 23 JUNE 近来一直在研究关于如何在我的WebGIS项目中实现对空间数据(已发布在GeoServer上)进行权限管理的问题.虽然到目前为止没能找到一个完美的解决方案,但通过这些天的学习与查阅资料,思路上多少有了一些进展,因此记录下来,做一个简单的小结. 1-GeoServer中的Security模块 GeoServer是一个基于J2EE基础实现的,允许用户共享和编辑地理空间数据的GIS应用服务器.——FROM GeoServer官方介绍. 其实,GeoServer的本质

Java编程思想(三) —— 访问权限的控制

之前没去注意的修饰符,一般变量前面没添加,一个是不知道有什么用,一个是懒,后面遇到项目的时候就会发现私有和公有区别还是很大的. (1)首先是包名 使用一个类的时候,例如集合类,就需要引入这个包,然后再使用该包下面的类.如: package com.myown.iaiti; public class Print { static void print(String s){ System.out.println(s); } } 自定义的包,通过引入自己的包,以后你就可以使用自己写的方法进行字符串的打

25 包和访问权限

将类放到一个包中,需要使用package"包名" 编译时需要使用-d参数,该参数的作用是依照包名生成相应的文件夹 一个类的全名应该是"包名"+"."+"类名" 包名命名规范: 包名所有的字母小写 包名一般情况下,是你的域名倒过来写 java 当中的访问权限 public :公共权限  //可以修饰类.成员变量和成员函数 没有任何限制,在不同的包中都可以访问 private:私有权限  // 可以修饰成员变量和成员函数 只能在本

包和访问权限(二)

1.Java当中的访e:问权限 1.public:公共权限 public String name; 既可以修饰类又可以修饰成员变量和成员函数: 如果一个类的权限声明为public,那么类名必须与.java文件名必须相同 如果一个类的权限不是public,就无法从外部类中进行访问在 在一个包的外部来调用对象的某一个成员变量或成员函数那么要求这个成员变量或成员函数必须是public权限 总结:没有任何限制,同一个包当中,或者不同包当中的类都可以自由访问 2.private:私有权限 private

java4android (包和访问权限)

什么是Java当中的软件包? 为什么要使用软件包? 如何给一个类打包? //将类放置到一个包中,需要使用package"包名" //打包 编译的方法 javac -d . Test.java //出现错误:编码GBK的不可映射字符 javac -encoding UTF-8 -d . Test.java //-d 根据包名safiri生成文件夹 .的意思是在当前目录下生成safiri文件夹 //一个类的全名应该是"包名"+"."+"类名

包和访问权限(二)

1. java的访问权限 2. 软件包的导入 1. java的访问权限 <1> public  公共权限 既可修饰类  又可修饰成员变量和成员函数 不在同一个包, 对其访问时必须是公共类 1 package mirror; 2 3 class Person{ 4 public String name; 5 public void introduce(){ 6 System.out.println("name"); 7 } 8 } package Mirror; class

17.包和访问权限

软件包 为java类提供了命名空间 将类放置到一个包当中,需要使用package"包名" 编译时需要使用 -d 参数,该参数的作用是依照包名生成相应的文件夹 例如:D:\work\src>javac -d . Test.java 一个类的全名应该是“包名” + “.” + “类名” 运行:java Arron.Test 在不同的包中时,调用需写上包名 包名的命名规范 1.要求包名所有的字母都要小写 2.包名一般情况下,是你的域名倒过来写 Arron.org D:\work\src

包和访问权限2

1.Java当中的访问权限 public:公共权限 可以修饰类.成员变量.成员函数 没有任何限制,同一个包当中或者不同包当中的类都可以自由访问 修饰类的时候:类的名字必须和文件名相同 修饰成员变量时候: 修饰成员函数时候: 在不同的包当中,一个类要访问另一个类的话,要求被访问类应该是public权限 private:私有权限 可以修饰成员变量和成员函数 只能在本类中使用 能修饰变量和函数 被声明的变量和函数只能在当前类中使用 default:包级别访问权限 可以修饰类.成员变量和成员函数 如果两

Java中的包(package)

包的概念 Java中包(package)的概念和C++中命名空间(namespace)的概念很类似,都可以限制类的作用域.二者最大的差别在于,Java中的包隐式地指明了类的树形层级结构(同时也是Java源码文件的目录结构).这样做的好处在于:可以通过文件系统中对于文件路径唯一性的要求来限制类的唯一性. 代码组织 编写一个Java源代码文件(.java文件)时,此文件通常被称为编译单元.在编译单元内最多允许有一个public类,且该类的名称必须与文件名完全相同(包括大小写). 编译一个.java文