Java语言入门（二）——Java语言基础

环境配置

(1)jdk下载网址 http://java.sun.com
(2)安装在D:\java目录下，安装成功后，配置java_home、path、classpath的路径
(3)新建系统变量JAVA_HOME 和CLASSPATH
1）变量名：JAVA_HOME
变量值：C:\Program Files\Java\jdk1.7.0
2）变量名：CLASSPATH
变量值：.;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar;
(4)修改系统变量path
变量名：Path
变量值：%JAVA_HOME%\bin;%JAVA_HOME%\jre\bin;
(5)在命令行中对环境变量进行编辑的方法
1）查看当前可用的所有环境变量（=系统变量+用户变量）
set
2）查看某个环境变量，如PATH
set PATH
3）添加环境变量，如xxx=aa
set xxx=aa
4）将环境变量（如xxx）的值置为空
set xxx=
5）在某个环境变量（如PATH）后添加新的值（如d:\xxx）
set PATH=%PATH%;d:\xxx
（注：在dos窗口中以命令行方式对环境变量的操作只对当前窗口的应用有效）

类

(1)类封装了一类对象的状态和方法，是用来定义对象的模板。
(2)基本格式如下：
Class 类名
{ 属性；
方法；}

class Test-2.1   //类的第一个字母习惯大写
{
    public static void main(String args[])   //main方法和C一样，都是程序的入口	
    {
         System.out.println(“Hello World!”);   //Java严格区分大小写
     }
}

(3)小结
1）public类，类名必须与文件名一致。
2）一个文件中若有多个类，在编译时则会生成相应多个class文件(即字节码程序)。
3）在一个.java文件中，只能有一个public类，且文件名与public类名一致。
4） 运行程序时输入的是：java 类名（因此必须注意文件名与类名不同的情况）。

注释

3种注释形式：
(1) // 单行注释，调试程序时使用
(2) /* 多行注释，
不可嵌套多行注释，
可嵌套单行注释*/
(3) /** 生成java解释文档 */

输出形式

(1)System.out.println (“Hello”); //有换行
(2)System.out.print (“Hello”); //没有换行
(3)因此：System.out.println(“Hello”);
= System.out.print (“Hello\n”);

常量

(1)整型常量：十进制（12）十六进制 （0x12）八进制（012）
(2)长整型常量：13L
(3)单精度浮点数：5.1f .4f 2e3f 0f
(4)双精度浮点数 ：5.1，.4，2e-3，0d
(5)布尔常量 ：true和false
(6)字符串常量 ：“Hello World“ ”123”，
(7)null常量 ：只有一个值，用null表示，表示对象的引用为空
(8)字符常量 :‘a’‘8’ '\u0027’‘\n’ ‘\b’ ‘\t

变量

(1)java中的包、类、方法、参数和变量的名字，可由任意顺序的大小写字母、数字、下划线(_)和美元符号($)组成，但标识符不能以数字开头，不能是关键字。
(2)非法的标识符：class 、 98.3 、 Hello World
(3)java 无sizeof ,goto, const 关键字，但也不能用goto、 const作为变量名。True 和false不是保留字，但也不能作变量，因为有唯一的编译意义。
(4)基本数据类型：
byte １字节 -27—27-1
short ２字节 -215—215-1
int ４字节 -231—231-1
long ８字节 -263—263-1
float ４字节 1.4E-45~3.4E+38 , -1.4E-45~-3.4E+38
double ８字节 4.9E-324~1.7E+308, -4.9E-324~-1.7E+308
char ２字节 0—216-1
boolean １字节 true false

class Test-2.2
{
   public static void main(String[] args) 
   {
      int  x=012;   //八进制
      byte m=(byte)x;		
      System.out.println(m);   //10
      System.out.println(x);   //10
      System.out.println(0x12);   //18
      float y=1.5f; 
      System.out.println(y);   //1.5
      char z=97;
      System.out.println(z);   //a
   }
}

关键字

Java关键字共53个，其中包含两个保留字const，goto。

abstract	default	goto	prackage	this
assert	do	if	private	throw
boolean	double	implements	protected	throws
break	else	import	public	transient
byte	enum	instanceof	return	true
case	extends	int	short	try
catch	false	interface	static	void
char	final	long	strictfp	volatile
class	finally	native	super	while
const	float	new	switch
continue	for	nulll	synchronized

变量的类型转换

