java的语言基础.txt

Java的语言基础

            1.2.3 接口interface  
            接口是一个非功能性、抽象的类，它包含常量和没有功能性的方法声明。也就是说，用interface，你可以指定一个类必须做什么，而不是规定它如何去做。接口在语句的构成上与类十分相似，但是它们缺少实例变量，而且它们定义的方法是不含有方法体的。 
             

            接口中声明的变量，一般是final和static型的，意思是它们的值不能通过实现类而改变，也就是说它们被看作是常量，而且它们还必须以常量值初始化。 
             

            对于接口来说，它们定义以后都是需要类来实现implement的。也就是说，使用具体的类来实现上面的“如何做”。一个类可以实现多个接口，一个接口也可以被多个类来实现。 
             

            另外，接口也可以扩展其他接口来实现继承。如：  

            interface MyInterface extends YourInterface, Runnable {}  

            1.2.4 方法method  
            方法声明的是被调用执行的代码，它可以使用传递的参数并且返回一定类型的返回值。对于方法的修饰符也比较复杂和繁多。我们仍然以一个例子来简单谈论以下其中的一些修饰符。 
             

            public static final synchronized double getPrice ( final int 
            itemCode, Color itemColor )  
            throw Exception { /* code here */}  

            首先，Public是定义的方法的访问控制属性，这个我们在下一章会有详细介绍。  

            然后，static、final和synchronized是特殊的修饰符。同样需要注意的是其中final和abstract修饰符不能同时使用的。 
             

            最后，我们可以看到该方法getPrice返回一个double数据类型的返回值，而且里面定义了两个参数（itemCode和itemColor）。 
             

            另外，我们还注意它通过throw修饰符，表示它会抛出一个Exception的异常，关于异常我们在后面的章节会介绍到。  

            接下来我们会介绍两种比较特殊的方法。  

            -> Main方法  

            Main（）方法是Java程序的入口起点，它和其他方法的定义类似，只是它包含一个字符串数组用来传递命令行方式执行程序时所跟的参数。如下的例子它把命令行方式所跟的参数全部显示出来： 
             

            代码:  
            public class MainTest {  

               public static void main ( String [] args ) {  

                 for ( int j = 0 ; j < args.lenth; j++ ) {  

                   System.out.println(“Argument ” + j + “: ” + args[j]);  

                  }  

              }  

              }  
            执行如下：  

            c:\java project\Main> java MainTest Philip K Dick  

            Argumet 0: Philip  

            Argumet 1: K  

            Argumet 2: Dick  

            这里需要注意的是，如果Main（）方法没有使用static修饰符，那么编译不会出错，但是如果你试图执行该程序将会报错，提示main（）方法不存在。这是因为你如果这样使用命令行的形式直接执行该程序，MainTest类并没有实例化，所以其main（）方法也不会存在，而使用static修饰符则表示该方法是静态的，不需要实例化即可使用。 
             

            -> 构造函数Constructor Method  

            当类被实例化的时候，第一个被调用的方法就是构造函数。构造函数的主要作用就是初始化变量。如果没有定义构造函数，那么Java会使用其超类的默认构造函数。 
             

            构造函数与其他方法相比，主要具有以下的特点：  

            -> 构造函数的名字和其类名相同。  

            -> 没有返回值。  

            -> 构造函数不能像其他超类的方法那样被继承。  

            -> 不能使用final、abstract、synchronized、native或者static修饰符。  

            有时候，我们在编写构造函数的时候，可能需要首先调用其超类的构造函数，这里我们使用super的关键字，实际上它同this关键字的作用类似，只是它指的是其超类。如下的例子： 
             

            代码:  
            class DataServer extends Server {  

                public String serverName;  

                public DataServer ( int startCode ) {  

                   super ( startCode );  

                   serverName = “Customer Service”;  

                }  

            }  

            需要注意的是，调用超类构造函数super（）的语句必须放在其构造函数定义的前面，否则编译器会报错。  

            1.2.5 变量variable  
            变量是Java程序的一个基本存储单元。变量由一个标识符、类型及一个可选初始值的组合定义。此外，如同定义方法一样，它也有各种的修饰符。比如访问控制属性的修饰符public、private、protected和final、static等。这里需要注意的是，变量不能使用synchronized、abstract和native修饰符。 
             

            在定义变量的时候需要指明其类型，除了常用的基本类型（比如int型、Boolean型等）以外，也可以使用对象类型。  

            1.2.6 引入语句import  
            使用import引入语句是允许你选择某个包中的某个类或者所有类，使之能在你当前的代码中能方便的使用。例如：  

            import java.util.Dictionary; //引入java.util包中的Dictionary类  

            import javax.swing.*; //引入javax.swing包中的所有的类  

            当然如果你不使用引入语句也可以使用其他包中的其他的类，只要你指定引用对象的全名。比如：  

            java.util.Date now = new java.util.Date();  

            另外，java.lang包是会被自动引入到源程序中的。 
            1.3 关键字和标识符  
            Java语言一共使用了48个保留关键字，他们主要可以分为如下几类。  

            -> 访问控制  

            private , protected , public  

            -> 类、方法和变量修饰符  

            abstract , class , extends , final , implements , interface , native 
            , new , static , 
             strictfp , synchronized , transient , volatile  

            -> 程序控制语句  

            break , case , continue , default , do , else , for , if , 
             instanceof , return , switch , while  

            -> 错误处理  

            catch , finally , throw , throws , try  

            -> 包相关  

            import , package  

            -> 基本类型  

            boolean , byte , char , double , float , int , long , short  

            -> 变量引用  

            super , this , void  

            -> 未使用的关键字  

            const , goto  

            这些关键字的具体意义可以参考语法书，这里就不再详细阐述了。  

            另外，除了这48个关键字以外，还有3个语法保留字，即null、true和false。  
            1.4 变量的初始化  
            变量从声明的位置来看可以分为两种类型，一是实例变量instance variable，即声明在类一级；另一种是局部变量local 
            variable，它声明在方法一级。这两类变量除了声明的位置不同，它们最主要的区别在于是否需要初始化的问题。下面我们具体来讨论一下这个问题。 
             

            -> 实例变量  

            类的成员就是定义在类一级的变量。它们实际上是可以不需要初始化的，系统一般会自动给它们赋一个默认值。  

            -> 基本类型  

            对于8种基本类型来说，Boolean型默认赋值false，char型会默认为Unicode字符集的/u0000，而其余几种类型都默认为0。 
             

            -> 对象类型  

            对于对象类型，系统不会赋予任何默认值，但会表示为null。  

            -> 数组类型  

            数组类型于对象类型类似，当你不初始化它的时候，它也是等于null。但如果你初始化它，则有些不同，它与基本类型相似会默认为0。  

            -> 局部变量  

            对于局部变量，一般来说它必须初始化。因为无论是基本类型还是对象类型，系统都不会自动赋于任何默认值，所以你必须指定一定的值。当然，如果你定义了局部变量而不去使用它，编译也是可以通过的。 

            2.1 访问控制  
            封装将数据和处理数据的代码连接起来。同时，封装也提供了另外一个重要属性：访问控制。通过封装你可以控制程序的某个部分可以访问类的成员，防止对象的滥用，从而保护对象中数据的完整性。对于所有的面向对象的语言，比如C++，访问控制都是一个很重要的方面。由于Java语言使用了包的概念，使它的访问控制相对来说更复杂一些。我们把控制访问控制权限的修饰符主要分为两类，类和它的方法及变量，下面我们分别简单介绍。 
             

            -类的访问控制  

            -> 
            Default：当类不使用任何访问控制修饰符时，即采用的默认的访问控制权限。它允许同一个包内的类访问，而对于它所在包以外的类则不能访问。 
             

            -> Public：允许任何包中的任何类访问，对Java里面的所有类开放。  

            -方法和变量的访问控制  

            -> Public：所有类均可以访问。  

            -> Private：只能被它所在的类中的成员访问，使该定义的成员对外在的类不可见。  

            -> Protected：可以被同一个包的类访问，另外其所有子类也可以访问。  

            -> 
            Default：当成员不使用任何访问控制修饰符时，即采用默认的访问控制权限。它和Protected类似，唯一的区别在于子类访问权限，它仅允许同一个包的子类访问，而其他包中的子类则不可以访问。 
             

            2.2 其他修饰符  
            除了访问控制修饰符，Java还有其他繁多的修饰符来声明类、方法和变量，下面分别针对所修饰的对象来简单介绍一下主要的修饰符。  

            -类修饰符  

            -> final：用来指定该类不能被其他类扩展，从而阻止继承。