发表于 | 分类于

控制流程语句

你的源文件中的语句通常情况下是根据出现的顺序从上往下执行的。 不过，控制流程，可以通过使用决策，循环以及分支结构打破这种执行流程，使你程序根据不同的情况执行特定的代码块。该章节描述了Java编程语言所持支的决策语句 (if-then, if-then-else, switch),循环语句(break, continue, return) 以及分支语句 (break, continue, return) 。

发表于 | 分类于

表达式，语句，代码块练习

问题答案

  1. 元素安抚可以用来构建计算值的_。

  2. 表达式是_的核心组件。

  3. 语句可以组织为_.

  4. 以下代码片段是一个_表达式.

    1
    1 * 2 * 3

  5. 语句类似与自然语言中的句子，但是不用句号左结尾，而是 用_ .

  6. 代码块是包含在_内的一组空语句或者多个语句，可以出现在任何允许出现单独代码块的地方

练习答案

区分以下表达式语句的类型:

  • aValue = 8933.234; //
  • aValue++; //
  • System.out.println("Hello World!"); //
  • Bicycle myBike = new Bicycle(); //

答案

阅读全文 »

发表于 | 分类于

表达式，语句，代码块

现在你已经理解了变量和运算符，是时候表现真正的技术了，哦不是时候学习表达式，语句，代码块 expressions, statements, and blocks了.运算符可以用来构成表达式，计算值；表达式时语句的核心部件；语句可以被组织为代码块。

表达式Expressions

表达式 是由变量，运算符，以及方法调用按照Java语言的语法组成的结构，最终球的一个单独的值。已经见到过表达式的例子，参考下面的代码:

1
2
3
4
5
6
7
int cadence = 0;
anArray[0] = 100;
System.out.println("Element 1 at index 0: " + anArray[0]);
int result = 1 + 2; // result is now 3
if (value1 == value2) 
    System.out.println("value1 == value2");

表达式返回值的数据类型取决于表达式使用的元素。表达式 cadence = 0 返回 int 因为赋值运算符返回其左边的操作因子相同的数据类型；再本例中, cadence 是一个int. 就像你看到的其他表达式一样，表达式也可以返回其他数据类型的值，例如 boolean 或者 String.

Java编程语言允许你使用各种各样的小表达式作为一小部分来构建混合表达式，只要数据类型取其他部分匹配。下面是一个混合表达式的例子：

1
1 * 2 * 3

在这个特定的例子里，表达式计算的顺序并不重要，以为乘法计算的结果不依赖计算顺序，结果始终一致，不管你如何计算。然而，并不是所有的表达式都不需要考虑顺序。例如，以下表达式，你先计算加法或者除法得到的结果时不一样的:

1
x + y / 100    // ambiguous有歧义

你可以使用小括号(和)来严格区分表达式的执行顺序。例如：想要让上面的表达式无歧义，你可以这样写：

1
(x + y) / 100  // unambiguous, recommended无歧义，推荐

如果你没有明确的指示运算符的运算顺序,则运算顺序由运算符默认的优先级来确定。拥有更高优先级的运算符，将会有限运算。例如：除法比加法拥有更高的优先级。因此以下两个表达式的运算结果时一样的：

1
2
x + y / 100 
x + (y / 100) // unambiguous, recommended

当书写复合表达式时，用小括号明确指示那一个运算符先进行计算。这么做可以时代码更加易读和易于管理。

语句Statements

语句可以大致理解为自然语言中的句子。一个语句勾构成了一个完整的执行单元。以下类型的表达式以 (;)分号结束可以组成语句。

  • 赋值表达式Assignment expressions
  • 自增自减符号的运用Any use of ++ or --
  • 方法的调用Method invocations
  • 创建对象表达式Object creation expressions

这些语句被成为表达式语句expression statements. 以下时一些表达式语句的例子。

1
2
3
4
5
6
7
8
// assignment statement 赋值语句
aValue = 8933.234;
// increment statement 自增语句
aValue++;
// method invocation statement 方法调用语句
System.out.println("Hello World!");
// object creation statement 创建对象语句
Bicycle myBike = new Bicycle();

除了表达式语句之外，还有另外两种语句：声明语句，和控制流程语句（ declaration statements and control flow statements）. 声明语句声明一个变量，你已经见过很多例子:

1
2
// declaration statement
double aValue = 8933.234;

最后，控制流程语句控制语句被执行的规则。下一章节你将会学到更多控制流程相关的内容Control Flow Statements.

