你的位置:首页 > Java教程

[Java教程]第3章 Java的基本程序设计结构


3.1 一个简单的Java应用程序
public class FirstSample{
    public static void main(String[] args){
        System.out.println("We will not use 'Hello World!'");
    }
}
  • Java对大小写敏感
  • public关键字称为访问修饰符(access modifier),用于控制程序的其他部分对这段代码的访问级别
  • class关键字 - 类是构建所有Java应用程序的构建块,Java应用程序中的全部内容都必须放置在类中。
  • 类名命名规范:
        1)以大写字母开头,后面可以跟字母和数字的任意组合,但不能使用Java保留字作为类名
        2)骆驼命名法:如果类名中有多个单词组成,每个单词的第一个字母都应该大写
        3)源代码文件名必须与公共类的名字相同,并用.java作为扩展名。对于上面源代码,文件命名为FirstSample.
  • javac FirstSample.java
          编译源代码就会得到一个包含这个类字节码的文件。编译器将字节码文件自动命名为FirstSample.class,并与源文件存储在同一目录下。
  • java FirstSample
          运行程序时,Java虚拟机将从指定类中的main方法开始执行,因此,在类的源代码中必须包含main方法。main方法必须声明为public
  • 每条语句必须由分号结束
  • 可以将一条语句写在多行上,回车不是语句结束的标志。
3.2 注释
  • 三种注释方式
          1)最常用的方式//   ----单行注释
          2)/*   */    -----多行注释,注释内容可以写在多行,此注释方式不能嵌套    
          3)/**
              *This is the first sample program in Core Java
              *@version 1.01 1997-03-22
              *@author Gary Cornell
              */
             public class FirstSample{                    public static void main(String[] args){
                    System.out.println("We will not use 'Hello World!'");
                }
             }

             这种方式的注释可以用来自动生成文档
 
3.3 数据类型
  • Java是一种强类型语言,即必须为每一个变量声明一种数据类型。
  • 8种基本类型(primitive type)
          1)4种整型 byte  short int long
          2)2种浮点型 float double
          3)1种字符类型char ---用于表示Unicode编码的字符单元的字符类型char
          4)1种用于表示真值的boolean类型
  • 整型 ----用于表示没有小数部分的数值,允许是负数

           1)int类型最常用
           2)表示地球上的人数,就要用long型了
           3)byte和short类型主要用于特定场合
           4)Java中整型的范围与运行Java代码的机器无关。这就解决了软件在不同平台或同平台不同操作系统间移植的问题。由于Java程序必须保证在所有机器上都能够得到相同的运行结果,所以每种数据类型的取值范围必须固定。
           5)长整型数值有一个后缀L(如4000000000L)
           6)十六进制数有一个前缀0x(如0xCAFE)
           7)八进制数有一个前缀0(如010)
           8)二进制数有一个前缀(如0b1001,就是9)  【Java7开始】
           9)可以为数字字面量加下划线,,(如1_000_000或0b1111_0100_0010_0000 表示1百万),只是为了更易读,Java编译器会去除这些下划线。
          10)Java没有任何无符号类型(unsighed)
  • 浮点类型 -----用于表示有小数部分的数值

          1)double表示这种类型的数据精度是float类型的两倍,绝大部分应用程序都采用double类型
          2)只有很少情况下,使用使用float类型
          3)float类型的数值有一个后缀F(如3.14F),没有后缀F的浮点数值(如3.14)默认为double型
          4)三个特殊的浮点数值  ---- 用于表示溢出和出错的情况
             a)正无穷大 ---- 对应常量Double.POSITIVE_INFINITY
                 一个正整数除以0的结果为正无穷大
             b)负无穷大 ---- 对应常量Double.NEGATIVE_INFINITY
             c)NaN(不是一个数字)  ----- 对应常量Double.NaN
                0/0或者负数的平方根结果为NaN
           5)所有非数值的值都是不相同的,可以使用Double.isNaN方法来检验某个值是否为NaN
              if(Double.isNaN(x))
              而不能使用如下方式检验
              if(x==Double.NaN)
           6)如果需要在数值计算中不含任何舍入误差,就用该使用BigDecimal类
  • char类型  ----用于表示单个字符。通常用来表示字符常量。
          1)特殊字符的转义序列符

           2)强烈建议不要在程序中使用char类型,最好将需要处理的字符串用抽象数据类型表示。
  • boolean类型
           有两个值false和true,用来判定逻辑条件。整型值和布尔值之间不能进行相互转换。
 
