Thinking in Java学习扎记(九)

转载 2004年09月04日 18:08:00
第五章       隐藏实现细目
  首先考虑oop的一个重要思想--让变动的东西和不变动的事物彼此分开。
  java库的程序员在编写库的时候最需要考虑到的就是,一旦他们改变类中的某个函数或者是成员变量,让已经使用前一版本库的程序不会受到变动的影响。库的编写者无法知道程序员调用用了库中那些函数和变量,因而无法修改库的成员,于是为了解决这样的问题,java中出现了访问控制符,其作用就是告诉程序员,那些是可用的,那些是不可用的,而java中的访问控制符是受package(包)的影响的,因此,在学习访问控制符以前,先要学习好包。
  package:程序库单元
    现在大家想象一下这种情况,假如你现在本地开发了一套java程序,现在把他投入使用,当你把程序放到服务器上的时候,也许你会发现,服务器上的原有的class和你现在程序中的class重名了!怎么解决呢?这个时候就需要java中的命名空间了。正是因为有了命名空间,使得名称相同的class各自存活在各自的相对领域中,互不干扰,当你需要调用不同命名空间内的class时,使用import关键字,例如:调用整个程序库import java.util.*;这样就是在调用一个包,如果你想调用其中的一个类,这样import java.util.math;
    如何设定自己的包?使用package xxx ;放在程序的最前面,就是把该程序收录到xxx包中,使用的时候,只要import xxx就可以了。关键字import和package提供的是,无论多少人撰写class,永远不会发生命名冲突!
    
独一无二的package命名
      package应该把所有隶属于同一个package的class放置在同一个目录中,或者使用jar。那么现在又出现2个问题:如何产生独一无二的package名,并且如何找出深藏在文件目录中class。我们一般使用反转的国际域名来保障问题1的正确解决,我的域名是blog.csdn.com/maoerzuozuo,于是我使用maoerzuozuo.com.csdn.blog来命名包,这样我就能产生和其他人不重复的package名称(除非他把我的东西抢先使用)。第2个问题通过环境变量中的classpath解决,classpath含有一个或者多个目录,每个目录看成class文件的查找起点,把你的包名称转换成磁盘目录进行查找
      
package maoerzuozuo.com.csdn.blog.test;
      public class demo
      {
       public demo()
       {
        System.out.println("maoerzuozuo.com.csdn.blog.test.demo");
       }
      }
      调用
  
    import maoerzuozuo.com.csdn.blog.test.*;
      public class test
      {
       public static void main(String args[])
       {
        demo d= new demo();
       }
      }
      我们把2文件存储在f:/maoerzuozuo/com/csdn/blog/test/下,接着我们调用他,并且设定环境变量classpath=.;f:/; 于是程序正常运行,编译器能找到我调用的包,并且能正常运行。注意:你需要调用的class必须是public的!
      
冲突
      假如我调用了2个包,但是2个包中都有test类,当我实例化test类时候,你必须告诉编译器你实例化的是哪个包中的class,否则就会引起冲突
      例如 
java.util.Date d= new java.util.Date();
    
自定一个程序库
      现在,我们可以定义属于自己的程序库,方便自己的使用,这里我们定义一个输出类,用来方便我们程序使用.我们现在来写一个显示类
     
 package maoerzuozuo.com.csdn.blog.test;
      public class show
      {
       public static void go(String s)
       {
        System.out.println(s);
       }
      }
      我们把他存放在F:/maoerzuozuo/com/csdn/blog/test 下,并且在环境变量的下classpath做好指向,现在来使用
     
 import maoerzuozuo.com.csdn.blog.test.show;
      class test
      {
       public static void main(String args[])
       {
        show.go("hello");
       }
      }
      但是请注意,当我们调用show.go(123);的时候,go()函数没办法像System.out.println();一样把int自动进行转化为string
    
