CSDN博客

img Nepalon

Java编程思想(2nd)学习笔记(2-5)

发表于2003/10/20 10:50:00  1119人阅读

分类: 学习笔记

第2章           万事万物皆对象

一.所有对象都必须由你建立

1.  存储在哪里

1)      寄存器:我们在程序中无法控制

2)      stack:存放基本类型的数据和对象的reference,但对象本身不存放在stack中,而是存放在Heap

3)      Heap:存放用new产生的数据

4)      Static storage:存放在对象中用static定义的静态成员

5)      Constant storage:存放常量

6)      NON-RAM:硬盘等永久存储空间

2.  特例:基本型别

基本类型数据存放在Stack中,存放的是数据。而产生对象时,只把对象的reference存放在stack中,用于指向某个对象,对象本身存放在Heap中。

3.  Java中的数组

当你产生某个存储对象的数组时,真正产生的其实是存储reference的数组。引数组建立后,其中的每一个reference都会被自动设为null,表示“不指向任何对象”。

二.建立新的数据型别:Class

1.  数据成员和函数

1.1       基本成员的缺省值

1)  class的某个成员属于基本型别时,即使你没有为它提供初值,Java仍保证它有一个缺省值。

2)  只有当变量身份是“class内的成员时,Java才保证为该变量提供初值。

三.函数(Mehtods),引数(arguments),返回值(return values

1.  引数列

当引数传递的是对象时,传递的是对象的reference

四.注解用内嵌式文档

Java提供两种注解风格:/*XXXX*///XXXX

 

第3章           控制程序流程

一.使用Java运算符

1.关系运算符

1. 当对两个对象运用关系运算符进行比较时,比较的是object reference,如:

Integer n1 = new Integer(3);

Integer n2 = new Integer(3);

System.out.println(n1==n2);

结果为false,因为两个object referencen1n2)值是不同的

2 quals()的缺省行为也是拿referenct来比较。不过Java中的class覆写了equals方法,如:

Integer n1 = new Integer(3);

Integer n2 = new Integer(3);

System.out.println(n1.quals(n2));//值为true

2.  逻辑运算符

1)  只能将andornot施用于boolean值身上。如果逻辑运算符两边的值存在non-boolean值,将会出错,如:

int test1 = 1;

System.out.println((test && 1<2);//编辑出错,testnon-boolean

3.  位移运算符

如果所操作的位移对象是charbyteshort,位移动作发生之前,其值会先被晋升为int,运算结果会是int

二.流程控制

1.  迭代(iteration

1.1       逗号运算符

逗号运算符只能用于for循环的控制表达式中的initializationstep两部分中,如:for(int i=0, j=I+1; I<5; i++, j=I*2)

1.2       breakcontinue

break表示退出循环;continue表示退出本次循环,回来循环起始位置。

1.3       label

label只有放在迭代语句之前才起作用,在label和迭代语句之间插入任何语句都不会起作用。

2.  Switch

switch中的选择器必须是intchar型,如:

float i = 2;

switch ( i )//将出错,因为i不是intchar之一

3.  计算细节

1)  floatdouble转为整数值,总是以完全舍弃小数的方式进行。

4.  Math.random()的输出范围是[0, 1]

 

第4章           初始化和清理

一.以构造函数(constructor)确保初始化的进行

如果某个class具备构造函数,Java便会在对象生成之际,使用者有能力加以操作之前,自动调用其构造函数,于是便能名确保初始化动作一定被执行。

二.函数重载(Method overloading

1.  区分重载函数

由于只能从函数名和函数的引数列来区分两个函数,而重载函数具有相同的函数名称,所以每个重载函数都必须具备独一无二的引数列。

2.  Default构造函数

1)  default构造函数是一种不带任何引数的构造函数。如果你所开发的class不具任何构造函数,编译器会自动为你生成一个default构造函数。

2)  如果你自行定义了任何一个构造函数(不论有无引数),编译器就不会为你生成default构造函数。

3)  如果定义了一个class,如

class Bush{

Bush(int I){}

}

