封装性是指对外部的封装

 子类不能访问基类实例本身的受保护成员:

 

main方法中创建另一个类的对象，然后调用其方法

 

1、课程名称：包及访问控制权限
 包的定义及使用、常用包介绍、JAR命令、访问控制权限、命名要求
2、知识点
2.1、上次课程的主要知识点
 1、 异常的产生及处理流程
 2、 throw和throws关键字的作用
2.2、本次预计讲解的知识点
 1、 包的定义及使用
 2、 系统常用包
 3、 JAR命令
 4、 访问控制权限
3、具体内容
3.1、包的定义及使用
3.1.1、包的定义
 所谓的包就是一个文件夹，因为在多人开发中为了避免命名重复的问题发生，所以引入了包的概念。通过不同的包可以保存同名的类。
3.1.2、包的操作
 在一个*.java文件之中使用package就可以定义个包了。
 在包的命名中，所有的单词要采用小写的形式。
 语法如下：
package 包名称.子包名称.子包名称 ;
例如：以下的程序使用了包的定义
package org.lxh ;
public class Hello{
 public static void main(String args[]){
  System.out.println("Hello World!!!") ;
 }
};
 与之前打印“Hello World”不同的是，此处类定义在了包中，也就是说，如果一个类定义了一个包，那么类的访问全名：包.类名称。
 在JAVA中提供了专门打包指令，可以根据定义的package生成所要的文件夹。
 javac -d . Hello.java
  • “-d”：表示的是生成目录，根据package的定义生成
  • “.”：表示在当前所在的文件夹之中生成
 则以后，如果要是再想访问此类的话，输入的类名称为：org.lxh.Hello
 既然可以在程序中定义一个包，那么程序就可以导入若干包，导入的语法如下：
import 包.类名称 ;
例如：以下的程序自己定义了一个包的类，同时进行访问
• 定义Hello.java的类。
package org.lxh.demo1 ;
class Hello{
 public void print(){
  System.out.println("Hello World!!!") ;
 }
};
 • 定义Demo的类，此类导入上面的包.类名称：
package org.lxh.demo1 ;
public class Demo{
 public static void main(String args[]){
  new Hello().print() ;
 }
};
 以上的类并没有导包，因为在同一个文件夹之中。发现以上代码跟之前没太大的差别。
 那么下面将Demo所在的包定义成：org.lxh.demo2，与Hello不在同一个包中。
Demo.java：
package org.lxh.demo2 ;
import org.lxh.demo1.Hello ;
public class Demo{
 public static void main(String args[]){
  new Hello().print() ;
 }
};
 出现了以下的错误信息：
Demo.java:2: org.lxh.demo1.Hello 在 org.lxh.demo1 中不是公共的；无法从外部软件包中对其进行访问
import org.lxh.demo1.Hello ;
                     ^
Demo.java:5: 找不到符号
符号： 类 Hello
位置： 类 org.lxh.demo2.Demo
                new Hello().print() ;
                    ^
2 错误
 问题的原因，说Hello不是公共的，所以不能访问，也就是说默认的访问权限可以在同一个包中访问，但是不能让所有的不同包的用户访问。
 声明public class和class的区别：
• 使用public class声明则类名称必须与文件名称一致，如果一个类想被外包所访问，则此类一定要声明成publli class
• 使用class声明的类可以与文件名称不一致，此类只能在本包中访问。
 所以，以上的程序，应该把Hello的定义修改为：public class Hello。
Hello.java：
package org.lxh.demo1 ;
public class Hello{
 public void print(){
  System.out.println("Hello World!!!") ;
 }
};
 在之前的程序之中，可以发现导入的时候导入的是一个具体的类名称，如果在一个包下有很多的类呢？则要一个个导入吗？明显很复杂，所以在JAVA中可以使用通配符“*”表示导入所需要的类。
修改Demo.java：
package org.lxh.demo2 ;
import org.lxh.demo1.* ;
public class Demo{
 public static void main(String args[]){
  new Hello().print() ;
 }
};
疑问：
 如果一个个的导入包，是不是会比使用“*”性能要高呢？
