java基础语法学习

变量本质上就是代表一个”可操作的存储空间”，空间位置是确定的，但是里面放置什么值不确定。我们可通过变量名来访问“对应的存储空间”，从而操纵这个“存储空间”存储的值；
Java是一种强类型语言，每个变量都必须声明其数据类型。变量的数据类型决定了变量占据存储空间的大小。比如，int a=3; 表示a变量的空间大小为4个字节；
变量作为程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。变量在使用前必须对其声明, 只有在变量声明以后，才能为其分配相应长度的存储空间。

变量的声明：

int a=10;
double b;
//"int"、"double"均为数据类型，"a"、"b"为变量声明；
//可以在声明变量的同时给变量进行初始化 ；也可以先声明再初始化；

int a,b,c;
/*可以一行声明多个变量*/
int a;
int b;
int c;
/*也可以分别声明*/
/*推荐使用第二种声明方法*/

变量有局部变量、成员变量、静态变量三类。

常量：

int a=3.14;
String  b='c';
/*其中“a”，“b”为变量，“3.14”，“c”为常量*/

final int AGE = 100;
/*Java中可利用"final"来定义常量*/
final type varName = value;     // 声明格式

/*一般将“3.14”，“c”成为字面常量，使用final修饰的称为符号常量*/

变量和常量命名规范：

