分享

java

 afskd 2011-04-23


1.4.1
第一个java application

  //这是我们的第一个java application,该程序保存在文件Property.java中
 import java.util.*; /*下面我们用到了Date和Properties这两个类,是
            属于java.util这个包的;*/

            /*而System和Runtime这两个类,是属于
            java.lang这个包的。*/

 public class Property { //程序员给这个类取名为Property
  public static void main(String args[]){ //main是类的主方法
  System.out.println(new Date( )); //在命令行下面打印出日期
  Properties p=System.getProperties( ); //获得系统的Properties对象p
  p.list(System.out); //在命令行下打印出p中的各个系统变量的值
  System.out.println("--- Memory Usage:"); /*打印一行字符串---Memory Usage*/
  Runtime rt=Runtime.getRuntime( ); //获得系统的Runtime对象rt
  System.out.println("Total Memory= "
          + rt.totalMemory( ) //打印总内存大小
          +" Free Memory = "
          +rt.freeMemory( )); //打印空闲内存大小
    }
  }  
  
  --观看动画--


  在java中,程序都是以类的方式组织的,java源文件都保存在以java为后缀的.java文件当中。每个可运行的程序都是一个类文件,或者称之为字节码文件,保存在.class文件中。而作为一个java application,类中必须包含主方法,程序的执行是从main方法开始的,方法头的格式是确定不变的:
   public static void main(String args[])

  其中关键字public意味着方法可以由外部世界调用。main方法的参数是一个字符串数组args,虽然在本程序中没有用到,但是必须列出来。

  程序的第一行非常有意思:
    System.out.println(new Date());
  
  打印语句的参数是一个日期对象Date,而创建Date对象的目的就是把它的值发给println()语句。一旦这个语句执行完毕,Date对象就没用了,而后"无用内存回收器"会将其收回。

  第二行中调用了System.getProperties( )。从帮助文档中可知,getProperties( )是System类的一个静态方法(static 方法),由于它是"静态"的,所以不必创建任何对象就可以调用该方法。在第三行,Properties对象有一个名为list( )的方法,它将自己的全部内容都发给一个PrintStream对象,该对象就是list()方法的参数。

  第四行和第六行是典型的打印语句,其中第六行通过运算符"+"的重载来连接多个字符串对象,在java中只有当"+"运算符作用于字符串时在能够进行重载。但是让我们仔细观察下述语句:
   System.out.println("Total Memory= "
           + rt.totalMemory( ) //打印总内存大小
           +" Free Memory = "
           +rt.freeMemory( )); //打印空闲内存大小

  其中,totalMemory( )和freeMemory( )返回的是数值,并非String对象。如果将一个字符串与一个数值相加,结果会如何?在这种情况下,编译器会自动调用一个toString()方法,将该数值(int型或者float型)转换成字符串。经过这样处理以后,就可以用"+"进行字符串连接了。

  main()的第五行通过调用Runtime的getRuntime()方法创建了一个Runtime对象,该对象中包含了内存等信息。


 //这是我们的第一个java applet,该程序保存在文件HelloEducation.java中
 import java.awt.Graphics; //在进行显示输出时,需要用到类Graphics的对象;
 import java.applet.Applet; //Applet类是所有的java applet的父类;

 public class HelloEducation extends Applet {
          //程序员给这个类取名为HelloEducation
          //所有的applet程序都是Applet类的子类

   public String s;
   public void init() {        //
     s=new String("Welcome to Tongfang Education");
              //生成一个字符串对象

 }
 public void paint(Graphics g){
     g.drawString(s,25,25);
             //在浏览器中坐标为(25,25)的位置显示字符串s

   }
 }  

  --观看动画--

  applet程序是从方法init( )开始执行的,在该方法中完成了对字符串s的初始化工作,而显示功能是在方法paint( )中执行的。paint( )方法是类Applet的一个成员方法,其参数是图形对象Graphics g,通过调用对象g的drawString( )方法就可以显示输出。

 


  一个完整的java源程序应该包括下列部分:
  package语句; //该部分至多只有一句,必须放在源程序的第一句
  import语句; /*该部分可以有若干import语句或者没有,必须放在所有的
          类定义之前*/

  public classDefinition; //公共类定义部分,至多只有一个公共类的定义
       //java语言规定该java源程序的文件名必须与该公共类名完全一致
  classDefinition; //类定义部分,可以有0个或者多个类定义
  interfaceDefinition; //接口定义部分,可以有0个或者多个接口定义

  例如一个java源程序可以是如下结构,该源程序命名为HelloWorldApp.java:
   package javawork.helloworld; /*把编译生成的所有.class文件放到包
                   javawork.helloworld中*/

   import java.awt.*;  //告诉编译器本程序中用到系统的AWT包
   import javawork.newcentury; /*告诉编译器本程序中用到用户自定义
                  的包javawork.newcentury*/

   public class HelloWorldApp{......} /*公共类HelloWorldApp的定义,
                      名字与文件名相同*/

   class TheFirstClass{......} //第一个普通类TheFirstClass的定义
   class TheSecondClass{......} //第二个普通类TheSecondClass的定义
              ...... //其它普通类的定义
   interface TheFirstInterface{......} /*第一个接口
                      TheFirstInterface的定义*/

                 ...... //其它接口定义

  
