JAVA语言基础知识

最新推荐文章于 2023-03-03 02:14:48 发布
最新推荐文章于 2023-03-03 02:14:48 发布
阅读量242 收藏 1
点赞数 1
分类专栏： # JAVA 文章标签： 数据类型 控制流程语句 Java语言基础 变量

语言基础知识

变量（variable）

在前面的课程中我们知道对象将它的状态存储在字段（fields）中:

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

什么是对象的讨论中给大家引入了字段（fields），但是你们还可能仍有一些问题，例如：字段命名的规范和约定是什么？除了int，还有其他什么的数据类型？字段声明的时候需要赋予初始值么？假如字段声明时不赋初值那系统会自动赋予默认值么？在本章节中我们将讨论这些问题，但在讨论之前我们需要意识到一些专业术语之间的区别。在Java编程语言中，术语”field“、”variable“都用到过，这是一些编程新手困惑的来源，因为它们似乎指代同一样东西。

Java编程语言定义了一下几种类型的变量：

  • 实例变量（非静态字段）。从技术上讲，对象将它们各自的状态存储在非静态字段（Non-Static Fields）中,也就是说字段的声明不加static关键字。非静态字段是人们所熟知的实例变量（Instance Variables），因为由同一个类创建出来的不同实例（对象）的成员属性（Fields values）是不同的。如一个自行车对象的currentSpeed与其他自行车对象的是无关的。
  • 类变量（静态字段）。任何字段在声明时用静态（static）修饰词修饰的都是类变量（class variables）,这是在告诉编译器，无论对某个类进行实例化多少次，该变量仅存一份（there si exactly one copy of this variable in existence）。例如代码static int numGears = 6,意思是说某个自行车类所创建的自行车对象都是6个档位的。此外用关键字final修饰将表示Gears的数量将不会改变。
  • 本地变量（Local Variables）。这类似对象将状态存储于字段中，一个方法经常在本地变量中存储临时状态。声明一个本地变量和声明一个字段很类似（如，int count = 0）。没有一特殊的关键字来置顶一个变量为本地变量，决定因素完全来自变量所处的位置——方法的{}之间。像这样，本地变量只在方法内部可见，类内其他地方是无法访问到的。
  • 参数（Parameters）。例如public static void main(String[] args)中的args就是main方法的参数。应该记住的最重要事情是参数（parameters）最会被归类为变量（variables）而不是字段（field）。

偶尔你也可能看到在文章中用到“成员”这个词。类型的字段、方法和嵌套类型统称其为成员。

命名（Naming）

每种编程语言都有它自己的一堆命名规则和约定，Java编程亦是如此。变量的命名的约定和规则如下：

  • 变相是大小写敏感的。变量的命名要遵循regex=\^[a-zA-Z|$|_][a-zA-Z0-9],即以大小写字母或下划线或美元符号开始，组成元素为数字和字母，下划线和美元符号。一般不建议变量中包含美元符号、下划线。
  • 变量的子集仍是数字、字母、下划线和美元符号。命名最好不是单词的缩写以便易于维护和阅读。要注意的是变量命名不能是保留字或者关键字。
  • 如果组成变量的名称只包含一个单词，最好将它拼成小写形式。如果变量名称有多个单词，那么除第一单词的首字母小写外，确保每个单词的首字母大写，即驼峰命名法。如果是常量则应全为大写字母，如果常量由多个单词构成，单词之间用下划线连接，如static final int NUM_GEARS=6.

原始数据类型（Primitive Data Types）

Java语言是静态语言，这意味着变量要使用之前须得先声明。这涉及到声明变量的类型和名称，例如：
int gears = 1;

这样做是告诉你的程序，存在这样一个字段”gears“，它存放数值数据，初始值为1.变量的数据类型决定了它可能存储的值以及可执行的操作。除了int类型，Java编程语言提供了其他7种原始数据类型。这八种原始数据类型是：

