java字符的使用 计算机中的存储单元 基本数据类型 变量定义 运算符的使用： 数据类型的转换： 转换： ASCII表 赋值运算符 比较运算符 逻辑运算符 三元运算符 if...else if...
文章目录
- java基础知识
-
- 常用快捷键：
- 字符的使用
- 计算机中的存储单元
- 基本数据类型
- 变量定义
- 运算符的使用：
- 数据类型的转换：
- 转换：
- ASCII表
- 赋值运算符
- 比较运算符
- 逻辑运算符
- 三元运算符
- 方法
- if...else if...
- 选择语句(switch case)
- 循环
- for循环语句
- while循环(先判断后执行)
- do...while... (先执行后判断)
- for与do ...while...循环的区别
- 跳出语句
- \b 和 \r
- scanner类
java基础知识
常用快捷键：
ctrl+alt+下键：将上面一行完整的代码复制在下一行。
allt+上键:将这一行的代码移动到上一行。（上下位置的互换，可以单行，也可以多行）
alt+下键：将这一行代码移动到下一行。（上下位置的互换，可以单行，也可以多行）
ctrl+alt+L：将打乱的代码回归整齐。
ctrl+D：删除一整行的代码。（也可以选择多行同时删除）
ctrl+shift+F10：运行代码。
ctrl+Z：撤销上一步的动作。
ctrl+Y：(如果撤销的动作多了，那么后退)后退一步。
Tab：缩进。（也可以选择多行同时缩进。）
加注释：ctrl+shift+/
取消注释：ctrl+shift+\
字符的使用
package example;
public class zhuanyi {
public static void main(String[] args){
System.out.println("\"你好\"");//两个\\，表示转移字符，输出：”你好“
System.out.println("\\你好\\");//输出：\你好\
//换行符号\n,输出：你
// 好
System.out.println("你\n好");
System.out.println("你\t好\t世\t界");//制表符号：间隔相同
}
}
运行结果如下：
"你好"
\你好\
你
好
你 好 世 界
计算机中的存储单元
- 最小的信息单位bit(比特)
- 最小的存储单位Byte(字节)
（1字节=8比特）
- 8bit=1B
- 1024KB= 1KB
- 1024KB=1MB
- 1024MB=1GB
- 1024GB=1TB
- 1024TB=1PB
- 1024PB=1EB
- 1024EB=1ZB
基本数据类型
四类：整形，浮点型，布尔型，字节型。
引用数据类型：类，数组，接口。
| 数据类型 | 关键字 | 内存大小 | 取值范围 | 默认值 |
|---|---|---|---|---|
| 字节型 | byte | 1B | -128~127(2*7-1) | 0 |
| 短整型 | short | 2B | -32768~32767(2*15-1) | 0 |
| 整形 | int | 4B | 21开头的十位数(2*31-1) | 0 |
| 长整型 | long | 8B | 92开头的19位数(2*63-1) | 0 |
| 单精度浮点型 | float | 4B | -1.4013E+45~3.4028E+38 | 0.0 |
| 双精度浮点型 | double | 8B | 4.9E-324~1.7977E+308 | 0.0 |
| 字符型 | char | 2B | 0~6553 | “\u0000”(代表空格的意思) |
| 布尔型 | boolean | 1B | true/flase | flase |
备注: Java默认的基本数据类型中，整型为int，浮点型为double。
变量定义
变量定义的格式包括三个要素： 数据类型 、 变量名 、 数据值 。
- 获取数据类型的方法示例：
package example;
public class basedatatype {
public static void main(String[] args){
System.out.println(getType(123));//整型
System.out.println(getType(128735433865733L));//长整型
System.out.println(getType(3.4f));//单精度浮点型float.
System.out.println(getType(3.4));//双精度浮点型double.
}
//获取对应数据的类型
public static String getType(Object o){
String type=o.getClass().toString();
return type;
运行结果：
class java.lang.Integer
class java.lang.Long
class java.lang.Float
class java.lang.Double
运算符的使用：
package example;
public class operator {
public static void main(String[] args){
System.out.println(1+3);//加号也可以用来连接字符串。
String m= "你";
String n="好";
System.out.println(m+n);
}
}
运行结果：
4
你好
"+"不仅可以用作数学中的算数计算，也可以用来连接多个字符串。
特别注意：
%：取余数。a%2==0时为偶数，不等于0 就是奇数
/ ：取商。
++i：表示先运算后赋值。
i++：表示先赋值后运算。
示例：
a++：
int a=1;
int b=a++;
System.out.println(a);//a=2
System.out.println(b);//b=1
运行结果：
2
1
++c：
int c=1;
int d=++c;
System.out.println(c);//c=2
System.out.println(d);//d=2
运行结果：
2
2
/：（除法的运算）
int e=5;
int i=2;
double s=e/i;
System.out.println(s);
运算结果：
2.0
特别的：在除法运算时，除数不能为0，即分母不为0,否则报错！
数据类型的转换：
示例：（将整型转换为字符串）
int a =3;
String s="" +a;
System.out.println(getType(a));
System.out.println(getType(s));
运行结果：
class java.lang.Integer
class java.lang.String
转换：
- 自动转换（也成为隐式转换）：范围小的向范围大的转换为自动转换，否则为强制转换。
各个数据类型从小到大的关系为：byte - 强制转换：小范围数据类型 标识符=（小范围数据类型） 变量名称（示例如下）：
//强制转换（将双精度型转换为整型）
double m=3.4;
int n=(int) m;
System.out.println(getType(n));
System.out.println(n);
int q=65;
char p=(char)q;
System.out.println(p);
运行结果：
class java.lang.Integer
3
A
ASCII表
0–9（48~57）是字符
A–Z（65~90）
a–z（97~122）
package example;
public class sum {
public static void main(String[] args){
int m=97;
char n=97;
System.out.println(n+","+m);
}
}
运行结果：a,97
记得更改类名
package example;
public class sum {
public static void main(String[] args){
char e='a';
int i=e;
System.out.println(i);
char chinesechar='\u674e';
System.out.println(chinesechar);
}
}
运行结果：
97
李
赋值运算符
比较运算符
逻辑运算符
& 与/和（and）
flase&执行true/flase==flase
只有&两边的表达式的值都是true,整体结果才是true，其他都是false(全真才真，一假就假)
&不具有短路效果，即左边false，右边还会执行；&&具有短路效果，左边为false，右边则不执行
&&
false&&不执行(true/false)==false
一错就错
| 或
||短路或
true||不执行（true/false）==true
只有|两边的表达式的值都是false，整体结果才是false，其他都是true，（一真就真，全假就假）
|与||的区别
- | 既是逻辑运算符也是位运算符；|| 只是逻辑运算符
- | 不具有短路效果，即左边true，右边还会执行；|| 具有短路效果，左边为true，右边则不执行
短路的特点：只要第一个表达式的结果能确定整体表达式的结果，后面的表达式就短路不执行
！非/取反(非错即对)
^ 异或
任何数和0相异得到的是这个数本身 eg:1 ^ 0 =1，0 ^ 0=0
任何数和1相异或得到的是这个数相反 eg:0 ^ 1=1,
一个数自己和自己异或得到的是0 eg: 1 ^ 1=0,
举例：
public static void main(String[] args) {
System.out.println(true && true);//true
System.out.println(true && false);//false
System.out.println(false && true);//false，右边不计算
System.out.println(false || false);//falase
System.out.println(false || true);//true
System.out.println(true || false);//true，右边不计算
System.out.println(!false);//true
}
三元运算符
- 格式：数据类型 变量名 = 布尔类型表达式？结果1：结果2
- 三元运算符计算方式：
布尔类型表达式结果是true，三元运算符整体结果为结果1，赋值给变量。
布尔类型表达式结果是false，三元运算符整体结果为结果2，赋值给变量。
举例：
public static void main(String[] args) {
int i = (1==2 ? 100 : 200);//1==2不成立，输出2对应的值：200
System.out.println(i);//200
int j = (3<=4 ? 500 : 600);//3<=4成立，输出3对应的值500，
System.out.println(j);//500
}
运行结果：
200
500
例如：用三元运算符比较三个数字的大小：
int a=100;
int b=110;
int c=1100;
int max1= a > b ? ( a > c ? a : c ) : ( b > c ? b : c );
System.out.println(max1);
int max2 = ( a > b ? a : b ) > c ? ( a > b ? a : b) : c;
System.out.println(max2);
运行结果：
1100
1100
方法
- 方法的定义
修饰符 返回值类型 方法名 （参数列表）｛
代码…
return ;
｝
定义格式解释：
修饰符： 目前固定写法 public static 。 - 方法的调用：方法在定义完毕后，方法不会自己运行，必须被调用才能执行，我们可以在主方法main中来调用我们自己定义好的方法。在主方法中，直接写要调用的方法名字就可以调用了。
public static void main(String[] args) {
//调用定义的方法method
method();
}
//定义方法，被main方法调用
public static void method() {
System.out.println(“自己定义的方法，需要被main调用运行”);
} - 方法定义注意事项：
方法必须定义在一类中方法外
方法不能定义在另一个方法的里面
if…else if…
if(布尔表达式){
语句1
}else if{
语句2
}else if{
语句3
}…{
语句n
}else{
语句n+1
}
一旦有某个语句执行了，那么后面的else if语句将不再执行
例如：
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
System.out.println("请输入想要查询的月份：");
int d = sc.nextInt();
if(d>12|d<1){
System.out.println("你是自己创造了个月份嘛~");
}else{
if(d==3|d==4|d==5){
System.out.println("Spring春季");
}else{
if(d==6|d==7|d==8){
System.out.println("Summer夏季");
}else{
if(d==9|d==10|d==11){
System.out.println("Autumn秋季");
}else{
if(d==12|d==1|d==2){
System.out.println("Winter冬季");
}else{
System.out.println("重新输入吧~");
}
}
}
}
}
}
选择语句(switch case)
switch(表达式){
case 值1:
表达式的值和值1匹配上了，需要执行的代码;
break;
case 值2:
表达式的值和值2匹配上了，需要执行的代码;
break;
case 值3:
表达式的值和值3匹配上了，需要执行的代码;
break;
default:
如果表达式的值和以上的case后面的值都没有匹配上，那么就执行这里的代码。
break;
}
例如：
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
System.out.println("请输入月份");
int month=sc.nextInt();
switch (month){
case 3:
case 4:
case 5:
System.out.println("Spring");
break;
case 6:
case 7:
case 8:
System.out.println("summer");
break;
case 9:
case 10:
case 11:
System.out.println("Autumn");
break;
case 12:
case 1:
case 2:
System.out.println("Winner");
break;
default://default:预设
System.out.println("你是自己创造了个月份嘛~");
}
执行流程：
- switch后的值与case的值作比较
- 如果相等，执行case下的语句
- 如果遇到break，就跳出switch结构，执行后续
- 如果没有break，会造成case击穿（即一直循环执行不停止,不会在判断下一个case的值，直接向后运
行，直到遇到break，或者整体switch结束.) - 如果不相等对比下一个。
- switch后支持byte,short,in,char,String enum(枚举)
- case值的数据类型要与switch的值数据类型一致
循环
- 循环四要素
- 循环初始值
- 循环控制条件
- 循环体
- 循环迭代
for循环语句
格式：for(初始化表达式①; 布尔表达式②; 步进表达式④){
循环体③
}
执行流程
执行顺序：①②③④>②③④>②③④…②不满足为止。
①负责完成循环变量初始化
②负责判断是否满足循环条件，不满足则跳出循环
③具体执行的语句
④循环后，循环条件所涉及变量的变化情况
(先执行初始值，再判断，为true执行循环体，然后执行迭代，继续判断，如果为false,就跳出for循环结构)
1,变量名:再同一作用域内不能重复;
2,变量:在这一范围内有效；
3,同一作用域：在同一个最近的{}内。
对于第一点的解释(以1~100的奇数和与偶数和为例)：
所属方法不同：
package example;
public class word {
public static void main(String[] args){
/*int a=1;
while(a<6){
System.out.println("hello~");
a++;
}
System.out.println("a"+a);*/
//i属于main方法
//输出1~100奇数和偶数
int i=0;
while(i<=100){
if(i%2==0){
System.out.println("偶数有："+i);
}else{
System.out.println("奇数有："+i);
}
i++;
}
}
//i属于sleep方法
public void sleep(){
int i=0;
while(i<=100){
if(i%2==0){
System.out.println("偶数有："+i);
}else{
System.out.println("奇数有："+i);
}
i++;
}
}
}
//两个i所属的方法不同,也就是作用域不同，所以不会报错
例如：作用域不同
package example;
public class sum2 {
public static void main(String[] args){
int sum1=0;
int sum2=0;
//i=0:初始条件
//i<=100:循环条件
//i++:迭代
//for{}里面的是循环体
for(int i = 0;i <= 100;i++){
if(i%2==0){
sum1+=i;
}else{
sum2+=i;
}
}
System.out.println("1~100的偶数和为："+sum1+".");
System.out.println("1~100的奇数和是："+sum2+".");
for(int i = 0;i <= 100;i++){
if(i%2==0){
sum1+=i;
}else{
sum2+=i;
}
}
System.out.println("1~100的偶数和为："+sum1+".");
System.out.println("1~100的奇数和是："+sum2+".");
//两个i所属的作用域不同，分别属于两个for,所以不会报错
}
}
例如：作用域相同
package example;
public class sum2 {
public static void main(String[] args){
int i=0;
//i属于main方法的作用域
int sum1=0;
int sum2=0;
//i=0:初始条件
//i<=100:循环条件
//i++:迭代
//for{}里面的是循环体
//i虽然是for作用域，但是for的作用域也属于main方法，所以for(int i = 0;i <= 100;i++)中的i会报错
for(int i = 0;i <= 100;i++){
if(i%2==0){
sum1+=i;
}else{
sum2+=i;
}
}
System.out.println("1~100的偶数和为："+sum1+".");
System.out.println("1~100的奇数和是："+sum2+".");
}
}
例如：
package example;
public class sum2 {
public static void main(String[] args){
int sum1=0;
int sum2=0;
//i=0:初始条件
//i<=100:循环条件
//i++:迭代
//for{}里面的是循环体
for(int i = 0;i <= 100;i++){
if(i%2==0){
sum1+=i;
}else{
sum2+=i;
}
}
System.out.println("1~100的偶数和为："+sum1+".");
System.out.println("1~100的奇数和是："+sum2+".");
}
}
while循环(先判断后执行)
- while(布尔表达式){
循环体；
循环迭代；（++/–）控制循环次数
} - 执行流程：
- 先判断while后的表达式
- true,执行{}内的语句
- 执行完{}的语句之后，再次判断while后的表达式
- 当判断为false时，不在执行{}的内容
- 继续执行后续
例如：
package example;
public class word {
public static void main(String[] args){
int a=1;
while(a<6){
System.out.println("hello~");
a++;
}
System.out.println("a"+a);
}
}
运行结果：
hello~
hello~
hello~
hello~
hello~
a6
do…while… (先执行后判断)
- 语法
初始化表达式①
do{
循环体③
步进表达式④
}while(布尔表达式②); - 执行流程：
①③④>②③④>②③④…②不满足为止
- ①负责完成循环变量初始化。
- ②负责判断是否满足循环条件，不满足则跳出循环。
- ③具体执行的语句
- ④循环后，循环变量的变化情况
（先执行do中的循环内容,再判断while后的表达式,当为true时,再执行do中的内容,再判断…,直到判断为false时,跳过循环,执行后续)
循环体(do…while…)至少执行一次(无条件执行一次循环体)
for与do …while…循环的区别
控制条件语句所控制的那个变量，在for循环结束后，就不能再被访问到了，而while循环结束还可以继续使用，如果你想继续使用，就用while，否则推荐使用for。原因是for循环结束，该变量就从内存中消失，能够提高内存的使用效率。
在已知循环次数的时候使用推荐使用for，循环次数未知的时推荐使用while
跳出语句
- break
\b 和 \r
ASCII码转义符
\b = 退格键（backspace）
\r = 回车键（carrige return）
\n=换行符(enter)
- continue
scanner类
- 属于引用数据类型