package语句:由于java编译器为每个类生成一个字节码文件,且文件名与类名相同,因此同名的类有可能发生冲突。为了解决这一问题,java提供包来管理类名空间,包实际提供了一种命名机制和可见性限制机制。而在java的系统类库中,把功能相似的类放到一个包(package)中,例如所有的图形界面的类都放在java.awt这个包中,与网络功能有关的类都放到java.net这个包中。用户自己编写的类(指.class文件)也应该按照功能放在由程序员自己命名的相应的包中,例如上例中的javawork.helloworld就是一个包。包在实际的实现过程中是与文件系统相对应的,例如javawork.helloworld所对应的目录是path\javawork\helloworld,而path是在编译该源程序时指定的。比如在命令行中编译上述HelloWorldApp.java文件时,可以在命令行中敲入"javac -d f:\javaproject HelloWorldApp.java",则编译生成的HelloWorldApp.class文件将放在目录f:\javaproject\javawork\helloworld\目录下面,此时f:\javaprojcet相当于path。但是如果在编译时不指定path,则生成的.class文件将放在编译时命令行所在的当前目录下面。比如在命令行目录f:\javaproject下敲入编译命令"javac HelloWorldApp.java",则生成的HelloWorldApp.class文件将放在目录f:\javaproject下面,此时的package语句相当于没起作用。

  但是,如果程序中包含了package语句,则在运行时就必须包含包名。例如,HelloWorldApp.java程序的第一行语句是:package p1.p2;编译的时候在命令行下输入"javac -d path HelloWorldApp.java",则HelloWorldApp.class将放在目录path\p1\p2的下面,这时候运行该程序时有两种方式:
  第一种:在命令行下的path目录下输入字符"java p1.p2.HelloWorldApp"。
  第二种:在环境变量classpath中加入目录path,则运行时在任何目录下输入"java p1.p2.HelloWorldApp"即可。

  
import语句:如果在源程序中用到了除java.lang这个包以外的类,无论是系统的类还是自己定义的包中的类,都必须用import语句标识,以通知编译器在编译时找到相应的类文件。例如上例中的java.awt是系统的包,而javawork.newcentury是用户自定义的包。比如程序中用到了类Button,而Button是属于包java.awt的,在编译时编译器将从目录classpath\java\awt中去寻找类Button,classpath是事先设定的环境变量,比如可以设为:classpath=.;d:\jdk1.3\lib\。 classpath也可以称为类路径,需要提醒大家注意的是,在classpath中往往包含多个路径,用分号隔开。例如classpath=.;d:\jdk1.3\lib\中的第一个分号之前的路径是一个点,表示当前目录,分号后面的路径是d:\jdk1.3\lib\,表示系统的标准类库目录。在编译过程中寻找类时,先从环境变量classpath的第一个目录开始往下找,比如先从当前目录往下找java.awt中的类Button时,编译器找不着,然后从环境变量classpath的第二个目录开始往下找,就是从系统的标准类库目录d:\jdk1.3\lib开始往下找java.awt的Button这个类,最后就找到了。如果要从一个包中引入多个类则在包名后加上".*"表示。

  如果程序中用到了用户自己定义的包中的类,假如在上面程序中要用到javawork.newcentury包中的类HelloWorldApp,而包javawork.newcentury所对应的目录是f:\javaproject\javawork\newcentury,classpath仍旧是classpath=.;d:\jdk1.3\lib\,则编译器在编译时将首先从当前目录寻找包javawork.newcentury,结果是没有找到;然后又从环境变量classpath的第二个目录d:\jdk1.3\lib\开始往下找,但是仍然没有找到。原因在于包javawork.newcentury是放在目录f:\javaproject下面。因此,需要重新设定环境变量classpath,设为classpath=.;d:\jdk1.3\lib\;f:\javaproject\ 。所以编译器从f:\javaproject开始找包javawork.newcentury就可以找到。

  
源文件的命名规则:如果在源程序中包含有公共类的定义,则该源文件名必须与该公共类的名字完全一致,字母的大小写都必须一样。这是java语言的一个严格的规定,如果不遵守,在编译时就会出错。因此,在一个java源程序中至多只能有一个公共类的定义。如果源程序中不包含公共类的定义,则该文件名可以任意取名。如果在一个源程序中有多个类定义,则在编译时将为每个类生成一个.class文件。

  单行注释:从"//"开始到本行结束的内容都是注释,例如:
         //这是一行单行注释
         //则是另一行单行注释
  
  多行注释:在"/*"和"*/"之间的所有内容都是注释,例如:
         /*这是一段注释分布在多行之中*/

   文档注释:在注释方面java提供一种C/C++所不具有的文档注释方式。其核心思想是当程序员编完程序以后,可以通过JDK提供的javadoc命令,生成所编程序的API文档,而该文档中的内容主要就是从文档注释中提取的。该API文档以HTML文件的形式出现,与java帮助文档的风格与形式完全一致。凡是在"/**"和"*/"之间的内容都是文档注释。例如下面的DocTest.java文件:
       /** 这是一个文档注释的例子,主要介绍下面这个类 */
       public class DocTest{
          /** 变量注释,下面这个变量主要是充当整数计数 */
         public int i;
          /** 方法注释,下面这个方法的主要功能是计数 */
         public void count( ) {}
       } 

 

 

 1. java中的数据类型划分
  java语言的数据类型有简单类型和复合类型:
  简单数据类型包括:
     整数类型(Integer):byte, short, int, long
     浮点类型(Floating):float,double
     字符类型(Textual):char
     布尔类型(Logical):boolean

  复合数据类型包括:
     class
     interface
     数组

 
