java入门基础
java 学习笔记
jvm jre jdk 三者之间的关系
java安装
环境变量配置
java程序开发的三个步骤 ：编写 -》 编译 -》 运行
HelloWorld
public class HelloWorld {
public static void main(String[] args){
System.out.println("hello world");
}
}
使用记事本编辑以上文字
使用 javac.exe 进行编译，生成 HelloWorld.class
使用java 对生成的HelloWorld.class 运行 ：
注意： 使用java是不要对生成的class文件加后缀.class
可以记为： javac 后面的文件要加后缀， java 后面的文件不加后缀
notepad++ 开发
使用 notepad++ 在 设置 -》 首选项 -》 新建 -》默认语言改为 java, 编码改为 ANSI
就可以使用 notepad++进行开发调试
注释
单行注释：
// 后面是注释
多行注释（区块注释）
/*
可以写很多行注释
*/
// 第一行的第三个单词必须和苏所在的文件名称完全一样，大小写也要一样
// public class 后面代表定义一个类的名称， 类是java当中所有源代码的基本组织单位
public class HelloWorld {
// 第二行的内容是万年不变的固定写法，达标main方法
// 这一行代表程序执行的起点
public static void main(String[] args){
// 第三行代表打印输出语句（其实即使屏幕显示）
// 希望显示什么东西，就行在小括号中填写什么内容
System.out.println("hello world");
}
}
关键字
有特殊含义，被保留的，不能随意使用的字符
关键字的特点：
1. 完全小写的纯英文字母
2. 在有些编辑器中会有特殊的颜色
标识符
指在程序中自己定义的内容，方法的名称，或者变量的名称等
规则：1. 标识符可以包含：英文大小写字母，0-9，$, _
2. 不能以数字开头
3. 标识符不能是关键字
规范：
1. 类名规范：首字母大写，后面每个单词首字母大写（大驼峰式）
2. 变量名规范：首字母小写，后面每个单词首字母大写（小驼峰式）
3. 方法名规范：同变量名
常量
在Java程序运行期间固定不变的数据
常量的分类：
1. 字符串常量： 凡是使用双引号引起来的部分，叫做字符串常量，例如： “abc”,“hello”，双引号中可以写任意个
2. 整数常量：直接写上的数字，没有小数点，例如：100，0，-10
3. 浮点数常量：直接写上的数字，有小数点：例如：2.6，0.0
4. 字符常量：凡是用单引号引起来的单个字符，就叫做字符常量，例如：‘A’,‘b’,‘0’,‘中’，单引号中只能有一个
5. 布尔常量：只有两种常量，true ,false,
6. 空常量：null, 代表没有任意数据
public class Demo01Const{
public static void main(String[] args){
// 字符串常量
System.out.println("ABC");
System.out.println("");
System.out.println("A");
// 整数常量
System.out.println(100);
System.out.println(-100);
// 浮点数常量
System.out.println(10.0);
System.out.println(-10.0);
// 字符常量
System.out.println('C');
System.out.println(' ');
//System.out.println(''); // 两个单引号中间必须有切仅有一个字符，没有不行，
// 布尔常量
System.out.println(true);
System.out.println(false);
// 空常量
// System.out.println(null); // 不能直接打印空常量
}
}
数据类型
基本数据类型：整数， 浮点数， 字符，布尔
引用数据类型：类，数组，接口，字符串，lambda
- 基本数据类型 四类八种
-
整数型：
byte 8位 1字节 -128~127
short 16位 2字节 -32768~32767
int 32位 4字节 -2^32-1 ~ 2^31 (21亿) 最常用
long 64位 8字节 次常用 -2^63-1 ~ 2^63 (21亿)
java默认时 int型 -
浮点型：
float :32位 后缀F 和f， 1位符号位，8位指数，23位有效尾数
double 64位 最常用 后缀D和d,1位符号位，11位指数，52位有效尾数
java浮点型默认是double型，所以声明一个float型浮点型，需要在数字后面加上F或者f
例如：double d =88.8 float f = 888.8f 不加f会报错 -
字符型：char
char 16位，java字符使用unicode编码 -
布尔型：boolean
true 真
false 假 -
总结：
8位：byte
16位：short char
32位：int float
64位：long, double
boolean型 -
注意事项
- 字符串不是基本类型，是引用类型
- 浮点型可能只是一个近似值，而不是精确值
- 数据范围与字节数不一定相关，例如：float数据范围比long类型更广泛，但是float是4字节，long类型是8字节
- 浮点数当中默认时double,，如果一定要使用float类型，需要加上一个后缀f
如果是整数，默认时int类型，如果一定要使用long类型，需要加上一个后缀L,推荐使用大写字母后缀
-
变量
程序运行期间，内容可以发生改变的量
创建一个变量并且使用的格式
数据类型 变量名称；// 创建了一个变量
变量名称 = 数据值；// 赋值，将右边的数据值，赋值交给左边的变量
一步到位的格式：
数据类型 变量名称 = 数据值；// 在创建一个变量的同时，立刻放入指定的数据值
public class Demo02Variable {
public static void main(String[] args){
// 创建一个变量
// 格式 ：数据类型，变量名称
int num1;
// 向变量当中存入一个数据
// 格式：变量名称 = 数据值;
num1 = 10;
// 打印显示的是num1的值
System.out.println(num1); // 10
// 改变变量中的本来数字，变成新的数字
num1 =20;
System.out.println(num1); // 20
// 一步到位的方式
int num2 = 25;
System.out.println(num2); // 25
System.out.println("++++++++++++++++++++++++");
byte num3 = 100;
System.out.println(num3); // 100
//byte num4 = 200; // 超过了 byte的范围 -128~ 127 ,会发生错误
short num5 = 50;
System.out.println(num5); // 50
long num6 = 70L; // 使用long类型时，必须要用后缀L
System.out.println(num6); // 70
float num7 = 2.5F;
System.out.println(num7); // 2.5
double num8 = 2.2;
System.out.println(num8); // 2.2
char zifu1 = 'A';
System.out.println(zifu1); // A
char zifu2 = '中';
System.out.println(zifu2); // 中
boolean var1 = true;
System.out.println(var1);
}
}
使用变量的注意事项：
1. 如果使用多个变量，变量之间的名称不可以重复
2. 对于float和long类型来说，字母后缀F和L不要丢掉
3. 如果使用byte或者short类型的变量，那么右侧的数据值范围不能超过左侧数据类型的范围
4. 没有进行赋值的变量，不能直接使用，一定要赋值使用，才能使用。
5. 变量使用不能超过作用域的范围，
作用域：从定义一个变量的一行开始，一直到直接所属的大括号结束为止
6. 可以通过一个语句创建多个变量，但是一般情况下不推荐
int a=3,b=4,c=5;
数据类型的转换
- 自动类型转换 隐式
- 特点：代码不需要进行特殊处理，自动完成
- 规则：数据范围从小到大
public class Demo01DataType {
public static void main(String[] args){
System.out.println(1024); // 这就是一个整数，默认是int类型
System.out.println(3.13); // 这是一个浮点数， 默认是double类型
// 左边是long类型，右边默认是int类型，左右不一样
// 一个等号代表赋值，将右侧的int常量交给左侧的long变量进行存储
// int --》 long 符合了数据范围从小到大的需求
long num1 = 100;
System.out.println(num1); // 100
// 左侧是double，右边是float，左右不一样
// float --> double 从小到大
// 也发生了自动类型转换
double num2 = 2.5F;
System.out.println(num2); // 2.5
// 左侧是float类型，右侧是long类型，左右不一
// long --》 float 范围是 float更大一些，符合从小到大的规则
// 也发生了一自动的类型转换
float num3 = 30L;
System.out.println(num3); // 30.0
}
}
-
数据溢出
-
精度损失：
int num = (int) 3.9;
System.out.println(num); // 3 小数部分丢失，精度损失 -
强制类型转换 显式
- 特点： 代码需要进行特殊的格式处理，不能自动完成转换
- 格式： 范围小的类型 范围小的变量 = (范围小的类型)原本范围大的数据;
注意事项：
1. 强制类型转换一般不推荐，因为有可能发生精度丢失，数据溢出
2. byte/ short/ char 这三种类型都可以发生数学运算，例如 ‘+’
3. byte/ short / char 这三种类型在运算的时候，都会被首先提升为int类型，然后在计算
4. boolean类型不能发生数据类型转换
public class Demo02DataType {
public static void main(String[] args){
// 左侧是 int类型，右边是long类型，不一样
// long --> int 不是从小到大
// 不能发生自动类型转换
// 格式： 范围小的类型 范围小的变量 = (范围小的类型)原本范围大的数据;
// int num = 100L; // 报错
int num = (int)100L;
System.out.println(num);
//int num2 = (int)6000000000; // 错误，数据溢出
//System.out.println(num2);
int num3 = (int)3.99;
System.out.println(num3); //3 精度损失
char zifu1 = 'A';
System.out.println(zifu1+1); // 66 也就是A 被当做65来处理了
// 计算机底层会用一个数字（二进制）来代表字符A, 就是65
// 一旦char类型进行了数学运算，那么字符就会按照一定的规则翻译成一个数字
byte num4 = 40;
byte num5 = 50;
// byte + byte -> int + int -》 int
int result1 = num4+ num5;
System.out.println(result1); // 90
short num6 =60;
// byte + short -> int + int --》 int
// int强制转为short，这必须保证逻辑上真实大小没有超过short范围，否则会发生数据溢出
short result2 =(short)(num4 + num6)
}
}
byte short char 注意事项：
- 对于byte short char三种类型来说，如果右侧赋值的数值没有超过范围，那么javac编译器会自动进行隐含的为我们补上一个(byte) (short) (char)
- 如果没有超过左侧的范围，编译器补上强转
- 如果右侧超过了左侧的范围，那么编译器报错
public class Demo12Notice {
public static void main(String[] args){
// 右侧确实是一个int数字，但是没有超过左侧的范围，就是正确的
// int --》 byte 不是自动类型转换
byte num1 = /*(byte)*/30; // 右侧灭有超过左侧范围
System.out.println(num1); //30
// byte num2 = 129; // 右侧超过了左侧的范围 报错
}
}
- 在给变量进行赋值的时候，如果右侧的表达式当中全市常量，没有任何变量，那么编译器javac会直接将若干个常量表达式计算得到结果,
short result = 5=8; // 等号右边全部是常量，没有任何变量参与运算，编译之后，得到的.class字节码文件当中相当于 【直接就是】：
short result =13;
右侧的常量结果数值没有超过左侧范围，所以正确，
这个称为 “编译器的常量优化”
但是注意：一旦表达式中有变量参与，那么就不能进行这种优化。
public class Demo13Notice {
public static void main(String[] args) {
short = num1 =10; // 正确写法，右侧没有超过左侧范围
short a =5;
short b =8;
// short + short ⇒ int + int ==> int
// short result = a+b; // 错误写法，左侧需要的int类型
// 右侧不用变量，而是采用常量，而且只有两个常量，没有别人
short result = 5+8;
System.out.println(result); // 13 正确
// short result2 = 5+a+8; // 错误 有变量
}
}
ASCII编码表
一般我们只要记住0（48） ,A（65），a （97）这三个对应的ascii码就行
public class Demo03DataTypeChar {
public static void main(String[] args){
char zifu1 = '1';
System.out.println(zifu1+0); // 49
char zifu2 = 'A';
char zifu3 = 'c';
// 左侧是int, 右侧是char
// char --> int 确实是从小到大
// 发生了自动类型转换
int num = zifu3;
System.out.println(num); // 99
char zifu4 ='中';
System.out.println(zifu4+0); // 20013
}
}
数字和字符的对照关系表
ASCII表：American Standard code for information interchange 美国信息交换标准代码
Unicode码表：万国码，也是数字和符号的对照关系，开头0-127和ascii一样，但是从128开始包含更多的字符
运算符
算数运算符：+ - * / % ++ –
对于一个整数的表达式来说，除法用的是整除，整数除以整数，结果仍然是整数，只看商，不看余数
只有对于整数的除法来说，取模运算才有余数的意义
注意：一旦运算党总有不同类型的数据，那么结果将会是数据类型范围大的那种；
例如：int + double - > double + double --> double
- 四则运算当中的+有常用的三种用法：
- 对于数字来说，就是加法
- 对于字符char类型来说，在计算之前，char会被提升为int, 然后再计算
char 类型字符串， 和int 类型数字，之间的对照关系：ASCII和Unicode表 - 对于字符串String来说，加号代表字符串连接操作
- 任何数据类型和字符进行连时，结果都会变成字符串
public class Demo05Plus {
public static void main(String[] args){
String str1 = "hello";
System.out.println(str1); // hello
System.out.println("hello" + "world"); // helloworld
// 任何数据类型和字符进行连时，结果都会变成字符串
System.out.println("hello" + 20); // hello20
// 优先级问题
System.out.println("hello" + 20 + 30); // hello2030
System.out.println("hello" + (20 + 30)); // hello50
}
}
自增自减运算符
自增运算符：++
自减运算符：–
基本含义：让一个变量涨一个数字1， 或者让一个变量降一个数字1
使用格式：写在变量名之前，或者写在变量名之后，例如：++num, num++
常量不可变，不能使用自增或者自减
使用方式：
1. 单独使用
在单独使用时，前++ 或者后++ 没有任何区别，也就是 ++num 和num++ 是一样的
2. 混合使用时，有重大区别
1. 如果是前++， 那么变量立马+1，然后拿着结果进行使用 【先加后用】
2. 如果是后++， 那么首先使用变量本来的值，然后再让变量+1 【先用后加】
public class Demo06Operator {
public static void main(String[] args){
int num = 10;
System.out.println(num); //10
++num; // 前++ 单独使用
System.out.println(num); // 11
num++; // 后++ 单独使用
System.out.println(num); // 12
System.out.println("+++++++++++++++++");
int num2 = 20;
System.out.println(++num2); // 21 先让num2+1变成21,然后打印21
System.out.println(num2++); // 21 先打印num2, 然后在给num2+1 变22
System.out.println(num2); // 22
System.out.println("+++++++++++++++++");
int num3 = 40;
int result1= --num3; // 39
System.out.println(result1);
int result2 = num3--;
System.out.println(result2); // 39
System.out.println("+++++++++++++++++");
int x= 10;
int y = 20;
int result3 = ++x + y--;
System.out.println(result3); //31
System.out.println(x);
System.out.println(y);
// 30++; // 错误写法，常量不可变。
}
}
赋值运算符
- 基本赋值运算符 =
代表将右侧的数据交给左侧的变量 - 复合赋值运算符
+= a+=1 相当于 a =a+1
-= b-=1 相当于 b=b-1
= c=2 相当于 c=c*2
/= d/=3 相当于 d=d/3
%= e%=4 相当于 e=e%4 - 注意：
只有变量才能使用赋值运算符，常量不能进行赋值
复合赋值运算符其中隐含了一个强制类型转换
byte a =20;
a +=5;
// a = a+5
// 此出实际上是 a = (byte)(20+5)
比较运算符
= ,< ,> ,<= ,>= !=
返回布尔值
不可以进行连着进行比较 例如: 1 与 并且 && 全都是true才是true,否则是fasle 短路： 如果根据左边就可以判断最终结果，那么右边的代码将不再执行，从而节省性能 注意事项： 一元运算符 只需要一个数据就可以进行操作的运算符， 例如：取反！ 自增++ 格式：逻辑运算符
或 或者 || 至少一个是true，就是true， 全部是false, 才是false
非 取反 ! 本来是true, 变成false， 本来是 false, 变成truepublic class Demo09Logic {
public static void main(String[] args){
System.out.println(true && false); // false
System.out.println(true && true); // true
System.out.println(3<4 && 10>5); // true
System.out.println(true || false); // true
System.out.println(true || true); // true
System.out.println(false || false); // false
System.out.println(!false); // true
System.out.println(!true); // false
System.out.println("+++++++++++++++++++++++"); // false
// 短路
int a = 10;
// false && .. -》 false 后面不会执行
System.out.println(3>4 && ++a <100); // false
System.out.println(a); // 10
int b = 20;
System.out.println(3<4 || ++b <100); // true
System.out.println(b); // 20
}
}
1. 逻辑运算符只能用于boolean值
2. 与 或 需要左右各有一个boolean值，但是取反只要有唯一一个boolean值即可
3. 与 或 两种运算符如果有多个条件，可以连续写
条件A && 条件B || 条件C…
对于 1三元运算符
二元运算符 需要两个数据才能进行操作的运算符 例如: + -
三元运算符：需要三个数据才能进行操作的运算符
数据类型 变量名称 = 条件判断 ？表达式A : 表达式B
流程：
首先判断条件是否成立
如果成立为true，那么将表达式A的值赋值给左侧的变量
如果不成立为false, 那么将表达式B的值赋值给左侧的变量
注意事项：
1. 必须同时保证表达式A和表达式B都符合左侧数据类型的要求
2. 三元运算符的结果必须要被使用。
不能 a > b ? a : bpublic class Demo10Operator{
public static void main(String[] args){
int a =10;
int b = 20;
int max = a > b ? a : b;
System.out.println(max); // 20
}
}