博客

java中北大学ppt总结+课后习题第二章（小宇特详解）

基本数据类型

Java语言有8种基本数据类型。

逻辑类型：boolean。1字节

整数类型：

1字节整数类型：byte。

2字节整数类型：short。

4字节整数类型：int。

8字节整数类型：long。

字符类型：char。2字节

小数类型：

4字节小数：float。

8字节小数：double。

逻辑类型(又称布尔类型, boolean)

用于表示逻辑上的“真”与“假”。

Java中的逻辑型值只有true和false，不能用0和1代替，这是与C语言的区别。true和false是逻辑常量(小写)，是Java关键字。

整数类型

Java所有基本数据类型所在存储空间有唯一的标准，为程序移植带来方便。

Java的整数型数据有4种，都是有符号整数，Java不提供无符号整数类型。

整型常量的默认类型是int型。

浮点类型

实数常量的默认类型是double，无特殊要求时建议选择double类型；对于float型小数常量，需要在小数后加f或F。

字符类型

Java中的char型数据使用Unicode编码，即是一个字符占2个字节的存储空间，最高位不是符号位，取值范围0~65535。比如’a’字符的Unicode码等于97。

字符常量的三种表示：

直接通过字符来表示，比如’a’；

使用转义字符；

使用数值来表示，可以用三位八进制表示，即\ddd。或者使用Unicode值来表示字符，格式是\uXXXX，其中XXXX代表一个十六进制的整数。

隐式转换：

当把级别低的变量的值赋给级别高的变量时，系统自动完成数据类型的转换。

byte: 	short  int   long   float  double		
 char:  int   long   float  double
 short:int   long   float  double
 int:	long  float  double
 long:	float   double
 float:	double

显式转换：

语法：(类型)值或者变量

用户自定义数据类型：使用基本数据类型根据用户需要组合成的新的数据类型。属于变长数据类型。

字符串类型属于用户自定义类型，由于字符串太常用，所以Oracle公司的工程师已经利用Java语法把字符串定义成

一种用户自定义数据类型。

字符串自定义类型：String。

定义变量

变量定义语法：

数据类型 变量名[=值]； //定义一个变量

数据类型 变量名1 [=值] ，变量名2 [=值] ，……；

//定义多个变量

逻辑变量赋值

boolean b_data;

b_data = true;

boolean isrunning = false;

定义字符串

String 字符串变量；

字符串赋值

字符串变量 = “字符串”;

字符串变量 = 另外一个字符串变量;

字符串长度

String str=“Hello”;

int lenth=str.length();

连接字符串

String str1=“Hello” + “world”;

例一

public class TestDemo1_4 {
   public static void main(String[] args) {
      String str="Hello你好!";
      int lenth=str.length();
      System.out.println(lenth);

      String str1="Hello" + " world" + " 大家好！";
      System.out.println(str1 + "的长度是：" +    
                    str1.length());
   }
}

运行结果：

8

Hello world 大家好！的长度是：16

定义常量

final 类型 常量名[ = 初始值];

注意：

常量只能赋值一次。

常量不是一定要在定义的时候初始化的。

final int ii=20; //在定义的时候初始化。

ii=30; //不允许，因为常量不能二次赋值。

final int j;

j=20; //允许，因为常量j在这里是第一次赋值。

j=30; //不允许，因为常量不能二次赋值。

量的作用域

变量的作用域与它定义的位置和修饰符号有关。

在类块中定义—成员变量；

在函数块中定义—局部变量；

使用static修饰在类块中定义的变量—全局变量或类变量

 class   ClsA{
         int  m_a = 15;		           //成员变量
         static int m_b = 835;
         public static void main(String[] args){               int  a = 50;		//局部变量
         }
}
System.out.println(ClsA.m_b);//全局变量的使用方式：类块名.变量名

例二

public class TestDemo1_5 {
  static int m_c=20;//全局变量
  int m_a=50; //成员变量
  int a=10;   //成员变量
  public static void main(String[] args) {
     int a=30; //局部变量
     int m_c=200; //局部变量
     System.out.println("局部变量a=" + a);
     System.out.println("局部变量m_c=" + m_c);
     System.out.println("全局变量m_c=" + TestDemo1_5.m_c);
     TestDemo1_5 td = new TestDemo1_5();
     System.out.println("成员变量m_a=" + td.m_a);
     System.out.println("成员变量a=" + td.a);
     System.out.println("全局变量m_c=" + td.m_c);
  }
}
局部变量a=30
局部变量m_c=200
全局变量m_c=20
成员变量m_a=50
成员变量a=10
全局变量m_c=20