2.常量和变量
  常量:用保留字final来实现
     final typeSpecifier varName=value[,varName[=value]…];
                     如:final int NUM=100;

  变量:是java 程序中的基本存储单元,它的定义包括变量名、变量类型和作用域几个部分。其定义格式如下:
     typeSpecifier varName[=value[,varName[=value]…];
                 如:int count; char c='a';

  变量的作用域指明可访问该变量的一段代码,声明一个变量的同时也就指明了变量的作用域。按作用域来分,变量可以有下面几种:局部变量、类变量、方法参数和例外处理参数。在一个确定的域中,变量名应该是唯一的。局部变量在方法或方法的一个块代码中声明,它的作用域为它所在的代码块(整个方法或方法中的某块代码)。类变量在类中声明,而不是在类的某个方法中声明,它的作用域是整个类。方法参数传递给方法,它的作用域就是这个方法。例外处理参数传递给例外处理代码,它的作用域就是例外处理部分。

 1.布尔类型--boolean

  布尔型数据只有两个值true和false,且它们不对应于任何整数值。布尔型变量的定义如:
   boolean b=true;

 
2.字符类型--char

  字符常量:
  字符常量是用单引号括起来的一个字符,如'a','A';

  字符型变量:
  类型为char,它在机器中占16位,其范围为0~65535。字符型变量的定义如:
   char c='a'; /*指定变量c为char型,且赋初值为'a'*/

 
3.整型数据
  
  整型常量:
  ◇ 十进制整数
    如123,-456,0
  ◇ 八进制整数
    以0开头,如0123表示十进制数83,-011表示十进制数-9。
  ◇ 十六进制整数
    以0x或0X开头,如0x123表示十进制数291,-0X12表示十进制数-18。

  整型变量:

数据类型
所占位数
数的范围
byte
8
-27~27-1
bhort
16
-215~215-1
int
32
-231~231-1
long
64
-263~263-1


 
4.浮点型(实型)数据

  实型常量:
  ◇ 十进制数形式
    由数字和小数点组成,且必须有小数点,如0.123, 1.23, 123.0
  ◇ 科学计数法形式
    如:123e3或123E3,其中e或E之前必须有数字,且e或E后面的指数必须为整数。
  ◇ float型的值,必须在数字后加f或F,如1.23f。

  实型变量:

数据类型
所占位数
数的范围
float
32
3.4e-038 ~3.4e+038
double
64
1.7e-038 ~1.7e+038

 5.简单数据类型的例子:

【例2.1】
  public class Assign {
   public static void main (String args [ ] ) {
   int x , y ; //定义x,y两个整型变量
   float z = 1.234f ; //指定变量z为float型,且赋初值为1.234
   double w = 1.234 ; //指定变量w为double型,且赋初值为1.234
   boolean flag = true ; //指定变量flag为boolean型,且赋初值为true
   char c ; //定义字符型变量c

   String str ; //定义字符串变量str
   String str1 = " Hi " ; //指定变量str1为String型,且赋初值为Hi
   c = ' A ' ; //给字符型变量c赋值'A'
   str = " bye " ; //给字符串变量str赋值"bye"
   x = 12 ; //给整型变量x赋值为12
   y = 300; //给整型变量y赋值为300
   }
  }

  对各种类型的数据进行加工的过程成为运算,表示各种不同运算的符号称为运算符,参与运算的数据称为操作数,按操作数的数目来分,可有:
  ◇ 一元运算符:++,--,+,-
  ◇ 二元运算符:+,-,>
  ◇ 三元运算符:?:

  基本的运算符按功能划分,有下面几类:

  
1 算术运算符: +,―,*,/,%,++,――。
  
例如:
    3+2;
    a-b;
    i++;
    --i;

  
2 关系运算符: >,<,>=,<=,==,!=。
   例如:
    count>3;
    I==0;
    n!=-1;

  
3 布尔逻辑运算符: !,&&,|| 。
  
例如:
   flag=true;
   !(flag);
   flag&&false;

  
4 位运算符: >>,<<,>>>,&,|,^,~。
  
例如:
   a=10011101; b=00111001;则有如下结果:
   a<<3 =11101000;
   a>>3 =11110011 a>>>3=00010011;
   a&b=00011001; a|b=10111101;
   ~a=01100010; a^b=10100100;

  
5 赋值运算符 =,及其扩展赋值运算符如+=,―=,*=,/=等。
  
例如:
   i=3;
   i+=3;     //等效于i=i+3;

  
6 条件运算符 ? :
   例如:result=(sum= =0 ? 1 : num/sum);

  
7 其它:
   
包括分量运算符· ,下标运算符 [],实例运算符instanceof,内存分配运算符new,强制类型转换运算符 (类型),方法调用运算符 () 等。例如:
  System.out.println("hello world");
  int array1[]=new int[4];

  分支语句提供了一种控制机制,使得程序的执行可以跳过某些语句不执行,而转去执行特定的语句。

  
1.条件语句 if-else

   if(boolean-expression)
    statement1;
   [else statement2;]

  
2.多分支语句 switch

   switch (expression){
    case value1 : statement1;
   break;
    case value2 : statement2;
   break;
   …………
    case valueN : statemendN;
   break;
    [default : defaultStatement; ]
   }

   表达式expression的返回值类型必须是这几种类型之一:int,byte,char,short。
   case子句中的值valueN必须是常量,而且所有case子句中的值应是不同的。
   default子句是可选的。
  break语句用来在执行完一个case分支后,使程序跳出switch语句,即终止switch语句的执行(在一些特殊情况下,多个不同的case值要执行一组相同的操作,这时可以不用break)。

 1.while语句

  [initialization]
  while (termination){
    body;
  [iteration;]
  }

 
2.do-while语句

  [initialization]
  do {
    body;
  [iteration;]
  } while (termination);

 
3.for语句

  for (initialization; termination; iteration){
    body;
  }

  ◇
for语句执行时,首先执行初始化操作,然后判断终止条件是否满足,如果满足,则执行循环体中的语句,最后执行迭代部分。完成一次循环后,重新判断终止条件。
  ◇ 初始化、终止以及迭代部分都可以为空语句(但分号不能省),三者均为空的时候,相当于一个无限循环。
  ◇ 在初始化部分和迭代部分可以使用逗号语句,来进行多个操作。逗号语句是用逗号分隔的语句序列。
   for( i=0, j=10; i<j; i++, j--){
    ……
   }

 1.break语句

  ◇ 在switch语中,break语句用来终止switch语句的执行。使程序从switch语句后的第一个语句开始执行。
  ◇ 在Java中,可以为每个代码块加一个括号,一个代码块通常是用大括号{}括起来的一段代码。加标号的格式如下:
  BlockLabel: { codeBlock }
  break语句的第二种使用情况就是跳出它所指定的块,并从紧跟该块的第一条语句处执行。例如:
  break BlockLabel;
  break语句
  a:{…… //标记代码块a
  b:{…… //标记代码块b
  c:{…… //标记代码块c
  break b;
   …… //此处的语句块不被执行
  }
   …… /此处的语句块不被执行
  }
   …… //从此处开始执行
  }

 
2.continue语句

  continue语句用来结束本次循环,跳过循环体中下面尚未执行的语句,接着进行终止条件的判断,以决定是否继续循环。对于for语句,在进行终止条件的判断前,还要先执行迭代语句。它的格式为:
   continue;

  也可以用continue跳转到括号指明的外层循环中,这时的格式为
   continue outerLable;

  例如:
   outer: for( int i=0; i<10; i++ ){ //外层循环
   inner: for( int j=0; j<10; j++ ){ //内层循环
   if( i<j ){
     ……
   continue outer;

   }
     ……
   }
     ……
   }

 
3.返回语句return
   
  return语句从当前方法中退出,返回到调用该方法的语句处,并从紧跟该语句的下一条语句继续程序的执行。返回语句有两种格式:
  return expression ;
  return;

  return语句通常用在一个方法体的最后,否则会产生编译错误,除非用在if-else语句中



 1. 一维数组的定义

  type arrayName[ ];
  类型(type)可以为Java中任意的数据类型,包括简单类型和复合类型。
  例如:
   int intArray[ ];
   Date dateArray[];


 
2.一维数组的初始化

   静态初始化
    int intArray[]={1,2,3,4};
    String stringArray[]={"abc", "How", "you"};


  
动态初始化
    1)简单类型的数组
    int intArray[];
    intArray = new int[5];

   2)复合类型的数组
    String stringArray[ ];
    String stringArray = new String[3];/*为数组中每个元素开辟引用
                      空间(32位) */

    stringArray[0]= new String("How");//为第一个数组元素开辟空间
    stringArray[1]= new String("are");//为第二个数组元素开辟空间
    stringArray[2]= new String("you");// 为第三个数组元素开辟空间


 
