------- android培训、java培训、期待与您交流！ ---------
Java程序设计基本规则
Java程序区分大小写
花括号用来区分一组语句
程序必须以类的形式存在，一个程序执行必须包含如下语句
public className //类名为Name
{ //类名第一个字母大写，文件名与main方法所在public类的类名相同
publicstatic void main(String args[]) args[]接收运行时传入的参数
{
//程序代码
}
}
每条语句用分号“;”结束，注意中文分号与英文分号区别
Java单行注释用“//程序代码”，多行注释用“/* 程序代码 */”,文档注释用“/** 文档内容 */”
一个包含以上语句的Java程序的类名必须声明为public，带有public类的文件必须以类名命名，且拓展名必须为 .java。包含程序代码的Java源文件后缀就是 .java，习惯将第一个字母大写
一个字符串不能分行写，写不下可以分成两个字符串，用“+”相连
Java关键字（keywords）：（不可以用关键字做变量名）
访问控制：private 私有的 protected 受保护的 public 公共的
类、方法和变量修饰符：
abstract申明抽象 class 类 extends继承 final 最终
implements实现 interface 接口 native 本地 new 创建 static 静态
strictfp 严格 synchronized 线程同步 transient 短暂 volatile 易失
程序控制语句：
break 跳出循环 continue 继续 return 返回 do 运行 while 循环 if 如果
else 反之 for 循环 instanceof 实例 switch 开关 case 返回开关里的结果
default 默认
错误处理：
try 捕获异常 catch 处理异常 finally 有没有异常都执行 throw 抛出一个异常对象
throws 声明一个异常可能被抛出
包相关：import 引入 package 包
基本类型：
boolean 布尔型 byte 字节型 short 短整型 int 整型 char 字符型 double 双精度 float 浮点 long 长整型
变量引用：super 父类，超类 this 本类 void 无返回值
注意：Java中没有sizeof、goto、const关键字，但仍不可以用他们作变量名。
Java中的基本数据类型
整型：byte，short（短整型），int，long（长整型）
byte占1个字节，short占2个字节，int占4个字节，long占8个字节，
除0以外，十进制第一位不能是0
八进制必须是0开头
十六进制(Hex)用0x或0X开头
长整型常量必须是L结尾
浮点类型：float、double：浮点常量以f，d结尾，float变量占4个字节，double变量占8个字节，小数常量默认的是double类型，如：float=3.5;是错的，float=3.5f是对的。
字符型：char
布尔型：boolean（只有两个值true真 false假）
空类型：void 常用类型还有null类型，一般作为对象的引用。
通用控制字符：
\n 换行 \r 回车 \t Tab键，制表符 \b 退格
\ ' 单引号 \\反斜杠 \ '' 双引号 \f 换页
Java中的常量
Java中常量名一般用大写字母表示
Java中常量用final关键字修饰，常量只能被赋值一次。
如定义一个常量π: final double π=3.14;
Java中的变量
语法格式：类型 变量名[变量1,变量2,变量3,…,变量n];
变量名不可以是关键字，区分大小写，不可以是sizeof、goto、const
变量要先定义，后使用。变量在进行取值操作前必须被初始化或进行过赋值操作才可以。
编程技巧：尽量避免用单个字母来定义变量，提高程序可读性。
基本数据类型间的类型转换
规则：
所有byte型、short型和char型，计算结果可以提升到int型
如果一个操作数是long型，计算结果就是long型
如果一个操作数是float型，计算结果就是float型
如果一个操作数是double型，计算结果就是double型
注意：
字符串与字符一起打印出，会打印为字符串，
如System.out.println(""+'a'+1); 打印出的是a1
所有类型与自身兼容，int与int、double兼容，char与char、int、double兼容。
Java提供了大量数学函数，引用格式为”Math.”+函数名，除非指明，函数返回值类型为double型。
如：就直角三角形斜边长 double hyp=Math.sqrt(base*base+height*height);
自动类型提升：当两种类型彼此兼容，且目标类型的取值范围大于源类型时，会发生自动类型转换。如：byte b=3;int x=b;
强制类型转换：两种类型彼此不兼容，或目标类型取值范围小于源类型时，需要进行强制转换。如：byte a; int b; a=(byte)b;
字符'0'与整数0不是一回事，一个整数与一个字符相加，加的是此字符对应的二进制编码值，若k=1，k+'0'就不是1了，而是49。
编程技巧：boolean、char值存储空间小，范围小用途有限；int类型范围小，但运算快，且精确；double类型取值范围大，但运算速度慢，且结果不精确，有一定误差。
变量的作用域
变量要先定义，后使用，但也不是在变量定义后的语句一直都能使用前面定义的变量。我们可以用大括号将多个语句包起来形成一个复合语句，变量只能在定义它的复合语句中使用。
public classTestScope
{
public static void main(String[] args)
{
int x = 12;
{
int q = 96; // x和q都可用
int x = 3;//错误的定义，Java中不允许有这种嵌套定义
System.out.println("xis "+x);
System.out.println("qis "+q);
}
q = x;
System.out.println("x is"+x);
}
｝
局部变量的初始化
在一个函数或函数里面把代码块中定义的变量称为局部变量，局部变量在函数或代码块被执行时创建，在函数或代码块结束时被销毁。局部变量在进行取值操作前必须被初始化或进行过赋值操作，否则会出现编译错误！
Java中的运算符
算术运算符：+、-、 *、 /、 %、 ++、 --
赋值运算符：=，+=，-+，%=，*=，/=， >>>=，<<=，>>=，&=，∧=，|=
比较运算符：==，!=，<，>，<=，>=，可以用&&、||、!连接起来，
instanceof该运算符是双目运算符，左面的操作元是一个对象，右面是一个类。当左面的对象是右面的类创建的对象时，该运算符运算结果是true，否则是false。
逻辑运算符：&、|、^（异或）、!、&&、||
&：当两边操作数的位同时为1时，结果为1，否则为0。如1100&1010=1000
| ：当两边操作数的位有一边为1时，结果为1，否则为0。如1100|1010=1110
~：0变1,1变0
^：两边的位不同时，结果为1，否则为0.如1100^1010=0110
逻辑运算符
与（&&）、非（!）、或（||）
位运算符 与（&）、非（~）、或（|）、异或（^）
“&”和“&&”的区别在于，如果使用前者连接，那么无论任何情况，“&”两边的表达式都会参与计算。如果使用后者连接，当“&&”的左边为false，则将不会计算其右边的表达式。“|”和“||”的区别与“&”和“&&”的区别一样。
<< 左移：
>> 右移：如果最高位是0，左边移空的高位就都填入0；如果最高位是1，左边移空的高位就都填入1。
>>>无符号右移：不管移位的整数最高位是0还是1，左边移空的高位都填入0.
注意，对于把byte、short、char、int、long型做移位运算时，遵从下面规则：
对于低于int型的操作数将自动转换为int型再移位
对于int型整数移位a>>b，系统先将b对32取模，得到的结果才是真正移位的位数，如：a>>33与a>>1结果一样；a>>32即a>>0，所以结果不变。
对于long整数移位时a>>b，则是先将移位位数b对64去模。
对某个变量进行移位操作，变量本身并没有变，只是一个表达式而已，移位操作单独的操作没有意义
算法总结：由于计算机存储采用2进制，所以移位能为我们实现整数除以2的n次方的效果。左移n位就是乘以2的n次方，即2的n次方为y=1<<n；右移n位，就是除以2的n次方。如：x>>1与x/2效果一样。
编程技巧：太复杂的运算表达式可读性差，也极容易出错，不要在一行中编写太复杂的表达式，也就是不要在一行中进行太多的运算，多使用括号来表达运算先后。
自增++ 自减-- 运算符
做变量前缀时，首先变量进行+1或-1的运算，然后所得的值在表达式中参与运算。
做变量后缀时，变量先参与表达式中的运算，再进行+1或-1的运算。
编程技巧：表达式k++比相同功能表达式k=k+1运算得更快，但是自增自减运算符在程序中出现过多会降低程序的可读性，一般尽量把自增自减运算符作为后缀使用，并且不要在一个表达式中同时使用自增自减运算符和赋值操作符。
运算符优先级：
按优先级从高到低排列如下：[ ] ( ) ++ -- ! ~ instanceof * / % +- << >> >>> <> < = > \ == != &^&&|| ? : = op=
字符串
String 字符串是指字符的序列，定义方法有二：
String s1="listof characters"
Strings2=new String("list of characters");
字符串用加号+相连和添加
注意：String类型不是Java提供的基本数据类型，不能用逻辑操作符号==、<、>、<=、>=、!=来进行运算，可以用equals或compareTo来比较两个字符串。用法可查JDK API文档。（在程序中，用“==”来判断字符串在计算机的存储位置是否相同，不是判断内容是否一样。）
简单的屏幕输出，键盘输入
System.out.println();用于在屏幕输出由“+”相连的常量、表达式或各种类型的变量，并且以换行符结束，光标停留在显示的最后一行的开始。
System.out.print();与System.out.println();的输出功能一样，只是不换行，光标停留在显示的最后一个字符后。
System.in.read();可以从键盘读入字符，可以赋值给一个变量。
另外，Java提供了System.err.print和System.err.println来显示错误信息。
程序流程控制：顺序结构、选择结构、循环结构
顺序结构：就是程序从上到下一行一行执行的结构，中间没有判断和跳转，直到程序结束。
if 语句：指定条件和一段代码
格式：
if（条件语句）
{
执行语句块
}
条件语句为真，就执行{}内的语句，否则执行后面的语句
if（条件语句）
{
执行语句块1
}
else
{
执行语句块2
}
条件语句为真，就执行语句块1，否则执行语句块2。条件表达式（问号表达式）也有这样的功能，变量=布尔表达式？语句1:语句2;布尔表达式为真，执行语句1，否则执行语句2。
if（条件语句1）
{
执行语句块1
}
else if(条件语句2)
{
执行语句块2
}
…
else if（条件语句n）
{
执行语句块n
}
左边的格式：首先判断条件语句1是否为真，如果为真，就执行语句块1，不再执行后面的语句，不为真就判断条件语句2是否为真，为真就执行语句块2，不再执行后面的语句，否则判断条件语句3，依次类推。
switch语句：将一个表达式的值与许多其他值比较，并按比较结果选择下面该执行哪些语句。
格式：
switch（表达式）
{
case 取值1：
语句块1
break；
case 取值2：
语句块2
break；
…
case 取值n：
语句块n
break；
[default：
语句块n+1
break; ]
}
表达式必须是int型、byte型、short型或char类型。
执行时，先将switch中表达式的值与case后面的取值1比较，若相等，就执行语句块1，不等就与第二个case值比较，若相等就执行语句块2，以此类推。
每个case后面的语句块可以是多条语句，而且不用加{}。
对于某个case后的取值n与表达式值相同，若有break语句，就会跳出switch语句。
若没有break，一旦某个case取值与表达式相等，就会依次执行后面的语句，即使后面case取值n与表达式不等，也会执行，直到遇到break才会跳出switch语句。这样就可以做到多个条件下执行相同语句的功能。
所有case后面取值都与表达式不匹配时，就执行default语句。
循环语句，循环是使一段代码重复执行，直到某个条件发生才终止的一种语句结构。一个有效的循环语句包含3个要素：
条件判断：决定循环开始或结束的条件判断
循环变量的初始化：在条件判断中的循环变量要初始化
循环变量的修改：在循环的过程中，用于条件判断的变量在每次循环中必须不断改变（否则为死循环）
1） while循环
格式如下：
while(条件表达式)
{
执行语句
}
在while语句前，执行前应该将有条件判断功能的条件表达式中的循环变量进行初始化。
条件表达式值为真，就执行循环体中的语句，为假就结束循环。执行语句可以是多条语句，这时要用大括号括上。通常在执行语句中有循环变量改变的语句。
2） do while循环
格式如下：
do
{
执行语句
}
while(条件表达式);
在do while语句前的语句或执行语句中，对循环变量进行初始化。
首先执行一遍执行语句，再进行判断，while后面的括号末要加上标识语句结束的分号。
通常在执行语句中有循环变量改变的语句
3） for循环
格式如下：
for(初始化表达式；循环条件表达式，循环后的操作表达式)
{
执行语句
}
初始化表达式可以放在for语句外，循环条件表达式可以放在执行语句前用if语句进行判断，循环后的操作表达式可以放在执行语句后。所以for循环（）可以为（；；）。
每次循环后，会对循环条件表达式进行判断，为真就执行下一次循环，为假就循环结束。
4） break与continue
break的作用是：嵌套于switch、for、while、do while语句中，程序一旦执行到break就会跳出switch或循环语句。
continue的作用：可以嵌套在for、while、do while 语句中，执行到continue时，就跳过当前循环的语句块，而跳转到条件判断处，执行下一次循环。
编程技巧：
break与continue语句的跳跃会使程序结构不稳定，尽量避免使用，可以用不含break和continue的语句块实现相同的功能。
在循环过程中会改变的变量不要在循环体中初始化，否则每次循环又被初始化一次，得不到我们想要的结果。
函数（方法）
作用：让执行某些操作的代码放在一个函数中，可以只调用函数，知道函数名和参数情况就可以多次执行，不用重复写很多类似的代码。函数（方法method）就是用于解决复杂问题的一组代码段所形成的某个功能单元，通常由一些数据和一些操作组成。
方法格式：
返回值类型 函数名（参数类型 形式参数1，参数类型 形式参数2，…）
{ /*方法体*/
程序代码
return 返回值；
}
说明：
方法包括一个首部（header）和一个方法体（body），首部用来指定从其它方法传递信息到这个方法，方法体用来定义该方法具体执行的任务。一个方法可以调用其它方法，也可以被其它方法调用。可以通过定义它的参数来调整其行为，并且可以在被调用后返回一个值。
返回值类型：函数要返回的结果的数据类型，若为void表示无返回值
形式参数：在方法被调用时用于接收外部传入的数据的变量，可以为空
参数类型：该形式参数的数据类型
return语句：若不是void类型，return至少出现一次，一旦return语句被执行，方法体中的其他代码不再执行。void类型方法可以用语句retrun;让方法结束，比如如果想要结束main方法，退出程序就可以用return;语句。
返回值：方法在执行完毕后返回给调用它的程序的数据
实参：调用函数时实际传递给函数形式参数的数据
Java程序中至少包含一个public的类，至少有一个main方法，main方法位于public类中，程序的执行从这个main方法开始
参数传递
调用不带参数的方法时是在方法名后加一对空括号
调用带参数的方法时是在方法名后的括号中加入一组与输入参数类型相同或兼容的表达式，表达式之间用逗号隔开。
方法被执行时，系统会为其形参分配存储空间，名字与实际参数的值一样，之后把实际参数的值传递给这些形参。
方法调用时是将所有的参数的表达式的值传给方法首部相应的变量，方法中变量所做的改变在方法外是不可见的。
引用类型作为参数
引用变量像普通变量一样声明，但是一般都用关键字new初始化，如数组、字符串、对象等。在其他语言中，引用变量叫指针，Java不使用指针，但Java中除了byte，short，int，long，float，double，char，boolean等基本数据类型外，其他都是引用类型，不过我们可以像其他常规变量一样使用引用类型。这就隐含的使用了指针。
引用变量的名字不是表示变量本身而是变量的存储地点，引用变量自己存在栈内存中，其值的存储点是在堆内存中。如果改变了引用变量的值，那它就会指向不同的内存地址；如果改变了引用变量所指的数据的值，那么引用变量本身不变。当我们用==或!=检查两个引用变量是否相等时，该操作只检查它们是否指向同一地址，而不管其中的内容是否相等。
当引用变量作为方法的输入参数时，引用变量（实参）的值被拷贝给形参。如果方法改变形参的值，形参就指向另外的地方了，形参开始所指的存储点的值并没有改变，对引用变量（实参）没有影响，这种改变在这个方法外是不可见的（这个方法外无法知道是不是变了）。如果方法改变了形参所指向的堆内存中的存储点的值，那么引用变量（实参）指的这个存储点的值也会改变，可以查看引用变量所指的存储点的值是否有变化，这在该方法外是可见的。
函数的重载就是在同一个类中允许同时存在一个以上的同名函数，只要它们的参数个数或类型不同即可。
编程技巧：
方法很适合用来处理可以分解的大型任务，在解决问题时应该将其分解成一些较小的子任务，然后用单个方法解决这些子任务，这就叫模块化，将较大的任务模块化尤其适合那些较为复杂的问题。一般说来，每个方法应尽可能的短。
数组
作用：可以一下定义多个相同类型的变量，存多个值。
Java内存机制：
栈内存：在函数中定义的一些基本类型的变量和对象的引用变量都是在函数的栈内存中分配的，当一段代码块定义一个变量时，Java就在栈中为这个变量分配内存空间，当超过变量的作用域后，Java就会自动释放掉这个变量所分配的内存空间。释放了的内存空间可以被其他变量使用。
堆内存：用来存放由new创建的对象和数组，在堆中分配的内存，由Java虚拟机的垃圾回收器来自动管理。若没有被回收，即使不用相关数组和对象，也无法使用它们所占的内存，所以Java程序比较占内存。
数组声明：数组是一组顺序存储的同一类型的固定数据结构，每个Java数组都包含一个length的变量，用来存数组的当前大小。定义数组用 [] 标识，数组变量的缺省值是null。声明数组时，不能指定其长度，例如inta[5];//非法的。
声明数组一两个方括号，格式为：type arrayName[]; 或typep[]arrayName;（其中type是数组类型，可以是基本类型也可以是其他类型，比如字符串等。arrayName是数组名。变量arrayName存的是数组在堆内存中的地址，变量本身存在栈内存中）
初始化数组：
格式：arrayName=new type[size]; （其中arrayName是数组名，size为整型表达式，是数组的大小，这样就可分到相应的内存空间）
可以在一条语句中同时对数组进行声明和初始化，格式为：typearrayName[]=new type[size]; ，也可以这样初始化：type arrayName[]={value1,value2,…,valueN}; 其中value1、value2、…、valueN为同一类型的值。
数组初始化
动态初始化 数组定义与为数组元素分配空间和赋值的操作分开进行。
例： public class Test{
public static void main(Stringargs[]) {
int a[];
a = new int[3];
a[0] = 3; a[1] = 9 ; a[2] = 8 ;
Date days[];
days = new Date[3];
days[0] = new Date(1,4,2004);
days[1] = new Date(2,4,2004);
days[2] = new Date(3,4,2004);
}
}
class Date {
int year,month,day;
Date(int y, int m, int d) {year =y,month = m ,day =d;}
}
静态初始化 在定义数组的同时为数组元素分配空间并赋值。
例： public class Test {
public static void main(Stringargs[])
{
int a[] = { 3 , 5 , 8 };
Date days[] = {newDate(1,4,2004)
new Date(2,3,2004)
newDate(3,4,2004)
};
}
}
class Date {
int year,month,day;
Date(int y, int m, int d) {year =y,month = m ,day =d;}
}
访问数组元素
数组的下标是从0开始的，所以大小为N的数组按下标0，1，2，…，N-1进行访问，对于数组a，a[0]为其第一个元素。
若数组元素下标过大，会导致数组越界异常，通过ArrayIndexOutOfBoundsException返回运行错误。
每个数组有一个成员变量length，它在初始化时设定数组的大小，可以用.lenghth的格式来进行访问，数组a的长度为a.length ，a数组最后一个元素的下标是a.length-1
用增强for循环来访问数组中的每个元素。如要打印数组的每个元素:
int[] a={1,2,3,4,5,6,7,8,9,10};
for(intm:a){
System.out.print(m);
};
m是一个变量，程序执行时每循环一次，就把数组中的一个元素赋值给m，所以数组a元素的类型必须能够自动转换成m的类型，否则错误。
注意：必须对数组初始化并且是有效的值时才可以运用数组的各个元素。（若元素值为空就去引用，就会出现空指针异常的错误。）
多维数组
定义一个多维数组，并对其静态初始化：int[][] xx={{3,2,7},{1,5},{6}};
数组操作函数：
System.arraycopy()用于函数拷贝数组 （详情参看API的类System的arraycopy方法）
Arrays.sort 来排序数组 （详情参考API的类Arrays的sort方法）
编程技巧：可以用循环语句逐一打印出数组各个元素，控制循环最好使用length成员变量，而不是用一个确定的值。这样代码可以随数组大小变化而自动适应。而且数组初始化时也不要用一个固定值，应该用一个int型成员变量或是常量。
------- android培训、 java培训、期待与您交流！ ----------
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