数据输入与输出

输入数据

Scanner类：提供了多个不同的方法，可以从控制台接收不同类型的数据。

导入Scanner类

import java.util.Scanner;

创建Scanner类的对象：

Scanner scanner = new Scanner(System.in);

scanner对象调用下列方法，读取用户在命令行（例如，MS-DOS窗口）输入的各种基本类型数据：

String str = scanner.next(); //获取字符串

int i = scanner.nextInt(); //获取int型整数

double d = scanner.nextDouble(); //获取double型浮点数

float f = scanner.nextFloat(); //获取float型浮点数

Byte b = scanner.nextByte(); //获取byte型整数

short s = scanner.nextShort(); //获取short型浮点数

long long_data = scanner.nextLong(); //获取long型整数

boolean b2 = scanner.nextBoolean(); //获取布尔型数据

String str2 = scanner.nextLine(); //获取字符串

调用close()方法关闭scanner对象：

scanner.close();

格式化输出

使用System.out.println()或System.out.print()：

可输出串值、表达式的值，二者的区别是前者输出数据后换行，后者不换行。

允许使用并置符号“+”将变量、表达式或一个常数值

System.out.println(m + “个数的和为” + sum);

System.out.println(“:” + 123 + “大于” + 122);

JDK1.5开始，新增了和C语言中printf函数类似的数据输出方法，该方法使用格式如下：

System.out.printf(“格式控制部分”，表达式1，表达式2，…表达式n)

例三

从键盘接收两个整型数据，输出这两个数据的和。

解答：

public class TestScanner {
    public static void main(String[] args) {
        int num1,num2;
        System.out.println("请从键盘接收两个整数：");
        Scanner sc = new Scanner(System.in);
        num1 = sc.nextInt();
        num2 = sc.nextInt();
        System.out.println("这两个整数的和是："+(num1+num2));
    }
}

使用Scanner类创建对象，给该对象发送不同的消息，就会接收不同的数据。

运算符与表达式

+   -   *   /   %（取余）//双目

 +（取正） -（取负）  ++（自增1）  - -（自减1）//单目

   ==    !=     >     <    >=    <=   //关系运算符

注意：

关系表达式的运算结果是boolean型，运算符对应的关系成立，结果为true,否则为false。

逻辑运算

逻辑与 &&

逻辑或 ||

逻辑否 !

注意：

逻辑运算符的操作元必须是boolean数据，运算结果也只能是boolean类型。

&&和||也称为短路运算符，在计算表达式op1&&op2时，如果op1的值是false，则不再计算op2的值，直接得出该表达式的值为false； op1||op2同样的道理。

位运算

位运算符                      
& （与） 
~（非）
| （或）
^（异或）

移位运算符
<< （带符号左移） 
>>（带符号右移） 
>>>（无符号右移）

注意：

位运算符可以对两个整型数据进行位运算

位运算符也可以操作逻辑型数据

比较：x的初值为1

((y=1)==0)&&((x=6)==6)

比较：x的初值为1

((y=1)==0)&((x=6)==6)

复合运算

算术运算符或位运算符和赋值运算符号=复合而成的运算，也称复合赋值运算符。

+= 、-= 、*= 、/= 、%= 、&= 、^= 、|= 、<<= 、>>=

特殊的三目运算：

逻辑表达式？表达式1：表达式2

instanceof 运算符

instanceof 运算符是二目运算符，左边的操作元是一个对象，右边是一个类。

p1 instanceof Person

当左边的对象是右边的类或子类创建的对象时，该运算符运算的结果是true,否则是false。

运算优先级

可以使用()改变优先级别。

优先级别从高到低排列

[ ] 、( ) 		
Instanceof、 ++、 --、 ! 
* 、 /、 % 
 +   - 
<<   >>   >>> 
<、< = 、> 、>= 
== 、!= 
& 
^
|
&&
|| 
?、 : 
=     op= 

条件流程控制语句

例三

判断数据的奇偶性。

public class TestIsOdd {
    public static void main(String[] args) {
        int num;
        System.out.println("请从键盘接收一个整数：");
        Scanner sc = new Scanner(System.in);//新建了一个Scanner类的对象
        num = sc.nextInt();
        if(num % 2 == 0) {
             System.out.println(num+"是偶数！");
         }else {
             System.out.println(num+"是奇数！");
        }
    }
}