3.一维数组元素的引用

  数组元素的引用方式为:
     arrayName[index]

  index为数组下标,它可以为整型常数或表达式,下标从0开始。每个数组都有一个属性length指明它的长度,例如:intArray.length指明数组intArray的长度。

 1.二维数组的定义

  type arrayName[ ][ ];
  type [ ][ ]arrayName;

 
2.二维数组的初始化

  
静态初始化
  int intArray[ ][ ]={{1,2},{2,3},{3,4,5}};

  Java语言中,由于把二维数组看作是数组的数组,数组空间不是连续分配的,所以不要求二维数组每一维的大小相同。

  
动态初始化
  1) 直接为每一维分配空间,格式如下:
  arrayName = new type[arrayLength1][arrayLength2];
  int a[ ][ ] = new int[2][3];

  2) 从最高维开始,分别为每一维分配空间:
  arrayName = new type[arrayLength1][ ];
  arrayName[0] = new type[arrayLength20];
  arrayName[1] = new type[arrayLength21];
  …
  arrayName[arrayLength1-1] = new type[arrayLength2n];

  3) 例:
  二维简单数据类型数组的动态初始化如下,
  int a[ ][ ] = new int[2][ ];
  a[0] = new int[3];
  a[1] = new int[5];

  对二维复合数据类型的数组,必须首先为最高维分配引用空间,然后再顺次为低维分配空间。
  而且,必须为每个数组元素单独分配空间。

  例如:
  String s[ ][ ] = new String[2][ ];
  s[0]= new String[2];//为最高维分配引用空间
  s[1]= new String[2]; //为最高维分配引用空间
  s[0][0]= new String("Good");// 为每个数组元素单独分配空间
  s[0][1]= new String("Luck");// 为每个数组元素单独分配空间
  s[1][0]= new String("to");// 为每个数组元素单独分配空间
  s[1][1]= new String("You");// 为每个数组元素单独分配空间

 
3.二维数组元素的引用
  
  对二维数组中的每个元素,引用方式为:arrayName[index1][index2]
  例如: num[1][0];

 
4.二维数组举例:

【例2.2】两个矩阵相乘
  public class MatrixMultiply{
   public static void main(String args[]){
   int i,j,k;
   int a[][]=new int [2][3]; //动态初始化一个二维数组
   int b[][]={{1,5,2,8},{5,9,10,-3},{2,7,-5,-18}};//静态初始化
                           一个二维数组

   int c[][]=new int[2][4]; //动态初始化一个二维数组
   for (i=0;i<2;i++)
     for (j=0; j<3 ;j++)
      a[i][j]=(i+1)*(j+2);
   for (i=0;i<2;i++){
     for (j=0;j<4;j++){
      c[i][j]=0;
   for(k=0;k<3;k++)
     c[i][j]+=a[i][k]*b[k][j];
      }
     }
   System.out.println("*******Matrix C********");//打印Matrix C标记
   for(i=0;i<2;i++){
     for (j=0;j<4;j++)
      System.out.println(c[i][j]+" ");
     System.out.println();
      }
     }
   }

 

 

 1.字符串常量

  字符串常量是用双引号括住的一串字符。
    "Hello World!"

 
2.String表示字符串常量

  用String表示字符串:
  String( char chars[ ] );
  String( char chars[ ], int startIndex, int numChars );
  String( byte ascii[ ], int hiByte );
  String( byte ascii[ ], int hiByte, int startIndex, int numChars );
  String使用示例:
  String s=new String() ; 生成一个空串

  下面用不同方法生成字符串"abc":
  char chars1[]={'a','b','c'};
  char chars2[]={'a','b','c','d','e'};
  String s1=new String(chars1);
  String s2=new String(chars2,0,3);
  byte ascii1[]={97,98,99};
  byte ascii2[]={97,98,99,100,101};
  String s3=new String(ascii1,0);
  String s4=new String(ascii2,0,0,3);

 
3.用StringBuffer表示字符串

  StringBuffer( ); /*分配16个字符的缓冲区*/
  StringBuffer( int len ); /*分配len个字符的缓冲区*/
  StringBuffer( String s ); /*除了按照s的大小分配空间外,再分配16个
               字符的缓冲区*/

 

 

 1.类String中提供了length( )、charAt( )、indexOf( )、lastIndexOf( )、getChars( )、getBytes( )、toCharArray( )等方法。

  