代码块Blocks

代码块是包含在花括号内的一组空语句或者多个语句，可以出现在任何允许出现单独代码块的地方。以下是代码块的示例代码, BlockDemo:

1
2
3
4
5
6
7
8
9
10
11
class BlockDemo {
     public static void main(String[] args) {
          boolean condition = true;
          if (condition) { // begin block 1
               System.out.println("Condition is true.");
          } // end block one
          else { // begin block 2
               System.out.println("Condition is false.");
          } // end block 2
     }
}

发表于 | 分类于

运算符总结Summary of Operators

一下快速参考总结了Java编程语言所支持的运算符。

赋值运算符

1
=     赋值 Simple assignment operator

数学运算符

1
2
3
4
5
6
+       加法/字符串链接Additive operator (also used
        for String concatenation)
-       减法Subtraction operator
*       乘法Multiplication operator
/       除法Division operator
%       取余数Remainder operator

一元运算符

1
2
3
4
5
6
7
8
9
10
11
+       一元正号操作，可省略Unary plus operator; indicates
        positive value (numbers are 
        positive without this, however)
-       一元负号操作，取相反数Unary minus operator; negates
        an expression
++      自增操作，表达式值增加1.Increment operator; increments
        a value by 1
--      自减操作，表达式值减少1.Decrement operator; decrements
        a value by 1
!       逻辑否操作，取反。Logical complement operator;
        inverts the value of a boolean

相等及关系运算

1
2
3
4
5
6
==      等于Equal to
!=      不等于Not equal to
>       大于Greater than
>=      大于等于Greater than or equal to
<       小于Less than
<=      小于等于Less than or equal to

条件运算Conditional Operators

1
2
3
4
&&      条件与运算Conditional-AND
||      条件或运算Conditional-OR
?:      三木运算Ternary (shorthand for 
        if-then-else statement 简便的if-then-else形式)

类比较运算Type Comparison Operator

1
2
instanceof      将一个对象与具体的类，接口比较Compares an object to 
                a specified type

位运算与位移运算Bitwise and Bit Shift Operators

1
2
3
4
5
6
7
~       一元补码运算Unary bitwise complement
<<      有符号左位移Signed left shift
>>      有符号右位移Signed right shift
>>>     无符号右位移Unsigned right shift
&       位与运算Bitwise AND
^       位异或运算Bitwise exclusive OR
|       位或运算Bitwise inclusive OR

发表于 | 分类于

运算符问题与练习

问题

  1. 观察以下代码片段.

    1
    arrayOfInts[j] > arrayOfInts[j+1]

    包含了那些运算符?

  2. 观察以下代码片段.

    1
    2
    int i = 10;
    int n = i++%5;
    1. 代码执行以后 i 和 n 的值应该是什么?
    2. 如果用前置自增操作符(++i))，取代后置自增操作符 (i++), i and n 的最终值应该是什么?

  3. 为了反转一个boolean, 应该使用哪一个操作符?

  4. 哪一个运算符是位了比较两个对象的值, = 还是 == ?

  5. 解释后面的代码片段: result = someCondition ? value1 : value2;

练习

  1. 将一下代码改变位符合运算符为变量赋值:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    class ArithmeticDemo {
         public static void main (String[] args){
              
              int result = 1 + 2; // result is now 3
              System.out.println(result);
              result = result - 1; // result is now 2
              System.out.println(result);
              result = result * 2; // result is now 4
              System.out.println(result);
              result = result / 2; // result is now 2
              System.out.println(result);
              result = result + 8; // result is now 10
              result = result % 7; // result is now 3
              System.out.println(result);
         }
    }

  2. 以下代码中，解释 “6”为什么被打印了两次:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    class PrePostDemo {
        public static void main(String[] args){
            int i = 3;
            i++;
            System.out.println(i);    // "4"
            ++i;                     
            System.out.println(i);    // "5"
            System.out.println(++i);  // "6"
            System.out.println(i++);  // "6"
            System.out.println(i);    // "7"
        }
    }
阅读全文 »

发表于 | 分类于

位运算与位移运算Bitwise and Bit Shift Operators

Java编程语言同样提供了完整的位运算以及位移运算运算符。因为本节所讨论的运算符并不常用。因此简单介绍，目的只是为了让你意识到这些运算符的存在。

