关闭

Java(2)

522人阅读 评论(0) 收藏 举报

 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.不同类型数据间的优先关系如下:

   低------------------------------------------->高
   byte,short,char-> int -> long -> float -> double

 
2.自动类型转换规则

  整型,实型,字符型数据可以混合运算。运算中,不同类型的数据先转化为同一类型,然后进行运算,转换从低级到高级;

操作数1类型
操作数2类型
转换后的类型
byte、short、char    int     int
byte、short、char、int    long     long
byte、short、char、int、long    float     float
byte、short、char、int、long、float    double     double

  
 
3.强制类型转换
 
  高级数据要转换成低级数据,需用到强制类型转换,如:
  int i;
  byte b=(byte)i; /*把int型变量i强制转换为byte型*/
 对各种类型的数据进行加工的过程成为运算,表示各种不同运算的符号称为运算符,参与运算的数据称为操作数,按操作数的数目来分,可有:
  ◇ 一元运算符:++,--,+,-
  ◇ 二元运算符:+,-,>
  ◇ 三元运算符:?:

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

  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.表达式的类型

  表达式的类型由运算以及参与运算的操作数的类型决定,可以是简单类型,也可以是复合类型:
  布尔型表达式: x&&y||z;
  整型表达式: num1+num2;


  2.运算符的优先次序

   表达式的运算按照运算符的优先顺序从高到低进行,同级运算符从左到右进行:

优先次序
运算符
1
. [] ()
2
++ -- ! ~ instanceof
3
new (type)
4
* / %
5
+ -
6
>> >>> <<
7
> < >= <=
8
= = !=
9
&
10
^
11
|
12
&&
13
||
14
?:
15
= += -= *= /= %= ^=
16
&= |= <<= >>= >>>=

  例如,下述条件语句分四步完成:
  Result=sum==0?1:num/sum;
  第1步:result=sum==0?1:(num/sum)
  第2步:result=(sum==0)?1:(num/sum)
  第3步:result=((sum==0)?1:(num/sum))
  第4步:result=
 分支语句提供了一种控制机制,使得程序的执行可以跳过某些语句不执行,而转去执行特定的语句。

  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不支持其它运算符的重载。
 java中的数据类型有简单数据类型和复合数据类型两种,其中简单数据类型包括整数类型、浮点类型、字符类型和布尔类型;复合数据类型包含类、接口和数组。表达式是由运算符和操作数组成的符号序列,对一个表达式进行运算时,要按运算符的优先顺序从高向低进行,同级的运算符则按从左到右的方向进行。条件语句、循环语句和跳转语句是java中常用的控制语句。

  数组是最简单的复合数据类型,数组是有序数据的集合,数组中的每个元素具有相同的数据类型,可以用一个统一的数组名和下标来唯一地确定数组中的元素。Java中,对数组定义时并不为数组元素分配内存,只有初始化后,才为数组中的每一个元素分配空间。已定义的数组必须经过初始化后,才可以引用。数组的初始化分为静态初始化和动态初始化两种,其中对复合数据类型数组动态初始化时,必须经过两步空间分配:首先,为数组开辟每个元素的引用空间;然后,再为每个数组元素开辟空间。Java中把字符串当作对象来处理, java.lang.String类提供了一系列操作字符串的方法,使得字符串的生成、访问和修改等操作容易和规范。
1. 对象的基本概念

  对象是系统中用来描述客观事物的一个实体,它是构成系统的一个基本单位。一个对象由一组属性和对这组属性进行操作的一组服务组成。从更抽象的角度来说,对象是问题域或实现域中某些事物的一个抽象,它反映该事物在系统中需要保存的信息和发挥的作用;它是一组属性和有权对这些属性进行操作的一组服务的封装体。客观世界是由对象和对象之间的联系组成的。

  主动对象是一组属性和一组服务的封装体,其中至少有一个服务不需要接收消息就能主动执行(称作主动服务)。1.封装性

  封装性就是把对象的属性和服务结合成一个独立的相同单位,并尽可能隐蔽对象的内部细节,包含两个含义:
  ◇ 把对象的全部属性和全部服务结合在一起,形成一个不可分割的独立单位(即对象)。
  ◇ 信息隐蔽,即尽可能隐蔽对象的内部细节,对外形成一个边界〔或者说形成一道屏障〕,只保留有限的对外接口使之与外部发生联系。
  封装的原则在软件上的反映是:要求使对象以外的部分不能随意存取对象的内部数据(属性),从而有效的避免了外部错误对它的"交叉感染",使软件错误能够局部化,大大减少查错和排错的难度。

OOA-Object Oriented Analysis     面向对象的分析
  
  OOD-Object Oriented Design      面向对象的设计
  
  OOI-Object Oriented Implementation  面向对象的实现

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);
    }
  }

 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;
    }
  }

0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:433964次
    • 积分:4747
    • 等级:
    • 排名:第6319名
    • 原创:34篇
    • 转载:140篇
    • 译文:0篇
    • 评论:84条
    文章分类
    最新评论