根据每个季节输出合适的语句。

public class TestSwitch {
    public static void main(String[] args) {
        String season;
        System.out.println(“请从键盘接收一个季节名(英文)");
        Scanner sc = new Scanner(System.in);
        season = sc.next();
        switch(season) {
           case "spring":System.out.println("播种的季节！");break;
           case "summer":System.out.println("繁花似锦的季节！");break;
           case "autumu":System.out.println("收获的季节！");break;
           case "winter":System.out.println("白雪皑皑的季节！");break;
           default:System.out.println("你确定输入的是季节么？");
        }
     }
}

循环流程控制语句

例四

从键盘接收十个整型数据，完成这十个数据的和。

public class TestFor {
    public static void main(String[] args) {
        int num, sum = 0;
        System.out.print("请依次输入10个整数：");
        Scanner sc = new Scanner(System.in);
        for(int i = 0; i < 10; i++) {
            num = sc.nextInt();
            sum += num;
        }
         System.out.print(“这10个整数的和是：" + sum);
   }
}

中断流程控制语句

例五

计算10以内所有奇数的和。

public class TestContinue {
    public static void main(String[] args) {
        int sum=0,i;
        for(i = 0; i < 10; i++) {
            if(i % 2 == 0) {
                 continue;
            }
            sum += i;
        }
        System.out.println("sum = " + sum);
    }
}

输出50以内的所有素数。

public class TestBreak {
public static void main(String[] args) {
    int i,j;
    for(j = 2; j <= 50; j++) {
        for(i = 2; i <= j / 2; i++) {
            if(j % i == 0) 
                break;
        }
       if(i > j/2) {
            System.out.println(j + "是素数！");
       }
   }
}
}

定义数组

数组是相同类型的变量按照顺序组成的一种复合数据类型，这些相同类型的变量称为数组的元素或单元，数组通过数组名加索引来使用数组的元素，索引从0开始。

定义数组的语法

类型   数组名[ ];                   //不推荐用
类型   数组名1[ ], 数组名2[ ], …;    //不推荐用
类型[ ]  数组名;   
类型[ ]  数组名1, 数组名2, …;

注意：类型可以是基本类型与用户自定义类型。

Java不允许在声明数组中的方括号内指定数组长度。

初始化数组与数组赋值

int [ ] arr; //引用变量

在Java中，没有初始化的数组是不能使用的。

如上例，定义数组时仅仅是定义了一个特殊类型的变量，并且为该变量分配了存储空间（固定占4个字节），将来用于存放数组存储区的首地址，因此这个特殊类型的变量也称为引用变量，也就是说将来可以通过这个变量去引用和操作所指向的数组；然而，此时这个数组存储区还不存在，即系统还没有为数组本身分配任何存储空间。

数组的初始化包含两个过程：

根据实际数据长度分配空间。

对数组中的每个元素赋初值。

注意：数组在分配空间的时候会用缺省的初始值对数组的每个元素进行初始化。

int [ ]  arr;            // 定义数组
arr = new int[4];  // 创建数组（初始化）时必须指定数组实际长度
int [ ]  arr = new int[4];     


类型[ ]   数组名;
数组名 = new  类型[数组长度]; 
类型[ ]  数组名 = new  类型[数组长度];

数组中每个元素的初始化方式：

//方式一：对数组每个元素逐一初始化。
 int[ ]   arr = new  int[4];	
 arr[0] = 1;
 arr[4] = 5;		 //非法：数组不能越界	
 