名称说明
byte8位有符号补码整数,范围为[-2^7 ,2^7-1]。由于它占用内存空间小，在大型数组应用场景中使用很有意义。
short16位有符号补码整数,范围为[-2^{15} ,2^{15}-1]。由于它占用内存空间小，在大型数组应用场景中使用很有意义。
int32位有符号补码整数,范围为 [-2^{31} ,2^{31}-1].
long64位有符号补码整数,范围为 [-2^{63} ,2^{63}-1].
float单精度32位,用float而不是double可省很多内存。
double双精度64位,用float而不是double可省很多内存。
boolean只有两种可能的值：true或者false。它占用的内存大小没有精确定义。
char16位Unicode字符，范围为[‘\u0000’,’\uffff’]

除以上八种原始数据类型之外，Java编程语言通过java.lang.String提供了字符串。把字符串放在”“之内即可自动创建String对象，如String s = “this is a String”;String对象是不可变（immutable）的，意味着一旦创建将不可改变。

默认值（Default values）

声明一个字段时赋予一个值不总是必要的。字段声明时不初始化编译器将会赋予一个合理的默认值，默认值将会是0或者null,至于是什么将取决于数据类型。下面是各种数据类型对应的模式值：

数据类型默认值（对于字段而已）
byte0
short0
int0
long0L
float0.0f
double0.0d
char‘\u0000’
String(or any object)null
booleanfalse

备注：局部变量有些特殊。编译器绝不会为未初始化的局部变量赋予默认值。当你不能在声明局部变量时初始化它，确保在使用它之前进行赋值。假如访问未初始化的局部变量时，编译器会报错。

public void test(){
 int count;
 System.out.println(a);
}

将会报错：variable count might not have been initialized
字面量（Literals）

你也许注意到初始化一个原始数据类型的变量是不需要new关键字的。原始类型是内置于语言中的特殊数据类型，它们不是从类中创建而来的对象。字面量是代表固定值的源码，即是说字面量的值直接就是源码所显示的那样，不需要通过任何计算。

数组（Arrays）

数组是一个容器对象（container object），它保存单一类型的数据。当数组创建时，它的长度就固定了。

包含10个元素的数组

数组内的每一项内容被称为元素（Element）,通过数字索引访问它们。如上图所示，索引从0开始，以9结束。

class ArrayDemo {
    public static void main(String[] args) {
        // declares an array of integers
        int[] anArray;

        // allocates memory for 10 integers
        anArray = new int[10];

        // initialize first element
        anArray[0] = 100;
        // initialize second element
        anArray[1] = 200;
        //...
        //print the first item in this array
        System.out.println("Element at index 0: "+ anArray[0]);
        System.out.println("Element at index 1: "+ anArray[1]);
        //...
    }
} 
The output from this program is:

Element at index 0: 100
Element at index 1: 200
//...
声明一个变量来引用数组（declaring a variable to refer to an Array）

上面一个例子声明的数组的方式如下：

// declares an array of integers
int[] anArray;

和声明其他类型的变量一样，声明数组也由两部分组成：数组的类型和数组的名称。数组的类型写成type[],type指的是数据存放的数据类型。[]括号表明变量持有一个数组。和其他变量类型一样，声明不会实际创建一个数组，这仅仅简单地告诉编译器这个变量将存放某种类型的数据。类似地，你可以用其他类型声明一个数组：

byte[] anArrayOfBytes;
short[] anArrayOfShorts;
long[] anArrayOfLongs;
float[] anArrayOfFloats;
double[] anArrayOfDoubles;
boolean[] anArrayOfBooleans;
char[] anArrayOfChars;
String[] anArrayOfStrings;

当然你也可以那么声明：

// this form is discouraged
float anArrayOfFloats[];
创建，初始化以及访问数组（creating，initializing,and accessing an Array）

使用new操作来创建一个数组。

// create an array of integers
anArray = new int[10];

接下来几行是给数组赋值：

anArray[0] = 100; // initialize first element
anArray[1] = 200; // initialize second element
anArray[2] = 300; // and so forth

访问数组是通过数字索引：

System.out.println("Element 1 at index 0: " + anArray[0]);
System.out.println("Element 2 at index 1: " + anArray[1]);
System.out.println("Element 3 at index 2: " + anArray[2]);

当然，你可以用以下方式来创建以及初始化一个数组：