(1)自动类型转换（也叫隐式类型转换）:从精度小往精度大的数据类型转换；
隐式转换：byte ->short(或 char )-> int ->long ->float ->double
(2)强制类型转换（也叫显式类型转换）: 从精度大往精度小的数据类型转换。（这种转换会损失数据的精度，所以需要显式转换）
(3)java默认整型int、默认小数型double
(4)所有的byte型、short型和char的值在运算过程中将被提升到int型。
(5)字符常量用单引号表示，字符串常量用双引号表示。
(6)如果碰到字符串类型，那么所有类型都要向字符串类型转换
(7)溢出时， Max+1 ——> 最小；
Min-1 ——> 最大：

class Test-2.3
{
   public static void main(String[] args) 
   {
      int  x=136;   //二进制1000 1000
      byte y=(byte)x;  
      /*强制转换，byte占八位，取二进制1 000 1000后八位即1000 1000,十进制表示-2^7+2^3= -128+8=-120*/

       System.out.println("x= "+x);   //x=136
       System.out.println("y= "+y);   //y=-120
    }
}

变量的生命周期

(1)成员变量：在类中声明，它的作用域是整个类。
局部变量：在一个方法或一个代码块声明，它的作用域是该方法或该代码块。
方法参数：它的作用域是该方法。
变量的作用域决定了生命周期。
(2)Java内不允许重复定义同一个变量。
(3)成员变量可以允许不赋初值，但数值变量不赋初值则出错。
(4){}内是一个代码块，里面的变量生命周期是一样的，其中定义的变量作用范围仅在{}内。

class Test-2.4 
{   
   int a;    //成员变量
   public static void main(String[] args) 
  {
     int x=23;//局部变量,作用域main方法
    {
       //int x=26; 
       /*局部变量，其作用域是该{}代码块，由于该代码块在main方法内，所以这里定义的x会与上面定义的x冲突*/
        System.out.println(x);   //23
     } //复合语句
        System.out.println(x);   //23
  }
}

Java运算符

算术运算符(+ - * / % ++ – )

(1)“+”:第一个“+”运算符，若做的是字符连接操作时，所有数据向字符串类型转换，若做的是运算相加（即有数值类型数据参加运算），所有数据向int型转换
(2)“/ ”:整数除和小数除是有区别的。整数之间做除法时，只保留整数部分而舍弃小数部分。9/2=4
(3)“%”：对负数取模，可以把模数负号忽略不记。5%-2=1
(4)应用技巧：循环，取整

class Test-2.5
{
   public static void main(String[] args) 
  {    
      System.out.println('a');   //a
      System.out.println("a");   //a
      System.out.println("hello"+"world");   //helloworld
      System.out.println('a'+'b');      //195
      System.out.println("a"+1+" ");    //a1    
      System.out.println(" " +1+'a');   // 1a  
      System.out.println(" "+'a'+1);    // a1
      System.out.println(1+'a'+" "); 	//98
  }
}

class Test-2.6
{
   public static void main(String[] args) 
  {    
      int x=9;
      float y1=x/2;
      float y2=x/2f;
      float y3=(float)x/2;
      int z1=x%2;
      int z2=-x%2;
      int z3=x%-2;
      System.out.println(y1+","+y2+","+y3);    //4.0,4.5,4.5   
      System.out.println(z1+","+z2+","+z3);    //1,-1,1
   }
}

赋值运算符(= += -= *= /= %= )

class Test-2.7
{
   public static void main(String[] args) 
  {    
      int x=50;
      int y=(x+4)/5;   //取整
      System.out.println(y);   //10	
  }
}

class Test-2.8
{
   public static void main(String[] args) 
  {    
     int x=0;
     while(true){   //循环
         x=(x+1)%10;   
         System.out.println(x);}
   }
}

比较运算符(== != < > <= >= )

(1)比较运算符的结果都是boolean型，也就是要么是true，要么是false
(2)浮点型只能无限接近但无法精确相等。无法用==来判断。
(3)“= =”和“！=”的操作元既可以是基本类型，也可以是引用类型。
(4)instanceof 检查是否是类的对象
“hello” instanceof String true

逻辑运算符(& | ^ ! && || )

(1)逻辑运算符用于对boolean型结果的表达式进行运算，运算的结果都是boolean型 。
(2)“&”和“&&”的区别在于，如果使用&连接，那么无论任何情况，“&”两边的表达式都会参与计算。如果使用&&连接，当“&&”的左边为false，则将不会计算其右边的表达式。
(3)“|”和“||”的区别与“&”和“&&”的区别一样

