java ——概要、变量与运算符

✍作者：电子科大不知名程序员

🌲专栏：java学习指导

各位读者如果觉得博主写的不错，请诸位多多支持；如果有错误的地方，欢迎在评论区指出

命令行

d: 到D盘

dir 呈现目录

md java 创建文件夹，名字为java

cd d:\java 进入d盘中的java文件夹

cd… 退回到上一层目录（文件夹）

cd/ 回到整个盘（D)下

用上下键可以调出之前使用到过的指令

del 1.doc 删除文件名为1.doc的文件

del *.txt 删除所有以.txt结尾的文件

rd team2 删除名为team2的文件夹（目录）（前提：team2是空文件）

del team1 删除team1内容中的文件（删除的还是文件）

cd/ 推到盘的根目录位置

java的环境搭建

JDK java开发工具包（包含JRE:运行环境（虚拟机（JVM）+核心类库））

JVM：java虚拟机（使java程序具有跨平台性）

JDK在不同的操作系统不一样（因为不同操作系统对应的JVM不一样）

HelloWorld

创建一个java格式的文件

实现流程：

先创建一个以java为后缀的文件，通过记事本打开后，形成源文件；然后再通过命令javac.exe来对该文件进行编译；形成.class文件（字节码文件）；再对此进行java.exe形成结果

在编译文件前，我们首先要到该文件所在的路径下；生成字节码文件的名字是我们创建的类名

按提示将其添加：

然后将main内添加一些内容：

源文件修改后需要重新编译

注意：java中需要严格区分大小写

注释（Comment）

特点：注释内容不参与编译（生成的.class文件中不包含注释的信息）

文档注释：java特有

注释内容可以被JDK提供的工具javadoc所解析，生成一套以网页形式体现的该程序的说明文档（包含作者和版本）

多行注释不能嵌套使用！

java API的文档

总结

1.JDK，JRE，JVM三者之间的关系

JDK=JRE+java开发工具（javac.exe,java.exe,javadoc.exe)

JRD=JVM+Java核心类库

2.为什么要配置path环境变量？

使某个程序，比如javac.exe，在任意目录下都可以运行

package my_first_java_code;public class 输出 {public static void main(String[] args) {System.out.println("name:");System.out.println(); System.out.println("address:");}
}

System.out.println();//这里是println，意思是输出的占一行，因此这里什么都不写的意思就是换一行

println理解为输出一段字符串后换行，我们也可以使用print然后加\n达到换行的目的

运行结果如下：

关键字与保留字

关键字

保留字：现java版本尚未使用，但以后版本可能会作为关键字使用（goto、const）

标识符

java对各种变量、方法、类等要素取名时使用的字符序列称为标识符

技巧：凡是可以自己取名字的地方都叫标识符

标识符的命名规则：

1.26个英文大小写、下划线、0-9或$；

2.数字不能作为开头；

3.不能使用关键字和保留字，但可以包含它们

4.严格区分大小写，长度无线制

5.标识符不能含有空格

java的命名规范

包名：多单词组成所有字母都小写

类目、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz

变量名，方法名：多单词组成，第一个单词首字母小写，第二个单词开始每个单词首字母大写

常量名：所有字母都大写。多单词用下划线连接

以上要求，如果不遵守也不会对编译产生什么影响，但建议还是要遵守

起名字的时候，尽量做到见名知意，不要出现中文；

变量

类型：字符串、整型、浮点型、布尔类型…（java要求的是强类型，使用变量时需要规定变量类型）

包含：变量类型、变量名、储存的值

变量需要先声明赋值再使用（未定义、未被赋值都不行）

定义格式：数据类型 变量名=变量值;