public int length() 此方法返回字符串的字符个数
   public char charAt(int index) 此方法返回字符串中index位置上的字符,其中index 值的 范围是0~length-1
   public int indexOf(int ch)
    public lastIndexOf(in ch)
  
  返回字符ch在字符串中出现的第一个和最后一个的位置
   public int indexOf(String str)
    public int lastIndexOf(String str)
  返回子串str中第一个字符在字符串中出现的第一个和最后一个的位置
   public int indexOf(int ch,int fromIndex)
    public lastIndexOf(in ch ,int fromIndex)
  返回字符ch在字符串中位置fromIndex以后出现的第一个和最后一个的位置
   public int indexOf(String str,int fromIndex)
    public int lastIndexOf(String str,int fromIndex)
  返回子串str中的第一个字符在字符串中位置fromIndex后出现的第一个和最后一个的位置。
   public void getchars(int srcbegin,int end ,char buf[],int dstbegin)
   srcbegin 为要提取的第一个字符在源串中的位置, end为要提取的最后一个字符在源串中的位置,字符数组buf[]存放目的字符串,    dstbegin 为提取的字符串在目的串中的起始位置。
  public void getBytes(int srcBegin, int srcEnd,byte[] dst, int dstBegin)
  参数及用法同上,只是串中的字符均用8位表示。

 
2.类StringBuffer提供了 length( )、charAt( )、getChars( )、capacity()等方法。

  方法capacity()用来得到字符串缓冲区的容量,它与方法length()所返回的值通常是不同的。

 1.String类提供的方法:

   concat( )
   replace( )
   substring( )
   toLowerCase( )
   toUpperCase( )

  ◇
public String contat(String str);
  用来将当前字符串对象与给定字符串str连接起来。
  ◇ public String replace(char oldChar,char newChar);
  用来把串中出现的所有特定字符替换成指定字符以生成新串。
  ◇ public String substring(int beginIndex);
  public String substring(int beginIndex,int endIndex);
  用来得到字符串中指定范围内的子串。
  ◇ public String toLowerCase();
  把串中所有的字符变成小写。
  ◇ public String toUpperCase();
  把串中所有的字符变成大写。

 
2.StringBuffer类提供的方法:

  append( )
  insert( )
  setCharAt( )

  如果操作后的字符超出已分配的缓冲区,则系统会自动为它分配额外的空间。
  ◇ public synchronized StringBuffer append(String str);
  用来在已有字符串末尾添加一个字符串str。
  ◇ public synchronized StringBuffer insert(int offset, String str);
  用来在字符串的索引offset位置处插入字符串str。
  ◇ public synchronized void setCharAt(int index,char ch);
  用来设置指定索引index位置的字符值。

  注意:String中对字符串的操作不是对源操作串对象本身进行的,而是对新生成的一个源操作串对象的拷贝进行的,其操作的结果不影响源串。

  相反,StringBuffer中对字符串的连接操作是对源串本身进行的,操作之后源串的值发生了变化,变成连接后的串。

 1.字符串的比较

  String中提供的方法:
  equals( )和equalsIgnoreCase( )
  它们与运算符'= ='实现的比较是不同的。运算符'= ='比较两个对象是否引用同一个实例,而equals( )和equalsIgnoreCase( )则比较  两个字符串中对应的每个字符值是否相同。

 
2.字符串的转化

  java.lang.Object中提供了方法toString( )把对象转化为字符串。

 
3.字符串"+"操作

  运算符'+'可用来实现字符串的连接:
  String s = "He is "+age+" years old.";
  其他类型的数据与字符串进行"+"运算时,将自动转换成字符串。具体过程如下:
  String s=new StringBuffer("he is").append(age).append("years old").toString();

  注意:除了对运算符"+"进行了重载外,java不支持其它运算符的重载。

 1.类声明:

  [public][abstract|final] class className [extends superclassName] [implements interfaceNameList]
  {……}

  其中,修饰符public,abstract,final 说明了类的属性,className为类名,superclassName为类的父类的名字,interfaceNameList为类所实现的接口列表。

 
2.类体

  类体定义如下:
  class className
  {[public | protected | private ] [static]
  [final] [transient] [volatile] type
  variableName;                 //成员变量
  [public | protected | private ] [static]
  [final | abstract] [native] [synchronized]
  returnType methodName([paramList]) [throws exceptionList]
   {statements}                 //成员方法
  }

 
3.成员变量

  成员变量的声明方式如下:
  [public | protected | private ] [static]
  [final] [transient] [volatile] type
  variableName;                 //成员变量
  其中,
  static: 静态变量(类变量);相对于实例变量
  final: 常量
  transient: 暂时性变量,用于对象存档
  volatile: 贡献变量,用于并发线程的共享

 
4.成员方法

  方法的实现包括两部分内容:方法声明和方法体。
  [public | protected | private ] [static]
  [final | abstract] [native] [synchronized]
  returnType methodName([paramList])
  [throws exceptionList]            //方法声明
   {statements}                //方法体

  方法声明中的限定词的含义:
  static: 类方法,可通过类名直接调用
  abstract: 抽象方法,没有方法体
  final: 方法不能被重写
  native: 集成其它语言的代码
  synchronized: 控制多个并发线程的访问

  ◇ 方法声明
  方法声明包括方法名、返回类型和外部参数。其中参数的类型可以是简单数据类型,也可以是复合数据类型(又称引用数据类型)。

  对于简单数据类型来说,java实现的是值传递,方法接收参数的值,但不能改变这些参数的值。如果要改变参数的值,则用引用数据类型,因为引用数据类型传递给方法的是数据在内存中的地址,方法中对数据的操作可以改变数据的值。

  例3-1说明了简单数据类型与引用数据的区别。

【例3-1】
  import java.io.*;
  public class PassTest{
  float ptValue;
  public static void main(String args[]) {
  int val;
  PassTest pt=new PassTest();
  val=11;
  System.out.println("Original Int Value is:"+val);
  pt.changeInt(val);                   //值参数
  System.out.println("Int Value after Change is:" +val); /*值参数
                    值的修改,没有影响值参数的值*/

  pt.ptValue=101f;
  System.out.println("Original ptValue is:"+pt.ptValue);
  pt.changeObjValue(pt); //引用类型的参数
  System.out.println("ptValue after Change is:"+pt.ptValue);/* 引用参数值的修改,改变了引用参数的值*/
  }
  public void changeInt(int value){
  value=55;            //在方法内部对值参数进行了修改
  }
  public void changeObjValue(PassTest ref){
  ref.ptValue=99f;        //在方法内部对引用参数进行了修改
    }
  }

   查看运行结果

  ◇ 方法体
  方法体是对方法的实现,它包括局部变量的声明以及所有合法的Java指令。方法体中声明的局部变量的作用域在该方法内部。若局部变量与类的成员变量同名,则类的成员变量被隐藏。

  例3-2 说明了局部变量z和类成员变量z的作用域是不同的。

