1、 Java 变量类型Java 修饰符Java 语言提供了很多修饰符，主要分为以下两类： 访问修饰符 非访问修饰符修饰符用来定义类、方法或者变量，通常放在语句的最前端。我们通过下面的例子来说明：public class className / .private boolean myFlag;static final double weeks = 9.5;protected static final int BOXWIDTH = 42;public static void main(String arguments) / 方法体访问控制修饰符ava 中，可以使用访问控制符来保护对类、变量、方法和构
2、造方法的访问。Java 支持 4 种不同的访问权限。默认的，也称为 default，在同一包内可见，不使用任何修饰符。私有的，以 private 修饰符指定，在同一类内可见。共有的，以 public 修饰符指定，对所有类可见。受保护的，以 protected 修饰符指定，对同一包内的类和所有子类可见。默认访问修饰符-不使用任何关键字使用默认访问修饰符声明的变量和方法，对同一个包内的类是可见的。接口里的变量都隐式声明为 public static final,而接口里的方法默认情况下访问权限为 public。实例：如下例所示，变量和方法的声明可以不使用任何修饰符。String version =
3、 “1.5.1“;boolean processOrder() return true;私有访问修饰符-private私有访问修饰符是最严格的访问级别，所以被声明为 private 的方法、变量和构造方法只能被所属类访问，并且类和接口不能声明为 private。声明为私有访问类型的变量只能通过类中公共的 getter 方法被外部类访问。Private 访问修饰符的使用主要用来隐藏类的实现细节和保护类的数据。下面的类使用了私有访问修饰符：public class Logger private String format;public String getFormat() return this.
4、format;public void setFormat(String format) this.format = format;实例中，Logger 类中的 format 变量为私有变量，所以其他类不能直接得到和设置该变量的值。为了使其他类能够操作该变量，定义了两个 public 方法：getFormat() （返回 format 的值）和 setFormat(String)（设置format 的值）公有访问修饰符-public被声明为 public 的类、方法、构造方法和接口能够被任何其他类访问。如果几个相互访问的 public 类分布在不同的包中，则需要导入相应 public 类所在的包
5、。由于类的继承性，类所有的公有方法和变量都能被其子类继承。以下函数使用了公有访问控制：public static void main(String arguments) / .Java 程序的 main() 方法必须设置成公有的，否则，Java 解释器将不能运行该类。受保护的访问修饰符-protected被声明为 protected 的变量、方法和构造器能被同一个包中的任何其他类访问，也能够被不同包中的子类访问。Protected 访问修饰符不能修饰类和接口，方法和成员变量能够声明为 protected，但是接口的成员变量和成员方法不能声明为 protected。子类能访问 Protected
6、 修饰符声明的方法和变量，这样就能保护不相关的类使用这些方法和变量。下面的父类使用了 protected 访问修饰符，子类重载了父类的 openSpeaker()方法。class AudioPlayer protected boolean openSpeaker(Speaker sp) / 实现细节class StreamingAudioPlayer boolean openSpeaker(Speaker sp) / 实现细节如果把 openSpeaker()方法声明为 private，那么除了 AudioPlayer 之外的类将不能访问该方法。如果把openSpeaker()声明为 publ
7、ic，那么所有的类都能够访问该方法。如果我们只想让该方法对其所在类的子类可见，则将该方法声明为 protected。访问控制和继承请注意以下方法继承的规则： 父类中声明为 public 的方法在子类中也必须为 public。 父类中声明为 protected 的方法在子类中要么声明为 protected，要么声明为 public。不能声明为 private。 父类中声明为 private 的方法，不能够被继承。 非访问修饰符 为了实现一些其他的功能，Java 也提供了许多非访问修饰符。 static 修饰符，用来创建类方法和类变量。 Final 修饰符，用来修饰类、方法和变量，final 修饰
8、的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。 Abstract 修饰符，用来创建抽象类和抽象方法。 Synchronized 和 volatile 修饰符，主要用于线程的编程。Static 修饰符 静态变量：Static 关键字用来声明独立于对象的静态变量，无论一个类实例化多少对象，它的静态变量只有一份拷贝。静态变量也被成为类变量。局部变量不能被声明为 static 变量。 静态方法：Static 关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。静态方法从参数列表得到数据，然后计算这些数据。对类变量和方法的访问可以直接使用 classn
9、ame.variablename 和 classname.methodname 的方式访问。如下例所示，static 修饰符用来创建类方法和类变量。public class InstanceCounter private static int numInstances = 0;protected static int getCount() return numInstances;private static void addInstance() numInstances+;InstanceCounter() InstanceCounter.addInstance();public static
10、 void main(String arguments) System.out.println(“Starting with “ +InstanceCounter.getCount() + “ instances“);for (int i = 0; i 检查左操作数的值是否大于右操作数的值，如果是那么条件为真。 （A B）非真。= 检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真。 （A = B）为假。b = “ + (a b) );System.out.println(“a = a = “ + (b = a) );System.out.println(“b b = falsea
11、 = a = trueb 按位右移运算符。左操作数按位右移右操作数指定的位数。 A 2 得到 15 即 1111 按位右移补零操作符。左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充。A2 得到 15 即 0000 1111实例下面的简单示例程序演示了位运算符。复制并粘贴下面的 Java 程序并保存为 Test.java 文件，然后编译并运行这个程序：public class Test public static void main(String args) int a = 60; /* 60 = 0011 1100 */ int b = 13; /* 13 = 0000 1101
12、 */int c = 0;c = a /* 12 = 0000 1100 */System.out.println(“a c = a | b; /* 61 = 0011 1101 */System.out.println(“a | b = “ + c );c = a b; /* 49 = 0011 0001 */System.out.println(“a b = “ + c );c = a; /*-61 = 1100 0011 */System.out.println(“a = “ + c );c = a 2; /* 15 = 1111 */System.out.println(“a 2 =
13、“ + c );c = a 2; /* 15 = 0000 1111 */System.out.println(“a 2 = “ + c ); 以上实例编译运行结果如下：a boolean b = false;System.out.println(“a System.out.println(“a | b = “ + (a|b) );System.out.println(“!(a 以上实例编译运行结果如下：a int b = 20;int c = 0;c = a + b;System.out.println(“c = a + b = “ + c );c += a ;System.out.prin
14、tln(“c += a = “ + c );c -= a ;System.out.println(“c -= a = “ + c );c *= a ;System.out.println(“c *= a = “ + c );a = 10;c = 15;c /= a ;System.out.println(“c /= a = “ + c );a = 10;c = 15;c %= a ;System.out.println(“c %= a = “ + c );c = 2 ;System.out.println(“c = 2 = “ + c );c = 2 ;System.out.println(“
15、c = a = “ + c );c System.out.println(“c c = a ;System.out.println(“c = a = “ + c );c |= a ;System.out.println(“c |= a = “ + c ); 以上实例编译运行结果如下：c = a + b = 30c += a = 40c -= a = 30c *= a = 300c /= a = 1c %= a = 5c = 2 = 5c = 2 = 1c a = 10; b = (a = 1) ? 20: 30; System.out.println( “Value of b is : “ +
16、 b );b = (a = 10) ? 20: 30; System.out.println( “Value of b is : “ + b );以上实例编译运行结果如下：Value of b is : 30Value of b is : 20instanceOf 运算符该运算符用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型）。instanceof 运算符使用格式如下：( Object reference variable ) instanceOf (class/interface type)如果运算符左侧变量所指的对象，是操作符右侧类或接口(class/interface)
17、的一个对象，那么结果为真。下面是一个例子：String name = James;boolean result = name instanceOf String; / 由于 name 是 String 类型，所以返回真如果被比较的对象兼容于右侧类型,该运算符仍然返回 true。看下面的例子：class Vehicle public class Car extends Vehicle public static void main(String args)Vehicle a = new Car();boolean result = a instanceof Car;System.out.prin
18、tln( result);以上实例编译运行结果如下：trueJava 运算符优先级当多个运算符出现在一个表达式中，谁先谁后呢？这就涉及到运算符的优先级别的问题。在一个多运算符的表达式中，运算符优先级不同会导致最后得出的结果差别甚大。例如，（1+3）（3+2）*2，这个表达式如果按加号最优先计算，答案就是 18，如果按照乘号最优先，答案则是 14。再如，x = 7 + 3 * 2;这里 x 得到 13，而不是 20，因为乘法运算符比加法运算符有较高的优先级，所以先计算3 * 2 得到 6，然后再加 7。下表中具有最高优先级的运算符在的表的最上面，最低优先级的在表的底部。类别 操作符 关联性后缀
19、() . (点操作符) 左到右一元 + + - ！ 从右到左乘性 * / 左到右加性 + - 左到右移位 = = = = | = 从右到左逗号 ， 左到右Java 循环结构 - for, while 及 do.while顺序结构的程序语句只能被执行一次。如果您想要同样的操作执行多次,，就需要使用循环结构。Java 中有三种主要的循环结构： while 循环 dowhile 循环 for 循环在 Java5 中引入了一种主要用于数组的增强型 for 循环。while 循环while 是最基本的循环，它的结构为：while( 布尔表达式 ) /循环内容只要布尔表达式为 true，循环体会一直执行下
20、去。实例public class Test public static void main(String args) int x = 10;while( x 20 ) System.out.print(“value of x : “ + x );x+;System.out.print(“n“);以上实例编译运行结果如下：value of x : 10value of x : 11value of x : 12value of x : 13value of x : 14value of x : 15value of x : 16value of x : 17value of x : 18valu
21、e of x : 19dowhile 循环对于 while 语句而言，如果不满足条件，则不能进入循环。但有时候我们需要即使不满足条件，也至少执行一次。dowhile 循环和 while 循环相似，不同的是， dowhile 循环至少会执行一次。do /代码语句while(布尔表达式);注意：布尔表达式在循环体的后面，所以语句块在检测布尔表达式之前已经执行了。 如果布尔表达式的值为true，则语句块一直执行，直到布尔表达式的值为 false。实例public class Test public static void main(String args)int x = 10;doSystem.ou
22、t.print(“value of x : “ + x );x+;System.out.print(“n“);while( x 20 );以上实例编译运行结果如下：value of x : 10value of x : 11value of x : 12value of x : 13value of x : 14value of x : 15value of x : 16value of x : 17value of x : 18value of x : 19for 循环虽然所有循环结构都可以用 while 或者 do.while 表示，但 Java 提供了另一种语句 for 循环，使一些循环
23、结构变得更加简单。for 循环执行的次数是在执行前就确定的。语法格式如下：for(初始化; 布尔表达式 ; 更新) /代码语句关于 for 循环有以下几点说明： 最先执行初始化步骤。可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句。 然后，检测布尔表达式的值。如果为 true，循环体被执行。如果为 false，循环终止，开始执行循环体后面的语句。 执行一次循环后，更新循环控制变量。 再次检测布尔表达式。循环执行上面的过程。实例public class Test public static void main(String args) for(int x = 10; x 20;
24、 x = x+1) System.out.print(“value of x : “ + x );System.out.print(“n“);以上实例编译运行结果如下：value of x : 10value of x : 11value of x : 12value of x : 13value of x : 14value of x : 15value of x : 16value of x : 17value of x : 18value of x : 19Java 增强 for 循环Java5 引入了一种主要用于数组的增强型 for 循环。Java 增强 for 循环语法格式如下:fo
25、r(声明语句 : 表达式)/代码句子声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。表达式：表达式是要访问的数组名，或者是返回值为数组的方法。实例public class Test public static void main(String args)int numbers = 10, 20, 30, 40, 50;for(int x : numbers )System.out.print( x );System.out.print(“,“);System.out.print(“n“);String names =“Ja
26、mes“, “Larry“, “Tom“, “Lacy“;for( String name : names ) System.out.print( name );System.out.print(“,“);以上实例编译运行结果如下：10,20,30,40,50,James,Larry,Tom,Lacy,break 关键字break 主要用在循环语句或者 switch 语句中，用来跳出整个语句块。break 跳出最里层的循环，并且继续执行该循环下面的语句。语法break 的用法很简单，就是循环结构中的一条语句：break;实例public class Test public static voi
27、d main(String args) int numbers = 10, 20, 30, 40, 50;for(int x : numbers ) if( x = 30 ) break;System.out.print( x );System.out.print(“n“);continue 关键字continue 适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代。在 for 循环中，continue 语句使程序立即跳转到更新语句。在 while 或者 dowhile 循环中，程序立即跳转到布尔表达式的判断语句。语法continue 就是循环体中一条简单的语句：continue
28、;实例public class Test public static void main(String args) int numbers = 10, 20, 30, 40, 50;for(int x : numbers ) if( x = 30 ) continue;System.out.print( x );System.out.print(“n“);以上实例编译运行结果如下：10204050Java 分支结构 - if.else/switch顺序结构只能顺序执行，不能进行判断和选择，因此需要分支结构。Java 有两种分支结构： if 语句 switch 语句 if 语句 一个 if 语句
29、包含一个布尔表达式和一条或多条语句。 语法 If 语句的用语法如下： if(布尔表达式) /如果布尔表达式为 true 将执行的语句 如果布尔表达式的值为 true，则执行 if 语句中的代码块。否则执行 If 语句块后面的代码。public class Test public static void main(String args)int x = 10;if( x 20 )System.out.print(“这是 if 语句“);以上代码编译运行结果如下：这是 if 语句if.else 语句if 语句后面可以跟 else 语句，当 if 语句的布尔表达式值为 false 时，else 语句
30、块会被执行。语法ifelse 的用法如下：if(布尔表达式)/如果布尔表达式的值为 trueelse/如果布尔表达式的值为 false实例public class Test public static void main(String args)int x = 30;if( x 20 )System.out.print(“这是 if 语句“);elseSystem.out.print(“这是 else 语句“ );以上代码编译运行结果如下：这是 else 语句if.else if.else 语句if 语句后面可以跟 elseifelse 语句，这种语句可以检测到多种可能的情况。使用 if，el
31、se if， else 语句的时候，需要注意下面几点： if 语句至多有 1 个 else 语句，else 语句在所有的 elseif 语句之后。 If 语句可以有若干个 elseif 语句，它们必须在 else 语句之前。 一旦其中一个 else if 语句检测为 true，其他的 else if 以及 else 语句都将跳过执行。 语法 if.else 语法格式如下: if(布尔表达式 1) /如果布尔表达式 1 的值为 true 执行代码 else if(布尔表达式 2) /如果布尔表达式 2 的值为 true 执行代码 else if(布尔表达式 3) /如果布尔表达式 3 的值为 t
32、rue 执行代码 else /如果以上布尔表达式都不为 true 执行代码 实例public class Test public static void main(String args)int x = 30;if( x = 10 )System.out.print(“Value of X is 10“);else if( x = 20 )System.out.print(“Value of X is 20“);else if( x = 30 )System.out.print(“Value of X is 30“);elseSystem.out.print(“This is else sta
33、tement“);嵌套的 ifelse 语句使用嵌套的 if-else 语句是合法的。也就是说你可以在另一个 if 或者 elseif 语句中使用 if 或者 elseif 语句。语法嵌套的 ifelse 语法格式如下：if(布尔表达式 1)/如果布尔表达式 1 的值为 true 执行代码if(布尔表达式 2)/如果布尔表达式 2 的值为 true 执行代码你可以像 if 语句一样嵌套 else if.else。实例public class Test public static void main(String args)int x = 30;int y = 10;if( x = 30 )if
34、( y = 10 )System.out.print(“X = 30 and Y = 10“);以上代码编译运行结果如下：X = 30 and Y = 10switch 语句switch 语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支。语法switch 语法格式如下：switch(expression)case value :/语句break; /可选case value :/语句break; /可选/你可以有任意数量的 case 语句default : /可选/语句switch 语句有如下规则： switch 语句中的变量类型只能为 byte、short、int 或者 cha
35、r。 switch 语句可以拥有多个 case 语句。每个 case 后面跟一个要比较的值和冒号。 case 语句中的值的数据类型必须与变量的数据类型相同，而且只能是常量或者字面常量。 当变量的值与 case 语句的值相等时，那么 case 语句之后的语句开始执行，直到 break 语句出现才会跳出switch 语句。 3 当遇到 break 语句时，switch 语句终止。程序跳转到 switch 语句后面的语句执行。case 语句不必须要包含 break 语句。如果没有 break 语句出现，程序会继续执行下一条 case 语句，直到出现 break 语句。 switch 语句可以包含一个
36、 default 分支，该分支必须是 switch 语句的最后一个分支。default 在没有 case语句的值和变量值相等的时候执行。default 分支不需要 break 语句。 实例 public class Test public static void main(String args) /char grade = args0.charAt(0); char grade = C; switch(grade) case A : System.out.println(“Excellent!“); break; case B : case C : System.out.println(“W
37、ell done“); break; case D : System.out.println(“You passed“); case F : System.out.println(“Better try again“); break; default : System.out.println(“Invalid grade“); System.out.println(“Your grade is “ + grade); 以上代码编译运行结果如下： Well done Your grade is CJava Number 类一般地，当需要使用数字的时候，我们通常使用内置数据类型，如：byte、in
38、t、long 、double 等。实例int a = 5000;float b = 13.65;byte c = 0x4a;然而，在实际开发过程中，我们经常会遇到需要使用对象，而不是内置数据类型的情形。为了解决这个问题，Java 语言为每一个内置数据类型提供了对应的包装类。所有的包装类（Integer 、Long、Byte、Double、Float、Short）都是抽象类 Number 的子类。这种由编译器特别支持的包装称为装箱，所以当内置数据类型被当作对象使用的时候，编译器会把内置类型装箱为包装类。相似的，编译器也可以把一个对象拆箱为内置类型。Number 类属于 java.lang 包。下
39、面是一个使用 Integer 对象的实例：public class Testpublic static void main(String args)Integer x = 5;x = x + 10;System.out.println(x); 以上实例编译运行结果如下：15当 x 被赋为整型值时，由于 x 是一个对象，所以编译器要对 x 进行装箱。然后，为了使 x 能进行加运算，所以要对 x 进行拆箱。Number 方法下面的表中列出的是 Number 子类实现的方法：序号 方法与描述1 xxxValue()将 number 对象转换为 xxx 数据类型的值并返回。2 compareTo()将 number 对象与参数比较。3 equals()判断 number 对象是否与参数相等。4 valueOf()返回一个 Number 对象指定的内置数据类型5 toString()以字符串形式返回值。6 parseInt()将字符串解析为 int 类型。7 abs()返回参数的绝对值。8 ceil()对整形变量向左取整，返回类型为 double 型。9 floor()对整型变量向右取整。返回类型为 double 类型。