int[] anArray = { 
    100, 200, 300,
    400, 500, 600, 
    700, 800, 900, 1000
};

数组的大小取决于里面元素的个数。

你也可以通过使用多个[]定义多维数组，比如String[][] name.

class MultiDimArrayDemo {
    public static void main(String[] args) {
        String[][] names = {
            {"Mr. ", "Mrs. ", "Ms. "},
            {"Smith", "Jones"}
        };
        // Mr. Smith
        System.out.println(names[0][0] + names[1][0]);
        // Ms. Jones
        System.out.println(names[0][2] + names[1][1]);
    }
}

//The output from this program is:

Mr. Smith
Ms. Jones
拷贝数组（Copying Arrays）
class ArrayCopyDemo {
    public static void main(String[] args) {
        char[] copyFrom = { 'd', 'e', 'c', 'a', 'f', 'f', 'e',
                'i', 'n', 'a', 't', 'e', 'd' };
        char[] copyTo = new char[7];

        System.arraycopy(copyFrom, 2, copyTo, 0, 7);
        System.out.println(new String(copyTo));
    }
}

//The output from this program is:

caffein
操作数组（Array Manipulations）

在编程中，数组是一个有力而有用的概念。Java SE提供了对数组的一些常见操作，例如拷贝、搜索、排序等。这些操作是类java.util.Arrays提供的。

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

        char[] copyFrom = {'d', 'e', 'c', 'a', 'f', 'f', 'e',
            'i', 'n', 'a', 't', 'e', 'd'};

        char[] copyTo = java.util.Arrays.copyOfRange(copyFrom, 2, 9);

        System.out.println(new String(copyTo));
    }
}
关于变量的小结

Java语言术语库中包含 “fields” 和 “variables”.

  1. 同一类的不同实例，其Instance variables (non-static fields) 是不同的.
  2. 字段声明时用static修饰词修饰的是Class variables (static fields); 无论类被实例化多少遍class variable只存在一份. 3. 局部变量在方法内部存放临时状态.
  3. 参数是提供给方法额外信息的变量（variable）。局部变量和参数总被归成 “variables” (而不是 “fields”).

当为字段和变量命名时，需要遵循一定的约定和规则。

  • 八种原始数据类型是: byte, short, int, long, float, double, boolean, and char. java.lang.String类代表字符串。
  • 编译器会为以上提高的数据类型赋予合理的默认值;然而，对于本地变量（局部变量）来说，默认值将不会被赋予.
  • 字面量是源码所代表的固定的值，不需计算即可得出.数组是存储单一类型的变量，数组一旦创建，其长度将不会改变。

操作符（operators）

你已经学会了如何声明和初始化变量后，你可能想使用它们。学习Java编程怨言是一个好的起始点。运算符是在一个、两个或者三个操作数（operands）上执行具体操作的符号（symbol）。

在探索Java编程语言的操作符时，预先知道哪些运算符具有最高优先权（highest precedence）是非常有帮助的。下标所列举的运算符是按照优先权排序的，越靠近表格顶端的运算符具有越高的优先权。优先权更高的运算符先于优先权更低的执行。同一行的运算符具有同等的优先权，这时应该制定一个谁先执行的规则。除赋值运算符外，所有的运算符都是从左到右计算值；赋值运算符从右向左计算值。

运算符（Operators）优先权（Precedence）
postfix:后缀expr++ expr–
unary:一元的++expr –expr +expr -expr ~ !
multiplicative:乘法* / %
additive:加法+ -
shift:移位<< >> >>>
relational:相关的< > <= >= instanceof
equality:相等== !=
bitwise AND:按位与&
bitwise exclusive OR:异或^
bitwise inclusive OR:或‘|’ 没有引号，因为|是markdown关键字，须得转义
logical AND :逻辑与&&
logical OR：逻辑或‘||’,没有引号，因为|是markdown关键字，须得转义
ternary:三元的? :
assignment:赋值= += -= *= /= %= &= ^=

