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 1字节 -27—27-1
short 2字节 -215—215-1
int 4字节 -231—231-1
long 8字节 -263—263-1
float 4字节 1.4E-45~3.4E+38 , -1.4E-45~-3.4E+38
double 8字节 4.9E-324~1.7E+308, -4.9E-324~-1.7E+308
char 2字节 0—216-1
boolean 1字节 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循环。
}
}