• 从JAVA中的类的加载来看，程序中使用了“*”，那么对于JVM来说不会将一个包下的所有类全部导入，而只导入自己所需要的类，不需要的根本不会使用上，所以一各个导入与写“*”，在性能上是完全一样的。
 另外，因为在JAVA中会存在类名称相同的情况，所以，以后一旦出现了类名称相同的情况，则可以使用完整的包.类名称的方式声明一个类的对象。
例如：修改Demo.java
package org.lxh.demo2 ;
public class Demo{
 public static void main(String args[]){
  org.lxh.demo1.Hello h = new org.lxh.demo1.Hello() ;
  h.print() ;
 }
};
 以上为标准的操作语法，也是在一般的开发中使用较多的语法。
注意：
 所有的类必定放在一个包中，没有包的类是不存在。
3.1.3、静态导包指令（了解）
 在JDK 1.5之后，JAVA提供了静态导入的操作，可以将一个类中的全部静态方法导入进来直接使用。
例如：以下的一个类定义了若干个静态方法
package org.lxh.d1 ;
public class Print{
 public static void printHello(){
  System.out.println("Hello") ;
 }
 public static void printWorld(){
  System.out.println("World") ;
 }
};
 此类中本身提供了两个静态方法。
编写一个Test类，使用以下的语法导入：
import static 包.类.*
例如：验证以上语法
package org.lxh.d2 ;
import static org.lxh.d1.Print.* ;
public class Test{
 public static void main(String args[]){
  printHello() ;  //  静态方法
  printWorld() ;  //  静态方法
 }
};
 但是，一般正常情况下，此特性是没人使的。
3.1.4、系统常用包
 在JAVA中的JDK里本身已经为用户提供了很多的开发包，掌握这些开发包的时候可以方便的实现各种功能，一些常见的包如下所示：
No. 包名称 作用
1 java.lang 此包为基本的包，像String、Integer这样的类就都保存在此包之中，在JDK 1.0的时候如果想编写程序，则必须手工导入此包，但是JDK 1.1之后解决了此问题，所以此包现在为自动导入
2 java.lang.reflect 此包为反射机制的包，是java.lang的子包
3 java.util 此包为工具包，一些常用的类库、日期操作等等都在此包之中，如果把此包掌握精通各种设计思路都好理解
4 java.text 提供了一些文本的处理类库
5 java.sql 数据库操作包，提供了各种数据库操作的类和接口
6 java.net 完成网络编程的包
7 java.io 输入、输出处理类
 其中以java.util、java.io包是最麻烦的。而且也是最重要的
3.2、JAR命令
 一般情况下，用户开发完成的包，都会交给其他用户去使用，如果给的时候往往不可能把一堆的*.class文件给这些用户，而是将这些CLASS文件打成一个压缩包的形式。
 直接在屏幕上输入jar就可以查看到jar的使用命令语法。
 
 主要参数：
  • c：创建新的存档
  • v：生成详细输出到标准输出上
  • f：指定存档文件名
例如：现在有以下的一个类：
HelloDemo.java：
package org.lxh ;
public class HelloDemo{
 public void print(){
  System.out.println("Hello World!!!") ;
 }
};
 之后对此程序进行打包编译：javac -d . HelloDemo.java
 输入：jar -cvf my.jar org，将org目录打包成JAR文件，文件名称为：my.jar。
 一个*.jar文件之中包含了META-INF才可以使用。
此时，编写一个测试程序，使用此*.jar包
package org.lxh.demo ;
import org.lxh.* ;
public class TestDemo{
 public static void main(String args[]){
  new HelloDemo().print() ;
 }
};
 编译TestDemo.java类。出现以下的错误提示：
TestDemo.java:5: 找不到符号
符号： 类 HelloDemo
位置： 类 org.lxh.demo.TestDemo
                new HelloDemo().print() ;
                    ^
