Java变量的使用
标识符的使用
标识符： 凡是自己可以起名字的地方都叫标识符，比如：类名、变量名、方法名、接口名等…
标识符的命名规则
-
不能使用关键字和保留字，但能包含关键字和保留字；
-
可以包含字母、数字、下划线和美元符号，但不能以数字开头；
-
Java 严重区分大小写且长度无限制，所以需要特别注意大小写；
-
不能包含空格；
扩展：
关键字： 被Java语言赋予了特殊含义，用做专门用途的字符串（单词）；比如 int、this等
保留字： 现有Java版本尚未使用，但以后版本可能会作为关键字使用。自己命名标识符时要避免使用这些保留字；比如 goto、const 等
Java 中的名称命名规范
-
包名：所有字母都为小写，比如：xxxx
-
类名和接口名：多个单词组成时，首字母大写，比如：XxxxYyyy
-
变量名和方法名：多个单词组成时，首个单词的首字母为小写，后面的单词首字母为大写，比如：xxYyZz
-
常量名：所有字母都为大写，比如：XXXX
注意： 不准守规则就会报错，但是不准守规范不会报错 (但是建议一定要遵守！)
变量
变量的概念
-
内存中的一个存储区域
-
该区域有自己的名称（变量名）和类型（数据类型）和值
-
Java 中每个变量必须先声明，再赋值，然后才能使用
-
该区域的数据可以在同一类型范围内不断变化
-
Java 中的变量有四个基本属性：变量名，数据类型，存储单元和变量值
-
语法：数据类型 变量名 = 变量值； 或 数据类型 变量名； 变量名 = 变量值；
案例
public class Variate{
public static void main(String[] args){
//可以直接声明然后赋值使用
int count1 = 20;
System.out.print(count1);
//也可以先声明一个值，之后在进行赋值和使用
int count2;
count2 = 30;
System.out.print(count2);
}
}
注意点
- Java中每个变量必须先声明，后使用
- 使用变量名来访问这块区域的数据
- 变量的作用域：其定义所在的一对{ }内
- 变量只有在其作用域内才有效
- 同一个作用域内，不能定义重名的变量
基本数据类型与引用数据类型
基本数据类型的使用
public class Test_03 {
public static void main(String[] args) {
/**
* 1.整型：byte（1字节）、short（2字节）、int（4字节）、long（8字节）：要以 L/l 结尾
* 1字节 = 8bit （也就是 二的八次方 = 2*2*2*2*2*2*2*2 = 256）
* 整型常量默认为 int 类型，除非是表示更大的数值，才使用 long 类型
*/
byte count1 = 10; // 返回10
short count2 = 20; // 返回20
int count3 = 30; // 返回30
long count4 = 40L; // 返回40
/**
* 2.浮点型：表示带小数的值，一般用来存储金额
* 单精度浮点 float（4字节）：表示的数值范围比 long 大，变量要以 F/f 结尾；尾数只能精确到 7 位数
* 双精度浮点 double（8字节）；尾数可以精确到 float 的两倍
* 通常使用浮点型的时候都是使用 double，因为它更精确数值更大
* 浮点类型常量默认为 double 类型
*/
float avg1 = 1.2F; // 返回1.2
double avg2 = 2.5; // 返回2.5
/**
* 3.字符型：char（1字符）,只能且必须写一个字符的数据，所以一般用于写性别
* 1 个字符 = 2 个字节（一个英文字母和一个汉字都表示一个字符！）
* 使用 char 的时候，要使用 ''（单引号） 括起来
* 表示方式：① 声明一个字符
* ② 转义字符
* ③ Unicode 字符编码
*/
char sex = '男';
char tm = '\t'; // 转义字符；常用的有 \n 和 \t（还有很多其它的，大家可以自行百度）
char c1 = 'a'; // 编译通过，返回 97
char c2 = 97; // 编译通过，返回 a，更多可以查看 “ASCII码表”
System.out.println("hello" + tm + "world");
//4.布尔型：boolean，一般用于判断，且只能设置两个值：true 和 false（默认为 false）
boolean error1 = true; //真
boolean error2 = false; //假
System.out.println(count1 == count2); //返回假（false）
System.out.println(count1 + 10 == count2); //返回真（true）
// 扩展
System.out.println("打印的时候显示多引号 -> \"JAVA\""); //返回 "JAVA"
}
}
扩展：
UTF-8 （字符编码）是在互联网上使用最广的一种 Unicode 的实现方式（一般编程的时候都会将字符编码设置为 UTF-8）；世界上有很多种编码格式，如果每个人都使用不同的编码方式，那么最后就会导致出现乱码的情况，就比如中国人说汉语，美国人说英语，如果都只说自己的语言，那么对方是听不懂的，编码亦是如此！
Ps： 如果大家在导入项目或者写项目的时候出现乱码，那么就可能是导出的代码格式和导入的代码格式不一致导致的！
String 类型的使用
-
声明 String 类型变量时，使用 " "（双引号）进行标识
-
有默认值，null
-
String 可以和八种基本数据类型进行运算，使用 + 号（String 中的加号表示连接运算）；运算结果为 String 类型！
切记： String 是属于引用数据类型的！
案例
public class Test_05 {
public static void main(String[] args) {
String name = "张三";
System.out.println(name); // 返回 张三
String name2 = ""; //返回一个空格
String name3; //返回 null
//String name4 = 111; //编译失败，变量值必须要加上双引号！
//char 类型虽然也是字符类型，但是它的使用限制会比较高
// char c1 = ''; //编译不通过
char c2 = ' '; //编译通过，返回一个 空格
int i1 = 10;
boolean b1 = true;
String s1 = "hello";
String s2 = i1 + s1;
//int i2 = i1 + s1; //编译失败，因为与String类型进行运算的结果都必须用String类型进行接收
String ss = b1 + s1;
System.out.println(ss); //编译成功，返回 truehello
System.out.println(s2); //编译成功，返回 10hello
char c3 = 'a';
String i2 = c3 + i1 + s1;
String s3 = c3 + s1+i1;
/*
通过下面的结果我们就可以看到char类型的变量值直接与String类型进行运算的时候
不会转成对应的数据，而是会直接进行拼接
如果是先与其他类型进行运算，那么就会自动转换为对应的数据，然后在进行拼接
*/
System.out.println(i2); //返回 107hello
System.out.println(s3); //返回 ahello10
}
}
基本数据类型转换
前提： 这里讨论的只是七种基本数据类型变量间的运算，不包含 boolean 类型
一、自动类型提升：
当容量小的数据类型的变量与容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型！
byte、short、char —> int —> long —> float —> double
如果 byte、short、char 要进行运算时，那么结果类型的最低要求为 int 类型！
示例：
public class Test_04 {
public static void main(String[] args) {
// 此处只演示个别几个类型转换，不过大家可以看上面从大到小排序的规则进行其它类型的转换测试
byte b1 = 10;
int i1 = 10;
// byte sum = b1 + i1; //编译不通过
int sum = b1 + i1; //编译通过，返回20
long sum2 = b1 + i1; //编译通过，返回20
float f = b1 + i1; //编译通过，返回20.0
double d = b1 + i1; //编译通过，返回20.0
//因为float 和 double 类型是浮点型，所以在转换后会自动加上一个小数
System.out.println(d);
char c = 'a';
int i2 = 10;
int i3 = c + i2;
System.out.println(c); //因为 char 类型是字符型，所以直接输出会打印对应的字符，返回 a
System.out.println(i3); //在经过转换后会变为指定类型，所以此处会打印为整数，返回 107
char c2 = 'b';
byte b2 = 10;
byte b3 = 20;
int i4 = 10;
short s1 = 12;
//特别：当 byte、short、char 三种类型的变量做运算时结果为 int 类型
// char c3 = c2 + b2; //编译不通过
// short s1 = c2 + b2; //编译不通过
// byte s2 = b2 + b3; //编译不通过
int i5 = c2 + b2;
int i6 = c2 + s1;
System.out.println(i5); //编译通过，返回108
}
}
二、强制类型转换：
自动类型提升运算的逆运算
① 需要使用强转符：( )
② 注意： 强制类型转换，可能导致精度损失！
/*
整型常量，默认类型为 int 型
浮点常量，默认类型为 double 型
*/
public class Test_04 {
public static void main(String[] args) {
double avg = 10.5;
//如果在以下情况中不使用强转符进行强制转换则会编译错误
int count = (int) avg; //截断操作
System.out.println(count); //编译通过，返回10
//强制转换缺点：精度丢失
long l1 = 123;
short ss1 = (short) l1;
System.out.println("这种转换不会造成精度丢失：" + ss1); //返回123
int ii1 = 128;
byte bb1 = (byte)ii1;
System.out.println("这种情况下就会造成精度丢失：" + bb1); //返回 -128
/**
* 编码情况一：
* long 值后面需要加上 L ，否则会直接自动转换为 int 类型,但是一旦值的长度超过了 int 的最大容量就会编译失败
*/
// long l2 = 1234565432123456543; //编译失败
long l3 = 1234231231232343231L; //编译通过
/**
* 编码情况二：
* float 值后面需要加上 F ，否则就会编译失败（它不会自动转成 double 类型）
* 因为小转大需要进行强制转换
*/
// float f1 = 12.5; //编译失败
byte bb2 = 12;
float ff2 = 10.2F;
// byte bb3 = bb2 + 1; //编译失败，因为 1 是 int 类型，所以不能使用 byte 类型接收
// float f3 = ff2 + 2.3; //编译失败，因为 2.3 是 double 类型，所以不能使用 float 类型接收
}
}
说明： 此时的容量大小指的是输入的范围的大和小，比如：float 容量要大于 long 的容量
局部变量与成员变量
局部变量：
-
在方法内部创建，且只能在方法内部使用
-
没有默认值
-
位于栈（zhan）内存
成员变量：
-
在方法外部创建，直接写在类中，整个类都可以使用
-
如果没有赋值，则会自动生成一个默认值
-
位于堆内存中
示例：
public class Hello{
//成员变量
int count1 = 2;
public static void main(String[] args){
//局部变量
int count2 = 10;
System.out.println("成员变量的值为："+count1);
System.out.println("局部变量的值为："+count2);
}
}
运算符
运算符指明对操作数的运算方式。组成表达式的Java操作符有很多种。运算符按照其要求的操作数数目来分，可以有单目运算符、双目运算符和三目运算符，它们分别对应于1个、2个、3个操作数。运算符按其功能来分，有算术运算符、赋值运算符、关系运算符、逻辑运算符、位运算符和其他运算符。
算数运算符
示例：
/*
1. 算术运算符
+、-、*、/、%、++、--
*/
public class Demo {
public static void main(String[] args) {
//加减乘都差不多，所以直接从除法（/）开始
int num1 = 12;
int num2 = 5;
int sum1 = num1 / num2;
System.out.println(sum1); //输出 2
int sum2 = num1 / num2 * num2;
System.out.println(sum2); //输出 10
double sum3 = num1 / num2;
System.out.println(sum3); //输出 2.0
double sum4 = 1.0 * num1 / num2;
double sum5 = num1 / (num2 + 0.0);
double sum6 = (double) num1 / num2;
System.out.println(sum4); //输出 2.4
System.out.println(sum5); //输出 2.4
System.out.println(sum6); //输出 2.4
/**
* 取余（%）
* 结果的符号与被模数的符号相同
* 开发中，经常使用 % 来判断能否被除尽的情况
*/
int n = 12;
int m = 5;
int s = n % m;
System.out.println(s);
/**
* 前++ 和 后++
* 前++：先自增1，然后在运算
* 后++：先运算，然后在自增1
*/
int i = 10;
int a = 10;
System.out.println(i++); //输出10
System.out.println(i); //输出11，因为在上面的i++执行完后会自增1，所以此处打印输出11
System.out.println(++a); //输出11
short sh = 10;
sh = sh + 1; //编译失败
sh++; //编译成功
/**
* 前-- 和 后--
* 前--：先自减1，后运算
* 后--：先运算，后自减1
*/
int z1 = 10;
int z2 = 10;
System.out.println(z1--); //输出10
System.out.println(--z2); //输出9
//获取个十百位上的值
int num = 187;
int bai = num / 100;
int shi = num % 100 / 10;
int ge = num % 10;
System.out.println("个位为："+ge);
System.out.println("十位为："+shi);
System.out.println("百位为："+bai);
}
}
赋值运算符
示例：
/*
2.赋值运算符
*/
public class Demo1 {
public static void main(String[] args) {
int a = 10;
a += 2; //运行后a的值就会变为12，这个就是 a=a+2 的简写
a -= 2; //以下都是同样的思路，比如-=就是 a=a-2 的简写，乘法就是a=a*2的简写等...
a /= 2;
a %= 2;
a *= 2;
short s = 5;
s = s + 2; //编译失败
s += 2; //编译成功
//连续赋值
int i = 1,j=2; //这样写也是可以编译成功的，中间使用逗号隔开
}
}
比较运算符（关系运算符）
示例：
/**
* 3.比较运算符
*/
public class Demo3 {
public static void main(String[] args) {
int i = 10;
int j = 20;
System.out.println(i == j); //返回false
System.out.println(i != j); //返回true
System.out.println(i >= j); //返回false
System.out.println(i <= j); //返回true
System.out.println(i < j); //返回true
System.out.println(i > j); //返回false
}
}
逻辑运算符
示例：
/**
* 4.逻辑运算符
* 操作的都是boolean的值
*/
public class Demo4 {
public static void main(String[] args) {
/**
* if 是选择结构，后面会说，这里就简单做一下测试，在括号中的条件成立后，输出里面的数据
*/
int i = 10;
int j = 10;
boolean b = false;
boolean a = true;
/**
* 区分 & 和 &&
* 相同点1：& 和 && 的运算结果是相同的
* 相同点2：当符号左边为 true 时，二者都会执行符号右边的运算
* 不同点：当符号左边为false时，& 会继续执行右边的运算，而 && 不会执行
* 开发中推荐使用 &&
*/
if(b & (i++ > 0)){
System.out.println("条件为true，i的值为："+i);
}else{
System.out.println("条件为false，i的值为："+i);
}
if(b && (j++ > 0)){
System.out.println("条件为true，j的值为："+j);
}else{
System.out.println("条件为false，j的值为："+j);
}
/**
* | 和 ||的区别
* 相同点1：| 和 || 的运算结果是相同的
* 相同点2：当符号左边为 false 时，二者都会执行符号右边的运算
* 不同点：当符号左边为 true 时，| 继续执行右边的运算，而 || 不会在执行右边的运算
* 开发中推荐使用
*/
if(a | (i++ > 0)){
System.out.println("条件为true，i的值为："+i);
}else{
System.out.println("条件为false，i的值为："+i);
}
if(a || (j++ > 0)){
System.out.println("条件为true，j的值为："+j);
}else{
System.out.println("条件为false，j的值为："+j);
}
//非（!）
if(!(i > j)){ //返回false
System.out.println("i 小于 j");
}else{
System.out.println("i 大于等于 j");
}
}
}
位运算符
示例：
/**
* 5.位运算符（暂时先简单了解）
* 结论：
* 1.位运算符操作的都是整型的数据
* 2.<<: 在一定范围内，每向左移1位，相当于 *2
* 3.>>: 在一定范围内，每向右移1位，相当于 /2
*/
public class Demo5 {
public static void main(String[] args) {
int i = 21;
/**
* 经典面试题：如何快速的算出 2 * 8 的值?
* 这个时候就可以使用到这里的位运算符，比如：2 << 3 或 8 << 1
*/
System.out.println("位移2位后的值：" + (i << 2)); //首位是0时返回正数
System.out.println("位移27位后的值：" + (i << 27)); //首位是1时返回负数
}
}
三元运算符
格式：(条件表达式)？表达式1：表达式2
示例：
/**
* 6.三元运算符
* 说明
* 1.条件表达式的结果为boolean类型
* 2.根据条件表达式的真或假决定执行
* 3.三元运算符是可以嵌套的
*/
public class Demo6 {
public static void main(String[] args) {
int i = 10;
int j = 20;
/**
* 如果条件表达式为true，则执行表达式1
* 如果条件表达式为false，则执行表达式2
*/
System.out.println(i > j ? "Hello" : i + j); // 输出30
System.out.println(i < j ? "Hello" : i - j); // 输出Hello
/**
* 嵌套的三元运算符
* 在执行完第一个条件表达式后，如果不成立则执行后面的条件表达式，直到输出对应值为止
* 比如：i>j 不成立，所以执行了 i<j 。如果成立了则会直接结束，比如 i < j ，这个时候就会成立所以就会直接返回 Hello
* 如果条件表达式过多，那么不推荐使用！
*/
System.out.println(i > j ? "Hello" : i < j ? "i小于j" : "i大于j"); //返回i大于j
}
}
程序流程控制
- 顺序结构： 程序从上到下逐行的进行，中间没有任何判断和跳转。
- 分支结构： 根据条件，选择性的执行某段代码。
- 循环结构： 根据循环条件，重复性的执行某段代码。
了解
编码格式： UTF-8（目前最常使用的）
转义：
public class Hello{
public static void main(String[] args){
//如果只是单纯的想打印 \n 就可以使用转义的方式在前面再加一个 \
System.out.println("你好\\n嘿嘿");
//在一般情况下不加双引号就直接写入文字或未定义的变量时会导致报错，所以就可以使用以下这种方式
System.out.println("我叫\"小明\"。");
}
}
字符图：
二进制转十进制：
十进制转二进制：
理论练习
-
标识符的命名规则有哪些？
① 不以数字开头 ② 不包含除下划线和美元符号以外的任何特殊符号 ③ 不能包含关键字和保留字 ④ 严格区分大小写 ⑤ 不能包含空格 -
标识符的命名规范有哪些？
① 包名全部小写 ② 类名和接口名每个单词首字母大写 ③ 变量名和方法名首个单词首字母小写，其它单词首字母大写 ④ 常量名全部大写 -
Java 变量按照数据类型怎么划分？并指出 Java 的基本数据类型有哪 8 种，并指出各自占用的内存空间大小。
分为基本数据类型和引用数据类型。 八大基本数据类型分别是：byte（1字节）、short（2字节）、char（2字节）、int（4字节）、long（8字节）、float（4字节）、double（8字节），boolean -
说明基本数据类型变量之间自动类型提升的运算规则。
是以每个基本数据类型的空间大小来进行自动类型提升的，大的空间类型可以自动转换为小的基本数据类型 byte、short、char ---> int ---> long ---> float ---> double -
说明基本数据类型变量之间强制类型转换的使用规则和强转可能出现的问题。
如果想要小的空间类型转换为大的空间类型则可以使用强制类型转换(使用强转符)。 可能出现的问题：精度丢失
935
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