在通用（general-purpose）编程中，某些运算符使用更频繁些；例如赋值运算符”=”比无符号又移运算符”>>>”更加常见。考虑到这一点，在接下来的讨论中将重点关注常用的运算符，最后才转向不常见的运算符。每一次讨论都附上代码，研究他们的输出内容将有助于你刚学的知识。

赋值、算术、一元操作符

最简单的赋值运算符
最常见的运算符就是赋值运算符”=”，它将右边的值赋给左边的操作数（operand）:
int cadence = 0;
赋值运算符也可以用于给对象赋予对象引用。

算术运算符
Java编程语言提供了加（addition）、减（subtraction）、乘（multiplication）、和除（division）运算符。这些运算符你在基础数学上已经学过，但是”%”你可能感到陌生，这个运算符是将操作数除某个数然后返回其余数的意思。

运算符描述
+加运算符（用于字符串则是连接操作（concatenation））
-减运算符
*乘运算符
-除运算符
%除留余数运算符

下面的类ArithmeticDemo测试以上的运算符：

class ArithmeticDemo {

    public static void main (String[] args) {

        int result = 1 + 2;
        // result is now 3
        System.out.println("1 + 2 = " + result);
        int original_result = result;

        result = result - 1;
        // result is now 2
        System.out.println(original_result + " - 1 = " + result);
        original_result = result;

        result = result * 2;
        // result is now 4
        System.out.println(original_result + " * 2 = " + result);
        original_result = result;

        result = result / 2;
        // result is now 2
        System.out.println(original_result + " / 2 = " + result);
        original_result = result;

        result = result + 8;
        // result is now 10
        System.out.println(original_result + " + 8 = " + result);
        original_result = result;

        result = result % 7;
        // result is now 3
        System.out.println(original_result + " % 7 = " + result);
    }
}

This program prints the following:

1 + 2 = 3
3 - 1 = 2
2 * 2 = 4
4 / 2 = 2
2 + 8 = 10
10 % 7 = 3

可以将算术运算符和赋值运算符组合（combine）起来，以实现复合赋值（compound assignments），如x += 1.
+运算符用在字符串，则是拼接，如：

class ConcatDemo {
    public static void main(String[] args){
        String firstString = "This is";
        String secondString = " a concatenated string.";
        String thirdString = firstString+secondString;
        System.out.println(thirdString);
    }
}

output
This is a concatenated string.

一元（unary）运算符
一元运算符只需要一个操作数；它们执行自增一、自减一、否定一个表达式（-1）、布尔值（!true）取反等操作。

运算符描述
+加运算符，表明是正数（正数前加不加+都是一样的效果）
-减运算符，否定一个表达式
++自增一运算符
–自减一运算符
！逻辑运算符，反转一个boolean值

UnaryDemo类测试一元运算符：

class UnaryDemo {

    public static void main(String[] args) {

        int result = +1;
        // result is now 1
        System.out.println(result);

        result--;
        // result is now 0
        System.out.println(result);

        result++;
        // result is now 1
        System.out.println(result);

        result = -result;
        // result is now -1
        System.out.println(result);

        boolean success = false;
        // false
        System.out.println(success);
        // true
        System.out.println(!success);
    }
}

自增一和自减一可以放在操作数的前面也可以放于后面。区别是++result计算结果是result自增一，而result++计算结果是result本身。下面请看例子：

class PrePostDemo {
    public static void main(String[] args){
        int i = 3;
        i++;
        // prints 4
        System.out.println(i);
        ++i;               
        // prints 5
        System.out.println(i);
        // prints 6
        System.out.println(++i);
        // prints 6
        System.out.println(i++);
        // prints 7
        System.out.println(i);
    }
}

等式、关系、条件运算符

等式（Equality）和条件（Relational）运算符
等式和条件运算符表明一个操作数是否大于、小于、等于、或不等于另一个操作数。注意测试两个原始数据类型的变量是否相等是用”==”而不是”=”.

运算符描述
==equal to
!=not equal to
>greater to
>=greater than　or equal to
<less than
<=less than or equal to

如：

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");
    }
}
Output:

value1 != value2
value1 <  value2
value1 <= value2

条件运算符（conditional operators）