3.4 变量
  • 每一个变量属于一种类型(type),声明变量时,变量所属的类型位于变量名之前。声明是完整语句,必须由分号结尾。变量名必须以字母开头的由字母、下划线和数字组成。
          double salary;
          int vacationDays;
          long earthPopulation;
          boolean done;
  • 也可以在一行中声明多个同类型的变量,但不提倡这种做法,可读性差。
          int i,j;
  • 变量名是大小写敏感的。hireDay和hireday是两个完全不同的变量。
  • 变量名不能使用java保留字。
  • 变量初始化
          1)声明一个变量后,必须使用赋值语句对一个变量进行显示的初始化,千万不能使用未经初始化的变量。
              int vacationDays; //声明变量
              System.out.println(vacationDays); //未被初始化就使用了,出错 variable not initialized
          2)对已经声明过的变量进行赋值
             int vacationDays;
             vacationDays = 12;
          3)也可以将变量的声明和初始化放在同一行
             int vacationDays = 12;
          4)Java中可以将变量声明放在代码中的任何位置(有些语言必须将所有变量声明放在最前面的位置)
          5)在Java中,变量的声明尽可能的靠近变量第一次使用的地方,这是一种良好的编程风格。
  • 常量
          1)函数作用域内的常量
             利用关键字final定义。表示这个变量只能被赋值一次,一旦被赋值之后,就不能再被改变了。习惯上常量名使用全大写。
            public class Constants{
                 public static void main(String[] args){
                        final double CM_PER_INCH = 2.54;  //位于main方法内部
                        double paperWidth = 8.5;
                        double paperHeight = 11;
                        System.out.println("Pager size in centimeters:" + paperWidth * CM_PER_INCH + " by " + paperHeight *  CM_PER_INCH);
                 }
           }
          2)类常量
          Java中,经常希望某个常量能在一个类中的多个方法中使用,或者提供给其他类使用,通常将这些常量称为类常量。可以使用关键字static final设置一个类常量。
          public class Constants2{
                 public static final double CM_PER_INCH = 2.54;  //位于main方法外部(类的成员变量),因此可供类内部的所有方法使用,而且由于定义为public,因此其他类的方法也能使用这个常量,使用方法为Constants2.CM_PER_INCH
                 public static void main(String[] args){
                        double paperWidth = 8.5;
                        double paperHeight = 11;
                        System.out.println("Pager size in centimeters:" + paperWidth * CM_PER_INCH + " by " + paperHeight *  CM_PER_INCH);
                 }
           }
 
3.5 运算符
  • 算术运算符

          1) 加  +  
          2) 减  -
          3) 乘  *
          4) 除  /
              a)当参与/运算的两个操作数都是整数时,表示整数除法;
                 15/2等于7
                 整数被0整除会产生一个异常
              b)否则,表示浮点除法。
                  15.0/2等于7.5
                  浮点数被0除会得到无穷大或NaN结果。
          5)求余(取模) %

              15%2等于1
          6)可以在赋值语句中采用简化格式书写二元算术运算符
              x += 4;
              等价于:
              x = x+4;
             类似还有:*=或%=
  • 自增运算符与自减运算符
          int m = 7;
          int n = 7;
          int a = 2 * ++m;   //a为16,m为8   前缀方式,先自增,后使用
          int b = 2 * n++;   //b为14, n为8      后缀方式,先使用,后自增
  • 关系运算符和boolean运算符
          1)关系运算符
             a) ==  检测是否相等
                 3 == 7 的值为false
             b) !=   检测是否不想等
                 3 != 7 的值为true
             c) 经常使用的关系运算符还有:
                 <  小于
                 >  大于
                 <= 小于等于
                 >= 大于等于
          2)boolean逻辑运算符
             a) &&   表示逻辑“与”
                  按照短路方式求值,如果第一个操作数能够确定表达式的值,第二个操作数就不必计算了。
                  expression1 && expression2
                  若expression1值为false,则整个逻辑表达式的值为false,因此expression2就不计算了,即expression2有异常也不会报错。
             b) ||       表示逻辑“或”
                 按照短路方式求值,如果第一个操作数能够确定表达式的值,第二个操作数就不必计算了。
                 expression1 || expression2
                 若expression1值为true,则整个逻辑表达式的值为true,因此expression2就不计算了,即expression2有异常也不会报错。
             c)  !     表示逻辑“非”
         3) ?   三元操作符
             condition ? expression1 : expression2
             当条件condition为真时,计算第一个表达式,并将表达式值作为整个三元表达式的值。
             当条件condition为假时,计算第二个表达式,并将表达式值作为整个三元表达式的值。
  • 位运算符
          1) &   与
          2) |     或
          3) ^   异或
          4) ~   非
          5) >> 右移位
          6) << 左移位
          7) >>> 右移位
 