package my_first_java_code;public class 定义变量 {public static void main(String args) {int myAge=18;System.out.println(myAge);//注意，这里不加双引号，因为不是字符串了}
}

变量都定义在作用域内（作用域即是{}内），出作用域后不能使用；同一个作用域内不能定义同名的变量

数据类型

整型

分析，一个byte有8个比特位，由0、1组成一共有2^8=256种组合，由于要区分正负，我们将它对半分开，即可得到它的表数范围

特别的，声明long型变量，必须以“l”或"L"结尾

long L1=1234567;

通常定义整型变量时使用int型

浮点型

float（4字节）\double（8字节）

浮点型，表示带小数点的数值；

1.如图即可产生一个问题：同样都是占4个字节的空间，为什么float表数范围比int、long还要大？

​ 因为float表示数值的方式是以幂次+小数的方式

2.定义float变量时，变量值的末尾从应该用“f”或“F”来表示

double d1=123.1;
System.out.println(d1);
float d2=123.1F;
System.out.println(d2);

3.通常定义浮点型变量时用double：范围更大、精度更高、书写时可以省区f/F

字符类型

char：一字符=2字节

1.定义char型变量通常使用一段单引号’ ’

char c1='a';
char c2='AB';    //wrong:只能声明一个字符
char c3='中';    //right:可以写一个汉字（或其它语言）    

2.表示方式：声明一个字符；转义字符

char c4='\n';     //right:换行符

于是下列两端代码表示相同的意思:

System.out.println("hello");

System.out.print("hello+c4");

3.直接使用Unicode值来表示字符型常量

char c5='\u0043';

布尔型

boolean

1.只能取两个值之一：true/false

boolean bb1=true;
boolean bb2=false;

注意： 与C语言不同，C语言用0/1来判断，而java就是用的true和flase来表示

2.常常在条件判断、循环结构中使用

基本数据类型间的运算

基本数据类型之间的运算规则：

前提：这里讨论的是7种数据类型变量间的运算，不会包含boolean类型的

1.自动类型提升：

byte b1=2;
int i1=129;
byte b2=b1+i1;     //wrong
int i2=b1+i1;      //right
long l1=b1+i1;     //right
float f1=b1+i1;    //right

​ byte、char、short------> int------> long ------>float ------>double

​ 结论：当表示数的容量小的数据类型的变量与容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型

​ 特别的：当byte、char、short三种类型的变量做运算时，结果为int类型**（就算是short和short这种同类型的，它们的结果仍是int来接收）**

2.强制类型转换：自动类型提升的逆运算

double d1=12.3;
int i1=d1;           //wrong

double d1=12.3;
int i1=(int)d1;      //若输出i1，值为12，该操作为截断操作

需要使用强转符：（）；强制类型转换后可能导致精度损失

编码情况

1.定义long型未加L------> 系统会默认为int型，若遇到过大的整数则会编译失败

​ 若float型未加F：编译失败

2.对于整型常量，默认类型为int型；浮点常量默认类型为double型

short s1=1;
short s2=s1+1;    //wrong:1的类型为int型

String

String类型变量的使用：

1.String属于引用数据类型,翻译为：字符串

2.声明String类型变量时，**使用一对" "*8

String s1="hello world";
System.out.println(s1);

3.String类型" "内可以什么都没有，而char’ '内必须且只能放一个字符

String s="";   //right
char c='';     //wrong

4.String可以和8种基本数据类型变量做运算，且运算只能是连接运算；运算结果仍为String类型

int number=1001;
String numberStr="学号：";
String info=numberStr+number;    //+:连接运算

我们来分析如下程序

情况1：

public class StringTest {public static void main(String[] args) {String str ="hello";char c='a';  //a:97int num=10;System.out.println(c+num+str);      //107helloSystem.out.println(c+str+num);      //ahello10System.out.println(c+(num+str));    //ahello10System.out.println((c+num)+str);    //107hello}
}

由于a的ASCII码值为97，因此再做c+num（a+10)时是一个字符类型+整型的运算，使用ASCII码来计算

情况2:

package my_first_java_code;public class StringTest2 {public static void main(String[] args) {//输出*	*System.out.println('*'+'\t'+'*'); //ASCLL码作加法运算，结果为int型System.out.println('*'+"\t"+'*'); //有Strin后+代表连接System.out.println('*'+'\t'+"*"); //前面的是char类型加法，后面为String再连接System.out.println('*'+('\t'+"*"));}
}

运行结果如下：

进制与进制间的转换

2进制：以0b或0B开头

8进制：以数字0开头表示

16进制：0-9及A-F，以0x或0X开头

public class Conversion_between_bases {public static void main(String[] args) {int num1=0b110;int num2=110;int num3=0127;int num4=0x110A;System.out.println("num1= "+num1);System.out.println("num2= "+num2);System.out.println("num3= "+num3);System.out.println("num4= "+num4);}
}

运行结果如下：

系统会将他们的值转为10进制

运算符

算术运算符

+：正号、加、字符串连接

1.除号

int num1=12;
int num2=5;
int result1=num1/num2;
System.out.println(result1);    //2int result2=num1/num2*num2;
System.out.println(result2);    //10double result3=num1/num2;
System.out.println(result3);    //2.0double result4=num1/(num2+0.0);   
System.out.println(result4);    //2.4double result5=(double)num1/num2; 
System.out.println(result5);    //2.4

2.取模号

​ %：取余运算------>结果的符号与被模数的符号相同 被模数%模数=余数

3.自增/自减

++a：先让a自增1后再使用；a++先使用再让a自增1（对于--来说同理）

注意：自增从自减不会改变本身变量的数据类型

short s1=10;
s1=s1+1;            //wrong:这里的1是int型
s1=(short)(s1+1);   //right
s1++;               //right:自增1不会改变本身变量的数据类型

问题：

byte b1=127;
b1++;
System.out.println("b1="+b1);    //-128(按二进制的本质来理解即可)

赋值运算符

= += -= *= /= %=

1.赋值

//连续赋值
int i1,i2;  
i1=i2=10;                   //rightint i1=10;i2=10;            //right

2.对于 += -= *= /= %=它们来说，和自增自减一样不会改变本身变量的数据类型

3.开发中如果希望变量实现+2的操作的方法：

num=num+2;      
num+=2;      //更好

比较运算符

比较运算符"==“不能误写成”="

public class CompareTest {public static void main(String[] args) {int i=10;int j=20;System.out.println(i==j);  //判断是否相等System.out.println(i=j);   //将j的值赋值给i后输出boolean b1=true; boolean b2=false;System.out.println(b2==b1); //判断是否相等System.out.println(b2=b1);  //赋值后输出}
}

逻辑运算符

&      逻辑与
|      逻辑或
!      逻辑非
&&     短路语
||     短路或
^      逻辑异或（两者不同值为true,两者相同值为false）

我们发现，&和&&；|和||好像一样，那它们有什么区别呢

说明：逻辑运算符操作的都是boolean类型的变量

1.&和&&的区别（且）

​ &和&&的运算结果相同 ；当符号左边是false时，两者都会执行符号右边的结果

​ 不同：当符号左边是false时，&会继续执行符号右边的运算，&&不再执行符号右边的运算**（短路）**

2.|和||的区别（或）

​ |和||的运算结果相同 ；当符号左边是false时，两者都会执行符号右边的结果

​ 不同：当符号左边是false时，|会继续执行符号右边的运算，||不再执行符号右边的运算**（短路）**

【总结】：开发者用短路语&&、||更好

位运算符

其中&、|、^在逻辑运算符中也存在

移位操作符：移动的是二进制

我们先引入进制的概念:

例如数值15 15-十进制表示=1*10^1+5*100 而15换算成八进制即为17

那么我们知道，15的二进制表示为1111，1111称为15的二进制序列

整型的二进制表示：原码、反码、补码

15 整数，在C语言可以存放到int类型的变量中，int类型是4个字节-32bit,其中最高位（32位）叫做符号位

15 00000000 00000000 00000000 00001111 -原码

15 00000000 00000000 00000000 00001111 -反码

15 00000000 00000000 00000000 00001111 -补码

正整数的原码、反码、补码相同

---

-15 由于它是负数，它的最高位是1表示负数

-15 10000000 00000000 00000000 00001111 -原码 ：负数的原码最高位为1，其它位不变

-15 11111111 11111111 11111111 11110000 -反码：原码的符号位不变，其他位按位取反

-15 11111111 11111111 11111111 11110001 -补码：反码的二进制位加一即得补码

整数在内存中的存储是二进制的补码，移位操作符移动的是存储在内存中的补码

左移

#include<stdio.h>
int main(){int a = 4;//00000000 00000000 00000000 00000100  - 4的原码、补码int b = a << 1;     //把a向左移动一位printf("a=%d b=%d\n", a, b);return 0;
}

运行结果如下：

00000000 00000000 00000000 00000100 - 4的补码向左移动移位后移动后结果是00000000 000000000 00000000 00001000（补码向左移动一位），那么对应的值b为8

左移有扩大一倍的效果

右移

1.逻辑右移：右边丢弃，左边补0

2.算术右移：右边丢弃，左边补原符号位（一般编译器采用算术右移）

右移方式取决于编译器

对于移位操作符，不要移动负数位，这个标准是未定义的

右移有缩小一倍的效果

三元运算符

格式：（条件表达式）？表达式1：表达式2

逻辑：条件表达式==true ------>表达式1(且表达式1作为整个表达式的值)

​ 条件表达式==false------>表达式2(且表达式2作为整个表达式的值)

//找a，b中的较大值
int max=(m>n)?m:n    //a如果大于b则输出a否则输出b

要求：表达式1和表达式2要统一类型

三元运算符是可以嵌套使用的

//获取三个数的最大值(n1,n2,n3)
int max1=(n1>n2)?n1:n2;
int max2=(max1>n3)?max1:n3;
//这里可以嵌套，但可读性太差了

三元运算符与if-else：

凡是可以使用三元运算符的地方，都可以改写成if-else，但逆过来就不一定了

• 4的补码向左移动移位后移动后结果是00000000 000000000 00000000 00001000（补码向左移动一位），那么对应的值b为8

左移有扩大一倍的效果

右移

1.逻辑右移：右边丢弃，左边补0

2.算术右移：右边丢弃，左边补原符号位（一般编译器采用算术右移）

右移方式取决于编译器

对于移位操作符，不要移动负数位，这个标准是未定义的

右移有缩小一倍的效果