【例3-2】
  import java.io.*;
  class Variable{
  int x=0,y=0,z=0;              //类的成员变量
  void init(int x,int y) {
  this.x=x; this.y=y;
  int z=5;                 //局部变量
  System.out.println("** in init**");
  System.out.println("x="+x+" y="+y+" z="+z);
    }
  }
  public class VariableTest{
  public static void main(String args[]){
  Variable v=new Variable();
  System.out.println("**before init**");
  System.out.println("x="+v.x+" y="+ v.y+" z="+v.z);
  v.init(20,30);
  System.out.println("**after init**");
  System.out.println("x="+v.x+ " y="+ v.y+" z="+v.z);
    }
  }

   查看运行结果

  上例中我们用到了this,这是因为init()方法的参数名与类的成员变量x,y的名字相同,而参数名会隐藏成员变量,所以在方法中,为了区别参数和类的成员变量,我们必须使用this。this-----用在一个方法中引用当前对象,它的值是调用该方法的对象。返回值须与返回类型一致,或者完全相同,或是其子类。当返回类型是接口时,返回值必须实现该接口。

 5.方法重载
 
  方法重载是指多个方法享有相同的名字,但是这些方法的参数必须不同,或者是参数的个数不同,或者是参数类型不同。返回类型不能用来区分重载的方法。

  参数类型的区分度一定要足够,例如不能是同一简单类型的参数,如int与long。

【例3-3】
  import java.io.*;
  class MethodOverloading{
  void receive(int i) {
  System.out.println("Receive one int data");
  System.out.println("i="+i);
  }
  void receive(int x, int y) {
  System.out.println("Receive two int datas");
  System.out.println("x="+x+" y="+y);
    } 
  }
  public class MethodOverloadingTest{
  public static void main(String args[]) {
  MethodOverloading mo=new MethodOverloading();
  mo.receive(1);
  mo.receive(2,3);

    } 
  }

  查看运行结果(编译器会根据参数的个数和类型来决定当前所使用的方法)

 6. 构造方法

   构造方法是一个特殊的方法。Java 中的每个类都有构造方法,用来初始化该类的一个对象。
   构造方法具有和类名相同的名称,而且不返回任何数据类型。
   重载经常用于构造方法。
   构造方法只能由new运算符调用

【例3-4】
  class Point{
  int x,y;
  Point(){
  x=0; y=0;
  }
  Point(int x, int y){
  this.x=x;
  this.y=y;
    }
  }

 1. 对象的生成

  对象的生成包括声明、实例化和初始化。
  格式为:
  type objectName=new type([paramlist]);

  ◇ 声明:type objectName
  声明并不为对象分配内存空间,而只是分配一个引用空间;对象的引用类似于指针,是32位的地址空间,它的值指向一个中间的数据结构,它存储有关数据类型的信息以及当前对象所在的堆的地址,而对于对象所在的实际的内存地址是不可操作的,这就保证了安全性。
  

  ◇ 实例化:运算符new为对象分配内存空间,它调用对象的构造方法,返回引用;一个类的不同对象分别占据不同的内存空间。

  ◇ 生成:执行构造方法,进行初始化;根据参数不同调用相应的构造方法。

 
2. 对象的使用

  通过运算符"."可以实现对变量的访问和方法的调用。变量和方法可以通过设定访问权限来限制其它对象对它的访问。

  ◇调用对象的变量
  格式:objectReference.variable
  objectReference是一个已生成的对象,也可以是能生成对象的表达式
  例: p.x= 10;
     tx=new Point( ).x;

  ◇调用对象的方法
  格式:objectReference.methodName([paramlist]);
  例如:p.move(30,20);
     new Point( ).move(30,20);

 
3. 对象的清除

  当不存在对一个对象的引用时,该对象成为一个无用对象。Java的垃圾收集器自动扫描对象的动态内存区,把没有引用的对象作为垃圾收集起来并释放。
  System.gc( );  
  当系统内存用尽或调用System.gc( )要求垃圾回收时,垃圾回收线程与系统同步运行。

 1. 封装性

  java语言中,对象就是对一组变量和相关方法的封装,其中变量表明了对象的状态,方法表明了对象具有的行为。通过对象的封装,实现了模块化和信息隐藏。通过对类的成员施以一定的访问权限,实现了类中成员的信息隐藏。

  ◇ 类体定义的一般格式:

  class className
  {   [public | protected | private ] [static]
     [final] [transient] [volatile] type
     variableName;            //成员变量
     [public | protected | private ] [static]
     [final | abstract] [native] [synchronized]
     returnType methodName([paramList])
     [throws exceptionList]
     {statements} //成员方法
  }

  ◇ java类中的限定词
  java语言中有四种不同的限定词,提供了四种不同的访问权限。

  1) private
  类中限定为private的成员,只能被这个类本身访问。
  如果一个类的构造方法声明为private,则其它类不能生成该类的一个实例。

  2) default
  类中不加任何访问权限限定的成员属于缺省的(default)访问状态,可以被这个类本身和同一个包中的类所访问。

  3) protected
  类中限定为protected的成员,可以被这个类本身、它的子类(包括同一个包中以及不同包中的子类)和同一个包中的所有其他的类访问。

  4) public
  类中限定为public的成员,可以被所有的类访问。

  表3-1列出了这些限定词的作用范围。

【表3-1】 java中类的限定词的作用范围比较