运算符描述
&&条件与：Conditional-And
||条件或：Conditional-OR

这两个运算符具有短路（short-circuiting）特征，意味着第二个操作数的估算不一定会进行，而是在需要的时候才执行。

class ConditionalDemo1 {

    public static void main(String[] args){
        int value1 = 1;
        int value2 = 2;
        if((value1 == 1) && (value2 == 2))  //只执行value1 == 1，因为已经true了
            System.out.println("value1 is 1 AND value2 is 2");
        if((value1 == 1) || (value2 == 1))  //只执行value1 == 1
            System.out.println("value1 is 1 OR value2 is 1");
    }
}
运算符描述
? :条件运算符；因为需要三个操作数，所以叫三元运算符；可以认为是if-then-else
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);
    }
}

三元运算符好处就是可读性比if-then-else强，结构紧凑。

比较运算符instanceof

instanceof运算符是将一个对象和另一个具体类型比较。你可以利用它来测试某个对象是否是某个类的实例、是否是某个子类的实例、是否是某个接口实现类的实例。

下面程序，定义了一个父类（Parent.java），一个简单的接口（MyInterface.java）和一个继承父类并实现接口的子类（Child.java）：

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 {}
Output:

obj1 instanceof Parent: true
obj1 instanceof Child: false
obj1 instanceof MyInterface: false
obj2 instanceof Parent: true
obj2 instanceof Child: true
obj2 instanceof MyInterface: true

注意null是所有东西的实例。

移位运算符

运算符描述
&与
|或
~非
^异或
class Test {

    /**
     * Java中，用前置只能表示八进制、十进制、十六进制
     * 前置0：八进制
     * 无任何前置：十进制（decimal）
     * 前置0x或0X: 十六进制（Hexadecimal）
     *
     * @param args
     */
    public static void main(String[] args) {

        int octalNum = 010;//octal八进制 8
        int hexNum = 0X10;//hex十六进制 16
        int num = 10;//十进制
        log("八进制%s转二进制：%s", octalNum, binary(octalNum));
        log("十六进制%s转二进制：%s", hexNum, binary(hexNum));
        log("十进制%s转二进制：%s", num, binary(num));

        log("");

        log("取非：~%s=%s", binary(octalNum), binary(~octalNum));
        log("取或：%s|%s=%s", binary(octalNum), binary(num), binary(octalNum | num));
        log("取与：%s&%s=%s", binary(octalNum), binary(num), binary(octalNum & num));
        log("取异或：%s^%s=%s", binary(octalNum), binary(num), binary(octalNum ^ num));

        log("");
        log("左移2位：%s<<2=%s", binary(num), binary(num << 2));
        log("右位2位：%s>>2=%s", binary(num), binary(num >> 2));
        log("无符号右移2位：%s>>>2=%s", binary(num), binary(num >> 2));
    }

    private static String binary(int num) {
        return Integer.toBinaryString(num);
    }

    public static void log(String format, Object... args) {
        System.out.println(String.format(format, args));
    }
}


output
八进制8转二进制：1000
十六进制16转二进制：10000
十进制10转二进制：1010

取非：~1000=11111111111111111111111111110111
取或：1000|1010=1010
取与：1000&1010=1000
取异或：1000^1010=10

左移2位：1010<<2=101000
右位2位：1010>>2=10
无符号右移2位：1010>>>2=10

表达式，语句，块（expressions,statements,and blocks）

你已经掌握了变量和运算符，现在该是学习表达式、语句和块的时候了。运算符是表达式的组成部分，它扮演者计算的角色；表达式是语句的核心部分；用块来组织语句。

表达式（Expression）

表达式是由变量、运算符、方法调用组成的一个构造（a construct），它的职责是计算一个值。如：

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”返回的是cadence的类型int。和你所看到的一样，表达式也可以返回其它的类型，如表达式”value1 == value2”就是返回boolean。

Java编程语言允许使用许多个不同的表达式来构成一个复合表达式，只要各个子表达式中的计算值相互匹配，如：
1 * 2 * 3

1*2*3这个表达式的顺序无关紧要，因为无论如何调用次序它们的值都是一样的。但是这并不符合所有的表达式，如：