1 错误
 找不到HelloDemo的类。所以，如果此时，想要访问的话，则必须设置classpath。但是一般情况下classpath设置在当前目录中是较为常见的，所以此时的设置classpath的语法如下：
set classpath=.;E:\javademo\oo8\my.jar
 通过“;”区分出不同的classpath路径，就可以访问了，也就是说，只要是*.jar包则一定要配置classpath之后才可以使用。
3.3、访问控制权限
在JAVA中提供了四种访问权限：
 • private（私有）：只有同一个类可以访问
 • default（默认）：在同一个包下都可以访问
 • protected（受保护）：同一个包下和不同包的子类可以访问
 • public（公共）：所有的都可以访问
范围 private default protected public
同一类中的成员 √ √ √ √
同一包中的成员 × √ √ √
不同包中的子类 × × √ √
不同包中的非子类 × × × √
例如：以下代码验证protected访问权限
1、 建立一个PHello.java的类。
package org.lxh1 ;
public class PHello{
 protected String info = "HELLO" ;
};
2、 建立一个不同包的类，里面有一个子类。
package org.lxh2 ;
import org.lxh1.* ;
class D extends PHello{
 public void print(){
  System.out.println(super.info) ;
 }
};
public class PDemo{
 public static void main(String args[]){
  D h = new D() ;
  h.print() ;
 }
};
 以上的代码可以在子类中访问受保护成员。但是如果现在在不同包的非子类中访问，则出现以下的错误：
package org.lxh3 ;
import org.lxh1.* ;
public class PTest{
 public static void main(String args[]){
  PHello p = new PHello() ;
  p.info = "HELLO" ;   不是子类
 }
};
 错误提示：
PTest.java:6: info 可以在 org.lxh1.PHello 中访问 protected
                p.info = "HELLO" ;
                 ^
1 错误
3.4、命名要求
 只要是JAVA的开发中所有的命名都必须按照此要求编写：
  • 类：所有单词的首字母大写
  • 方法：第一个单词的首字母小写，之后每个单词的首字母大写
  • 属性：第一个单词的首字母小写，之后每个单词的首字母大写
  • 包：所有单词的字母小写
  • 常量：所有单词的字母大写
4、总结
1、 包可以为类的开发提供方便，可以解决同名类所带来的问题
2、 可以使用package定义一个包，之后使用import在需要的地方导入包
3、 JDK中提供了很多常用的系统功能包，例如：java.util包
4、 JAR命令可以把开发的包打成一个文件，之后交给其他用户使用
5、 JAVA分为四种访问控制权限：private<default<protected<public
5、面向对象总结
面向对象三大特征：
 • 封装性：是为了让类中的内容对外不不可见，但是后来发现如果一个类要访问封装的属性则封装属性所在的类必须提供getter和setter方法，不方便，所以产生了内部类，因为通过内部类可以方便的访问出外部类的私有属性，但是内部类本身会破坏代码的结构。
 • 为了保证整体代码的结构，引入了继承的特性，实际上所谓的封装性是指对外部的封装。所以在类的声明中可以使用protected声明，因为使用protected声明可以直接让子类访问。那么这样一来。就好象内部类可以访问外部类中的私有属性，解决了私有属性访问的问题，同时又保证了程序代码的结构性。
 • 产生继承之后，发现如果一个类的子类过多了，则在操作的时候就很麻烦，所以使用对象的多态性，一切的操作标准以父类为标准，这样的话可以减少很多代码。
 • 在JAVA中因为类与类之间的继承有单继承的局限，有的时候并不能通过单继承解决全部的问题，所以引入了接口的概念，一个类可以实现多个接口。
 • 接口的多实现性逐步成为一个操作的标准，所以有了严格的规定，一个类不要去继承一个已经实现好的类，而应该只继承抽象类或实现接口。
 • 在开发不可避免的会出现类名称的重复性，所以使用了包的概念。
 • 对于所有的操作代码，因为其可能会出现问题，所以要把所有的错误交给被调用处处理。