一. Java基础
1. 常见DOS命令
- exit：退出当前DOS命令窗口
- cls：清屏
- 复制：右键标记，选中内容，再点击右键
- cd 路径 (change directory)：改变目录
- 绝对路径：从盘符作为出发点的路径
- 相对路径：从当前路径下作为出发点的路径
- cd … ：回到上级目录（“…”代表上级目录，“.”代表当前目录）
- cd \ ：回到根目录
- 切换盘符：c: 回车；d: 回车；e: 回车
- del *.class：删除当前路径所有class文件
2. 编译与运行
-
.java文件：java源程序
-
.class文件：编译后的字节码文件
-
使用JDK中自带的javac.exe命令进行java程序的编译，javac在DOS命令窗口中使用
-
一个java源文件可以编译生成多个.class文件
-
java.exe命令主要负责运行阶段，在DOS窗口中使用
使用方法：java 类名
例如：硬盘上有一个A.class，则输入：java A （不能写成java A.class）
- 运行过程：
1. 打开DOS命令窗口，输入：java A
2. java.exe命令会启动Java虚拟机（JVM），JVM会启动类加载器ClassLoader
3. 默认情况下，ClassLoader在当前目录搜索A.class文件，找到该文件则将该字节码文件装载到JVM当中（也可以指定ClassLoader去某个指定路径加载字节码文件，这时需要配置环境变量classpath：classpath=.class文件所在路径。classpath属于java语言中的环境变量，不属于Windows操作系统【path变量属于操作系统】。当classpath配好后，类加载器只去指定路径加载文件）
4. JVM将A.class字节码文件解释成二进制数据，然后操作系统执行二进制和底层硬件平台进行交互
3. JDK安装
-
JDK安装时不需要再单独安装JRE（JDK已经自带JRE）
-
JDK目录介绍：
-
JDK/bin：存放命令如javac.exe和java.exe
-
配置环境变量：系统变量path下添加javac路径（\bin文件夹）
4. HelloWorld程序
- 打开记事本编写程序，文件格式改为.java
- java语句以“;”结束
- 空格符通常无关紧要： x == 3 ;
- java大小写敏感，public为小写
public class HelloWorld{ //表示定义一个公开的类，起名HelloWorld
//类体，类体中不允许直接编写java语句（除声明变量外）
/*
public表示公开的
static表示静态的
void表示空
main表示方法名是main
(String[] args)是一个main方法的形式参数列表
*/
public static void main(String[] args){ //表示定义一个公开的静态的主方法，是程序的入口（规定写法）
//一个程序只需要一个main方法
//方法体
//方法体中的java代码遵守自上而下的顺序执行，前一行代码执行结束后下一行才能执行
System.out.println("Hello World!"); //java语句以";"终止，向控制台输出字符串，java中所有字符串都必须在""里
}
}
-
打开命令行窗口输入javac 路径\HelloWorld.java，会在相同路径下生成.class文件
-
首先将目录切换到.class文件所在目录
-
输入java 类名，即java HelloWorld，输出Hello World!
-
源程序的注释：注释不会被编译到.class字节码文件中
javadoc注释信息会被javadoc.exe工具解析提取并生成帮助文档
//单行注释，只注释当前行
/*
多行注释
多行注释
多行注释……
*/
/**
* javadoc注释
* javadoc注释
* javadoc注释
*/
5. public class和class的区别
-
一个java源文件中可以定义多个class
-
一个java源文件中public的class不是必须的；若定义public class，则只能有一个，且与java源文件名相同
-
一个class会定义生成一个xxx.class字节码文件
-
每一个class中都可以编写main方法，都可以设定程序入口。想执行B.class中的main方法：java B
-
在命令窗口执行java A，要求A.class中必须有主方法
二. Java语言基础
1. 标识符
- 在java源程序中凡是程序员有权利命名的单词都是标识符
- 标识符在EditPlus中显示为黑色
- 标识符标识元素：类名、方法名、变量名、接口名、常量名……
- 标识符只能由“数字、字母、下划线_、美元符号$”组成，不能以数字开头
- 严格区分大小写，关键字不能做标识符，理论上无长度限制
public class IdentifierTest01 //IdentifierTest01是一个类名
{
//main是一个方法名
public static void main(String[] args){ //args是一个变量名
}
}
-
标识符命名规范：
见名知意，遵守驼峰命名方式：SystemService、UserService、CustomerService
类名、接口名：首字母大写，后面每个单词首字母大写
变量名、方法名：首字母小写，后面每个单词首字母大写
常量名：全部大写
2. 关键字、字面值
-
关键字是开发java语言时提前制定好的具有特定含义的字符
-
关键字在java语言中全部小写，在EditPlus中显示为蓝色
-
常见关键字：public、class、static、void……
-
字面值：10、100、3.14、“abc”、‘a’、true、false，字面值就是数据
-
数据类型：
整数型字面值：10、100
浮点型字面值：3.14
布尔型字面值：true、false
字符串型字面值：“abc”、“中国人”
字符型字面值：‘A’、‘人’
-
java语言中所有字符串型字面值必须用双引号；字符型字面值必须用单引号
3. 变量
-
变量本质是内存中的一块空间，这块空间有数据类型、有名字、有字面值
-
变量是内存中存储数据的最基本单元，变量使内存空间可以重复使用
-
数据类型指导程序在运行阶段应该分配多大的内存空间
-
变量赋值：变量名 = 字面值 i = 10
-
"="是赋值运算符，先运算等号右边的表达式，表达式执行结束后的结果赋值给左边的变量
-
声明和赋值可以一起完成：int i = 10
-
变量赋值后可以重新赋值，变量的值可变化：
int i = 10
System.out.println(i); //10
int i = 20
System.out.println(i); //20
int i = 100
System.out.println(i); //100
-
变量访问方式：
读取变量中保存的数据：get/获取 i = 20
修改变量中保存的数据：set/设置 System.out.println(i)
-
一行上可以声明多个变量：int a,b,c
-
java中的变量必须先声明才能访问，未赋值的变量没有初始化，编译时会报错
int a,b,c = 300 //a和b没有初始化，c赋值300
-
在同一个“作用域”中，变量名不能重复使用，变量可以重新赋值
-
变量的作用域：变量的有效范围，出了这个范围该变量就无法访问了（出了大括号就不认识了）
public class VarTest03{
static int k = 90； //这里的static不要去掉
public static void main(String[] args){
int i = 100； //变量i的作用域是main方法
System.out.println(i); //可以
System.out.println(k); //可以
}
public static void dosome(){
System.out.println(i); //这里已经不是i变量的作用域，错误
System.out.println(k); //可以
for(int a=0;a<10;a++){ //a变量的作用域是整个for循环，for循环结束后a变量的内存就自动释放了
}
System.out.println(a); //无法访问变量a
int j; //作用域是main方法
for(j=0;j<10;j++){
}
System.out.println(j); //访问的是main方法中的j变量
}
}
-
变量的分类：根据变量声明的位置分类
局部变量：在方法体中声明的变量
成员变量：在方法体外（类体之内）声明的变量，成员变量没有赋值系统会默认赋值（向0看齐）
-
在不同作用域中变量名可以相同
public class Vartest04{
int k = 200; //成员变量
public static void main(String[] args){
int i = 3; //局部变量
System.out.println(i); //java遵循“就近原则”,输出3
}
int i = 100;
}
4. 数据类型
-
数据类型的作用：指导JVM在运行程序的时候给该数据分配多大的内存空间
-
基本数据类型：（四大类八小种）
整数型：byte，short，int，long
浮点型：float，double
布尔型：boolean
字符型：char
-
字符串"abc"不属于基本数据类型，属于引用数据类型
-
八种基本数据类型各自占用空间大小：
基本数据类型 占用空间大小（字节） 取值范围 byte 1 -128 ~ 127 0 short 2 -32768 ~ 32767 0 int 4 -2147483648 ~ 2147483647 0 long 8 0 float 4 0.0f double 8 0.0d boolean 1 true、false false char 2 ‘\u0000’ -
字节（byte）：1 byte = 8 bit （1个字节 = 8个比特位），一个比特位表示一个二进制位：1/0
4.1 char类型：
public class DataTypeTest01
{
public static void main(String[] args){
char c = 'a'; //定义一个char类型的变量起名c，赋值为“a”
System.out.println(c); //输出c的值“a”
char b = 97; //表示将97对应的ASCII码字符赋值给b
char x = '国'; //一个中文占用两个字节，char类型也为两个字节
System.out.println(x); //输出“国”
char y = 'abc'; //abc是字符串，编译报错
char a = ''; //java中不允许这样编程，编译报错
char e = 'e';
e = 'f'; //char类型也可以改变赋值内容
System.out.println(e)； //输出“f”
}
}
- 转义字符“\”：转义字符出现在特殊字符前，会将特殊字符转换成普通字符
char c1 = 'n';
char c2 = '\n'; //'\n'是一个字符，表示换行
System.out.println //println表示输出之后换行
System.out.print //print表示输出后不换行
char x = 't';
char x = '\t'; //'\t'为制表符tab，与空格不同
char k = '\'; //反斜杠'\'将后面的单引号转义成不具备特殊含义的普通单引号字符
System.out,println(k) //左边的单引号缺少了结束的单引号字符，编译报错
char k = '\\'; //第一个反斜杠具有转义功能，能将后面的反斜杠字符转义为普通的反斜杠字符
System.out.println(k); //java中两个反斜杠代表一个普通的反斜杠字符
char a = '\''; //输出一个单引号'
System.out.println("\"Hello World\"") //\"表示普通的双引号输出"Hello World"
JDK中自带的native2ascii.exe命令，可以将文字转换成unicode编码模式：
在命令行输入native2ascii回车，然后输入文字即可得到unicode编码
char n = '\u4e2d'; //\u与后面四个字符表示unicode编码
System.out,println(n); //'中'对应的unicode编码是4e2d，输出“中”
- java中的integer与boolean两种类型不相容：
int x = 1;
while (x){ } //不能这样用
boolean isHot = true;
while (isHot) { } //正确用法
4.2 整数型：byte、short、int、long
-
java语言中的“整数型字面值”被默认为int型，要想被当做long型处理的话需要在整数型字面值后添加l/L，建议用大写L
-
java语言中的整数型字面值有三种表示方式：
十进制：缺省默认的方式
八进制：编写八进制整数型字面值时要以0开始
十六进制：编写十六进制整数型字面值时要以0x开始
int a = 10; //十进制
int b = 010; //八进制
int c = 0x10; //十六进制
System.out.println(a); //输出10
System.out.println(b); //输出8
System.out.println(c); //输出16
System.out.println(a + b + c); //输出34
- long类型：整数型字面值默认被当作int型处理。int类型占4个字节是小容量，long类型占8个字节是大容量，小容量可以自动转换成大容量，称为自动类型转换机制
long x = 123; //整数型字面值123被当做int型处理
//int类型字面值123赋值给long类型的变量x，存在类型转换
long y = 2147483648; //编译错误：过大的整数：2147483648
//2147483648被当做int型，但超出int型范围
long z = 2147483648L; //在字面值后加L：该字面值开始就被当作long类型处理，不存在类型转换
-
强制类型转换：大容量转换成小容量，需要加上强制转换符（变量前加类型），但运行阶段可能损失精度
所有数据强制转换都是去掉左边的二进制
long x = 100L; //x变量是long类型，八个字节
int y = x; //y变量是int类型，4个字节，编译报错，大容量不能直接赋值给小容量
int y = (int)x; //加上强制转换符后编译通过
System.out.println(y); //强制转换原理：
//原始数据：00000000 00000000 00000000 00000000 00000000 00000000 00000000 01100100
//强制转换后的数据：00000000 00000000 00000000 01100100
long k = 2147483648L;
int e = (int)k; //输出“-2147483648”，损失精度严重
//原始数据：00000000 00000000 00000000 00000000 10000000 00000000 00000000 00000000
//强制转换后的数据：10000000 00000000 00000000 00000000在计算机中是一个补码形式
//将以上的补码转换到原码就是最终的结果
byte a = 127; //编译通过
//在java语言中，当一个整数型字面值没有超出byte类型取值范围的话，该字面值可以直接赋给byte类型变量
byte b = 128; //编译报错，128这个int类型字面值已经超出byte类型取值范围
byte c = (byte)128; //强制转换
System.out.println(c); //输出-128
//原始数据：00000000 00000000 00000000 10000000
//强制转换后的数据：10000000（补码）
//计算过程：10000000（补码）-1 = 01111111 --> 10000000（原码）--> -128
short s = 32767; //编译通过
short s1 = 32768; //编译报错
char cc = 65535; //编译通过，cc是char类型2个字节，65535是int类型4个字节
cc = 65536; //编译报错
-
正数的补码和原码相同；负数的补码是负数绝对值对应的二进制码按位取反再加1
-
当一个整数型字面值没有超出byte、short、char的取值范围，这个字面值可以直接赋给byte、short、char类型的变量。
4.3 浮点型：float、double
- double和float在存储时都采用近似值
- 在java中所有的浮点型字面值默认当做double型来处理，要想该字面值当做float型来处理，需要在字面值后面添加f/F
double d = 3.0; //3.0是double型字面值，d是double型变量，不存在类型转换
float f = 5.1; //编译报错
//5.1是double型字面值，f是float型变量，大容量转换成小容量需要强制转换符
float f = (float)5.1; //强制类型转换
float f = 5.1F; //5.1是float类型字面值，f也是float型变量
4.4 布尔型：boolean
- java中布尔型只有两个值：true、false；不像c语言中0和1可以表示假和真
- 在底层存储时
boolean flag = 1; //编译错误：不兼容的类型
boolean loginSuccess = true;
if(loginSuccess){
System.out.println("登陆成功");
}else{
System.out.println("登录失败")；
}
4.5 类型转换
-
8种数据类型中除布尔型外剩下7种类型都可以相互转换
-
小容量向大容量转换为自动转换，容量大小排序：
byte < short < int < long < float < double
< char <
任何浮点型不管占用多少字节，都比整数型容量大
char和short可表示的种类数量相同，但是char可以取更大的正整数
-
byte、short、char混合运算时，各自先转换成int型再做运算
-
多种数据类型混合运算，先转换成容量最大的那种类型再做运算
-
强制类型转换符运算优先级高于乘除法*/，但低于小括号()
int f = 10/3; //10和3都是int型，f赋值为3
long g = 10;
int h = g/3; //g是long型，3是int型，运算结果为long型，而h是int型，编译报错
int h = (int)g/3; //可以强制转换，因为运算结果没有超出int型范围
byte h = (byte)(int)g/3; //g先转换为int型，再转换为byte型与int型运算，最终结果为int型
//int型字面值赋值给byte型变量h，编译报错：可能精度损失
byte h = (byte)(int)(g/3); //(g/3)为long型，转换为int型后再转换为byte型，变量h也是byte型
short i = 10;
byte j = 5;
short k = i + j; //short类型和byte类型运算时会转换为int型，运算结果为int型，编译报错
double d = 10/3; //10/3结果为int型3，int型赋值给double型变量，d的值为3.0
char l = 'a';
System.out.println(l); //输出a
System.out.println((byte)l); //输出a的ascii码值97
int m = l + 100; //l的值a的ascii码值转换为int型参与运算，结果为197赋值给m
5. 运算符
5.1 算术运算符：
-
加：+ 减：- 乘：* 除：/ 求余数取模：%
自加1：++ 自减1：–
-
一个表达式有多个运算符，运算符有优先级，不确定的加小括号提升优先级
int i = 10;
int j = 3;
System.out.println( i + j ); //13
System.out.println( i - j ); //7
System.out.println( i * j ); //30
System.out.println( i / j ); //3
System.out.println( i % j ); //1
- ++和–可以出现在变量前，也可以出现在变量后，只要++运算结束，变量值自加1；是单目运算符
int x = 10;
x ++; //11
++ x; //11
- ++出现在变量后：先做赋值运算，再对变量中保存的值自加1
int a = 10;
int b = a ++;
System.ouy.println(a); //11
System.out.println(b); //10
- ++出现在变量前：先自加1再赋值
int m = 20;
int n = ++ m;
System.out.println(m); //输出21
System.out.println(n); //输出21
int e = 100;
System.out.println(e++); //输出100
System.out.println(e); //输出101
int s = 100;
System.out.println(++s); //输出101，s = 101
System.out.println(s++); //输出101，s = 102
System.out.println(--s); //输出101，s = 101
System.out.println(s--); //输出101，s = 100
System.out.println(s--); //输出100，s = 99
System.out.println(s); //输出99
5.2 关系运算符
- 大于：> 小于：< 大于等于：>= 小于等于：<= 等于：== 不等于：!=
int a = 10;
int b = 10;
System.out.println(a > b); //false
System.out.println(a >= b); //true
System.out.println(a < b); //false
System.out.println(a <= b); //true
System.out.println(a == b); //true
System.out.println(a != b); //false
- 关系运算符的运算结果一定是布尔型：true/false
- 关系运算符运算原理：比较变量中保存的值的大小
5.3 逻辑运算符
-
逻辑与：& 逻辑或：| 逻辑非：! 逻辑异或：^
短路与：&& 短路或：||
-
逻辑运算符要求两边的算子都是布尔类型，且最终运算结果也是布尔型
-
短路与/或和逻辑与/或的运算结果是相同的，只不过短路与/或存在短路现象
System.out.println(5 >3 & 5> 2); //true
System.out.println(5 >3 & 5> 6); //false
System.out.println(true | false); //true
System.out.println(false | false); //false
System.out.println(!true); //false
System.out.println(!false); //true
System.out.println(true ^ true); //false
System.out.println(true ^ false); //true
System.out.println(false ^ false); //false
- 逻辑与和短路与
int x = 10;
int y = 8;
System.out.println(x < y & ++x < y); //逻辑与，输出false
System.out.println(x); //输出11，逻辑与两个表达式都执行
int x = 10;
int y = 8;
System.out.println(x < y && ++x < y); //短路与，输出false
System.out.println(x); //输出10，x < y结果为false，表达式的值也为false
//后面的表达式没有再执行，这种现象称为短路现象
- 短路或：第一个表达式结果为true时不计算第二个表达式
5.4 赋值运算符
- 赋值类运算符包括两种：基本赋值运算符（=）、扩展的赋值运算符（+=、-=、*=、/=、%=）
- 赋值类运算符优先级：先执行表达式，然后将结果赋值给变量
- 扩展类的赋值运算符不改变运算结果类型：例如最初变量类型是byte，无论怎么追加或追减，最终的数据类型还是byte型
int i = 10; //基本赋值运算符
i = i + 5; //i = 15
i += 5; //扩展的赋值运算符，等同于i = i + 5，20
i -= 5; //等同于i = i - 5，15
i *= 2; //等同于i = i * 2，30
i /= 4; //等同于i = i / 4，7
i &= 2; //等同于i = i & 2,1
byte b = 10;
b = b + 5; //编译报错，5是int型，b+5的结果是int型
b += 5; //编译通过，等同于b = (byte)(b + 5)
byte z = 0;
z += 128; //等同于z = (byte)(z + 128)
System.out.println(z); //z = -128，损失精度
z += 10000；
System.out.println(z); //z = -112
long x = 10L;
int y = 20;
y += x; //等同于y = (int)(y + x)
5.5 字符串连接运算符
-
“+”运算符在java语言中的作用：
-
加法运算，求和：“+”运算符两边的数据都是数字时，一定是加法运算
-
字符串的连接运算：“+”运算符两边的数据只要有一边是字符串，一定是字符串连接运算，且运算的结果也为字符串类型
-
-
一个表达式中可以出现多个“+”，自左向右依次运算（没有括号时）
System.out.println(10 + 20 + 30); //输出“60”，加号为求和
System.out.println(10 + 20 + "30"); //输出“3030”
//从左向右依次运算，第一个加号是求和，第二个加号是字符串连接
System.out.println(10 + (20 + "30")); //输出“102030”
//括号里的加号是字符串连接
//先计算括号里为“2030”，括号外的加号也是字符串连接
System.out.println("10" + 20 + 30); //输出“102030”
//要输出“10 + 20 = 30”
int a = 10;
int b = 20;
System.out.println(a + " + " + b + " = " + (a + b));
- 引用类型String（字符串类型）
String s = "abc"; //String是引用数据类型，s是变量名，"abc"是String类型的字面值
String username = "zhangsan";
System.out.println("登陆成功，欢迎" + username + "回来")； //输出“登陆成功，欢迎zhangsan回来”
5.6 三元运算符
-
三元运算符/三目运算符/条件运算符语法规则：
布尔表达式 ? 表达式1 : 表达式2
-
当布尔表达式的结果是true时，选择表达式1作为整个表达式的执行结果
当布尔表达式的结果是false时，选择表达式2作为整个表达式的执行结果
public class abc{
public static void main(String[] args){
10; //编译错误：不是一个完整的java语句
'男' //编译错误：不是一个完整的java语句
boolean sex = false;
sex ? '男' : '女'； //编译错误：不是一个完整的java语句
char c = sex ? '男' : '女'； //等号右边表达式的执行结果为'女'，即char c = '女'
System.out.println(c); //输出'女'
char c1 = sex ? "男" : '女'; //编译错误，类型不兼容
//结果可能是String类型或char类型，而变量类型为char
System.out.println(sex ? '男' : "女")； //可以正常运行
}
}
3189
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
