包及访问控制权限.docx
《包及访问控制权限.docx》由会员分享，可在线阅读，更多相关《包及访问控制权限.docx（17页珍藏版）》请在冰点文库上搜索。
包及访问控制权限
1、课程名称：
包及访问控制权限
2、知识点
2.1、上次课程的主要知识点
1、Object类：
是所有类的父类，一个类如果没有继承一个类的话，则默认继承Object类，在Object类中的toString（）方法主要是取得对象的信息，而equals（）方法是专门用于进行对象的比较操作。
2、匿名内部类：
匿名内部类在开发中肯定要使用，尤其是在以后的框架开发中更是100%应用，所以此部分必须掌握；
3、包装类：
将基本数据类型包装成类的形式，就称为包装类，随后也一定要记住的是，包装类中可以存在拆箱及装箱操作，而且使用包装类可以方便的实现字符串向基本数据类型的转换；
4、链表程序本身没指望大家可以100%掌握，每个人必须清楚的知道链表的基本实现原理，就是靠引用和this，以后当不知道存放对象个数的时候就可以使用链表完成；
5、异常处理的流程，如果程序中产生了异常之后，则JVM会自动的为程序实例化一个异常类的实例化对象，之后在try语句中捕获，如果没有捕获，则交给JVM默认处理，如果捕获的话，则与catch中的异常类型相互匹配，如果匹配成功，则表示可以使用此catch进行处理，最后不管是否出现了异常都会执行finally代码，而且finally代码的作用必须结合标准的异常处理格式来讲，而且异常类的对象传递的时候也依然符合对象的向上转型关系，可以直接使用Exception捕获异常。
6、异常分为两大类：
Throwable
·Exception：
表示的是程序中出现的异常，用户可以进行处理；
·Error：
表示的是JVM错误，此时程序并没有运行，所以即使出现了错误，程序也无法处理。
2.2、本次预计讲解的知识点
1、包的定义及使用；
2、JDK1.5的新特性——静态导入；
3、java常用包的简介；
4、jar命令；
5、访问控制权限。
3、具体内容
3.1、包的定义及使用（重点）
在实际的工作之中肯定是属于多人进行同一个项目的开发，有可能不同的开发人员会定义同名的操作类，这样一来由于操作系统中一个文件夹中不能存放同一文件，所以肯定会发生覆盖的问题，而且会造成扯皮的问题。
那么要想解决这个问题，只能靠文件夹区分，因为不同的文件夹可以存放同名的文件，而所谓的包就是指一个文件夹，如果程序中加上包之中，则完整的类名称就是：
“包.类”名称。
3.1.1、定义包
如果要想定义一个包的话，可以使用package关键字完成。
packageorg.lxh.demo;//定义包
publicclassHello{
publicstaticvoidmain（Stringargs[]）{
System.out.println（"HelloWorld!
!
!
"）;
}
}
现在的程序之中一旦定义了包之后，则完整的类名称就是“org.lxh.demo.Hello”，可是按照包的定义来讲，现在一个类肯定是要保存在文件夹之中，所以在java之中，如果程序中存在了包的话，则编译的时候加上“-d”的参数就会表示自动的根据package的定义生成文件夹：
javac-d.Hello.java
·“-d”：
要根据定义的包，生成文件夹；
·“.”：
表示要生成文件夹的目录，“.”表示在当前所在的文件夹之中生成。
一旦程序打包之后，则以后程序运行的话都必须加上包名称，即：
javaorg.lxh.demo.Hello，而不能说进入到包中直接运行。
从实际开发来讲，每一个类必须存放在一个包中，而且没有包的类是100%不存在的。
3.1.2、导入包
一个类一旦放在了包中之后，则就会牵扯到包的导入问题，例如，现在要导入某一个包中的某些操作类，此时，就必须依靠import关键字完成。
范例：
定义如下的一个类
packageorg.lxh.demoa;
classMessage{
publicvoidgetInfo（）{
System.out.println（"世界，你好！
"）;
}
}
之后再定义一个Test.java程序，此程序定义在“org.lxh.demob”包中，并且要使用Message类，这个时候肯定要牵扯到导包的操作。
packageorg.lxh.demob;
importorg.lxh.demoa.Message;//导入包.类
publicclassTest{
publicstaticvoidmain（Stringargs[]）{
newMessage（）.getInfo（）;
}
}
现在两个程序编写完成之后下面需要对程序进行编译，现在应该先编译Message.java，之后再编译Test.java，因为Test.java程序使用了Message.java，所以必须先将Message编译成*.class文件。
总结：
关于publicclass和class声明类的区别
·publicclass声明类：
文件名称必须与类名称保持一致，在一个*.java文件之中只能定义一个publicclass，如果一个类希望被外包所访问，则使用publicclass；
·class声明类：
文件名称可以与类名称不一致，但是运行的时候必须运行类名称，在一个*.java中可以定义多个，如果一个类只能被本包所访问，则使用class；
范例：
修改Message.java类
packageorg.lxh.demoa;
publicclassMessage{
publicvoidgetInfo（）{
System.out.println（"世界，你好！
"）;
}
}
但是这里面有一个问题了，以上是按照“包.类”的形式一个个导入的，如果现在要同时导入某一个包的多个类，那么按照以上的做法肯定要写多条导入语句，这样很麻烦，所以在java中专门提供了一个通配符“*”，表示自动导入所需要的操作类。
importorg.lxh.demoa.*;//导入包.类
问题：
如果现在使用“*”导入那么与单独导入一个类相比，是不是性能会差很多呢？
单独导入和使用*的形式导入在性能是一样的，因为java程序即使使用了*，也只会导入所需要的类，而不需要的类一概不导入。
但是在导包的操作中会存在一个比较麻烦的问题，就是有可能同时会导入相同类的不同包。
packageorg.lxh.demox;
publicclassMessage{
publicvoidsay（）{
System.out.println（"今天下雨了。
"）;
}
}
现在有两个Message类：
org.lxh.demoa.Message、org.lxh.demox.Message，可是现在在Test.java中由于自身的需要，需要同时导入demoa和demox两个包。
packageorg.lxh.demob;
importorg.lxh.demoa.*;//导入包.类
importorg.lxh.demox.*;//导入包.类
publicclassTest{
publicstaticvoidmain（Stringargs[]）{
newMessage（）.getInfo（）;
}
}
此时两个包中都存在了Message类，所以，程序编译的时候将出现如下的问题：
Test.java:
6:
referencetoMessageisambiguous,bothclassorg.lxh.demox.Messageinorg.lxh.demoxandclassorg.lxh.demoa.Messageinorg.lxh.demoamatch
newMessage（）.getInfo（）;
^
1error
在这种情况下，为了准确的知道要使用的是那一个类，所以在使用类的时候建议加上包的名称。
packageorg.lxh.demob;
importorg.lxh.demoa.*;//导入包.类
importorg.lxh.demox.*;//导入包.类
publicclassTest{
publicstaticvoidmain（Stringargs[]）{
org.lxh.demoa.Messagemsg=neworg.lxh.demoa.Message（）;
msg.getInfo（）;
}
}
3.1.3、JDK1.5的新特性——静态导入（理解）
如果现在假设一个包中的一个类都是由静态方法所组成的话，则按照最早的思路，肯定是要先导包，之后再通过“类.方法（）”的形式调用类中的操作。
packagedemot;
publicclassMyMath{
publicstaticintadd（intx,inty）{
returnx+y;
}
publicstaticintsub（intx,inty）{
returnx-y;
}
}
范例：
下面按照最早的方式导入包，并且进行操作
packageorg.lxh.demob;
importdemot.*;//导入包.类
publicclassTest{
publicstaticvoidmain（Stringargs[]）{
System.out.println（MyMath.add（10,20））;
System.out.println（MyMath.sub（10,20））;
}
}
但是由于现在的MyMath类中的方法都是static型的方法，所以下面可以修改导入操作。
packageorg.lxh.demob;
importstaticdemot.MyMath.*;//导入包.类
publicclassTest{
publicstaticvoidmain（Stringargs[]）{
System.out.println（add（10,20））;
System.out.println（sub（10,20））;
}
}
但是，此特性只要知道即可，实际中千万别用。
3.2、jar命令（重点）
在实际的开发之中，用户开发好的程序肯定要交给客户使用，但是按照之前的开发可以发现，所有的程序都是以*.class文件的形式存在的，那么一个项目之中肯定有几万个*.class，如果将这些文件散着给用户，不方便，那么就需要打包。
在JDK之中专门提供了一个jar命令，通过jar命令可以完成打包操作，直接输入即可。
packageorg.lxh.demo;//定义包
publicclassHello{
publicstaticvoidmain（Stringargs[]）{
System.out.println（"HelloWorld!
!
!
"）;
}
}
现在定义了一个Hello.java的程序，之后对此程序进行打包编译：
javac-d.Hello.java，生成了*.class文件之后，下面就需要将程序打成*.jar包的形式，输入：
jar-cvfmy.jarorg
my.jar生成之后可以直接使用WinRAR打开。
虽然jar文件可以通过WinRAR打开，但是这个文件的格式与WinRAR是完全不一样的，所以不能混淆。
下面编写一个程序测试之前生成的my.jar文件的操作。
packageorg.lxh.test;
importorg.lxh.demo.*;
publicclassTest{
publicstaticvoidmain（Stringargs[]）{
Hello.main（args）;
}
}
但是现在在编译的时候会发现系统提示org.lxh.demo包不存在，可是这两个包现在却保存在同一个文件夹之中，那么可以得出结论，即使jar文件与程序在同一个文件夹之中也不能直接访问，需要配置classpath。
SETCLASSPATH=.;d:
\testjava\my.jar
一个jar文件要想使用必须在CLASSPATH中进行配置，当然，对于CLASSPATH也有另外一种配置形式，可以直接通过属性指定：
3.3、系统常用包（理解）
一个语言平台的发展取决于平台的支持性如何，例如：
之所以现在的开发语言主要就是JAVA、.NET，主要是因为这两大平台后面有大公司的支持，所以，一旦有什么新的要求，平台上可以立刻提供给开发者，而这些新的要求都会以一个个开发包的形式出现的，而java中就提供了大量的开发包，实际上包括以后的应用过程很长一段的时间之内，是巩固这些开发包中所提供的类库，常用的几个开发包如下：
·java.lang：
是一个默认的操作包，像String、Object等都是此包提供的，在JDK1.1之后，此包为默认导入；
·java.lang.reflect：
为反射操作包，也是java中最麻烦的一部分内容，而且应用相当广泛；
·java.util：
工具包；
·java.io：
提供IO操作的开发包；
·java.sql：
数据库编程开发包，可以直接进行数据库的操作；
·：
网络程序开发包；
·java.awt、javax.swing：
为图形界面开发包；
解释：
关于图形界面的问题？
图形界面的操作在整个java体系之中基本上就已经属于被废除的状态，但是不会废除，因为还有市场。
如果从java的发展来看，图形界面的展示绝对是java发展的一个最大特点，因为java程序最早的时候是依靠Applet程序执行的，而Applet程序主要是使用各个图形元素以达成相当华丽的显示效果。
而Applet中最早的时候使用的就是java.awt开发包，但是这个开发包属于重量级的开发包，它使用的时候需要依靠大量的windows的底层函数的支持，所以后来SUN的设计人员又开发出了一套轻量级的组件（javax.swing），但是此组件由于使用的是java开发，不受任何的操作系统限制。
当时微软公司致力于.NET平台的推广，而.NET中最早的组成：
VB、VC、ASP.NET、J#，J#实际上就是java语言，可是微软公司将这个语言的内核修改了，重新变成了J#，后来到WindowsXP的时候，微软公司干了一件事情，就是让所有的windows平台默认不再支持JVM了，Java程序不能再直接运行了，但是需要额外的安装，经过这若干件事情之后，微软发现打不过了，就和好了，根据J#的平台特点修改出了今天的C#，所以直到今天为止，C#的语法和Java是非常相似的，但同时一个问题就出现了，很多人发现，java的平台做单机程序实在是不方便，而且会受到局限，从而促使了java向网络方向发展。
Applet作为Java出现的一个始祖其本身的技术地位是相当高的，但是其本身也由于图形界面的原因，以及速度的原因导致了今天基本上不再使用了。
范例：
编写一个Applet程序。
packageorg.lxh;
importjava.applet.*;
importjava.awt.*;
publicclassMyAppletextendsApplet{
publicvoidpaint（Graphicsg）{
g.drawString（"HelloWorld",10,20）;
g.drawLine（20,30,80,90）;
}
}
编译之后，下面还需要编写一个html文件，通过此文件使用Applet程序。
通过浏览器就可以运行Applet程序了。
而且咱们之前所编写的所有程序都是由主方法开始执行，所以这种程序也称为Application程序。
3.4、访问控制权限（重点）
在java之中关于访问控制权限一共有四种：
private、default、protected、public，这四种访问控制权限的特点如下。
No.
范围
private
default
protected
public
1
同一个类中
√
√
√
√
2
同一包的其他类
√
√
√
3
不同包的子类
√
√
4
不同包的非子类
√
对于private、default、public基本上都比较熟悉了，下面观察一下protected，不同包的子类可以访问。
范例：
定义一个操作类
packagehelloa;
publicclassA{
protectedStringname="hello";
}
范例：
定义不同包的子类
packagehellob;
importhelloa.*;
classBextendsA{
publicvoidprint（）{
System.out.println（super.name）;
}
}
classTest{
publicstaticvoidmain（Stringargs[]）{
newB（）.print（）;
}
}
现在是在子类访问的，如果现在要想在Test访问呢，由于Test与A类相比，属于不同包的非子类，所以访问的话会出现如下的问题：
classTest{
publicstaticvoidmain（Stringargs[]）{
newB（）.name="HELLO";
}
}
B.java:
10:
name可以在helloa.A中访问protected
newB（）.name="HELLO";
^
1错误
3.5、命名规范（重点）
任何的开发都有其命名的操作标准，标准随着开发公司的不同也会有所不同，但是对于类的开发规范是统一的：
·类名称，每个单词的开头首字母大写，例如：
TestJava；
·属性，第一个单词的首字母小写，之后每个单词的首字母大写，例如：
studentName；
·方法，第一个单词的首字母小写，之后每个单词的首字母大写，例如：
printMsg（）；
·常量，要求每个单词的字母必须大写，例如：
finalINFO=""；
·包名称，要求全部的单词小写，例如：
org.lxh.demo
开发中必须严格遵守以上的命名规范，否则写的代码太业余了。
3.6、类图的表示（理解）
在工作之中，像类、接口等都会通过一些特定的图形来进行表示，只要是见到了这些图形的话，就应该可以立刻的知道类或接口的基本组成，如果要想画出类图的话，则可以采用以下的图形形式：
类名称
属性
方法
关于属性的编写，如果要想编写属性的话，则属性的格式如下：
“访问权限属性的名称:
属性类型”，
访问权限主要是三种：
public（+）、protected（#）、private（-）
·例如：
privateStringname-name:
String
关于方法的编写，与属性的编写是类似的，格式“访问权限方法名称（）：
方法返回值”
·例如：
publicStringgetName（）+getName（）:
String
但是，如果所有的代码编写之前都要使用这种方式去画图的话，则肯定很麻烦，往往在开发之中会使用许多的设计工具，而PowerDesigner工具就可以完成此功能。
以后可以直接根据这样的图形可以知道类的组成，当然，在PowerDesigner设计工具之中，也可以将以上的图形变为java程序代码。
除了表示出了之外，也可以表示出抽象类和接口，例如：
从之前的设计来讲，Person应该是一个抽象类比较合适，现在将其变为抽象类，而且定义两个接口。
但是，这种画法与编写程序相比肯定编写代码方便，所以在PowerDesigner工具之中，也提供导入的操作，可以自动的将代码变为图形显示。
除了这种类图之外，还可以表示出时序图，就是表示某一个操作调用的顺序，例如：
以工厂设计为例
·客户工厂取得接口实例调用接口方法。
还有一种图称为用例图，表示的是某一个角色所应该具备的功能。
这种图形一般在设计文档中出现较多，表示某一种用户所具备的功能是那些。
4、总结
面向对象部分为整个Java中的核心部分，此部分的重要内容：
1、类和对象的关系以及内存分配；
2、static定义的操作可以不受对象产生与否的控制；
3、继承可以扩充已有类的功能，但是从实际来讲不能继承普通类，只能继承抽象类和实现接口；
4、接口和抽象类的使用特点，及接口中设计到的主要的开发模式的代码必须可以背下来；
5、不管如何操作，多态性永远离不开方法的操作；
6、异常处理依然属于多态性的一种体现；
7、程序分包和访问权限之后，可以将一个大型的程序进行若干个细化的拆分。
升级会员 