public class BitOperator {
 
   public static void main(String[] args) {
    //转换为十进制输出,结果为8
    int i = 0b1000;
    System.out.println(i);
 
    //取非,结果为-9,不明白为什么?
    int j = ~i;
    System.out.println(j);
 
    //取余,结果为8
    int x = i & 0b11000;
    System.out.println(x);
 
    //取或,结果为9
    int y = i | 0b0001;
    System.out.println(y);
 
    //取异或,结果为5
    int z = i ^ 0b1101;
    System.out.println(z);
 
    //向左移两位,结果为32
    int a = i << 2;
    System.out.println(a);
 
    //向右移两位,结果为2
    int b = i >> 2;
    System.out.println(b);
 
    //向右移两位,结果为2.和上面的区别还是不清楚。>>>运算符将用0填充高位;>>运算符用符号位填充高位
    int c =  i >>> 2;
    System.out.println(c);
 
    //当int类型时,需要对>>右侧的操作数求摸32预算后,再移位.结果为2
    int d = i >> 34;
    System.out.println(d);
 
    //当int类型时,需要对>>右侧的操作数求摸64预算后,再移位,结果为2
    long e = i >> 66;
    System.out.println(e);
 }
 
  • 数学函数与常量
          1) Math(java.lang.Math)类中,包含了各种各样的数学函数
              a) Math.sqrt(x)  //计算一个数值的平方根
              b) Math.power(x,a)   //幂运算 求x的a次幂
              c) 常用三角函数
                   Math.sin
                   Math.cos
                   Math.tan
                   Math.atan
                   Math.atan2
              d) 指数函数以及他的反函数——自然对数以及以10为底的对数
                   Math.exp
                   Math.log
                   Math.log10
              e) Math.round(x)  //舍入运算符,返回long类型的数值
         2)Java还提供两个表示π和e常量的近似值
             Math.PI
             Math.E
  • 数值类型之间的转换

          1)上图6个实心箭头,表示无信息丢失的转换。有三个虚箭头,表示可能有精度损失的转换。
              当两个数值进行二元操作时,先要将两个操作数转换为同一种类型,然后再进行计算。
              如果两个操作数中有一个是double类型,另一个操作数就会转换为double类型。
              否则,如果其中一个操作数是float类型,另一个操作数将会转换为float类型。
              否则,如果其中一个操作数是long类型,另一个操作数将会转换为long类型。
              否则,两个操作数都会被转换成int类型。
  • 强制类型转换
          1)强制类型转换(cast)的语法格式是在圆括号里给出想要转换的目标类型,后面紧跟待转换的变量名。
  • 括号 与运算符级别

 
  • 枚举类型
          1)有时候,变量的取值只在一个有限的集合内,可以定义枚举类型。枚举类型包含有限个命名的值。
              enum Size {SMALL, MEDIUM, LARGE, EXTRA_LARGE};
              Size s = Size.MEDIUM;
              Size类型的变量只能存储这个类型声明中给定的某个枚举值,或者null值。null表示这个变量没有设置任何值。
 