同一个类
同一个包
不同包的子类
不同包非子类
private
*
default
*
*
protected
*
*
*
public
*
*
*
*

  2. 继承性

  通过继承实现代码复用。Java中所有的类都是通过直接或间接地继承java.lang.Object类得到的。继承而得到的类称为子类,被继承的类称为父类。子类不能继承父类中访问权限为private的成员变量和方法。子类可以重写父类的方法,及命名与父类同名的成员变量。但Java不支持多重继承,即一个类从多个超类派生的能力。

   创建子类
  格式:
  class SubClass extends SuperClass {
  …
  }

   成员变量的隐藏和方法的重写
  子类通过隐藏父类的成员变量和重写父类的方法,可以把父类的状态和行为改变为自身的状态和行为。

  例如:
  class SuperClass{
    int x; …
    void setX( ){ x=0; } …
  }
  class SubClass extends SuperClass{
    int x;   //隐藏了父类的变量x
    …
    void setX( ) { //重写了父类的方法 setX()
    x=5; } ….
  }

  注意:子类中重写的方法和父类中被重写的方法要具有相同的名字,相同的参数表和相同的返回类型,只是函数体不同。

  
◇ super
  java中通过super来实现对父类成员的访问,super用来引用当前对象的父类。Super 的使用有三种情况:

  1)访问父类被隐藏的成员变量,如:
    super.variable;

  2)调用父类中被重写的方法,如:
    super.Method([paramlist]);

  3)调用父类的构造函数,如:
    super([paramlist]);

【例3-5】
  import java.io.*;
  class SuperClass{
    int x;
    SuperClass( ) {
     x=3;
     System.out.println("in SuperClass : x=" +x);
    }
     void doSomething( ) {
     System.out.println("in SuperClass.doSomething()");
    }
  }
  class SubClass extends SuperClass {
    int x;
    SubClass( ) {
     super( );    //调用父类的构造方法
     x=5;      //super( ) 要放在方法中的第一句
     System.out.println("in SubClass :x="+x);
    }
     void doSomething( ) {
     super.doSomething( ); //调用父类的方法
     System.out.println("in SubClass.doSomething()");
     System.out.println("super.x="+super.x+" sub.x="+x);
    }
  }
  public class Inheritance {
     public static void main(String args[]) {
     SubClass subC=new SubClass();
     subC.doSomething();
    }
  }

    查看运行结果

 
3. 多态性

  在java语言中,多态性体现在两个方面:由方法重载实现的静态多态性(编译时多态)和方法重写实现的动态多态性(运行时多态)。

  1) 编译时多态
  在编译阶段,具体调用哪个被重载的方法,编译器会根据参数的不同来静态确定调用相应的方法。

  2) 运行时多态
  由于子类继承了父类所有的属性(私有的除外),所以子类对象可以作为父类对象使用。程序中凡是使用父类对象的地方,都可以用子类对象来代替。一个对象可以通过引用子类的实例来调用子类的方法。

   重写方法的调用原则:java运行时系统根据调用该方法的实例,来决定调用哪个方法。对子类的一个实例,如果子类重写了父类的方法,则运行时系统调用子类的方法;如果子类继承了父类的方法(未重写),则运行时系统调用父类的方法。

  在例3-6中,父类对象a引用的是子类的实例,所以,java运行时调用子类B的callme方法。

【例3-6】
  import java.io.*;
  class A{
     void callme( ) {
      System.out.println("Inside A's callme()method");
     }
  }
  class B extends A{
     void callme( ) {
      System.out.println("Inside B's callme() Method");
     }
  }
  public class Dispatch{
     public static void main(String args[]) {
      A a=new B();
      a.callme( );
     }
  }

    查看运行结果

   方法重写时应遵循的原则
  1)改写后的方法不能比被重写的方法有更严格的访问权限(可以相同)。
  2)改写后的方法不能比重写的方法产生更多的例外。

 
4. 其它

  ◇ final 关键字
  final 关键字可以修饰类、类的成员变量和成员方法,但final 的作用不同。
  
  1) final 修饰成员变量:
  final修饰变量,则成为常量,例如
  final type variableName;
  修饰成员变量时,定义时同时给出初始值,而修饰局部变量时不做要求。

  2) final 修饰成员方法:
  final修饰方法,则该方法不能被子类重写
  final returnType methodName(paramList){
  …
  }

  3) final 类:
  final修饰类,则类不能被继承
  final class finalClassName{
  …
  }


  ◇ 实例成员和类成员
  用static 关键字可以声明类变量和类方法,其格式如下:
  static type classVar;
  static returnType classMethod({paramlist}) {
  …
  }
 
  如果在声明时不用static 关键字修饰,则声明为实例变量和实例方法。
  1) 实例变量和类变量
  每个对象的实例变量都分配内存,通过该对象来访问这些实例变量,不同的实例变量是不同的。
  类变量仅在生成第一个对象时分配内存,所有实例对象共享同一个类变量,每个实例对象对类变量的改变都会影响到其它的实例对象。类变量可通过类名直接访问,无需先生成一个实例对象,也可以通过实例对象访问类变量。

  2) 实例方法和类方法
  实例方法可以对当前对象的实例变量进行操作,也可以对类变量进行操作,实例方法由实例对象调用。
  但类方法不能访问实例变量,只能访问类变量。类方法可以由类名直接调用,也可由实例对象进行调用。类方法中不能使用this或super关键字。

  例3-7 是关于实例成员和类成员的例子。

