java的语言基础.txt

Java的语言基础

            -> abstract：表示该类是不允许被实例化的类，也就是说该类需要被扩展继承。被这样声明的类也称为抽象类。  

            显而易见，final和abstract不能同时使用。  

            -方法修饰符  

            -> 
            abstract：被声明的方法称为抽象方法，不含任何代码，需要其继承的子类的相应方法覆盖重载。这里需要注意的是被声明有abstract方法的类必须被声明为abstract。 
             

            -> final：声明的方法不允许被覆盖重载。  

            -> 
            static：声明的方法被成为类方法，不依赖于任何的对象，不需要实例化对象即可直接使用类名来调用该方法。注意的是在该方法体内不可访问实例变量。 
             

            -> 变量修饰符  

            -> static：被声明为static的变量实际可以看作就是全局变量，同样不需要实例化对象即可直接使用类名来引用之。  

            -> final：被声明的变量的内容不可以被修改，实际可以被看作是一个常量，类似于C或者C++中的const。  

            2.3 缺省构造函数  
            我们都知道当对象被实例化的时候，构造函数总是被调用。如果我们在定义类的时候不指定一个构造函数，Java会自行创建一个不带参数的缺省构造函数。而如果我们定义有了一个构造函数，则Java不会再创建缺省构造函数。 
             

            更值得注意的是，如果子类的超类不含有不带参数的构造函数，那么子类在使用缺省构造函数就会出错，Java不会为子类创建不带参数的缺省构造函数。因此，我们在使用缺省构造函数的时候要比较小心。我们可以看如下的例子： 
             

            代码:  
            class Fruit {  

                public Fruit ( String color ) {  

                   System.out.print ( “color = ” + color ) ;  

                }  

            }  

            class Apple extends Fruit {  

                public static void main ( String [ ] args ) {  

                   Apple m = new Apple () ;  

                   }  

            }  

            运行结果出错：  

            Fruit.java:6: No constructor matching Fruit ( ) found in class 
             Fruit .  

            Class Apple extends Fruit {  

            1 error  

            2.4 合法的返回类型  
            由于在方法调用的时候，方法返回的类型有可能与实际声明的类型不同，因此我们需要关心什么样的返回类型才是合法的。实际上，系统采用了隐式的类型转换来处理类型的返回。以下几种情况的是合法的： 
             

            -> 如果声明的是浮点类型，那么可返回整型类型。  

            -> 如果声明的是整型类型，那么只要返回的整型类型范围小于或等于声明的类型，返回合法。  

            -> 如果声明的是对象类型，那么只要返回的是该对象类型，或者是其子类的对象类型，合法。 
            3 运算符  
            同大多数的编程语言一样，Java语言也包含了许多的运算符。如果大家学习过C或者C++，会发现下面介绍的各种Java的运算符都与之类似。  

            3.1.1 赋值运算符 =  
            这是任何编程语言的最基本的运算符，它用来给变量指定一个值。对于基本类型来说，赋值都便于理解，将新的值赋给变量并保存在变量中供使用。但对于对象类型来说，这里就有一点区别，特别需要提醒大家注意。 
             

            对象类型并不是把实际的值（这里是实例）赋给了对象类型的变量，而是赋给的一个参考指针。这样，源对象类型的变量和新的这个变量实际上是指向的同一个实例，如果使用其中一个让实例改变，那么相应的另一个所指向的实例也会改变。这里我们可以借用C里面的指针的概念来方便理解，但实际上Java是不具有指针的概念和定义的。 
             

            我们通过下面的例子可以进一步来理解这个概念。  

            代码:  
            import java.awt.Dimension;  
            class ReferenceTest {  
              Dimension a = new Dimension ( 5,10 );  
              System.out.println (“a.height = ” + a.height ) ;  
              Dimension b = a ;  
              b.height = 30 ;  
              System.out.println (“a.height = ” + a.height + “after change to b 
            ”);  
            }  
            }  

            运行结果：  

            c:\java Project\Reference>java ReferenceTest  

            a.height = 10  

            a. height = 30 afer change to b  

            另外，赋值运算符还可以和其他的运算符，联合组成新的赋值符。如*=、/=、+=、-=等等，这于C或者C++类似。  

            3.1.2 比较运算符  
            比较运算符是用来对相同数据类型的变量进行大小或者是否相等、相同的比较，返回的是Boolean类型的值。因此也就大概分为两类。  

            n >、>=、<、<=  

            这是比较变量的大小关系，与我们学过的任何编程语言相同，就不再介绍了。  

            n = = 、! =  

            这是比较变量是否相等或相同。这对于平常的比较基本类型的变量容易理解，只是我们要强调一下对对象类型的比较。与我们前面介绍的赋值运算符类似的是，它也是进行的对其参考指针的比较，而并不是比较两个内容上的差别。我们可以借助下面的例子来理解。 
             

            代码:  
            import java.awt.Button  
            class CompareRefernce {  
                public static void main ( String [ ] args ) {  
                   Button a = new Button ( “Exit”);  
                   Button b = new Button ( “Exit”);  
                   Button c = a;  
                   System.out.println ( “Is refernce a = = b ? ” + ( a = = b) ) 
            ;  
                   System.out.println ( “Is refernce a = = c ? ” + ( a = = c) ) 
            ;  
            }  
            }  


            运行结果：  

            Is refernce a = = b ? false  

            Is refernce a = = c ? true  

            3.1.3 instanceof运算符  
            这个是Java语言特殊的一个运算符，它是用来测试其对象是否属于某类或其超类。但是这里需要提醒大家的是，如果你使用instanceof来比较不是一个继承关系树上的类，Java能够编译通过，但运行的时候会报错。另外，你可以对null对象使用这个运算符，只是无论对于什么类测试的结果都是false。 
             

            3.1.4 算术运算符  
            加+、减-、乘*、除/和取模%运算，这与其他的编程语言类似，不再详述。  

            3.1.5 自增++、自减--运算符  
            Java的自增和自减运算符，与C语言类似，同样需要注意的是其放置的位置不同，可能的结果也不同。如果放置在变量的前面，表示先自增（减）再参与下步运算，而如果放置在后面则表示先参与运算再自增（减）。如下的例子说明了自增运算符的使用： 
             

            代码:  
            class IncDec{  
                public static void main ( String [ ] args ) {  
                   int a = 1;  
                   int b = 1;  
                   int c;  
            int d;  
            c = ++b;  
            d = a++;  
            c++;  
                   System.out.println ( “a = ” + a );  
                   System.out.println ( “b = ” + b );  
                   System.out.println ( “c = ” + c );  
                   System.out.println ( “d = ” + d );  
            }  
            }  


            运行结果：  

            a = 2  
            b = 2  
            c = 3  
            d = 1  

            3.1.6 字符串连接运算符 +  
            Java语言与C语言类似，也使用+作为连接字符串的运算符，这实际是对String类重载了+运算符。  

            3.1.7 位运算符  
            包括位移运算和位逻辑运算，这也与C语言相似。  

            -> 位移运算  

            >>右移、<<左移、>>>无符号右移。  

            -> 位逻辑运算  

            &与、|或、^异或、~非运算，这于其他的编程语言类似，不再详述。  

            3.1.8 逻辑运算符  
            与&&、或||，这于其他的编程语言类似，不再详述。只是需要提醒大家不要把它们和位逻辑运算符混淆，这也是初学者最容易犯的错误。  

            3.1.9 条件运算符 ？：  
            这与C语言完全相同，具体不再解释。  

            3.1.10 类型转换  
            我们在编写程序的时候经常需要对变量的类型进行转换，Java语言与其他的编程语言类似，也提供两种类型转换方式，即显式转换和隐式转换。转换的对象可分为两类，一是基本类型，二是对象类型。 
             

            这里需要掌握这样一个要点。对于基本类型来说，凡是大转小（以类型的宽度考虑）需要使用显式转换，也就是需要在变量前面强制给出需要转换成的类型。而对小转大来说，系统会自行进行隐式转换。 
             

            对于对象类型来说，也与之类似。凡是超类转子类则需要使用显式强制转换，而子类转超类系统可自行进行隐式转换。另外还需要注意的一点是，对于不在一个继承关系树上的类要进行强制转换，Java编译可通过，但实际运行会出错。 
             

            3.2 equals()方法  
            equals（）方法实际与= 
            =运算符作用相同，也是用来比较相同类型的两个变量是否相同或相等。只是有点区别的是，对于String类来说，它重载equals（）方法，使用它不是比较两个参考指针的区别，而是实际对所指向的具体内容进行比较，这也满足了平时我们对比较字符串的实际需求。当然，对其他类来说，你也可以重载equals（）方法，使其满足你的实际需要，来比较两个对象类型的变量。 
             

            3.3 优先级  
            与其他编程语言类似的，Java语言的运算符同样涉及到优先级别的问题，书上130页从高到低给出了所有运算符的优先级。建议大家，如果对某些运算符之间的优先级不是很清楚的时候，可以使用（）来改变它们的优先级关系。 
             

            3.4 方法的参数传递  
            最后，简单讨论一下方法的传递的问题。Java语言的参数传递类型主要可以分为两种，值传递和引用传递。借助C语言的概念，我们知道，第一种就是把参数值直接复制成方法体的参数，这样对方法体中的参数的改变不会影响到调用它的参数。而对于第二种，参数的引用（或者说是个指针）被传递给了方法体的参数，该引用用来访问调用中指定的实际参数。这样，对方法体参数的改变将会影响到调用方法体的参数。 
             
            由于没有指针的概念，Java的参数传递相对比较简单。对于一般的基本类型来说，都采用的是值传递；而对于对象类型则是使用的引用传递。