3.6 字符串
  • Java字符串就是Unicode字符序列。Java没有内置的字符串类型,而是在标准的Java类库中提供一个预定义类,很自然的叫做String。每个用双引号括起来的字符串都是String类的一个实例。
          String e="";  //an empty string
          String greeting="Hello";
  • 子串
          String类的substring方法,从一个较大的字符串中提取出一个字串。
          String greeting = "Hello";
          String s = greeting.substring(0,3);   //第二个参数是不想赋值的第一个位置,从0开始计数,指导3为止,但不包含3.
          创建一个由“Hel”组成的字符串
          substring的工作方式有一个优点:容易计算字串的长度,字符串s.substring(a,b)的长度为b-a
  • 拼接
          Java语言允许使用+号连接(拼接)两个字符串
          当将一个字符串与一个非字符串拼接时,后者被转换成字符串,任何一个Java对象都可以转换为字符串
  • 不可变字符串
           1)String类没有提供用于修改字符串的方法。
           greeting = greeting.substring(0,3) + "p!";
            2)由于不能修改Java字符串中的字符,所以在Java文档中将String类对象称为不可变字符串。当然可以修改字符串变量        greeting,让他引用另外一个字符串。
            3)不可变字符串有一个优点,编译器可以让字符串共享。字符串放在公共的存储池中,字符串变量指向存储池中相应的位置,如果复制一个字符串变量,原始字符串变量和复制的字符串变量共享相同的字符。Java设计者认为,共享的效率远远胜过提取、拼接字符串带来的低效率。
  • 检测字符串是否相等
          1)可以使用equals方法检测两个字符串是否相等
              s.equals(t)
              相等返回true,不相等返回false。
              s与t可以是字符串变量,也可以是字符串常量。
              "Hello".equals(greeting);
              检查两个字符串是否相等,而不区分大小写
              "Hello".equalsIgnoreCase("hello");
           2)一定不能使用==运算符检测两个字符串是否相等。这个预算符只能检查这两个字符串是否放在同一个位置上。当然如果字符串放置在同一个位置上必然相等,但是,完全有可能将内容相同的多个字符串拷贝放置在不同的位置上。
               String greeting = "Hello";
               if(greeting == "Hello") ...
               也许返回true
               if(greeting.substring(0,3) == "Hel")...
               也许返回false
               如果虚拟机始终将相同的字符串共享,就可以使用==运算符检测是否相等。但实际上只有字符串常量是共享的,而+或substring等操作的结果并不是共享的。
  • 空串和Null串
        1)空串""是长度为0的字符串。可以调用以下代码检查一个字符串是否为空。
           if(str.length() == 0)
           或
           if(str.equals(""))
           空串是一个Java对象,有自己的串长度(0)和内容(空)
       2)String变量还可以存放一个特殊值,null
           表示目前没有任何对象与该变量关联。
           要检查一个字符串是否为null,要使用以下条件:
            if(str == null)
           要检查一个字符串即不是null也不为空
           if(str != null && str.length() != 0)
           如果在一个null值上调用方法,会出现错误。
  • 代码点与代码单元
  • 字符串API
  • 阅读联机API文档
  • 构建字符串
          1)StringBuilder
             由较短的字符串构建字符串,解决字符串连接方式低效率问题。
             StringBuilder builder = new StringBuilder();
             builder.append(ch); //追加单个字符
             builder.append(str); //追加字符串
             在需要构建字符串时,就调用toString()方法,得到一个String对象。
             String completeString = builder.toString();
          2)StringBuffer
             是StringBuilder的前身,其效率稍低。但允许采用多线程执行添加或删除字符的操作。如果所有字符串在一个单线程中编辑(通常都是这样),则应该用StringBuilder替代。这两个类的API是相同的。
  • 读取输入(标准输入流 System.in)
          1)采用Scanner类进行收入
 
          import java.util.*;
public class InputTest {
 public static void main(String[] args) {
  Scanner in = new Scanner(System.in);    //构造一个Scanner对象,并于标准输入流关联
  System.out.print("What's your name?");
  String name = in.nextLine();    //输入一行
 
  System.out.print("How old are you?");
  int age = in.nextInt();   //输入一个整型数值
 
  System.out.println("Hello, " + name + ". Next year, you'll be" + (age + 1));
 }
}
 
  • 格式化输出
  • 文件输入与输出
package corejava;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.PrintWriter;
import java.nio.file.Paths;
import java.util.*;
 
public class FileInOutput {
 