 //方式二：在分配空间的时候批量初始化。
 int [ ]   arr = new int[ ]{1,2,3,4};  //不要指定元素个数

//方式三：在声明的时候new int[ ] 可以省略
 int[ ]   arr = {1,2,3,4};	
 

Java内存划分

Java把内存划分为两种：一种是栈内存，另一种是堆内存。

栈内存：用于存放在函数中定义的基本类型的变量和数组、对象的引用变量；

堆内存：用来存放由new创建的对象和数组，在堆中分配的内存，由Java虚拟机的自动垃圾回收器来管理。

因此：定义数组时，仅是在栈内存定义了一个特殊类型的变量，这个变量用来存放堆内存中为数组分配的内存空间的首地址，这样，栈中的这个变量就成了数组或对象的引用变量，以后就可以在程序中使用栈中的引用变量来访问堆中的数组了。

Java内存释放

引用变量本质上是普通变量，定义时在栈中分配，引用变量在程序运行到其作用域之外后被释放；

而数组和对象本身在堆中分配，即使程序运行到new（创建）数组和对象的语句所在的代码块之外，数组和对象占用的内存不会被释放；只有当数组和对象没有任何引用变量指向它时，才会变为垃圾，在随后一个不确定的时间被垃圾回收器回收走（释放掉）。

例六

注意：这里的栈内存是在剩余的空间内生成了一个随机数来表示位置

使用数组

使用数组的场景：

在赋值的时候使用、在表达式中使用、在函数调用的时候使用。

使用数组的方式：

使用数组中的某个变量。

使用整个数组。

int[ ]  arr = {1,2,3,4};
 int i = arr[1];			//赋值使用。
 System.out.println(arr[i]);		//直接使用。
 System.out.println(arr[i]+20);	//在表达式中使用。
 int r = Math.sqrt(arr[3]);		//在函数中使用。
 Arrays.sort(arr);			//直接使用数组。

数组的长度

int[ ] arr = {5, 3, 2, 4, 1};
 int len = arr.length;		//直接使用数组。	

利用数组长度，可以清楚数组边界，防止访问数组越界。

 int[ ] arr = {5, 3, 2, 4, 1};	
 for(int i = 0; i < arr.length; i++){	   
                 //可以利用数组的长度，方便的遍历数组。
 	System.out.println(arr[i]);
 } 

数组循环与for语句增强

从JDK1.5开始，引入了一种针对数组的特例化循环

for (声明循环变量：数组的名字){


…

}

注意：声明的循环变量的类型必须和数组的类型相同

int [ ]  arr = {1,2,3,4,5,6};
 for(int i: arr){		
 	System.out.println(i);	
                       // 注意：i不是arr数组的下标，而是变量
 } 

例七

用数组存放学生上学期各门功课的成绩，要求从键盘接收，并计算输出均分。

public class TestArray {
    public static void main(String[] args) {
        // 声明并定义数组
        float[] score = new float[10];
        // 从键盘接收数据
      Scanner sc=new Scanner(System.in);
        System.out.println("请输入上学期各门功课的成绩：");
        for(int i=0; i<score.length; i++){
            score[i]=sc.nextFloat();
        }
 //计算总分与均分
        float sum=0, aver;
       
        for(float i:score){
             sum=sum+i;
         }
       aver=sum/score.length;
        //输出均分
        System.out.println("平均成绩为："+aver);
   }
}

多维数组

多维数组的声明语法

 int[ ][ ] arr1, arr2, arr3;
 int[ ][ ][ ] arr4, arr5;

多维数组的初始化语法

int[ ][ ] arr1 = new int[3][2];

 int[ ][ ] arr2 = new int[][]{{1,2},{3,4},{5,6}};

 int[ ][ ] arr3 =  {{1,2},{3,4},{5,6}};

多维数组的使用语法

int[ ][ ] arr1 = {{1,2},{3,4},{5,6}};
System.out.println( arr1[1][0] );

多维数组的长度

 int[ ][ ] arr1= {{1,2},{3,4},{5,6}};
	
 int len1 = arr1.length; 	//数组的行数
 
