常量：在程序运行期间，固定不变的量
常量的分类：
- 字符串常量：凡是用双引号引起来的部分，叫做字符串常量，例如："abc", "hello", "123"
- 整数常量：直接写上的数字，没有小数点，例如：100, 200, 0, -250
- 浮点数常量：直接写上的数字，有小数点，例如：2.5, -3.14, 0.0
- 字符串常量：凡是用单引号引起来的单个字符，就是字符常量，例如：'a', 'b', '1', '我'（中文也代表一个字符）
- 布尔常量：true，false
- 空常量：null，代表没有任何数据
demo：
// 常量的输出 public class DemoConstant { public static void main(String[] args) { // 字符串常量 System.out.println("ABC"); System.out.println(""); // 整数常量 System.out.println(30); System.out.println(-10); // 字符常量 System.out.println('A'); System.out.println('我'); // 布尔常量 System.out.println(true); System.out.println(false); // 空常量，空常量不能拿来打印输出 // System.out.println(null); } }
变量
程序运行期间，内容可以发生变化的量
创建一个变量的两种形式：
// 先创建再赋值 int num; num = 20; // 直接创建加赋值 int num = 100;
变量使用注意事项：
- 如果创建多个变量，那么变量之间的名称不可以重复
- 对于 float 和 long 类型来说，字母后缀 F 和 L 不能丢掉
- 如果使用 byte 或 short 类型的变量，那么右侧的数据值不能超过左侧的类型
- 变量一定要赋值之后，才能使用，并不能超过作用域的范围，【作用域】：从定义变量的一行开始，一直到直接所属的大括号结束为止
demo：
public class Variable { public static void main(String[] args) { int a = 10; System.out.println("a: " + a); { int b = 20; System.out.println("b: " + b); } // System.out.println(b); // 已经超出了作用域范围 // 同时创建变量并赋值 int c = a; System.out.println("c: " + c); } }
基本数据类型（四类八种）
- 整数型：byte, short, int, long
- 浮点型：float, double
- 字符型：char
- 布尔型：boolean
| 数据类型 | 关键字 | 内存占用（字节） | 取值范围 |
| 字节型 | byte | 1 | -128 ~ 127 |
| 短整型 | short | 2 | -32768 ~ 32767 |
| 整型 | int（默认） | 4 | -2^31 ~ 2^31-1 |
| 长整型 | long | 8 | -2^63 ~ 2^63-1 |
| 单精度浮点型 | float | 4 | 比long范围广 |
| 双精度浮点型 | double | 8 | 最大 |
| 字符型 | char | 2 | 0 ~ 65535 |
| 布尔类型 | boolean | 1 | true, false |
注意事项：
- 字符串不是基本数据类型，是引用类型
- 浮点型可能是一个近似值，并非精确的值
- 数据范围与字节数不一定相关，有特例，例如 float 数据范围比 long 更加广泛，但只有 4 个字节
- 浮点数默认类型是 double，如果一定要使用 float 类型，需要加F
- 整数默认类型是 int，如果一定要使用 long 类型，需要加L，推荐使用大写：System.out.println(100L)
引用数据类型：字符串，数组，类，接口，Lambda
略
数据类型转换
当数据类型不一样时，将会发生数据类型转换，分为自动类型转换(隐式) 和 强制类型转换(显式)
1）自动类型转换(隐式)：
代码不需要进行特殊处理，自动完成，规则：数据范围从小到大(左边大，右边小)
public class DataType{ public static void main(String[] args){ // 左边是long类型， 右边是默认的int类型，符合了数据范围从小到大的要求，发生了自动转换 long num1 = 10; System.out.println(num1); // 10 // 左边是默认的double类型，右边是声明的float类型，符合从小到大的规则，也发生了自动类型转换 double num2 = 2.5F; System.out.println(num2); // 2.5 // 左边是float类型，右边是long类型，也发生了自动转换 float num3 = 30L; System.out.println(num3); // 30.0 } }
2）强制类型转换(显式)：
代码需要进行特殊格式处理，不能自动完成，格式：范围小的类型 范围小的变量名 = (范围小的类型) 原本范围大的值
强制类型转换一般不推荐使用，因为有可能发生 数据溢出 和 精度损失
byte / short / char 这三种类型都可以发生数学运算，比如做加法，在运算的时候，都会被首先提升为 int 类型，然后再计算
boolean 类型不能发生数据类型转换(与python不同)
public class DataType{ public static void main(String[] args){ System.out.println("="); // 左边是int类型，右边是long类型，不符合从小到大的要求，需要强制转换 int num1 = (int) 100L; // 100L在某些情况下可以是超过int范围的 System.out.println(num1); // 10 // 数据溢出的情况 int num2 = (int) 6000000000L; System.out.println(num2); // 1705032704 // 精度损失的情况 int num3 = (int) 3.99F; int num4 = (int) 4.11D; System.out.println(num3 + " " + num4); // 3 4 // 字符类型与整数类型做数学运算 char zifu1 = 'A'; // 计算机底层会用65(二进制)来代表字符A，char类型进行数学运算，按照规则就会翻译成对应的数字 System.out.println(zifu1 + 1); // 66 // 整数类型之间做数学运算 byte num5 = 40; // 注意，右侧的数值大小不能超过byte的范围 byte num6 = 50; // byte + byte --> int + int --> int int result1 = num5 + num6; // 相同变量不能重复使用 System.out.println(result1); // 90 // byte + byte --> int + int --> byte byte result2 = (byte) (num5 + num6); /* 强制转换：必须保证真实大小本来就没有超过byte范围，否则会发生数据溢出*/ System.out.println(result2); // 90 } }
算术运算符
运算法：四则运算 和 取模：+ - * / %
对于一个整数的表达式来说，除法用的是整除(python3中用 // 表示整除)
一旦运算中有不同的数据类型，那么结果将会是数据类型范围大的那种
public class DemoPerator{ public static void main(String[] args){ // 两个整数常量之间的数学运算 System.out.println(20 + 30); // 50 // 两个变量之间的数学运算 int a = 20, b = 30; System.out.println(a + b); // 50 // 变量和常量之间混合使用 System.out.println(a * 10); // 200 // 整除和取余 System.out.println(b / a); // 1 System.out.println(b % a); // 10 // 不同数据类型之间的运算，按范围大的标准来处理 // int + double --> double + double --> double double result = a + 2.5; System.out.println(result); // 22.5 int result2 = (int) (a + 2.5); System.out.println(result2); // 22 发生了强制转换 } }
“+” 的特殊意义：
- 对于数值来说，那就是加法
- 对于 char 类型来说，在计算之前，char 会被提升为 int，然后再计算
- 对于字符串 String 来说，加号表示字符串的连接，任何数据类型和字符串进行连接时，结果都会变成字符串（python中 str + int 会报错）
demo：
public class DemoPlus{ public static void main(String[] args){ // 字符串的连接 String str1 = "Hello"; System.out.println(str1 + " World!"); // Hello World! // 字符串和数字类型连接 System.out.println(str1 + 20); // Hello20 // 与多个数字的连接 System.out.println(str1 + 20 + 30); // Hello2030 // 优先级，使用小括号 System.out.println(str1 + (20 + 30)); // Hello50 } }
自增、自减运算符（++、--）：
- 在单独使用时，前++ 和 后++没有任何区别
- 在与赋值和打印混合使用时，有很大区别，如果是前++，那么变量立刻+1，然后拿着结果使用，如果是后++，那么先拿变量原来的值，然后+1
- 总结：前++是先加后用，后++是先用后加
demo：
public class DemoOperator{ public static void main(String[] args){ // 与打印操作混合使用 int num1 = 10; System.out.println(++num1); // 11 System.out.println(num1++); // 11 System.out.println(num1); // 12 // 与赋值语句混合使用 int num2 = 20; int num3 = num2++; int num4 = --num2; System.out.println(num3); // 20 System.out.println(num4); // 20 // 两个混合使用 int x = 100; int y = 200; int result = ++x + y--; System.out.println(result); // 301 System.out.println(x); // 101 System.out.println(y); // 199 } }
赋值运算符
基本赋值运算符：=，将右侧数据交给左侧变量
复合赋值运算符：+= -= *= /= (与python中一样)
public class DemoOperator{ public static void main(String[] args){ byte num1 = 10; // num1 = num1 + 5 // num1 = byte + int --> int + int --> int 然后 int --> byte num1 += 5; // 这里发生了一个强制类型转换 } }
比较运算符：>=、<=、==、!=
比较运算符的结果一定是一个boolean值，成立就是true，不成立就是false
如果进行多次判断，不能连着写，例如：1< x < 20
public class DemoOperator{ public static void main(String[] args){ int num1 = 10; System.out.println(num1 == 10); // true System.out.println(num1 != 10); // false // 不能进行多次判断 // System.out.println(1 < num1 < 20); } }
逻辑运算符：&&、||、!
逻辑运算符只能用于boolean值，与、或需要左右各自有一个 boolean 值，但是取反只要有唯一的一个 boolean 值
与、或两种运算符，如果有多个条件，可以连续写，例如：A && B && C
&&、|| 具有短路的效果：如果根据左边已经判断得到结果，那么右边的代码将不再执行，从而节省一定的性能
public class DemoLogic{ public static void main(String[] args){ System.out.println(true && true); // true System.out.println(1 < 2 && 2 < 3); // true System.out.println(false || true); // true // 短路效果 int num1 = 10; System.out.println(false && ++num1 < 10); // false ++num1 并不会执行 System.out.println(num1); // 10 System.out.println(true && ++num1 < 10); // false ++num1 会执行 System.out.println(num1); // 11 } }
三元运算符
一元运算符：只需要一个数据就可以操作的运算符，例如：取反!、自增++、自减--
二元运算符：需要两个数据才可以进行操作的运算符，例如：赋值，做加法运算
三元运算符：三个数据进行操作的运算符，在 python 中也叫三元表达式
格式：数据类型 变量类型 = 条件判断 ？ 表达式A : 表达式B;
int num = a > b ? a : b; 【a, b 都要符合左侧数据类型的要求】
public class TernaryExpression { public static void main(String[] args){ int a = 10; int b = 20; int max = a > b ? a : b; System.out.println("最大值：" + max); // 20 // 错误的写法，必须保证表达式都符合左侧数据类型的要求 // int min = a < b ? 2.5 : b } }
流程判断
分三种：if、if-else、if-else if-else
public class DemoIfElse{ public static void main(String[] args){ int score = 95; if (score >= 90 && score <=100) { System.out.println("A"); } else if (score >= 80 && score <90){ System.out.println("B"); } else if (score >= 70 && score <80){ System.out.println("C"); } else if (score >= 60 && score <70){ System.out.println("D"); } else if (score >= 0 && score <60){ System.out.println("flunk!"); } else { System.out.println("illegal data!"); } } }
switch语句
使用注意事项：
- 多个case后面的数值不可以重复
- switch后面的小括号当中只能是：基本数据类型中的 byte, short, int, char 和 引用数据类型中的 String, enum（枚举）
- switch语句格式可以很灵活：前后顺序可以颠倒，所以 break 语句最好不要省略
demo：
public class DemoSwitch{ public static void main(String[] args){ int num1 = 8; switch (num1){ case 1: System.out.println("Monday"); break; case 2: System.out.println("Tuesday"); break; case 3: System.out.println("Wednesday"); break; case 4: System.out.println("Thursday"); break; case 5: System.out.println("Friday"); break; case 6: System.out.println("Saturday"); break; case 7: System.out.println("Sunday"); break; default: System.out.println("illegal data!"); break; } } }
循环
public class DemoForLoop{ public static void main(String[] args){ for (int hour = 0; hour < 24; hour++){ for (int minute = 0; minute < 60; minute++){ System.out.println(hour + "时" + minute + "分"); } } } }
while 循环
public class DemoWhileLoop{ public static void main(String[] args){ int flag = 1; while (true){ System.out.println(flag); if (flag == 10){ break; } flag += 1; } } }
方法
方法的定义：方法名称的命名规则和变量一样，使用小驼峰体
public static void methodName(){ methodBody; // 可以为空，不需要写pass占位符 }
注意事项：
- 方法定义的先后顺序没有区别（因为java是先编译后执行）
- 方法的定义不能产生嵌套包含关系
- 方法定义完后，需要调用执行
- 如果方法有返回值，那么必须写
"return 返回值"，返回值类型必须和方法返回的类型对应起来
定义一个方法：
public class DemoMethod{ public static void main(String[] args){ // 程序执行入口，调用方法 mySelf(); } // 定义一个方法 public static void mySelf(){ System.out.println("my name is johny"); } }
方法传参：
public class DemoMethodArgs{ public static void main(String[] args){ int a = 10, b = 20; int result1 = sum(a, b); int result2 = sum(10, 20); System.out.println(result1); System.out.println(result2); } // 定义一个方法 public static int sum(int a, int b){ int result = a + b; return result; } }
定义一个方法，用来判断两个数字是否相等：
public class DemoMethodSame{ public static void main(String[] args){ boolean same = isSame(10, 10); System.out.println(same); } public static boolean isSame(int a, int b){ // 方式一：if-else /*if (a == b){ return true; } else { return false; }*/ // 方式二：三元表达式 // return a == b ? true : false; // 方式三 return a == b; } }
方法的重载：定义多个方法的名称一样，但是参数列表不同，好处是，只需记住方法名，就可以实现类似的多个功能，例如 println 方法就是实现的重载
public class DemoOverLoad{ public static void main(String[] args){ System.out.println(same((byte) 10, (byte) 10)); System.out.println(same((short) 10, (short) 20)); } public static boolean same(byte a, byte b){ return a == b ? true : false; } public static boolean same(short a, short b){ return a == b; } }
-
任何类型数据都能作为方法的传参，或返回值类型
-
数组作为方法的参数，传递的是数组的内存地址值，数组作为方法的返回值，返回的也是数组的内存地址值
public class DemoArrayReturn{ public static void main(String[] args){ int[] arrayResult = calculate(10, 20, 30); System.out.println("sum is:" + arrayResult[0]); // 60 System.out.println("argv is:" + arrayResult[1]); // 20 } // 定义一个计算的方法 public static int[] calculate(int a, int b, int c){ int sum = a + b + c; int argv = sum / 3; // 静态初始化一个数组 int[] resultArray = {sum, argv}; return resultArray; } }
数组
- 数组是一种引用数据类型
- 数组中的多个数据的类型必须一致
- 数组长度不可变
- 直接打印数组名称，得到的是数据在内存的 hash 值（十六进制）
创建数组的两种方式：
// 两种创建数组的方式：动态初始化(指定长度)，静态初始化(指定内容) public class DemoArray{ public static void main(String[] args){ // 定义一个长度为10，类型为int的数组 int[] arrayA = new int[10]; // 定义一个长度为20，类型为字符串的数组 String[] arrayB = new String[20]; // 静态初始化 byte one = 1, two = 2, tree = 3, four = 4; byte[] arrayC = new byte[] {one, two, tree, four}; String[] arrayD = new String[] {"hello", "world", "java"}; // 静态初始化省略格式 byte[] arrayE = {one, two, tree, four}; String[] arrayF = {"hello", "world", "java"}; } }
数组初始化步骤拆分（先定义后赋值）：
public class DemoArraySplit{ public static void main(String[] args){ // 静态初始化的拆分 String[] arrayA; // arrayG = {"hello", "world"}; // 这样写不行 arrayA = new String[] {"hello", "world"}; // 动态初始化的拆分写法 int[] arrayB; arrayB = new int[5]; } }
对象数组：
public class Person { private String name; private int age; public void setName(String name){ this.name = name; } public String getName(){ return name; } public void setAge(int age){ this.age = age; } public int getAge(){ return age; } public static void main(String[] args) { Person one = new Person(); Person two = new Person(); Person three = new Person(); // 创建array(静态省略写法) Person[] array = {one, two, three}; one.setName("甲"); System.out.println(array[0].name); // 甲 } }
补充：数组必须进行 new 初始化才能使用其中的元素，如果只是赋值了 null，没有进行 new 创建，那么会出现空指针异常：NullPointerException
public class DemoArrayNull{ public static void main(String[] args){ int[] arrayA = null; // arrayA = new int[3]; // NullPointerException System.out.println(arrayA[0]); } }
知识补充：
java的内存需要划分成5个部分
- 栈（Stack）：存放的都是方法中的局部变量，方法的运行一定要在栈中运行
- 局部变量：方法的参数，或者是方法内部的变量
- 作用域：一旦超出作用域，立刻从栈内存中消失
- 堆（Heap）：凡是new出来的东西，都在堆当中
-
堆内存里面的东西都有一个地址值(十六进制)，例如直接打印数组名称
-
堆内存里面的数据，都有默认值，规则如下：
-
如果是整数， 默认为0
-
如果是浮点数， 默认为0.0
-
如果是字符， 默认为 ‘/u0000’
-
如果是布尔， 默认为false
-
如果是引用数据类型， 默认为null
-
- 方法区（Method Area）：
- 存储 .class 相关的信息，包含方法的信息
- 本地方法栈(Native Method Stack)：与操作系统有关
- 寄存器(PC Register)：与CPU相关
ending ~