首页 / JAVA / Java中的包与访问权限的控制

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

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了Java中的包与访问权限的控制，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含5236字，纯文字阅读大概需要8分钟。

内容图文

多人开发

 在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


原文：http://blog.csdn.net/u013087513/article/details/51169550

内容总结

以上是互联网集市为您收集整理的Java中的包与访问权限的控制全部内容，希望文章能够帮你解决Java中的包与访问权限的控制所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1176632.html

来源：【匿名】