java是 SUN(Stanford University Network,斯坦福大学网络公司)1995年推出的一门高级语言。
是一种面向 Internet的编程语言。
java语言的特点
1简介有效:java是一种相当简洁的面向对象的语言,省略了c++中容易混淆的特性,如指针,结构,单元等
2可移植性
3面向对象
4解释型
5适合分布式计算
6较好的性能:(1)java语言源程序编写完成后,先使用java伪编译器进行编译,将其转换为中间代码(也称为字节码)在解释(2)提供了一种“准时时”编译器,当需要更快的速度的时候,可以使用just-in-time(JIT)编译器将字节码转换成机器码,然后将其缓冲下来,这样速度就更快
7健壮性
8多线程处理能力
9较高的安全性
10是一种动态语言
java程序的运行机制
计算机高级语言类型主要有编译型和解释型两种,java是2种类型的集合,在java中代码的处理过程如下。
在java中,源文件名称的后缀为.java,之后通过编译使*.java的文件生成一个*.class文件,在计算机上执行*.class文件,但是此时执行*.class的计算机并不是一个物理上可以看到的计算机,而是java自己设计的一个计算机---JVM,java是通过JVM进行可移植性操作的
java虚拟机----Java Virtual Machine(简称JVM)
它是运行所有 Java程序的抽象计算机,是 Java语言的运行环境,JVM读取并处理编译过的与平台无关的字节码(class)文件。
Java 编译器针对 JVM产生 class文件,因此是独立于平台的。
Java 解释器负责将 JVM的代码在特定的平台上运行。
Java 虚拟机是不跨平台的.
javac命令的作用
javac.exe是java本身提供的编译命令,主要目的是用来将*.java文件编译成*.class文件,此命令本身不属于windows系统,所以在使用时需要单独配置
classpath属性的作用
classpath主要指的是类的运行路径。在执行java命令时,对于本地的操作系统来说就意味着启动了一个JVM,那么JVM在运行时需要通过classpath加载所需要的类,而默认情况下classpath是指向当前目录(当前命令行窗口所在的目录)
java程序的注释
注释:单行//,多行/* */,文档注释/** */
1.单行注释 //:
2.多行注释 /* */:
3.文档注释 /** */:
java中的标识符
java中的包,类,方法,参数和变量的名字可以由任意的大小写字母,数字,下划线(_)和美元符号($)组成,但是标识符不能以数字开头,也不能使用java的保留关键字
变量和常量
变量时利用声明的方式将内存中的内存块保留下来以供程序使用。可以声明数据类型为整型,字符,浮点或者是其他数据类型,作为变量的保存值用.
数据类型划分
java的数据类型可分为基本数据类型和引用数据类型。原始数据类型也称为基本数据类型,包括boolean,byte,char,short,int,long float与double。另一种数据类型为引用数据类型。
|
数据类型 大小/位 可表示范围
long(长整形) 64位
int(整数) 32位
short(短整数) 16位
byte(位) 8位 -128-127
char(字符) 2位 0-255
float(单精度) 32位
double(双精度) 64位
整数类型
当数据不带小数或者分数时,可以声明为整数变量。在java中,整数数据类型可以分为long,int,short和byte。
字符类型
字符类型在内存中占有2个字节,可以用来保存英文字母等字符。计算机处理字符时,是把这些字符当成不同的整数来看待,严格来说,字符类型也算是整数类型。
PS:字符型常量也可以采用16进制编码方式表示,范围是'\u0000'-'\uFFFF',一共可以表示65535个字符,其中前256个字符和ASCII码中的字符完全重合
不仅如此,char类型的值也可直接作为整数型的值来使用,但它是一个16位无符号整数,即全部是整数,范围是0-65535.如果把一个在0-65535内的int整数赋值给char类型的变量,系统会自动把这个int整数当成char来处理
实例代码----字符和数字之间的转化
public class Demo{
public static void main(String args[]){
char ch1 = 'a' ; //字符是使用”'“括起来的数据
char ch2 = 97; //通过数字定义字符变量
System. out.println("ch1 = " + ch1) ;
System. out.println("ch2 = " + ch2) ;
}
};
结果:ch1 = a
ch2 = a
浮点数类型和双精度浮点数类型
在日常生活经常会使用到小数类型的数值,如身高,体重等,整数将不能满足程序的要求,在数学中,这些带有小数点的数值称为实数。在java中,这种数据类型称为浮点数类型(float).
需要注意的是,使用浮点型数值时,默认的类型是double,在数值后面加上D或者是d,作为double类型的标识。在java中,D或d是可有可无的。在数据后面加上f或者F,则作为float类型的识别。弱没有加上,java就会将该数据默认为double类型
实例代码
public class Demo{
public static void main(String args[]){
float num = 3.0f ; //定义一个浮点型变量
System. out.println("两个小数相乘:" + num * num) ;
}
};
结果:两个小数相乘:9.0
布尔类型
boolean类型那个的变量只有true和false两种。当将一个变量定义成布尔类型时,它的值只能是true或者false,除此之外,没有其他的值可以赋给这个变量
实例代码
public class Demo{
public static void main(String args[]){
boolean flag = true ; //定义布尔型变量
System. out.println("flag = " + flag) ; //打印输出
}
};
结果:flag = true
数据类型的转换
java的数据类型在定义时已经确定了,因此不能随意转换成其他类型的数据类型,但java允许用户有限度的做类型转换处理。
java会在下列条件都成立时,自动做数据转换类型
1 转换前的数据类型与转换后的类型兼容
2 转换后的数据类型的表示范围比转换前的类型大
实例代码
public class Demo{
public static void main(String args[]){
int x = 30; //定义整型变量
float y = 22.19f; //定义浮点型变量
System. out.println("x / y = " + (x / y)) ;
System. out.println("10 / 3.5 = " + (10 / 3.5)) ;
System. out.println("10 / 3 = " + (10 / 3)) ;
}
};
结果:x / y = 1.3519603
10 / 3.5 = 2.857142857142857
10 / 3 = 3
PS:如果2个int类型的常量进行计算,最终结果还是int类型,而其小数部分将会被忽略.
PS:任何类型的数据碰到String类型的变量或者常量之后都会向String类型转换
运算符,表达式与语句
赋值运算符
赋值运算符号(=)
实例代码
public class Demo{
public static void main(String args[]){
int num = 22 ;
System. out.println("第一次输出:num = " + num) ;
num= num - 3 ; // 修改变量内容,java会先处理等号后面num-3的部分,再赋值给等号前面的变量num
System. out.println("第二次输出:num = " + num) ;
}
};
结果:第一次输出:num = 22
第二次输出:num = 19
一元运算符
+ 正号
- 负号
! NOT,否
实例代码
public class Demo{
public static void main(String args[]){
boolean b = false ;
int x = 10 ;
int y = -30 ;
System. out.println("b = " + b + ", !b = " + !b) ; //取反
System. out.println("x = " + x + ", -x = " + -x) ; //使用符号
System. out.println("y = " + y + ", +y = " + +y) ; //使用正号
}
};
结果:
b = false, !b = true
x = 10, -x = -10
y = -30, +y = -30
算数运算符
算数运算符在数学中经常用到
+ 加法
- 减法
* 乘法
/ 除法
% 取模(取余数)
实例代码
public class Demo{
public static void main(String args[]){
int i = 10 ;
int j = 3;
System. out.println(i + " + " + j + " = " + (i+j)) ; //加法操作
System. out.println(i + " - " + j + " = " + (i-j)) ; //减法操作
System. out.println(i + " * " + j + " = " + (i*j)) ; //乘法操作
System. out.println(i + " / " + j + " = " + (i/j)) ; //加法操作
System. out.println(i + " % " + j + " = " + (i%j)) ; //取模操作
}
};
结果:10 + 3 = 13
10 - 3 = 7
10 * 3 = 30
10 / 3 = 3 如果2个int类型的常量进行计算,最终结果还是int类型,而其小数部分将会被忽略.
10 % 3 = 1
关系运算符
> 大于
< 小于
>= 大于等于
<= 小于等于
!= 不等于
== 等于
实例代码
public class Demo{
public static void main(String args[]){
System. out.println("3 > 1 = " + (3 > 1)) ; //使用大于号
System. out.println("3 < 1 = " + (3 < 1)) ; //使用小于号
System. out.println("3 >= 1 = " + (3 >= 1)) ; //使用大于等于号
System. out.println("3 <= 1 = " + (3 <= 1)) ; //使用小于等于号
System. out.println("3 == 1 = " + (3 == 1)) ; //使用等于号
System. out.println("3 != 1 = " + (3 != 1)) ; //使用不等于号
}
};
结果:3 > 1 = true
3 < 1 = false
3 >= 1 = true
3 <= 1 = false
3 == 1 = false
3 != 1 = true
自增与自减运算符
自增与自减运算符也是各个语言最常见的运算符,因为它们具有相当大的便利性
a=a++//a加1后再赋值给a存放
++a//直接给a加1
实例代码
public class Demo{
public static void main(String args[]){
int a = 3 , b = 3 ; //定义两个变量a和b
int x = 6, y = 6 ; //定义两个变量x和y
System. out.println("a = " + a) ;
System. out.println("\t a++ = " + (a++) + ", a = " + a) ; //先计算后自增
System. out.println("b = " + b) ;
System. out.println("\t ++b = " + (++b) + ", b = " + b) ; //先自增后计算
System. out.println("x = " + x) ;
System. out.println("\t x-- = " + (x--) + ", x = " + x) ; //先计算后自减
System. out.println("y = " + y) ;
System. out.println("\t --y = " + (--y) + ", y = " + y) ; //先自减后计算
}
};
结果:
a = 3
a++ = 3 , a = 4
b = 3
++b = 4 , b = 4
x = 6
x-- = 6 , x = 5
y = 6
--y = 5 , y = 5
逻辑运算符
&--------and,与
&&-------短路与
|--------or,或
||-------短路或
当使用逻辑运算符&&时,运算符前后的两个操作数的返回值都为真,运算的结果才会为真;使用逻辑运算符||时,运算符前后的两个操作数的返回值只要有一个为真,运算的结果就为真。
public class Demo{
public static void main(String args[]){
boolean a = true ;
boolean b = false ;
System. out.println("a || b = " + (a || b)) ;
System. out.println("a | b = " + (a | b)) ;
System. out.println("a && b = " + (a && b)) ;
System. out.println("a & b = " + (a & b)) ;
}
};
结果:
a || b = true
a | b = true
a && b = false
a & b = false
问题:为什么会有两种与和或操作?
与分为短路与和非短路与,或分为短路或和非短路或。
1 对于与(&&,&)来说,如果第一个条件结果为假,则后面条件不管真假,最终的结果都为假
2 对于或(||,|)来说,如果第一个条件结果为真,则后面条件不管真假,最终的结果都为真
那么也就是对于与和或来会说,第一个条件就是一个关键性的条件,在java中设置了短路与和短路或
3 对于与(&&,&)来说,要求所有的条件都判断,而如果使用了短路与(&&),第一个条件又为false,则后面的条件将不再判断
4对于或(||,|)来说,要求所有的条件都判断,而如果使用了短路与(||),第一个条件又为true,则后面的条件将不再判断
验证'&'(与)的作用
public class Demo{
public static void main(String args[]){
if(10!=10&10/0==0) {//因为&会把2个条件都验证一次
System. out.println("条件满足") ;
}
}
};
结果:程序报错java.lang.ArithmeticException: / by zero
验证'&&'(短路与)的作用
public class Demo{
public static void main(String args[]){
if (10!=10&&10/0==0) {//使用了短路与(&&),第一个条件又为false,则后面的条件将不再判断
System. out .println( "条件满足") ;
}
}
};
结果:无输出,不报错
验证'|'(或)的作用
public class Demo{
public static void main(String args[]){
if (10==10|10/0==0) {//因为|会把2个条件都验证一次
System. out .println( "条件满足") ;
}
}
};
结果:程序报错java.lang.ArithmeticException: / by zero
验证'||'(短路或)的作用
public class Demo{
public static void main(String args[]){
if (10==10||10/0==0) {//使用了短路或(||),第一个条件又为true,则后面的条件将不再判断
System. out .println( "条件满足") ;
}
}
};
结果:条件满足
位运算符
位运算符操作就是指进行二进制的运算
&---------按位与
|---------按位或
^---------异或(相同为0,不同为1)
~---------取反
<<--------左移位
>>--------右移位
>>>-------无符号移位
在java中所有的数据都是以而进制数据的形式进行运算的,即如果一个int型变量,要采用位运算时必须将其变为二进制数据。每一位二进制进行与,或,异或操作的结果如下
二进制数1---二进制数1---与操作(&)---或操作(|)---异或操作(^)
0 0 0 0 0
0 1 0 1 1
1 0 0 1 1
1 1 1 1 0
选择与循环语句
程序的结构有顺序结构,选择结果和循环结构三种。
顺序结构代码实例
public class Demo{
public static void main(String args[]){
System. out.println("顺序结构1" ) ;//依次打印信息
System. out.println("顺序结构2" ) ;//依次打印信息
System. out.println("顺序结构3" ) ;//依次打印信息
}
}
结果:顺序结构1
顺序结构2
顺序结构3
选择结构
选择结构是根据条件的成立与否决定要执行哪些语句的一种结构。这种结构可以依据判断条件的结构来决定要执行的语句。当判断条件为真时,就执行语句1;当判断条件为假,就执行语句2.
选择结构结构包括if,if...else,和switch语句,语句中加了选择结构之后,就像是十字路口,根据不同的选择,程序会有不同的结果
if语句
根据判断的结构来执行不同的语句时,使用if语句就是一个很好的选择,它会准确的检测判断条件是否成立,再决定是否要执行后面的语句
格式:
if(判断条件){
语句1;
语句2;
}
实例代码
public class Demo{
public static void main(String args[]){
int x = 3; //定义整型变量3
int y = 10 ; //定义整型变量10
System. out .println("=====比较开始 =====") ;
if (x>y){
System. out .println("x比y大!" );
}
if (x<y){
System. out .println("x比y小!" ) ;
}
System. out .println("=====比较完成 =======") ;
}
}
结果:=====比较开始 =====
x比y小!
===== 比较完成 =======
if...else语句
当曾旭中存在含有分支的判断语句时,就可以使用if...else语句处理。当判断条件成立时,执行if语句主体;判断条件不成立时,执行else后面的语句主体。
语句格式
if(判断主体){
语句主体1;
}else{
语句主体2;
}
实例代码
public class Demo{
public static void main(String args[]){
int x = 3; //定义整型变量x
if(x%2==1){ //判断于是是否为1
System. out.println("x是奇数!" ) ; // 如果余数为1表示奇数
} else{
System. out.println("x是偶数!" ) ; // 如果余数为0表示是偶数
}
}
}
结果:x是奇数!
三目运算符
有一种运算符可以代替if...else语句,就是三目运算符
变量 =判断条件?表达式1:表达式2,当条件成立时,就执行表达式1,否则执行表达式2
代码实例:使用三目运算符求2个数字中的最大值
public class Demo{
public static void main(String args[]){
int max = 0 ; //保存最大值
int x = 3; //定义整型变量x
int y = 10 ;
max= x>y?x:y ; //通过三目运算符求出最大值
System. out.println("最大值为:" + max) ;
}
}
结果:最大值为:10
switch语句
switch语句可以将多选一的情况简化,使程序更加简洁.
语句格式
switch(表达式){
case 选择值1: 语句主体1
break;
case 选择值2:语句主体2
break;
default:语句主体
}
switch流程
1先计算括号内表达式的结果(数字,字符,枚举)
2根据表达式的值检测是否符合case后面的选择值。若是所有值都不符合,则执行default语句,执行完毕立即离开switch语句
3如果某个case的选择值符合要求,则执行该case的语句,一直到break语句后才离开swtich语句
4若是没有在case后加上break语句,则会一直执行到switch的尾端才离开
代码实例
public class Demo{
public static void main(String args[]){
int x = 3 ;
int y = 6 ;
char op = '+' ;
switch(op){
case '+' :{ //执行加法操作
System. out.println("x + y = " + (x + y )) ;
break ;
}
case '-' :{ //执行减法操作
System. out.println("x - y = " + (x - y )) ;
break ;
}
default:{
System. out.println("未知的操作!" ) ;
break ;
}
}
}
}
结果:x + y = 9
循环结构
while是循环语句,也是条件判断语句。当事先不知道循环多少次该执行时,就要用到while
语句格式
while(循环条件判断){
语句1;
语句2;
循环条件更改;
}
实例代码
public class Demo{
public static void main(String args[]){
int x = 1;
int sum = 0 ; //保存累加的结果
while(x<=10){
sum+= x ; //进行累加操作
x++; //修改循环条件
}
System. out.println("1 --> 10累加的结果为:" + sum) ;
}
}
结果:1 --> 10累加的结果为:55
do....while循环
do....while循环是每次都是先执行一次循环主体,然后再测试判断条件的真假。无论循环成立的条件是什么,使用do....while循环时,至少都会执行一次循环主体
语句格式
do{
语句1
语句2
循环条件改变
}while(循环条件改变)
实例代码
public class Demo {
public static void main(String args[]) {
int x = 1;
int sum = 0;
do {
sum+= x;
x++;
} while (x <= 10);
System. out.println("1 --> 10累加的结果为:" + sum);
}
}
结果:1 --> 10累加的结果为:55
for循环
知道循环次数的情况下,就可以使用另外一种循环语句--for循环。
语句格式
for(赋值初值;判断条件;赋值增减量){
语句1;
语句n;
}
代码实例
public class Demo {
public static void main(String args[]) {
int sum = 0;
for (int i =0; i <= 10; i ++) {
sum+= i;
}
System. out.println("1 --> 10累加的结果为:" + sum);
}
}
结果:1 --> 10累加的结果为:55
循环的中断
break语句可以强迫程序中断循环,当程序执行到break语句时,即会离开循环,继续执行循环外的下一个语句。如果break语句出现在嵌套循环中的内层语句,则break会跳出当前层的循环
实例代码
public class Demo {
public static void main(String args[]) {
for(int i=0;i<10;i++){//使用for循环
if(i==3){//如果i的值为3,则退出整个循环
break ;//退出循环
}
System. out.println("i = " + i) ;//打印信息
}
}
}
countinue语句
continue语句可以强迫程序跳到循环的起始处,当程序运行到continue语句时,会停止运行剩余的循环体而是回到循环开始处继续运行。
所以continue只是中断了一次循环
实例代码
public class Demo {
public static void main(String args[]) {
for(int i=0;i<5;i++){//使用for循环
if(i==3){//如果i的值为3
continue ;//退出一次循环
}
System. out.println("i = " + i) ;//打印信息
}
}
}
结果:i = 0
i = 1
i = 2
i = 4
java基础学习小结
1 java的数据类型分为基本数据类型和引用数据类型
2 Unicode为每个字符制订了一个唯一的数值,在任何的语言,平台程序都可以放心的使用
3 boolean类型的变量只有true和false两个值
4 算数运算符的成员有加法,减法,乘法,除法和余数运算符
5 if语句可依据判断的结果来决定程序的流程
6 自增与自减运算符有相当大的便利性,利用他们可提高程序的简洁程度
7 当表达式中有类型不匹配时,有下列的处理方法
1占用较少字节的数据类型会转换成占用较多字节的数据类型
2有short和int类型时,则用int类型
3字符类型会转换成short类型
4若一个操作数的类型为double,则其他的操作数也会转换成double类型
8 break语句可以强迫程序中断循环,当程序遇到break语句时,即会离开循环,继续执行到循环外的下一个语句。如果break语句出现在嵌套循环中的内层循环,则break语句只会跳出当前层的循环
9 continue语句可以强迫程序跳到循环的起始处,当程序运行到continue语句时,会停止运行剩余的循环体而是回到循环开始处继续运行。
所以continue只是中断了一次循环