x + y /100 //有歧义

最好用()来精确告知编译器哪个子表达式先运行，如：

(x + y ) /100 //无歧义，建议

这样的话，更加便于维护。

语句

statements大概与自然语言中的句子相同。一个语句是一个完整单元的操作。下面的表达式用分号可以将表达式转换成语句：

  • 赋值表达式
  • 自增/自减操作
  • 方法调用
  • 对象创建

这样的语句叫做表达式语句（expression statements）,下面举一些例子：

// 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）、流语句（flow statements）。声明语句声明一个变量，如：
double aValue = 7843843.343;

块（Block）

将0个或者0个以上的语句放到{}中，就是一个块，如：

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

控制流程语句（Control flow Statements）

源代码内的语句通常是从上到下执行的。然而控制流语句通过使用决策（decision making）、循环和分支来分解执行流，使程序能够有条件地执行特殊的代码块。本节描述决策语句（if-then, if-then-else, switch），循环语句（for,while,do-while），分支语句（break,continue,return）.

if-then 和 if-then-else语句

if-then语句

这是最基本的控制流程语句，假如某个测试条件成立则执行，如Bicycle.java中，自行车移动了才能刹车：

void applyBrakes() {
    // the "if" clause: bicycle must be moving
    if (isMoving){ 
        // the "then" clause: decrease current speed
        currentSpeed--;
    }
}

if-then-else语句

void applyBrakes() {
    if (isMoving) {
        currentSpeed--;
    } else {
        System.err.println("The bicycle has already stopped!");
    } 
}

switch语句

有很多种执行路径的可能，switch接收的参数可以是byte、short、char、int、enumerated types,String和Character、Byte、Short、Integer.如：

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

        int month = 8;
        String monthString;
        switch (month) {
            case 1:  monthString = "January";
                     break;
            case 2:  monthString = "February";
                     break;
           //...
            default: monthString = "Invalid month";
                     break;
        }
        System.out.println(monthString);
    }
}

while 和 do-while语句

区别是，do-while块内的语句至少执行一次。如：

class DoWhileDemo {
    public static void main(String[] args){
        int count = 1;
        do {
            System.out.println("Count is: " + count);
            count++;
        } while (count < 11);
    }
}

for语句

for语句提供一种在一系列值上迭代的紧凑方式。重复循环直到某个终止条件被满足的方式被开发者称为for循环，通常for语句可以描述如下：

for (initialization; termination;  increment) {
    statement(s)
}
- initialization表达式。循环的起始，只运行一次。
- termination表达式：计算出的值为false，循环终止。
- increment表达式：每次迭代，表达式增加一个步长值或者减去一个步长值。

例子：

```java
class ForDemo {
    public static void main(String[] args){
         for(int i=1; i<11; i++){
              System.out.println("Count is: " + i);
         }
    }
}




<div class="se-preview-section-delimiter"></div>

```java
增强for循环(更加紧凑和易读)：