一元位运算符补码运算 “~“ 反转一个位的形式；可以用于任意一个整形类型，将每一个“0”变为“1”，将每一个“1”变为“0”。例如，一个byte包含8位；将该操作符应用到形如”00000000”的值将得到 “11111111”.

有符号的左位移运算符 “<<“ 将一个位组向左移动，有符号的右位移运算付”>>“将一个位组向右移动。位组为运算符左边的操作因子， 移动位置的数目为运算符右边的操作因子。无符号的右位移运算符 “>>>“ 在最左的位置上加入一个0，而 ">>" 之后的最左位置则要取决于符号的扩展。

位运算 &符号表示 位与运算。

位运算 ^符号表示位异或运算。

位运算 |符号表示位或运算。下面的程序, BitDemo, 使用的位与运算并且将结果打印了出来.

1
2
3
4
5
6
7
8
class BitDemo {
    public static void main(String[] args) {
        int bitmask = 0x000F;
        int val = 0x2222;
        // prints "2"
        System.out.println(val & bitmask);
    }
}

发表于 | 分类于

相等，关系，条件运算符

相等以及关系运算符

相等以及关系运算符确定一个运算银子是大于，小于，等于，或者不等于另一个。这些操作符大多数你可能都看起来很熟悉。注意判断两个原始值是否相等的时候一定要使用 “==“, 而不是 “=“.

1
2
3
4
5
6
==      equal to
!=      not equal to
>       greater than
>=      greater than or equal to
<       less than
<=      less than or equal to

下面的程序 ComparisonDemo,测试了比较操作符:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class ComparisonDemo {
    public static void main(String[] args){
        int value1 = 1;
        int value2 = 2;
        if(value1 == value2)
            System.out.println("value1 == value2");
        if(value1 != value2)
            System.out.println("value1 != value2");
        if(value1 > value2)
            System.out.println("value1 > value2");
        if(value1 < value2)
            System.out.println("value1 < value2");
        if(value1 <= value2)
            System.out.println("value1 <= value2");
    }
}

输出结果:

1
2
3
value1 != value2
value1 <  value2
value1 <= value2

条件运算符

运算符 && 和 || 代表了两个布尔表达式的逻辑与和逻辑或运算。这两个操作符都表现”短路”行为，意味着第二个操作因子仅在试用的时候才进行计算。

1
2
&& Conditional-AND
|| Conditional-OR

下面程序, ConditionalDemo1, 测试了操作因子:

1
2
3
4
5
6
7
8
9
10
11
class ConditionalDemo1 {
    public static void main(String[] args){
        int value1 = 1;
        int value2 = 2;
        if((value1 == 1) && (value2 == 2))
            System.out.println("value1 is 1 AND value2 is 2");
        if((value1 == 1) || (value2 == 1))
            System.out.println("value1 is 1 OR value2 is 1");
    }
}

另外一个条件运算符 ?:, 可以看作是 if-then-else (在控制流程部分讨论 )语句块的简写 .该操作符也被称为三元运算符因为他使用了三个操作因子。下面的例子中，该操作符可以读作: “如果 someCondition 是 true, 将 value1 的值赋给result. 否则的话，将 value2 的值赋值给 result.”

下面的程序, ConditionalDemo2, 测试了三元运算符?: :

1
2
3
4
5
6
7
8
9
10
11
12
class ConditionalDemo2 {
    public static void main(String[] args){
        int value1 = 1;
        int value2 = 2;
        int result;
        boolean someCondition = true;
        result = someCondition ? value1 : value2;
        System.out.println(result);
    }
}

因为 someCondition 是 true,这个程序打印了 “1” . 使用 ?: 运算符代替 if-then-else 语块可以使你的代码可读性更高; 例如当表达式比较紧凑又没有附加结果（赋值的时候）.

类型对照运算符instanceof

instanceof运算符那一个对象与具体的类进行对比。你可以使用它来测试对象是否是某个类的实例，是否是子类的实例，或者是否为实现了某个结构的类的实例。

下面的程序 InstanceofDemo,定义了一个父类 (类名 Parent),一个简单的接口 (接口名 MyInterface), 以及一个继承了父类并实现了接口的子类 (类名 Child) .

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
class InstanceofDemo {
    public static void main(String[] args) {
        Parent obj1 = new Parent();
        Parent obj2 = new Child();
        System.out.println("obj1 instanceof Parent: "
            + (obj1 instanceof Parent));
        System.out.println("obj1 instanceof Child: "
            + (obj1 instanceof Child));
        System.out.println("obj1 instanceof MyInterface: "
            + (obj1 instanceof MyInterface));
        System.out.println("obj2 instanceof Parent: "
            + (obj2 instanceof Parent));
        System.out.println("obj2 instanceof Child: "
            + (obj2 instanceof Child));
        System.out.println("obj2 instanceof MyInterface: "
            + (obj2 instanceof MyInterface));
    }
}
class Parent {}
class Child extends Parent implements MyInterface {}
interface MyInterface {}