【例3-7】
  class Member {
    static int classVar;
    int instanceVar;
    static void setClassVar(int i) {
     classVar=i;
     // instanceVar=i; // 类方法不能访问实例变量
    }
    static int getClassVar()
     { return classVar; }
    void setInstanceVar(int i)
     { classVar=i; //实例方法不但可以访问类变量,也可以实例变量
     instanceVar=i; }
     int getInstanceVar( )
     { return instanceVar; }
    }
    public class MemberTest{
     public static void main(String args[]) {
         Member m1=new member();
         Member m2=new member();
         m1.setClassVar(1);
         m2.setClassVar(2);
         System.out.println("m1.classVar="+m1.getClassVar()+"
                   m2.ClassVar="+m2.getClassVar());
         m1.setInstanceVar(11);
         m2.setInstanceVar(22);
         System.out.println("m1.InstanceVar="+m1.getInstanceVar
              ()+" m2.InstanceVar="+m2.getInstanceVar());
     }
    }

    查看运行结果

   类java.lang.Object
  类java.lang.Object处于java开发环境的类层次的根部,其它所有的类都是直接或间接地继承了此类。该类定义了一些最基本的状态和行为。下面,我们介绍一些常用的方法。

  equals() :比较两个对象(引用)是否相同。
  getClass():返回对象运行时所对应的类的表示,从而可得到相应的信息。
  toString():用来返回对象的字符串表示。
  finalize():用于在垃圾收集前清除对象。
  notify(),notifyAll(),wait():用于多线程处理中的同步。

 1. 抽象类

  java语言中,用abstract 关键字来修饰一个类时,这个类叫做抽象类,用abstract 关键字来修饰一个方法时,这个方法叫做抽象方法。格式如下:
  abstract class abstractClass{ …} //抽象类
  abstract returnType abstractMethod([paramlist]) //抽象方法

  抽象类必须被继承,抽象方法必须被重写。抽象方法只需声明,无需实现;抽象类不能被实例化,抽象类不一定要包含抽象方法。若类中包含了抽象方法,则该类必须被定义为抽象类。

 
2. 接口

  接口是抽象类的一种,只包含常量和方法的定义,而没有变量和方法的实现,且其方法都是抽象方法。它的用处体现在下面几个方面:
  ◇ 通过接口实现不相关类的相同行为,而无需考虑这些类之间的关系。
  ◇ 通过接口指明多个类需要实现的方法。
  ◇ 通过接口了解对象的交互界面,而无需了解对象所对应的类。

  1)接口的定义
  接口的定义包括接口声明和接口体。
  接口声明的格式如下:
  [public] interface interfaceName[extends listOfSuperInterface] { … }
   extends 子句与类声明的extends子句基本相同,不同的是一个接口可有多个父接口,用逗号隔开,而一个类只能有一个父类。

  接口体包括常量定义和方法定义
  常量定义格式为:type NAME=value; 该常量被实现该接口的多个类共享; 具有public ,final, static的属性。
  方法体定义格式为:(具有 public和abstract属性)
  returnType methodName([paramlist]);

  2)接口的实现
  在类的声明中用implements子句来表示一个类使用某个接口,在类体中可以使用接口中定义的常量,而且必须实现接口中定义的所有方法。一个类可以实现多个接口,在implements子句中用逗号分开。

  3) 接口类型的使用
  接口作为一种引用类型来使用。任何实现该接口的类的实例都可以存储在该接口类型的变量中,通过这些变量可以访问类所实现的接口中的方法。


 1. 内部类的定义和使用:

  内部类是在一个类的内部嵌套定义的类,它可以是其它类的成员,也可以在一个语句块的内部定义,还可以在表达式内部匿名定义。
  内部类有如下特性:

  ◇ 一般用在定义它的类或语句块之内,在外部引用它时必须给出完整的名称.名字不能与包含它的类名相同。
  ◇ 可以使用包含它的类的静态和实例成员变量,也可以使用它所在方法的局部变量。
  ◇ 可以定义为abstract。
  ◇ 可以声明为private或protected。
  ◇ 若被声明为static,就变成了顶层类,不能再使用局部变量。
  ◇ 若想在Inner Class中声明任何static成员,则该Inner Class必须声明为static。

  例3-8 是一个说明内部类如何使用的例子,其中,定义了两个内部类:MouseMotionHandler和MouseEventHandler,分别用来处理鼠标移动事件和鼠标点按事件。

【例3-8】
  import java.awt.*;
  import java.awt.event.*;
  public class TwoListenInner {
    private Frame f;
    private TextField tf;
      public static void main(String args[]) {
       TwoListenInner that=new TwoListenInner();
       that.go();
    }

      public void go() {
       f=new Frame("Two listeners example");
       f.add("North",new Label("Click and drag the mouse"));
       tf=new TextField(30);
       f.add("South",tf);
       f.addMouseMotionListener(new MouseMotionHandler());
       f.addMouseListener(new MouseEventHandler());
       f.setSize(300,300);
       f.setVisible(true);
    }
    public class MouseMotionHandler extends MouseMotionAdapter {
      public void mouseDragged(MouseEvent e){
       String s="Mouse dragging:X="+e.getX()+"Y="+e.getY();
       tf.setText(s);
      }
    }
    public class MouseEventHandler extends MouseAdapter {
      public void mouseEntered(MouseEvent e){
       String s="The mouse entered";
       tf.setText(s);
      }
      public void mouseExited(MouseEvent e){
       String s="The mouse left the building";
       tf.setText(s);
      }
    }
  }

  同学们可以运行一下这个程序,看一看它的运行结果。当你将鼠标移入frame时,文本框中会出现:"The mouse entered";当你在frame中拖曳鼠标时,文本框中会出现:"Mouse dragging:X=64 Y=117";当鼠标离开文本框时,文本框中出现:"The mouse left the building"。

 
2. 匿名类的定义和使用:

  匿名类是一种特殊的内部类,它是在一个表达式内部包含一个完整的类定义。通过对例6-7中go()部分语句的修改,我们可以看到匿名类的使用情况。

  public void go() {
         f=new Frame("Two listeners example");
         f.add("North",new Label("Click and drag the mouse"));
         tf=new TextField(30);
         f.add("South",tf);
         f.addMouseMotionListener(new MouseMotionHandler(){
         /*定义了一个匿名类,类名没有显式地给出,只是该类是
          MouseMotionHandler类的子类*/

           public void mouseDragged(MouseEvent e){
             String s="Mouse dragging:X="+e.getX()+"Y
             ="+e.getY();
             tf.setText(s);
           }
         });
         f.addMouseListener(new MouseEventHandler());

         f.setSize(300,300);
         f.setVisible(true);
         }

 
3. 内部类的优缺点:

  
◇ 优点:节省编译后产生的字节码文件的大小
  ◇ 缺点:使程序结构不清楚

    本站是提供个人知识管理的网络存储空间,所有内容均由用户发布,不代表本站观点。请注意甄别内容中的联系方式、诱导购买等信息,谨防诈骗。如发现有害或侵权内容,请点击一键举报。
    转藏 分享 献花(0

    0条评论

    发表

    请遵守用户 评论公约

    类似文章 更多