 public static void main(String[] args) throws FileNotFoundException,IOException {   

  //PrintWriter out = new PrintWriter("F:\\Java\\corejava\\book.txt");  绝对路径写法

  PrintWriter out = new PrintWriter("book.txt");  //相对路径写法

  out.println("code complete");

  out.println("Spring in action");

  out.close();

 

  //Scanner in = new Scanner(Paths.get("F:\\Java\\corejava\\book.txt"));

  Scanner in = new Scanner(Paths.get("book.txt"));

  String book1 = in.nextLine();

  String book2 = in.nextLine();

  in.close();

  System.out.println("book1:" + book1);

  System.out.println("book2:" + book2);

 

  System.out.println(System.getProperty("user.dir"));  //Java虚拟机启动路径为F:\Java\corejava\  因此上面的绝对路径和相对路径写法是等价的。

 }

}

 
3.8 控制流程
  • 块(block)作用域
1)块(即复合语句),是指由以对花括号括起来的若干简单的Java语句。
2)块确定了变量的作用域
3)一个块可以嵌套在另一个块中,但是不能在两个嵌套的块中声明同名的变量。
  • 条件语句
          if(condition) {
                statement;
          }
  • 循环
          1) while循环
          while (condition) statement;    //循环体中的内容,可能一次都不被执行
          2)do..while循环
          do statement while(condition);  //循环体中的内容,至少被执行一次
          3)for循环
  • 多重选择:switch语句
          1)case标签类型支持:char、byte、short或int或对应的包装器类(Character、Byte、Short和Integer)
          2)枚举常量
              enum Size{SMALL, MEDIUM, LARGE, EXTRA_LARGE};
              Size sz = Size.LARGE;
              switch(sz)
              {
                     case SMALL:  //no need to use Size.SMALL
                     ....
                     break;
                     ...
              }
          3)Java SE7开始,case标签还可以是字符串字面量
          String input = ...;
          switch(input.toLowerCase())
          {
              case "yes";  
                      ....
                     break;
                     .....
          }
  • 中断控制流程语句
          1) break语句
               用于退出switch语句、while语句、do..while语句、for语句
          2)带标签的break语句,用于跳出多重嵌套的循环语句。只能跳出语句块,而不能跳入语句块。
             ......
             read_data:
             while(...)
             {
                  ....
                  for(...)
                  {
                       ......
                       break read_data:
                       .......
                  }
             }
             //跳出标签后,从下面语句开始执行
             ................
        
          3)continue语句
             越过当前循环体的剩余部分,立刻跳到循环首部。计数器自增后,继续执行循环体。
         4)带标签的continue语句
            将跳到与标签匹配的循环首部。
       
3.9 大数值
  • java.Math包中的两个很有用的类:BigInteger和BigDecimal
  • 这两个类实现了可以处理包含任意长度数字序列的数值
  • BigInteger a= BigInteger.valueOf(100);  //使用静态的valueOf方法将普通的数值转换为大数值
  • 不能使用普通的算术运算符 + - * /来处理大数值,而需要使用大数值类中的add和multipy方法。
          BigInteger c = a.add(b);  //c= a+b;
          BigInteger d = c.multiply(b.add(BigInter.valueOf(2)));  // d= c*(b + 2)
 
import java.math.BigInteger;
 
public class BigIntegerTest {
 public static void main(String[] args) {
  BigInteger a = BigInteger.valueOf(5);
  BigInteger b = BigInteger.valueOf(6);
 
  BigInteger c = a.add(b);
  BigInteger d = a.multiply(b);
 
  System.out.println(c);
  System.out.println(d);
 }
}
 