输出结果:

1
2
3
4
5
6
obj1 instanceof Parent: true
obj1 instanceof Child: false
obj1 instanceof MyInterface: false
obj2 instanceof Parent: true
obj2 instanceof Child: true
obj2 instanceof MyInterface: true

使用的 instanceof 运算符的时候, 注意 null不是任何类的实例.

发表于 | 分类于

赋值，算术，一元运算Assignment, Arithmetic, and Unary Operators

简单的赋值操作The Simple Assignment Operator

你会碰到最常用的赋值运算符之一是”=“.你再Bicycle类中看到过；它将右边的值分配给左边的运算对象:

1
2
3
int cadence = 0;
int speed = 0;
int gear = 1;

该运算符同样适用于对象来指定对象引用,创建对象章节中中会讨论到。

算术运算符The Arithmetic Operators

Java编程语言提供了加减乘除运算符。你可以通过基础数学运算中对应的运算符号来识别他们。唯一一个新符号是”%“,用来一个数除以另一个数之后的余数作为它的结果。

Operator Description
+ 加法运算 (同样用于字符串连接)
- 减法运算
* 乘法运算
/ 除法运算
% 取模运算
阅读全文 »

发表于 | 分类于

运算符Operators

现在你已经学习了如何声明和初始化变量，或许你想知道如何对他们做些什么。学习Java编程语言的运算符是一个开始的好地方。运算符是特殊的符号，用来对一个，两个，或者三个运算对象进行特殊的操作人后返回一个结果。

当我们探索Java编程语言的运算符时，提前制动哪一个运算符具有更高的优先级或许会有帮助。下面列表中的运算符时根据优先级的顺序列出的。靠近上面出现的运算符具有更高的优先级。优先级较高的运算符会在相对级别较低的运算符之前计算。出现在同一行的运算符优先级相等。当相同优先级的运算符出现在同一个表达式中，规则必须规定哪一个先进行计算。所有的二元运算符除了赋值运算符都是从左向右计算；赋值运算符从右向左计算。

Operators/运算符 Precedence/优先级
postfix 后缀运算符 *expr*++ *expr*--
unary 一元运算符 ++*expr* --*expr* +*expr* -*expr* ~ !
multiplicative 乘法运算 * / %
additive 加减运算 + -
shift 位移运算 << >> >>>
relational 关系运算 < > <= >= instanceof
equality 等式运算 == !=
bitwise AND 位运算与 &
bitwise exclusive OR 位运算异或 ^
bitwise inclusive OR 位运算或 |
&&
logical OR 逻辑或 ||
ternary 三元运算符 ? :
assignment 赋值运算符 = += -= *= /= %= &= ^= |= <<= >>= >>>=

一般在编程中，某些运算符比其他一些出现的更加频繁；例如，赋值运算符=比无符号右位移运算符>>>要常见的多.因此在接下来的讨论中，将先关注更可能在基本常规中使用的的运算符，结尾的时候再介绍不太常用的。每一部分附有可以编译运行的代码，学习这些程序的输出可以加深理解。

发表于 | 分类于

问题与练习

问题

  1. 术语“实例变量”是非 ? 的另一种叫法。
  2. 术语“类变量”是 ? 的两一种叫法。
  3. 局部变量存储了临时的状态；它是在 ? 里声明的。
  4. 在方法的左括号和右括号里面声明的变量叫做 ?。
  5. Java编程预言的八种基本数据类型是 ?
  6. 字符串类型的数据由 java.lang.String 类表示。
  7. ?是持有固定数量的单一逐句类型值的容器对象。

练习

  1. 创建一个小项目定义一些fields。试着创建一些不合法的字段名，观察编译器产生的错误类型。使用命名规则与约定作为指导。
  2. 在练习1中创建的项目，试着不初始化fields的值而打印他们。对局部变量尝试同样的操作观察会产生什么类型的编译错误。熟悉常见的编译错误会使你更容易发现程序中的bug。

答案

阅读全文 »