```java
class EnhancedForDemo {
    public static void main(String[] args){
         int[] numbers = 
             {1,2,3,4,5,6,7,8,9,10};
         for (int item : numbers) {
             System.out.println("Count is: " + item);
         }
    }
}




<div class="se-preview-section-delimiter"></div>

分支语句（branching statments）

break 语句

break语句有两种形式：标记和未标记（labeled,unlabeled），可以在for,while,do-while循环中使用。未标记举例如下：

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

        int[] arrayOfInts = 
            { 32, 87, 3, 589,
              12, 1076, 2000,
              8, 622, 127 };
        int searchfor = 12;

        int i;
        boolean foundIt = false;

        for (i = 0; i < arrayOfInts.length; i++) {
            if (arrayOfInts[i] == searchfor) {
                foundIt = true;
                break; //跳出本次循环
            }
        }

        if (foundIt) {
            System.out.println("Found " + searchfor + " at index " + i);
        } else {
            System.out.println(searchfor + " not in the array");
        }
    }
}




<div class="se-preview-section-delimiter"></div>

标记的举例如下：

lass BreakWithLabelDemo {
    public static void main(String[] args) {

        int[][] arrayOfInts = { 
            { 32, 87, 3, 589 },
            { 12, 1076, 2000, 8 },
            { 622, 127, 77, 955 }
        };
        int searchfor = 12;

        int i;
        int j = 0;
        boolean foundIt = false;

    search:
        for (i = 0; i < arrayOfInts.length; i++) {
            for (j = 0; j < arrayOfInts[i].length;
                 j++) {
                if (arrayOfInts[i][j] == searchfor) {
                    foundIt = true;
                    break search; //不加search，则只能跳出内层循环
                }
            }
        }

        if (foundIt) {
            System.out.println("Found " + searchfor + " at " + i + ", " + j);
        } else {
            System.out.println(searchfor + " not in the array");
        }
    }
}

continue语句

提过本次循环，直接进入下次循环。

return语句
两种形式，一种是return;另一种是return result;

Taking_fish
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
5、运算符
hewenqing
12-11 320
Java运算符分成以下几组： 算术运算符 关系运算符 逻辑运算符 赋值运算符 其他运算符 5.1、算术运算符 操作符 描述 + 加法: 相加运算符两侧的值 - 减法: 左操作数减去右操作数 * 乘法: 相乘操作符两侧的值 / 除法: 左操作数除以右操作数 % 取余: 左操作数除以右操作数的余数 ++ 自增: 操作数的值增加1 ...
JAVA语言基础
qq_42940609的博客
01-25 853
1. java开发环境 编译运行过程： - 编译期：.java源文件，经过编译，生成.class字节码文件 - 运行期：JVM加载.class并运行.class(0和1) > 特点：跨平台、一次编译到处使用 名词解释： JVM：java虚拟机 ​ 加载.class并运行.class JRE：java运行环境 ​ 除了包含JVM以外还包含了运行java程序所必须的环境 ​ JRE = JVM+java系统类库(小零件) JDK：
单目运算符、双目运算符
ybkybkybk的博客
06-19 1万+
单目运算符、双目运算符1、单目运算符在运算中只要1个数字参与运算的叫单目运算。 只有一个操作数。 例子： 逻辑非运算符【!】、按位取反运算符【~】、自增自减运算符【++ –】、负号运算符【-】、类型转换运算符【(类型)】、指针运算符和取地址运算符【*和&】、长度运算符【sizeof】这些是单目运算符2、双目运算符在运算过程中需要2个数字参与运算的,叫做双目运算。 有两个操作数。 例子： 双目运算
C语言中的单目运算符，双目运算符与三目运算符
热门推荐
qq_18671205的博客
09-06 2万+
单目运算符：只有一个操作数，例如： 逻辑非运算符【!】、按位取反运算符【~】、自增自减运算符【++ --】、负号运算符【-】、类型转换运算符【(类型)】、指针运算符和取地址运算符【*和&】、长度运算符【sizeof】这些是单目运算符 双目运算符：有两个操作数，例如： ，+，-，*，/，=，== 等等三目运算符：需要三个操作数，例如： ？： ...
运算符
weixin_44420028的博客
03-04 95
JAVA的运算符，分为四类： 算数运算符、关系运算符、逻辑运算符、位运算符 算数运算符(9)：+ - * / % ++ – 关系运算符(6)：== != &gt; &gt;= &lt; &lt;= 逻辑运算符(6)：&amp;&amp; || ! ^ &amp; | 位运算符(7)：&amp; | ~ ^ &gt;&gt; &lt;&lt; &gt;&g
详解C++最新标准C++0x
sulliy的专栏
01-27 7476
<br />By Ajay Vijayvargiya | <br />Elaborating new C++ language features with a clear, sharp, and detailed discussion.Introduction<br />As you might be aware, the C++ language is being updated by the ISO standard. The codename for the new C++ language is C
JAVA基础语言
2301_76545552的博客
03-03 3076
一、整数类型 整数类型简称整型，用来存储整数数值，即没有小数部分的数值。可以是正整数，也可以是负数。整型数据根据它所占内存大小的不同，可分为byte、short、int和long 4种类型。它们具有不同的取值范围。 1.int型 定义int变量有以下四种语法： int型是java整型值的默认数据类型。当多个尚未运行定义数据类型的整数做运算时，运算的结果将默认为int类型。例如，下面这行代码： 等同于如下代码： 2.byte型 byte型的定义方式与int相同。定义int型变量
java语言基础知识（完整版）.zip
11-01
Java语言基础知识是编程学习的重要部分，它为开发者提供了构建复杂应用程序的基础。这个“java语言基础知识（完整版）.zip”压缩包包含了一份详尽的PDF文档，旨在全面讲解Java编程的核心概念。以下是对这些基础知识...
Java面试基础知识.doc
11-21
"Java面试基础知识" Java 面试基础知识是 Java 开发者在面试时需要了解的基础知识点。以下是 Java 面试基础知识的重要知识点...通过了解这些基础知识点，Java 开发者可以更好地掌握 Java 语言，并更好地完成开发任务。
Java基础知识点总结.docx
04-03
Java是一种广泛使用的面向对象的编程语言，其基础知识涵盖了多个方面，包括语法、面向对象特性、异常处理、多线程、I/O流、网络编程、反射技术、设计模式以及JVM等核心概念。以下是对这些知识点的详细说明： 一、...
java语言基础知识串讲
12-22
在Java语言基础知识串讲中，我们将深入探讨Java的核心概念，包括语法、数据类型、控制结构、类与对象等关键点。 首先，让我们从Java的基础语法开始。Java是一种静态类型的编程语言，这意味着在编写代码时需要声明...
LABVIEW TCP通讯调试助手
07-29
本文接收如何利用Labview的TCP通讯工具做通讯，这里手把手教各位做一个简单的TCP通讯调试助手，可以局域网互相聊天哦！ 具体介绍见下面连接：https://download.csdn.net/download/weixin_41671635/89595897
机器学习与人工智能教程
07-29
机器学习与人工智能教程
零基础入门转录组数据分析-WGCNA(加权基因共表达网络) 配套资源
最新发布
07-29
零基础入门转录组数据分析-WGCNA(加权基因共表达网络) https://blog.csdn.net/weixin_49878699/article/details/140304846 教程配套的原始数据+代码+处理好的数据文件
【创新未发表】Matlab实现引力搜索优化算法GSA-Kmean-Transformer-BiLSTM负荷预测算法研究.rar
07-29
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
原始ISET，用作ISETIO的基础-图像系统工程工具箱-matlab
07-29
原始ISET，用作ISETIO的基础 相机（Cam）的图像系统工程工具箱（ISET）。ISETCam是基础存储库。它包括其他ISET存储库用于表示场景、光学、能量、量子、颜色和软件实用程序的基本例程。ISETCam是运行ISETBio和大多数其他ISET存储库（如ISET3D、ISETAuto、ISETLens）所必需的。 原始ISET的开源版本，用作ISETIO的基础
【创新未发表】Matlab实现能量谷优化算法EVO-Kmean-Transformer-BiLSTM负荷预测算法研究.rar
07-29
1.版本：matlab2014/2019a/2021a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。 5.作者介绍：某大厂资深算法工程师，从事Matlab算法仿真工作10年；擅长智能优化算法、神经网络预测、信号处理、元胞自动机等多种领域的算法仿真实验，更多仿真源码、数据集定制私信+。 替换数据可以直接使用，注释清楚，适合新手
毕业设计，基于Java+Swing+SqlServer开发的图书管理系统，内含完整源代码，数据库，讲解视频
07-29
毕业设计，基于Java+Swing+SqlServer开发的图书管理系统，内含完整源代码，数据库，讲解视频 图书管理系统，是一个由人、计算机等组成的能进行管理信息的收集、传递、加工、保存、维护和使用的系统。利用信息控制企业的行为；帮助企业实现其规划目标。
Java语言基础知识概述
Java 基础知识是指 Java 语言的基本概念、语法和应用，包括 Java 语言的历史、特点、基本语法、变量、数据类型、运算符、控制结构、函数、数组、对象等内容。 Java 语言的历史 Java 语言起源于 Sun 公司的一个叫...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值