3.10 数组
  • 数组是一种数据结构,用来存储同类型的值的集合。
  • 通过一个整型小标可以访问数组中的每个值。a[i]表示整型数组中,第i个元素。
  • 申明数据变量
          int[] a;  //只声明了变量a,并没有将a初始化为一个真正的数组。
  • 初始化数组

          int[] a = new int[100];   //这个数组的下标是0-99,若访问a[100],或任何在0-99之外下标的元素,就会引发“array index out of bounds”异常而终止执行。
  • 创建一个数字数组时,所有元素都初始为0,boolean数组的元素会初始化为false。对象数组的元素则初始化为null
          String[] names = new String[10]; //此时,数组中的元素都为null
          for(int i =0;i<10;i++){
                names[i] = "";
          }
          //此时,数组中的元素都为"",空串。
  • 一旦创建了数组,就不能改变它的大小,尽管可以改变数组中的每个元素的值。
  • 如果经常需要在运行的过程中扩展数组的大小,则应该使用另一种数据结构:数组列表(array list)
  • for each循环
          for(variable : collection){
                statement;
          }
          //variable--定义一个变量用于暂存集合中的每一个元素
          //collection--这一集合表达式必须是一个数组或者是一个实现了Iterable接口的类对象。如,ArrayList
  • 在很多情况下,还是需要使用传统的for循环,例如,不希望遍历集合中的每个元素,或者在循环内部需要使用下标等。
  • 打印数组中的所有值
          Arrays类的toString方法:
          Arrays.toString(a); //返回一个包含数组元素的字符串 [2,3,5,10]
  • 数组初始化
          int[] smallPrimes = {2,3,5,7,11,13};
          使用这种语法,不需要调用new
          利用括号中提供的值进行初始化,数组的大小就是初始值的个数。
  • 匿名数组
          new int[]{17,19,23,29,31,37}
          这种语法形式可以在不创建新变量的情况下重新初始化一个数组。
          smallPrimes = new int[]{17,19,23,29,31,37}
  • Java中,允许数组长度为0
          new elementType[0]; //数组长度为0与null不同。
  • 数组拷贝
          1)Java中允许将一个数组变量拷贝给另一个数组变量。这时,两个变量将引用同一个数组。
          int[] a = {1,2,3,4,5};
          int[] b = a; //两个引用指向堆上的相同数组数组对象。
          b[2] = 30; //此时a[2]的值也变成了30
          2)将一个数组的值拷贝到新的数组中去(开辟新的空间保存,互不影响),则使用Arrays类的copyTo方法:
          int[] b= Arrays.copyOf(a,a.length);
          //第二个参数是新数组的长度,这个方法通常用来增加数组的大小。
          int[] c =Arrays.copyOf(b,b.length*2);
          如果数组元素的类型是数值型,那么多余的元素将被赋予0;如果数组元素是布尔型,则将赋值为false。相反,如果长度小于原始数组的长度,则只拷贝最前面的数据元素。
  • 命令行参数
         //main方法接受一个字符串数组,也就是命令行参数。
          package corejava;
 
public class CommandLineArgs {
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  System.out.println(args.length);
  for(String s:args){
   System.out.println(s);
   }
     }
}
 
          java CommandLineArgs -jrr tmac -lbj
 
  • 数组排序
          package corejava;
 
import java.util.Arrays;
public class SortTest {
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  int[] a = {1,3,2,5,9,7};
  System.out.println(Arrays.toString(a));
  Arrays.sort(a);  //采用优化的快速排序法,对数组进行排序
  System.out.println(Arrays.toString(a));
 }
}
 
  • 数组搜索

          Arrays.binarySearch

  • Arrays.equals(type[] a,type[] b)
          如果两个数组大小相同,并且下标相同的元素都对应相等,则返回true
  • 多维数组
          double[][] balance; //声明数组
          balance = new double[2][3]; //初始化数组
          //另一种初始化方式
          int[][] magicSquare ={
                                                    {16,3,2,13},
                                                    {5,10,11,8},
                                                    {9,6,7,12},
                                                    {4,15,14,1}
                                              }
          一旦数组被初始化,就可以利用两个方括号访问每个元素,balances[i][j]
 
          for each循环处理二维数组时,必须使用两个for each循环进行嵌套遍历
          for(double[] row:a)
               for(double value:row)
                     do something with value;
 
          快速打印一个二维数组元素的列表
          System.out.println(Arrays.deepToString(a));
 
  • 不规则数组
           1)Java实际上没有多维数组,只有一维数组,多维数组被解释为“数组的数组”
           2)不规则数组:即数组的每一行有不同的长度
               //首先需要分配一个具有所含行数的数组
               int[][] odds = new int[NMAX + 1][];
 
               for(int n=0; n < NMAX; n++)
                    odds[n] = new int[n+1];