当想用new Bush();来产生class的实例时,会产生错误。因为在定义class时已定义了构造函数,所以编译器就不会为class生成default构造函数。当我们用new Bush()来产生实例时,会尝试调用default构造函数,但在class中没有default构造函数,所以会出错。如:

class Sundae

{

    Sundae(int i) {}

}

public class IceCream

{

    public static void main(String[] args)

{

        //Sundae x = new Sundae();会编译出错,无构造函数Sundae()

        Sundae y = new Sundae(1);

    }

}

*:在定义一个class时,如果定义了自己的构造函数,最好同时定义一个default构造函数

3.  关键字this

1)  this仅用于函数之内,能取得“唤起此一函数“的那个object reference

2)  在构造函数中,通过this可以调用同一class中别的构造函数,如

public class Flower{

Flower (int petals){}

Flower(String ss){}

Flower(int petals, Sting ss){

//petals++;调用另一个构造函数的语句必须在最起始的位置

this(petals);

//this(ss);会产生错误,因为在一个构造函数中只能调用一个构造函数

}

}

**:1)在构造调用另一个构造函数,调用动作必须置于最起始的位置

2)不能在构造函数以外的任何函数内调用构造函数

3)在一个构造函数内只能调用一个构造函数

4.  Static的意义

无法在static函数中调用non-static函数(反向可行)。

三.清理(cleanup):终结(finalization)与垃圾回收(garbage collection

1)你的对象可能不会被回收

只有当程序不够内存时,垃圾回收器才会启动去回收不再被使用的对象的内存空间。某个对象所占用的空间可能永远不会被释放掉,因为你的程序可能永远不会逼近内存用完的那一刻,而垃圾回收器完全没有被启动以释放你的对象所占据的内存,那些空间便会在程序终止时才一次归还给操作系统

3)  只有在采用原生函数(native methods)时,才使用finalize()

四.成员初始化(member initialization

1)  函数中的变量不会被自动初始化,如

void f(){

int i;

i++;

}

将发生编译错误,因为i没有被初始化。

2)  class的数据成员会被自动初始化,具体情况如下(见P220例子):

基本型别:booleanfalsecharnull/u0000)、byte0short0int0

long0 float0double0

                     对象(reference):null

1.  初始化次序

1)  所有变量一定会在任何一个函数(甚至是构造函数)被调用之前完成初始化(见P233例子)

2)  在产生一个class的对象时,首先自动初始化class中的static成员变量,再执行所有出现于static数据定义处的初始化动作,最后执行static block,所有这些初始化操作只在第一次生成该对象时进行。

3)  自动初始化class中的其它成员变量。

4)  执行所有出现于数据定义处的初始化动作。如:int i=1;的执行顺序是先把I自动初始化为0,再执行数据定义处的初始化动作,初始化为1

5)  执行non-static block

6)  调用构造函数。

例:

class Cup{

       Cup(int marker){

              System.out.println("Cup(" + marker + ")");

       }

       void f(int marker){

              System.out.println("f(" + marker + ")");      

       }      

}

 

class Cups{

       static Cup c1 = new Cup(11);

       static Cup c2;

    Cup c3 = new Cup(33);

    Cup c4;

    {

        c3 = new Cup(3);

        c4 = new Cup(4);

    }

       static{

              c1 = new Cup(1);

              c2 = new Cup(2);

       }

       Cups(){

              System.out.println("Cups()");

       }

}

 

public class ExplicitStatic{

       public static void main(String[] args){

              System.out.println("Inside main()");

              Cups.c1.f(99);

       }

       static Cups x = new Cups();

       static Cups y = new Cups();

}

结果为:

Cup(11)

Cup(1)

Cup(2)

Cup(33)

Cup(3)

Cup(4)

Cups()

Cup(33)

Cup(3)

Cup(4)

Cups()

Inside main()

f(99)

2.  Array的初始化

1)  定义数组时不能指定大小。如int[4] iArr = {0, 1, 2, 3};,由于指定了数组的大小,会编译出错。

2)  对于基本型别数组,数组存放的是数据本身;对于class数组,数组只是存放reference的数组。任何数组都要进行初始化,使用没有进行初始化的数组会产生运行时错误,如:

int[] iArr;

System.out.pritnln(iArr[0]);//产生错误,因为iArr还未初始化

数组初始化可在任何地方,可用以下方法来对数组进行初始化:

a)  int[] iArr = {1,1,1,1};//数组的长度为{}元素的个数

b)  int i = 10;

int[] iArr = new int[i];//数组的长度可为变量(这在C/C++中不行)

System.out.println(iArr[0]);//iArr[0]是一个int,自动初始化值为0

Integer[] iArr2 = new Integer[i];

System.out.println(iArr2[0]);//iArr[0]是一个reference,自动初始为null

 

I)       对于基本型别数组,new产生的是用于存放数据的数组;否则,产生的只是存放reference的数组。

II)    new可用来初始化基本型别的数组,但不能产生non-array的  基本型别数据。

c)  int[] iArr = new int[]{1,1,1,1};

Integer[] iArr2 = new Integer[]{new Integer(1), new Integer(2)};

3.  多维数组(Multidimensionalarrays

多维数组每一维的大小可以不一样,如:

Integer[][][] a5;

a5 = new Integer[3];

for(int i=0; i<a5.length; i++)

   a5[i] = new Integer[i+1];

   for(int j=0; j<a5[i].length

       a5[i][j] = new Integer[i+j+1];

 

第5章           隐藏实现细节

一.Java访问权限饰词(access specifiers

Javapublicprotectfriendlyprivate四种访问权限,并且这四访问权限的访问范围越来越小。

1.  friendly

1)    如果一个class内的数据成员或方法没有任何权限饰词,那么它的缺省访问权限就是friendly。同一个package内的其它所有classes都可以访问friendly成员,但对package以外的classes则形同private

对于同一个文件夹下的、没有用packageclassesJava会自动将这些classes初见为隶属于该目录的default package,可以相互调用class中的friendly成员。如以下两个class分别在同一个文件夹的两个文件中,虽然没有引入package,但隶属于相同的default package

class Sundae{

//以下两个方法缺省为friendly

            Sundae(){}

                Void f() {System.out.println(“Sundae.f()”);

}

public class IceCream{

            public static void main(String[] args){

                Sundae x = new Sundae();  

                x.f();

            }

}

2.  public:可以被任何class调用

3.  privateprivate成员只能在成员所属的class内被调用,如:

class Sundae{

    private Sundae(){}//只能在Sundae class中被调用

    Sundae(int i) {}

    static Sundae makASundae()    {

        return new Sundae();

    }

}

public class IceCream{

    public static void main(String[] args){

// Sundae class中构造函数Sundae()private,所以不能用它进行初始化

        //Sundae x = new Sundae();

        Sundae y = new Sundae(1);//Sundae(int)friendly,可以在此调用

        Sundae z = Sundae.makASundae();

    }

}

4.  protected:具有friendly访问权限的同时,又能被subclass所访问。即,既能被同一package中的classes访问,又能被protected成员所在classsubclass访问

 

二.Class的访问权限

       1Class同样具有publicprotectfriendlyprivate四种访问访问权限:

              1public:在任何地方都可被使用

2protectprivate:除了它自己,没有任何class可以使用,所以class不能是

protectedprivateinner class除外)

3)  friendly:同一个package中的classes能用

2.  如何调用构造函数被声明为privateclass

1)  static函数

2)  Singteton模式

class Soup{

   private Soup(){}

  //1)静态函数方法

public static Soup makeSout(){

return new Soup();

}

     //2The "Singleton" pattern:

     private static Soup ps1 = new Soup();

     public static Soup access(){

         return ps1;

     }

     public void f(String msg){

         System.out.println("f(" + msg + ")");

     }

 }

 public class Lunch{

     public static void main(String[] args){

         //Soup priv1 = new Soup();编译错误

         Soup priv2 = Soup.makeSout();

         Soup priv3 = Soup.access();

         priv2.f("priv2");

         priv3.f("priv3");

     }

0 0

相关博文

我的热门文章

img
取 消
img