所有变量、方法、类名：见名知意
类成员变量：首字母小写和驼峰原则: monthSalary
局部变量：首字母小写和驼峰原则
常量：大写字母和下划线：MAX_VALUE
类名：首字母大写和驼峰原则: Man, GoodMa
方法名：首字母小写和驼峰原则: run(), runRun(）

基本数据类型：

整型变量/常量：

变量：

byte：占一个字节，表示范围-2^7~2^7-1(-128~127)；
short：占两个字节，表示范围-2^15~2^15-1(-32768~32767);
int：占四个字节，表示范围-2^31~2^31-1(约21亿)，Java默认整型为int类型；
long：占八个字节，表示范围-2^63~2^63-1，声明long类型要在后面加l或L；

常量：

有十进制、二进制（0b或0B开头）、八进制（0开头）、十六进制（0x或0X开头）

常见错误：

byte a=200;
//200超出了byte类型表示的范围，导致程序报错
long = 220000000;
//java默认类型为int类型，故22亿超出了int类型表示的范围，同样会报错，
long = 220000000L;  //正确赋值

/*
15  0b11  0x15 015分别表示十进制、二进制、十六进制、八进制整型常量；
*/

浮点型变量/常量：

变量：

float：占四个字节，单精度类型，尾数最高精确的7位有效数字；
double：占八个字节，双精度类型，表示浮点数值更精确，为java默认浮点数类型

常量：

带小数部分的十进制数，或者使用e或E代替10的科学计数法表示的数；

float = 3.14;//Java默认浮点数类型为double类型，所以3.14表示为double类型的浮点数
float = 3.14F;//正确赋值，也可用f

/*
3.14   314e-2  314E-2都表示浮点数常量；
*/

关于浮点数之间的比较：

public class HollowWord {
    public static void main(String[] args){
        double a = 3.14;
        double b = 314/100;
        if(a==b){System.out.println("True");}
        else{System.out.println("False");}
    }
}
//浮点数不能直接比较

java.math包下面的两个有用的类：BigInteger和BigDecimal，这两个类可以处理任意长度的数值。BigInteger实现了任意精度的整数运算。BigDecimal实现了任意精度的浮点运算。

import java.math.BigDecimal;//引用math库
public class HollowWord {
    public static void main(String[] args){
        BigDecimal a = BigDecimal.valueOf(1.0);
        a = a.subtract(BigDecimal.valueOf(0.1));//表示a-0。1
        a = a.subtract(BigDecimal.valueOf(0.1));
        a = a.subtract(BigDecimal.valueOf(0.1));
        a = a.subtract(BigDecimal.valueOf(0.1));
        a = a.subtract(BigDecimal.valueOf(0.1));//输出结果a=0.5
        double b = 1.0-0.1-0.1-0.1-0.1-0.1;//输出结果b=0.5000000000000001
        System.out.println(a);
        System.out.println(b);
        BigDecimal c = BigDecimal.valueOf(0.1);
        BigDecimal d = BigDecimal.valueOf(1.0/10);
        System.out.println(c.equals(d));/*equals用于判断c，d是否相等，相等返回true，不相等反回false，该程序输出结果为true*/
    }
}

浮点数存在舍入误差，数字不能精确表示。如果需要进行不产生舍入误差的精确数字计算，需要使用BigDecimal类。
避免比较中使用浮点数，需要比较请使用BigDecimal类

字符型常量/变量：

变量：

char：表示字符类型，用来表示unicode编码中的字符，占两个字节（Unicode编码被设计用来处理各种语言的文字，它占2个字节，可允许有65536个字符。）

常量：

Java中使用单引号来表示字符类型的常量；也可用从’\u0000’到’\uFFFF’之间的十六进制值来表示（前缀为u表示Unicode）

常用的转义字符表：

转义符	含义	对应unicode编码
\n	换行符	\u000a
\t	水平制表符	\u0009
\b	退格符（backspace）	\u0008
\r	回车	\u000d
\"	双引号	\u0022
\'	单引号	\u0027
\\	反斜杠	\u005c

public class HollowWord{
    public static void main(String[] args){
        char a = 'a';//'a'表示字符常量a
        //char b ='abc';程序会报错，abc属于字符串，不是字符
        char c = '\u0072';//用十六进制的Unicode编码表示字符
        char d = 'd';//字符要使用单引号括起来
        System.out.println(a+d);//输出结果为197，字符相加其实是字符的Unicode编码相加
        System.out.println(c);//输出结果为r，即'\u0072'表示字符'r'
        System.out.println(a+"\n"+d);//输出结果为两行，'\n'为换行符
        System.out.println((int)a);/*输出结果为97，int为强制类型转换，将a由char类型转换为int类型，故输出结果为a的Unicode编码值*/
    }
}

布尔类型变量/常量：

变量：

boolean：占一位，不可以使用0、1替换；

常量：

布尔类型常量true和false；

运算符：

算术运算fu符：

算术运算符包括二元运算符有+、-、*、/、%，一元运算符有--、++；

二元运算符的规则：

如果操作数有一个为long类型，则结果也为long类型；
没有long类型则结果为int类型，即使操作数全为，short，byte类型结果也为int类型；
如果操作数有一个为double类型，结果为double类型；
只有两个操作数均为float类型，结果才为float类型。

public class HollowWord{
    public static void main(String[] args){
        //int a = 12L+12;  //程序报错，因为12L为long类型故结果为long类型
        byte b = 1;
        byte c = 2;
        //byte d = b+c;  //程序报错，因为两个byte类型的数计算结果为int类型
        int f = b+c;
        double e = 0.1;
        float g = 0.1F;
        //float h = e+g;  //程序报错，因为e为double类型，故e+g结果为double类型
        double l = e+g;
    }
}

取模运算：

其操作数可以为浮点数,一般使用整数，结果是“余数”，“余数”符号和左边操作数相同，如：7%3=1，-7%3=-1，7%-3=1。

一元运算符自增/自减：

算术运算符中++，--属于一元运算符，该类运算符只需要一个操作数。

public class HollowWord{
    public static void main(String[] args){
        int a = 1;
        int b = 2;
        a = b++;  //先将a的值赋给b，然后b在自增，所以输出a=2，b=3；
        System.out.println("a="+a+"\nb="+b);
        a = ++b;  //b先自增，然后再将自增后的值赋给a，所以输出结果为a=4，b=4
        System.out.println("a="+a+"\nb="+b);
    }
}

赋值及其扩展赋值运算符：

运算符	用法举例	等效表达式
+=	a+=b	a=a+b
*=	a*=b	a=a*b
-=	a-=b	a=a-b
/=	a/=b	a=a/b
%=	a%=b	a=a%b

关系运算符：

包括有==、>=、<=、!=、>、<；

==、!= 是所有（基本和引用）数据类型都可以使用
> 、>=、 <、 <= 仅针对数值类型（byte/short/int/long, float/double。以及char）

逻辑运算符：

运算符		说明
逻辑与	&( 与)	两个操作数为true，结果才是true，否则是false
逻辑或	\|(或)	两个操作数有一个是true，结果就是true
短路与	&&( 与)	只要有一个为false，则直接返回false
短路或	\|\|(或)	只要有一个为true，则直接返回true
逻辑非	!（非）	取反：!false为true，!true为false
逻辑异或	^（异或）	相同为false，不同为true

短路与和短路或采用短路的方式。从左到右计算，如果只通过运算符左边的操作数就能够确定该逻辑表达式的值，则不会继续计算运算符右边的操作数，提高效率。

位运算符：

位运算符	说明
~	取反
&	按位与
\|	按位或
^	按位异或
<<	左移运算符，左移1位相当于乘2
>>	右移运算符，右移1位相当于除2取商

public class HollowWord{
    public static void main(String[] args){
        int a = 4; //对应的二进制数为0100
        int b = 2;  //对应二进制数为0010
        System.out.println(a&b); /*a b的二进制数对应位上分别进行与运算计算结果为0000即对应十进制0（按位与）*/
        System.out.println(a|b); /*a b的二进制数对应位上分别进行或运算计算结果为0110即对应十进制数6（按位或）*/
        System.out.println(a<<1); //左移一位相当于乘一个二，故输出结果为8
        System.out.println(a>>1);//右移一位相当于除一个二，故输出结果为2
        System.out.println(~a);
        System.out.println(a^b);/*a b的二进制数对应位上分别进行逻辑异或运算计算结果为0110即对应十进制数为6（按位异或）*/
    }
}

&和|既是逻辑运算符，也是位运算符。如果两侧操作数都是boolean类型，就作为逻辑运算符。如果两侧的操作数是整数类型，就是位运算符。

字符串连接符：

“+”运算符两侧的操作数中只要有一个是字符串(String)类型，系统会自动将另一个操作数转换为字符串然后再进行连接。

public class HollowWord{
    public static void main(String[] args){
        char a = 's';
        String b ="1";
        int c = 2;
        int d = 3;
        System.out.println(b+c);//因为b是字符串，故输出结果为12
        System.out.println(a+b);//输出结果为s1；
        System.out.println(c+d+b);//输出结果为51，因为先进行c+d结果为5，然后与字符串连接
        System.out.println(c+b+d);//输出结果为213，因为先进行c与字符串b连接得到字符串21，再与d连接得到213
    }
}

条件运算符（三目运算符）：

布尔类型表达式？表达式1:表达式2（若布尔类型表达式结果为true则计算表达式1，若布尔类型表达式结果为false则计算表达式2）

优先级	运算符	类	结合性
1	()	括号运算符	由左至右
2	!、+（正号）、-（负号）	一元运算符	由左至右
2	~	位逻辑运算符	由右至左
2	++、--	递增与递减运算符	由右至左
3	*、/、%	算术运算符	由左至右
4	+、-	算术运算符	由左至右
5	<<、>>	位左移、右移运算符	由左至右
6	>、>=、<、<=	关系运算符	由左至右
7	==、!=	关系运算符	由左至右
8	&	位运算符、逻辑运算符	由左至右
9	^	位运算符、逻辑运算符	由左至右
10	\|	位运算符、逻辑运算符	由左至右
11	&&	逻辑运算符	由左至右
12	\|\|	逻辑运算符	由左至右
13	? :	条件运算符	由右至左
14	=、+=、-=、*=、/=、%=	赋值运算符、扩展运算符	由右至左

逻辑与、逻辑或、逻辑非的优先级一定要熟悉！（逻辑非>逻辑与>逻辑或）。如：a||b&&c的运算结果是：a||(b&&c)，而不是(a||b)&&c

类型转换：

自动类型转换：

容量小的可以自动向容量大的类型转换（容量大小并不是指字节大小，如long类型为8个字节，float类型为4个字节但是long类型可以自动转换到float类型，但会损失一定的精度）
可以将整型常量直接赋给byte、short、char类型变量，而不需要进行强制类型转换，只要不超过其可表示范围；

强制类型转换：

语法格式：(type)var 运算符“()”中的type表示将值var想要转换成的目标数据类型。

类型转换常见问题：

int money = 1000000000; //10亿
int years = 20;
//返回的total是负数，超过了int的范围
int total = money*years;
System.out.println("total="+total);
//返回的total仍然是负数。默认是int，因此结果会转成int值，再转成long。但是已经发生//了数据丢失
long total1 = money*years; 
System.out.println("total1="+total1);
//返回的total2正确:先将一个因子变成long，整个表达式发生提升。全部用long来计算。
long total2 = money*((long)years); 
System.out.println("total2="+total2);

简单的键盘输入和输出：

import java.util.Scanner; //引用函数
public class HollowWord{
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入您的名字:");
        String name = scanner.nextLine(); //获取键盘输入
        System.out.println(name);
    }

}

https://www.sxt.cn/Java_jQuery_in_action/Java_Constant.html（以上内容整理于该课件）

可乐加冰67

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java基础语法学习

目录注释：标识符：标识符规则：标识符的规范：变量：变量的本质：变量的声明：常量：变量和常量命名规范：注释：单行注释：以“//”开头，“/*”后面部分即为注释内容；多行注释：以“/*”开头，“*/”结尾，“/*”与“*/”之间部分即为注释内容；文件注释：“/**”开头，“*/”结尾，“/**”与“*/”之间内容为注释内容；标识符：标识符规则：标识符必须以字母、下划线“_”、美元符开头；标识符其他部分可以是字母、下划线“_”，美元符和数字的任
复制链接

扫一扫