使用package的一些忠告
      当你是使用package的时候,其实你也就是间接的指定了实际的系统目录结构,因此,你的class必须位于这个目录之中,并且系统会从classpath开始,查询到该目录。
    
  
 java访问权限控制词
    java中,对类、函数、成员数据都会有访问控制符,他们依次为public 、private、protected 和 friendly(无访问控制符)4种,我记得我当时培训的时候,我的老师告诉我"public 是公用的,private是私房钱 protected是大熊猫"
   
 friendly(友好的)
      当在类、函数、成员数据前不写任何访问控制符的时候,就是friendly,他的意义就是在同一个包中,所有的class都可以访问,或者当你没有定义任何的包的时候,只要在同一个目录内的文件也是可以互相访问的,编译器会视他们为一个包,但是对于包外的class形同private,也可以称做package访问权限
    public (公用的)
      关键字public代表任何人都可以访问他
  
  private(私房钱)
      先想想私房钱的概念,私房钱只所以这么叫,是因为这个钱只有本人自己才能使用。所以private代表的意思就是说除了class本身,没有谁再能访问他了。private充分体现了封装性
   
 protected(大熊猫)
      大熊猫是受到保护的,并且他的子女因为继承大熊猫的关系也是受到保护的,所以protected的意义在于允许派生类访问基类的成员,而基类的包中的其他类也是可以访问的(friendly)
   
interface(接口) and implemention(实现)
    实现细节的隐藏通常使用访问控制符来实现,他可以把class内的数据根据不同的需要包装起来,让特定的人访问,建立不同的访问界限
    通常我们在2种情况下需要使用访问控制符
      1、告诉二次开发的程序员,那些是可用的,那些是不可用的,从而当我们更改 相关数据时,不会影响到其他的人原有的程序。
      2、将接口和实现分离,一般客户端程序员使用的是该类的接口,而具体的实现过程没有必要让程序员知道,我们可以将他封装起来。这样,我们可以把接口声明为公用的,而内部的实现过程可以根据实际的需要,声明为受保护的或者是私有的。
   
class 的访问权限
     把关键字放在class之前,可以声明该class的访问权限,需要注意的是
     1、每个文件中只能有一个public类用来表现单一的接口,文件内可以存在为了支持public类而存在的friendly类;
     2、public类的名称必须和所在文件的文件名相同,包括大小写也要一致;
     3、当文件内不包含任何public类的时候,你可以使用任意名称做为文件名;
     4、class的访问控制符不能是private或者是protected的,只能是friendly和public的,如果你希望别人无法产生对象,你只要把构造函数声明为private的就可以了
   
习题解答
     1、撰写一个程序,在其中产生ArrayList对象,但是不能明确导入 
java.util.*;
      public class test
      {
       public static void main(String args[])
       {
        java.util.ArrayList al = new java.util.ArrayList();
       }
      }
     6、撰写一个具有public 、private、protected、friendly的数据成员和函数,并且产生一个对象进行观察,当你取用类中成员的时候,有什么编译消息?
      package test;
      public class test
      {
       public int a;
       private int b;
       protected int c;
       int d;
       
       public void methodA(){}
       private void methodB(){}
       protected void methodC(){}
       void methodD(){}
       
       public static void main(String args[])
       {
        test T = new test();
        T.a=1;
        T.b=1;
//在不同/同一个包中cannot access the private members
        T.c=1; //在不同的包中cannot access the protected members
        T.d=1;
//在不同的包中cannot access the friendly members
        
        T.methodA();
        T.methodB();
//在不同/同一个包中cannot access the private members
        T.methodC();
//在不同的包中cannot access the protected members
        T.methodD(); //在不同的包中cannot access the friendly members
       }
      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             7、撰写一个class,让他其中的成员具有protected,在同一个文件内撰写第二个class,并且在这里操作第一个class中的protected数据
     
 class protectedDemo
      {
       protected int i;
      }
      public class test
      {
       public static void main(String args[])
       {
        protectedDemo pd = new protectedDemo();
        pd.i=10;
        System.out.println(pd.i);
       }
      }
      这个程序其实考察的是我们的"在同一个包中protected相当于包访问控制(friendly)"
    12、Create the following file in the c05/local directory (presumably in your CLASSPATH):
      //: c05:local:PackagedClass.java
      //=M @echo compile by hand to see results
   
   package c05.local;
      class PackagedClass {
        public PackagedClass() {
          System.out.println(
            "Creating a packaged class");
        }
      } ///:~
      
      Then create the following file in a directory other than c05:
      
      
      //: c05:foreign:Foreign.java
      //=M @echo compile by hand to see results
     
 package c05.foreign;
      import c05.local.*;
      public class Foreign {
         public static void main (String[] args) {
            PackagedClass pc = new PackagedClass();
         }
      } ///:~
      
      Explain why the compiler generates an error. Would making the Foreign class part of the c05.local package change anything?
      因为PackagedClass并非public的,而是friendly的,是包访问控制,只能在该包内的成员才能使用,如果把他放到和Foreign一样的目录,那么他们等于说是在同一个包中,当然可以顺利访问。
      

读第一遍Thinking in java的笔记

第一章1.Java一切都是对象,但操纵的标识符是对象的一个“引用”。简单的说,引用代表这个对象内存地址。 如:String s;实际上,我们并没有创建一个对象,我们只是创建了一个引用,它不指向任何...
  • u011253016
  • u011253016
  • 2016年07月18日 18:22
  • 1477

Thinking in Java 源码的获取以及编译问题

《Java编程思想》的源代码的获取、编译过程,以及编译中碰到的错误。还有Ant程序的获取和配置。...
  • pdcxs007
  • pdcxs007
  • 2014年01月09日 10:05
  • 3197

Thinking In Java 学习笔记(一)

最近都在学习java,以下是学习笔记。 1 线程 1.1基本线程处理 1)throw与throws的区别 前者用于抛出单个异常,并且该异常知道如何处理,通常是放在catch子句块中,当...
  • buleideli
  • buleideli
  • 2013年01月12日 11:04
  • 1289