class Test-2.9
{
   public static void main(String[] args) 
  {    
     int x=0;
     int y=5;
    // if(x!=0&y/x==1)
     if(x!=0&&y/x==1)//除数为0
     {System.out.println(x);}
     System.out.println(x);   //0
   }
}

位运算符(& | ^ ~)

(1)“&,|,^, ~”是按位运算的，是将两个操作元的每个二进制位进行与、或、异或、取反运算。
(2)与：只有参加运算的两位都为1，&运算的结果才为1，否则就为0。
(3)或：只有参加运算的两位都为0，|运算的结果才为0，否则就为1。
(4)异或：只有参加运算的两位不同，^运算的结果才为1，否则就为0。

class Test-2.10
{
   public static void main(String[] args) 
  {  
      int x=3,y=6;
      System.out.println(x|y);    //7
      System.out.println(x&y);    //2
      System.out.println(x^y);    //5
      System.out.println(~y);     //-7
      /*6=0000 0110,~6表示按位取反=1111 1001。
      因为计算机中存储的是补码，解释一下这个补码的值减1，变成反码 1111 1000
      首位为符号位，不变，其余取反，转为原码1000 0111= -7*/
   }
}

移位运算符(<< >> >>> )

(1)右移>>“运算的规则：右移N位，高位补零（原为正数），高位补1（原为负数）。相当于除以2^N。例如(11>>1) 5
(2)“无符号位右移>>>”将操作数的二进制位向右移N位；无视符号位，高位一律补零。
(3)对于低于int型的操作数将先自动转换为int型，再进行移位运算。
(4)移位运算符适用类型有byte、short、char、int、long
(5)对于int型整数移位a>>b，系统先将b对32取模，得到的结果才是真正移位的位数。例如：a>>33和a>>1结果是一样的，a>>32的结果还是a原来的数字。同理对于long型整数移位时a>>b ，则是先将移位位数b对64取模。

class Test-2.11
{
  public static void main(String[] args) {  
   int x=0x8000000;
   System.out.println(x);                             //134217728
   System.out.println(Integer.toBinaryString(x));     //1000000000000000000000000000
   //打印二进制
   System.out.println(Integer.toBinaryString(x>>1));  //100000000000000000000000000
   System.out.println(x>>1);                          //67108864
System.out.println(Integer.toBinaryString(x>>>1));    //100000000000000000000000000
   System.out.println(x>>>1);                         //67108864
   System.out.println(Integer.toBinaryString(x<<1));  //10000000000000000000000000000
   System.out.println(x<<1);}                         //268435456
}

class Test-2.12
{
   public static void main(String[] args) 
  {    
     System.out.println(1<<10);    //计算2的10次方
  }
}

Java流程控制

1 顺序结构
2 选择结构
(1) if (表达式) 语句；
(2) if (表达式) 语句1； else 语句2；
(3) if (表达式1) 语句1；
else if (表达式2) 语句2；
else if (表达式2) 语句3；
…
else 语句n；
(4) if (表达式1)
if (表达式2) 语句1；else语句2；
esle
if (表达式2) 语句3；else语句4；
注：1）if后面的表达式必须是布尔表达式；if后面的else不是必须的。
2）变量 ＝ 布尔表达式？语句1:语句2；
(5)Switch (表达式){
case 常量表达式1:语句1;break;
case 常量表达式2:语句2;break;
…
case 常量表达式n:语句n;break;
default: 语句n;}
注：switch语句判断条件可接受int, byte, char, short型，1.7版本可接受string型
3 循环结构
(1) while (表达式) 语句；
(2) do 语句 while (表达式);
(3) for(表达式1;表达式2 ;表达式3) 语句
注：break语句可以中止循环中的子语句和switch语句。一个无标号的break语句会把控制传给当前(最内)循环(while，do．for或Switch)的下一条语句。如果有标号，控制会被传递给当前方法中的带有这一标号的语句。无标号的continue语句的作用是跳过当前循环的剩余语句块，接着执行下一次循环。

st:while(true)
{
    while(true)
    {
         break st;     //执行完break st;语句后，程序会跳出外面的while循环，如果不使用st标号，程序只会跳出里面的while循环。
     }
}