 int len2 = arr1[1].length;	//数组的第1行的长度：列数

不规则数组

在Java中允许多维数组是不规则数组。

定义一个3行的数组，第一行3个元素，第二行2个元素，第三行6个元素。如下：

20 13 7
32 41 
5  62 37 18 9 10
int[ ][ ] arr1 = {{20,13,7}, {32,41}, {5,62,37,18,9,10}};

数组操作

操作数组的一个强大工具：Arrays工具

排序

public static void sort(double a[])

含义：把参数a指定的double类型数组按照升序排序

public static void sort(double a[], int start, int end)

含义：把参数a指定的double类型数组中索引start至end-1 的元素的值按照升序排序

二分法查找（要求数组已排序）

public static int binarySearch(double[] a, double number)

含义：判断参数number指定的数是否在a指定的数组中，再返回该元素的索引，不在，返回一个负数。

复制

public static int[] copyOf(int[] original, int newLength)

含义：把参数original指定的数组中从索引0开始的newLength个元素复制到一个新数组中，并返回这个新数组。

public static int[] copyOfRange(int[] original, int from, int to)

含义：把参数original指定的数组中从索引from开始到 to-1的元素复制到一个新数组中，并返回这个新数组。

例八

将一个放有文具英文名称的数组进行排序，并格式化输出原来的数组和排序后的数组，之后从键盘输入一个文具名称，看看是否在数组中？

public class TestArrays {
	public static void main(String[] args) {
    String[] words= {“ruler",“rubber",“pen",“pencil",“book",“ink",“globe"};
    //将上面的数组复制到另外一个数组中
    String[] wordsCopy=Arrays.copyOf(words, words.length);
    Arrays.sort(wordsCopy);
                     //输出原来的数组和排序后的数组
    for(int i = 0;i < words.length;i++) {
        System.out.printf("%-8s",words[i]);
    }
    System.out.println();
    for(String s:wordsCopy) {
       System.out.printf("%-8s",s);
    }
   System.out.println();
//从键盘接收一个文具名字，看看在数组中是否存在？
Scanner sc = new Scanner(System.in);
System.out.println("请从键盘输入要检索的文具：");
String key = sc.next();
int index = Arrays.binarySearch(wordsCopy, key);
if(index >= 0) {
	System.out.println("文具" + key + "在数组的" + index + "号位置！");
}else {
	System.out.println("文具" + key + "不存在");
}
 }
} 	

总结

1、Java不允许在声明数组的方括号内指定数组元素的个数；

2、必须使用new关键字创建数组然后才能进行数组的赋值和使用；

3、Java特有的访问数组的方式：

for (声明循环变量：数组的名字){


…

} //注意：声明的循环变量的类型必须和数组的类型相同

4、Java支持不规则数组

5、Java提供了工具类Arrays访问和操作数组。

枚举类型

定义枚举类型

语法：

修饰符  enum  枚举名{
       枚举值1，枚举值2，……[；]
                //如果没有其他成员，分号可以省略 
 }

注意：其中枚举值1，枚举值2，…称为枚举类型的常量，要符合标识符的规定。 例如：

enum  Season {
 	SPRING, SUMMER, AUTUMN, WINTER
 }

使用枚举类型

声明了一个枚举类型后，就可以用该枚举类型的枚举名定义一个枚举变量了，例如：

Season x;

枚举变量x只能取枚举类型中的常量。通过使用枚举名和“.”运算符获得枚举类型中的常量。例如

x = Season.SPRING;

例九

定义水果枚举类，设置每种水果的价格，然后输出！

public class TestEnum {
    public static void main(String[] args) {
    double price = 0;
    for(Fruit fruit : Fruit.values()) {
        switch(fruit) {
            case APPLE:  price = 4.5; break;
            case BANNER:  price = 2.5; break;
            case PEAR:  price = 2.3; break;
            case PEACH:  price = 3.6; break;
          }
          System.out.println(fruit + “每斤的价格" + price + "元！");
    }
}
}

课后作业（详解）

下列选项中,( )叙述是错误的。

• A. “int [] a,b[];”声明了一个int型一维数组a和一个int型二维数组b
• B. “float a[20];”是正确的数组声明
• C. “boolean yes=false;”是正确的boolean变量声明
• D. 1e2和2.05E2都是double型常量

正确答案:

B

java中声明数组的办法

1.

数组类型 [] 数组名 = {em1,em2,em3,…,emN};

//声明数组的时候初始化，一共N个元素，例如：

int[] array = {3,5,4,8,12,5};//一共六个元素

2.

数组类型[] 数组名 = new 数组类型[N

]//用new关键字声明数组的同时指定数组长度，例如：

String[] str = new String[6]; 数组长度为6，即数组有六个元素

3.**数组类型[] 数组名 = new 数组类型[] {em1,em2,em3,…,emN};**用new关键字声明数组的同时初始化数组，例如：int[] array = new int[] {2,4,5,6,8,9};array数组一共五个元素。

数组一旦声明，数组长度就已经确定。每个数组都有一个length属性，不可改变。可以改变数组元素。

下列选项中,( )叙述是错误的。

• A. System是关键字
• B. _class可以作为标识符
• C. char型字符串在Unicode表中的位置范围为0~65535
• D. 对于”int a[]=new int[3];”,a.length的值是3

正确答案:

A

System不是java关键字，只是java.lang包里提供了这个类，我们也可以自己创建类名为System。

这里百度的话，提示是关键字但是其实不是

下列选项中,( )字符序列可以是标识符。

• A. true
• B. default
• C. _int
• D. good-class

正确答案:

C

标识符是用户编程时使用的名字，用于给变量、 常量 、 函数 、语句块等命名，以建立起名称与使用之间的关系。

下列选项中,( )是正确的float变量的声明。

• A. float foo=1;
• B. float foo=1.0;
• C. float foo=2e1;
• D. float foo=2.02;

正确答案:

A

B为double型变量，赋值给float变量要强制类型转换，当把级别低的变量的值赋给级别高的变量时，系统自动完成数据类型的转换。这里用的是隐式转换。可以看上面的文章

下列选项中,( )是正确的float变量的声明。

• A. float foo=1e2;
• B. float foo=3.14;
• C. float foo=3.03d;
• D. float foo=0x0123;

正确答案:

D

A不能使用1e2

B这里存在强制类型转换

C3.03d格式不对

D0x0123是16进制

下列选项中,( )叙述是正确的。

• A. char ch=“R”;
• B. char ch=’\’;
• C. char ch=‘ABCD’;
• D. char ch=“ABCD”;

正确答案:

B

这里只能是单个字符并且是’’

使用转义字符，能够表示字符串

下列选项中，( )叙述是错误的。

A. 对于"int a[][]=new int[6][4];",a.length的值是6
B. 对于"int a[][]=new int[2][9];",a.length、a[0].length、a[1].length的值都是9
C. 对于"int [] a=new int[3];"a[0]、a[1]、a[2]的值都是0
D. "float height=1eF;"是正确的float变量声明

正确答案:

B

a[0].length的值为2

对于下列Test.java代码,( )叙述正确的。

public class Test {

public static void main(String[] args) {

int arr[]=new int[10]; System.out.println(arr[1]);

}

}

• A. 产生编译错误
• B. 输出null
• C. 编译正确，发生运行异常
• D. 输出0

正确答案:

D

定义了数组但是是空的，所以输出了0

下列选项中,( )叙述是错误的。

• A.char c=65535;
• B. byte b=127;
• C. int height=100;
• D. float f=3.14;

正确答案:

D

隐式转换

Test2.java代码如下,下列选项中,( )哪句代码是错误的。public class Test2 {

public static void main(String[] args) {

int x=8;

byte b=127;

b=x; x=‘a’;

long y=b;

float z=(int)6.89;

}

}

• A.b=x;
• B. x=‘a’;
• C.long y=b;
• D. float z=(int)6.89;

正确答案:

A

下列选项中,( )哪个是错误的。

• A.char c=‘a’;
• B. byte b=128;
• C. int height=100;
• D.float f=3.14F;

正确答案:

B

byte的范围是-128~127

下列选项中,( )哪句代码是错误的。

• A.char c=30320;
• B. byte b=127;
• C. int public=100;
• D. float f=3.14F;

正确答案:

C

char是无符号数据类型。因此，char变量不能为负值。字符数据类型的范围为0到65535

byte的范围是-128~127

对于float型小数常量，需要在小数后加f或F。

不能使用int public来定义常量

下列叙述正确的是（）

• A. 5.0/2+10的结果是double型数据
• B. （int）5.8+1.0的结果是int型数据
• C. ‘苹’+’果’的结果是char型数据
• D. （short）10+’a’的结果是short型数据

正确答案:

A

D明显是字符串

C明显不是char型

B因为后面的数字是double型

用下列代码替换程序标注的【代码】会导致编译错误的是（ ）

public class E{

public static void main(String [] args){

int m = 10, n = 0;

while([代码]){

​ n++;

}

}

}

• A. m–>0
• B. m++>0
• C. m=0
• D. m>100&&true

正确答案:

C

对于Test.java，下列叙述正确的是（ ）

public class Test{

public static void main(String [] args){

boolean boo = false; if(boo = true){

System.out.println(“hello”);

System.out.println(“你好”);

}

else{

System.out.println(“OK”);

System.out.println(“yes”);

} }}

• A. 出现编译错误
• B. 程序的输出结果是hello你好
• C. 程序输出的结果是ok
• D. 程序输出的结果是okyes

正确答案:

B

这里if里面的是将true赋值给boo，这样就执行了if里的代码。

对于“int n=6789;”，表达式的值为7的是（ ）

• A. n%10
• B. n/10%10
• C. n/100%10
• D. n/1000%10

正确答案:

C

6789/100=67 67取余10=7

用下列代码替换程序标注的【代码】会使程序输出hello的是（ ）public class Test{ public static void main(String [] args){ int m =0; if([代码]){ System.out.println(“您好”); }else{ System.out.println(“hello”); } }}

• A. m–<=0

• B. ++m>0

• C. m++>0

• D. –m<0

  
  正确答案:
  