Thinking in Java---Concurrent包下的新构件学习+赛马游戏仿真

Java5的java.util.concurrent包下引入了大量的用于解决并发问题的新类;相对于前面那些基础的线程同步和通信的方法,这些新类是一种更高层次上的抽象,使用起来还是比较容易的.这篇博客就...
  • acm_lkl
  • acm_lkl
  • 2016年02月24日 19:03
  • 1630

thinking in java 学习笔记(三)之重载

简单通过书中的例子,重新温习了一下重载: package com.halberd.extend; class Tree { int height; Tree() { System.o...
  • wclxyn
  • wclxyn
  • 2012年04月01日 23:51
  • 1122

(Thinking in Java学习笔记)字符串(用Markdowm写的)

不可变StringString对象是不可变的。 String类中每个看起来会修改String值得方法,实际上都是创建了一个全新的String对象,以包含修改后的字符串内容。 而最初的String对...
  • JedreckZhou
  • JedreckZhou
  • 2016年11月03日 21:08
  • 157

Thinking in Java学习笔记 Semaphore控制的资源池

SemaphoreDemo.java 一个资源池Pool,可以由多个线程检出和检入其中的资源,由Semaphore控制同步问题,由数组来记录每个资源的检出/检入状态 CheckoutT...
  • fantasyagain
  • fantasyagain
  • 2015年02月27日 14:04
  • 763

Thinking In Java 学习笔记(三)

接本系列上篇。 1 基础复习摘要 2.1 Finalize()使用 该函数只在垃圾回收器就要释放空间时,才会调用的。因此不能等同于C++的析构函数。 Finalize中进行的清除工作,主要是对...
  • buleideli
  • buleideli
  • 2013年03月11日 13:36
  • 779

Thinking in java学习笔记—泛型(擦除)

一、泛型擦除 在泛型代码内部,无法获得任何有关泛型参数类型的消息。 import java.util.Arrays; class AA{} class CC{} class B{} publi...
  • kisionl
  • kisionl
  • 2016年01月20日 23:04
  • 254

《Thinking in Java》学习笔记-----第6章 访问权限控制

目录: 编写Java源代码文件的基本要求是什么 如何起包名 Java不同访问权限修饰词的功能是什么 如何为具有私有化构造方法的类创建对象 编写Java源代码文件的基本要求是什么? 当编写一个Java源...
  • edutiantang
  • edutiantang
  • 2016年08月08日 10:51
  • 196
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Thinking in Java学习扎记(九)
举报原因:
原因补充:

(最多只允许输入30个字)