  C

++m 相当于 ( m = m + 1 )

m++ 相当于 ( tmp = m, m = m + 1, tmp )

下列哪行代码有错误（）

public class Test{

public static void main(String [] args){

byte b = ‘a’; int n = 100;

char c = 65;

b = b;

b = b+1;

}}

• A. byte b = ‘a’;
• B. char c = 65;
• C. b = b;
• D. b = b + 1;

正确答案:

D

计算的时候由于隐式转换，低等级的转换为高等级的，由于1默认int型，b计算的时候成了int型，将int型赋值给byte型报错。

如果改成b+=1，就正确了。

下列哪行代码有错误（）

public class Test{

public static void main(String [] args){

char ch = ‘花’;

byte n = -100;

ch = ch – ch;

n = n;

n = 127;

}}

• A. char ch = ‘花’;
• B. ch=ch – ch;
• C. n = n;
• D. n = 127;

正确答案:

B

两个char型运算时，自动转换为int型，花转换成int型就不能进行加减

下列哪行代码有错误（）

public class Test{

public static void main(String [] args){

int m = 1000; while(m>100){

m = m–;

if(m == 600){

continue;

m++;

}

}

}}

• A. while(m>100)
• B. m = m–;
• C. if(m == 600)
• D. m++

正确答案:

D

如果是m++的话程序就会一直运行下去

填空

写出下列代码的输出结果是( ).

public class E {public static void main(String[] args) {

System.out.println(Byte.MAX_VALUE);}}

正确答案：

(1) 127

byte的范围是-128~127

写出下列代码输出结果为( )

public class E{

public static void main(String[] args) {

int[][] a= {

{1,2,3,4},{5,6},{7,8,9}};

a[2]=a[0];

System.out.println(a[2][0]);}}

正确答案：

(1) 1

将数组的第一位赋值给a2

下列代码是汉字”你”“我””他”在Unicode表中的位置,写出下面代码的运行结果( )

public class OutputData {

public static void main(String[] args) {

char you=‘你’,I=‘我’,him=‘他’;

int a=(int)you,b=(int)I,c=(int)him;

System.out.println(“你在Unicode表中的位置：” + a);

System.out.println(“我在Unicode表中的位置：” + b);

System.out.println(“他在Unicode表中的位置：” + c); } }

正确答案：

(1)

你在Unicode表中的位置：20320

我在Unicode表中的位置：25105

他在Unicode表中的位置：20182

这里相当于是寻找汉字在unicode表中对应的10进制的数字

给出代码运行结果：

public class Test {

public static void main (String args[ ]) {

boolean boo =false; int x = -1;

boo = ((x=10)>9)||((x=100)>99);

System.out.println(boo+“hello”+x); //【代码】 }}

正确答案：

(1) truehello10

这里||是逻辑运算符或的意思，当第一个满足的时候，就不看第二个了。

给出代码的运行结果：

public class Test {

public static void main (String args[ ]) {

boolean boo =false; int x = -1;

boo = ((x=10)>9)|((x=100)>99);

System.out.println(boo+“hello”+x); //【代码】 }}

正确答案：

(1) truehello100

两种逻辑与（&&和&）的运算规则基本相同，两种逻辑或（||和|）的运算规则也基本相同。其区别是：&和|运算是把逻辑表达式全部计算完，而&&和||运算具有短路计算功能。所谓短路计算，是指系统从左至右进行逻辑表达式的计算，一旦出现计算结果已经确定的情况，则计算过程即被终止。

给出代码的运行结果

public class Test {

public static void main (String args[ ]) {

int m = 123; int sum = 0,t = 100;

while(t > 0){

sum = sum+m%10*t;

m = m/10; t = t/10; }

System.out.printf(“%d”,sum); //【代码】 }}

正确答案：

(1) 321

请给出代码的运行结果

public class Test {

public static void main (String args[ ]) {

int m = 0; char ch =‘A’;

switch(ch) {

case 9 :

case ‘a’ : m = m+1;;

​ break;

case ‘A’ : m = m+1;

case 66 : m = m+1;

default: m = m+3; }

System.out.println(m); //【代码】 }}

正确答案：

(1) 5

这里的switch先计算表达式的值，如果表达式的值和某个case后面的常量值相等，就执行该case里的若干个语句，直到碰到break为止

main是Java语言规定的关键字

• A. 对
• B. 错

正确答案:

错

“float area = 1e1;”是错误的float变量声明。

• A. 对
• B. 错

正确答案:

对

这里的声明变量后面必须有f

“byte amount = 128;”是正确的byte型变量声明。

• A. 对
• B. 错

正确答案:

错

-128~127

“int [] a,b;”声明了两个int型一维数组a和b。

• A. 对
• B. 错

正确答案:

对

“int a[],b;”声明了一个int型一维数组a和一个int型变量b。

• A. 对
• B. 错

正确答案:

对

对于”int [][] a={

{1,2,3},{4,5,6,7}};”,a[0].length的值是3,a[1].length的值是4。

• A. 对
• B. 错

正确答案:

对

对于"int a[][]=new int[2][9];",a.length的值是2,a[0].length、a[1].length的值都是9。 

• A. 对
• B. 错

正确答案:

对

定义了两个长度为9的数组，a.length是二维数组的长度，a[0].length、a[1].length都是一维数组的长度

“int a[20];”是正确的数组声明。

• A. 对
• B. 错

正确答案:

错

“boolean yes=TRUE;”是正确的boolean变量声明。

• A. 对
• B. 错

正确答案:

错

应该是小写

表达式10>20-17的结果是1

• A. 对
• B. 错

正确答案:

错

表达式5/2的结果是2

• A. 对
• B. 错

正确答案:

对

逻辑运算符的运算结果是boolean型数据

• A. 对
• B. 错

正确答案:

错

关系运算符的运算结果是int型数据

• A. 对
• B. 错

正确答案:

错

12 = 12是非法的表达式

• A. 对
• B. 错

正确答案:

对

表达式2>8&&9>2的结果为false

• A. 对

• B. 错

  
  正确答案:
  
  对

while（表达式）…语句中的“表达式”的值必须是boolean型数据

• A. 对
• B. 错

正确答案:

对

在while语句的循环体中，执行break语句的结果是结束while语句

• A. 对
• B. 错

正确答案:

对

switch语句中必须有default选项

• A. 对
• B. 错

正确答案:

错

if语句中的条件表达式的值可以是int型数据

• A. 对

• B. 错

  
  正确答案:
  
  错

应该是ture或者flase。表达式”的值必须是boolean型数据

某个case后面的常量值相等，就执行该case里的若干个语句，直到碰到break为止

main是Java语言规定的关键字

• A. 对
• B. 错

正确答案:

错

“float area = 1e1;”是错误的float变量声明。

• A. 对
• B. 错

正确答案:

对

这里的声明变量后面必须有f

“byte amount = 128;”是正确的byte型变量声明。

• A. 对
• B. 错

正确答案:

错

-128~127

“int [] a,b;”声明了两个int型一维数组a和b。

• A. 对
• B. 错

正确答案:

对

“int a[],b;”声明了一个int型一维数组a和一个int型变量b。

• A. 对
• B. 错

正确答案:

对

对于”int [][] a={

{1,2,3},{4,5,6,7}};”,a[0].length的值是3,a[1].length的值是4。

• A. 对
• B. 错

正确答案:

对

对于"int a[][]=new int[2][9];",a.length的值是2,a[0].length、a[1].length的值都是9。 

• A. 对
• B. 错

正确答案:

对

定义了两个长度为9的数组，a.length是二维数组的长度，a[0].length、a[1].length都是一维数组的长度

“int a[20];”是正确的数组声明。

• A. 对
• B. 错

正确答案:

错

“boolean yes=TRUE;”是正确的boolean变量声明。

• A. 对
• B. 错

正确答案:

错

应该是小写

表达式10>20-17的结果是1

• A. 对
• B. 错

正确答案:

错

表达式5/2的结果是2

• A. 对
• B. 错

正确答案:

对

逻辑运算符的运算结果是boolean型数据

• A. 对
• B. 错

正确答案:

错

关系运算符的运算结果是int型数据

• A. 对
• B. 错

正确答案:

错

12 = 12是非法的表达式

• A. 对
• B. 错

正确答案:

对

表达式2>8&&9>2的结果为false

• A. 对

• B. 错

  
  正确答案:
  
  对

while（表达式）…语句中的“表达式”的值必须是boolean型数据

• A. 对
• B. 错

正确答案:

对

在while语句的循环体中，执行break语句的结果是结束while语句

• A. 对
• B. 错

正确答案:

对

switch语句中必须有default选项

• A. 对
• B. 错

正确答案:

错

if语句中的条件表达式的值可以是int型数据

• A. 对

• B. 错

  
  正确答案:
  
  错

应该是ture或者flase。表达式”的值必须是boolean型数据