java基础

最新推荐文章于 2021-09-18 10:17:31 发布

天黑要加班

最新推荐文章于 2021-09-18 10:17:31 发布

阅读量222

点赞数

分类专栏： java知识点

本文链接：https://blog.csdn.net/weixin_42767528/article/details/83683946

版权

java知识点专栏收录该内容

12 篇文章 0 订阅

订阅专栏

1.进制转换
2.数据类型
3.运算符
4.流程控制语句

进制转换：

进制：遇几进一就是几进制
常用的进制：二进制，八进制，十进制，十六进制
二进制：遇二进一，是计算机能够识别的一种形式
八进制，十六进制：可以更好的表示二进制

计算机的存储单位：

1 Byte = 8 bit
1 kb = 1024 Byte
1 MB = 1024 KB
1 GB = 1024 MB
1 TB = 1024 GB
1 PB = 1024 TB

数据类型

定义：决定了变量所占内存空间的大小，并且给变量确定了类型.
分类:
- 有符号型(区分正,0,负)
- 无符号型(只有0,正数)
主要研究有符号型的：分两类：
- 1.简单数据类型.
  - 数值型
    - byte 1个字节 [-2^7, 2^7-1]
    - short 2个字节 [-2^15, 2^15-1]
    - int 4个字节 [-2^31, 2^31-1]
    - long 8个字节 [-2^63, 2^63-1]
  - 浮点型：小数
    - float：单精度型 4个字节这里采用的是科学计数法
    - double：双精度型 8个字节
  - 布尔型
    - Boolean 1个字节只有两个值true/false，注意：这里区别于c（c中0被认为是false，非0被认为是true），java中只有true和false
  - 字符型 ''表示字符，“”表示字符串
    - char 常规理解：1个字节
    - 常用的字符集：美国的ASCII , 欧洲的ISO8859-1, 中国的GBK/GB2312, 国际通用的UTF-8, 计算机的unicode
    - 中文对应的字节数 GBK/GB2312 2个字节, ISO8859-1 1个字节（不支持中文）， UTF-8 3个字节，unicode 2个字节
    - 编码：将字符转成二进制的过程
    - 解码：将二进制转回字符的过程
    - 乱码：由于在编码和解码的过程中使用的字符集不一致，造成的乱码
```
//数值型
/*
 * 区分数值和初始化
 * 赋值：一半是在定义好一个变量之后，单独赋值
 * 初始化：一定是在定义变量的同时完成赋值
 */
byte a = 12;//定义了一个Byte型的变量a并初始化成12
a = 14;//赋值
System.out.println("a = " + a);//+的作用：1.运算  2.当使用字符串与其他的数据类型变量进行相加时，+的功能是拼接

short b = 23;
int c = 34;

//浮点型
//求float型，double型的最大值
System.out.println(Float.MAX_VALUE);
System.out.println(Double.MAX_VALUE);
	
float d = 3.3F;//默认的是double类型，float类型需要加一个F
double e = 4.5;
	
//布尔型
boolean f = true;

//字符型,''表示字符，“”表示字符串
char g = 'a';
System.out.println((int)g);
```
- 2.引用数据类型—暂时不考虑

类型转换：

根据等级的高低从低到高：byte,char—short—int —long—float—double
强制类型转换：从高类型转成低类型可能造成数据的损失
自动类型转换：从低类型转成高类型不会造成数据的损失

//比较long型和float型的大小
System.out.println(Long.MAX_VALUE-Float.MAX_VALUE);
byte a = 12;	//         00001100
short b = a;	//00000000 00001100
System.out.println("a = " + a + "   b = " + b);
short c = 256;	//00000001 00000000
byte d = (byte)c;//        00000000
System.out.println("d = " + d);

//实例一
int e = 128;
byte f = (byte)e;
System.out.println("f = " + f);//-128

//实例二		数默认是int型	

byte num = 4;
num = (byte)(num + 3);
System.out.println("num = " + num);

运算符

从功能来分

算数运算符加减乘除取余% ++ –

System.out.println(3+4);//7
System.out.println(3*-2);//-6
System.out.println(-3/2);//遵守普通的运算规则，只适用于整数的运算
System.out.println(-3%2);//取余数时，余数的符号与被除数保持一致

  （自增）++  （自减）--    主要研究++两种情况：
  1. ++在前：变量会首先自身+1，再使用+1后的值参与整体的运算
  2. ++在后：变量首先会参与整体的运算，然后再自身+1


int a = 2,b,c = 3,d;
b = a++;//++在后    b = 2  a = 3
d = ++c;//++在前    c = 4  d = 4

// 练习：
int n = 2, m = 3,u = 1,o = 0;
o = n++ - --m + (u++ - n--);
System.out.println("n = " + n + "  m = " + m + "  u = " + u + " o = " + o);
//n = 2  m = 2  u = 2 o = -2
/*
 * 实例的分析：先考虑优先级，优先级相同再考虑结合性。先考虑优先级低的，使用排除法将优先级高的找出来，再一步一步计算
 * 1.先考虑=，使用排除法，根据右结合性，先算=的右边
 * 2.再考虑（）外的-、+，根据左结合性
 * 3.算n++  n = 3   n++ = 2
 * 4.算 --m  m = 2  --m = 2
 * 5.算（）  （1-3） u = 2  n = 2
 * 6.算2中的-+   2-2+（1-3） = -2
 * 7.算 =  将值赋给 o = -2
 */

赋值运算符 = *= -= += /=
- 都是将右边的值赋值给左边
关系运算符 < > <= >= != ==
- 注意：结果只有true 和 false
逻辑运算符与&& 或|| 非!
- 注意：结果只有true 和 false；参与运算的元素的值也只能是true 和 false
- 逻辑与&&：全真则真，一假则假
- 逻辑或||：全假则假，一真则真
- 非!：真则假，假则真

System.out.println(true&&false);//false
System.out.println(true&&true);//true
System.out.println(false||true);//true
System.out.println(!false);//true
System.out.println(3>4&&5<3);//false

  + 短路与：当有多个&&相连时，从左往右运算，只要得到一个false，就会停止运算(代码不再执行)，整个的结果就是false.
  + 短路或：当有多个||相连时，从左往右运算，只要得到一个true，就会停止运算(代码不再执行)，整个的结果就是true.
  + 如果后边又有了其他的逻辑运算符，将前面连续的值算出后，还需要进行当前运算符的运算

Boolean istrue = 3<1 && 4>3 && 2<4;
System.out.println(istrue);

位运算符直接操作二进制的位 ~按位取反 ^按位异或 &按位与 |按位或
- ~按位取反：1就是0,0就是1
- ^按位异或：相同则是0，不相同则是1
- &按位与：全1则1，有0则0
- 按位或：全0则0，有1则1
- 为什么要使用位运算符进行运算？
- 因为位运算直接操作的是二进制，速度更快，效率更高

/*
 * 实例： 11 和 7
 * 1011    11
 * 0111     7
 * 
 * 0011   &
 * 1111   |
 * 1100   ^
 * 
 * 按位取反
 * 1011  11
 * 0100  ~
 */
//实例：实现两个数的交换    x = 3  y = 4
//借助第三方变量
int x = 3, y = 4, temp = 0;
temp = x;
x = y;
y = temp;
System.out.println("x:"+x+"   y:"+y);
//弊端：需要借助三方变量

x = x ^ y;
y = x ^ y;
x = x ^ y;
System.out.println("x:"+x+"   y:"+y);

移位运算符直接操作二进制的位 <<1 左移一位，代表乘2 >>1右移一位，代表除以2
- 注意：先右移后左移不一定得到原来的数，先左移后右移也不一定能得到
```
int z = 5>>1;//0101  右移一位  0010
```

System.out.println(z);//2
z = x<<1;//0010 左移一位 0100
System.out.println(z);//4

从运算符操作的元素个数来分
1. 一元运算符： ++ – + - ！ ~
2. 二元运算符：+ - * /
3. 三元运算符：？：（三目运算符）
  - 组成：表达式1>表达式2？值1：值2
  - 解释：当表达式1>表达式2成立的时候，整个运算符的结果就是值1，否则就是值2
```
int r = 4,i = 5;
int q = r>i?r:i;
System.out.println(q);
```

流程控制语句

顺序结构

分支结构
if{} if{} else{} if{} else if {} if{ if{} else{} } switch case

if(判断条件(true/false)){  
执行的语句;  
}

if(true){  
 	执行语句1;  
}else{  
	执行语句2;  
}

if(条件1){  
	执行语句1;  
}else if(条件2){  
	执行语句2;  
}else if(条件3){  
	执行语句3;  
}else{  
	执行语句4;  
}

if(true){  
	if(true){  
 	   执行语句1;  
	}else{  
	   执行语句2;  
	}  
}  

int a = 3;
switch(a){
   case 1:{执行语句1; }
   break;//是结束的意思
 case 2:{执行语句2; }
   break;
 case 3:{执行语句3; }
   break;
 case 4:{执行语句4; }
   break;
 default:{执行语句5; }
 break;

}

实例代码：

public static void main(String[] args) {
	/*
	 * 讲解分支语句
	 * 
	 * 实例：判断当前的月份属于哪个季节
	 * 春季：3 4 5 夏季 ：6 7 8 秋季：9 10 11 冬季：12 1 2
	 * 使用分支语句
	 */
	int num = 3;
	
	
	if(num == 3) {
		System.out.println("春");
	}else if(num == 4){
		System.out.println("春");
	}else if(num == 5){
		System.out.println("春");
	}else if(num == 6){
		System.out.println("夏");
	}else if(num == 7){
		System.out.println("夏");
	}else if(num == 8){
		System.out.println("夏");
	}else if(num == 9){
		System.out.println("秋");
	}else if(num == 10){
		System.out.println("秋");
	}else if(num == 11){
		System.out.println("秋");
	}else if(num == 12){
		System.out.println("冬");
	}else if(num == 1){
		System.out.println("冬");
	}else if(num == 2){
		System.out.println("冬");
	}
	
	//优化
	if(num == 3 || num == 4 || num == 5) {
		System.out.println("春");
	}else if(num == 6 || num == 7 || num == 8){
		System.out.println("夏");
	}else if(num == 9 || num == 10 || num == 11){
		System.out.println("秋");
	}else{
		System.out.println("冬");
	}
	
	//if  的相关注意点：
	//第一个注意点：如果if后面没有{}，默认只能跟一条语句，如果想跟多条语句，只能加{}
	if(num > 5)
		System.out.println("haha");
	System.out.println("ok");
	
	//if 后面可以直接跟空语句
	if(num>5);
	
	//实例：根据学员的成绩判断状态 ABCDE
	int a = 33;
	//1.当把break删掉，程序不会结束，会继续执行下面的代码，直到遇到break结束，我们把switch的这种行为称为穿透性
	//2.switch（值）：值可取的内容：整形，字符串型（在jdk1.8开始使用），枚举型
	//3.case后边如果跟多条语句，最好也加{}
	switch(a/10) {
	case 1://这里只能写具体的值，不能写表达式
		System.out.println("不及格");
		break;//结束switch的意思
	case 2:
		System.out.println("不及格");
		break;
	case 3:
		System.out.println("不及格");
		break;
	case 4:
		System.out.println("不及格");
		break;
	case 5:
		System.out.println("不及格");
		break;
	case 6:
		System.out.println("及格");
		break;
	case 7:
		System.out.println("中");
		break;
	case 8:
		System.out.println("良");
		break;
	case 9:
		System.out.println("优");
		break;
	default :
		System.out.println("NB");
		break;
	}
	
	//继续优化
	switch(a/10) {
	case 1:case 2:case 3:case 4:case 5:
		System.out.println("不及格");
		break;
	case 6:
		System.out.println("及格");
		break;
	case 7:
		System.out.println("中");
		break;
	case 8:
		System.out.println("良");
		break;
	case 9:
		System.out.println("优");
		break;
	default :
		System.out.println("NB");
		break;
		
	//switch和if哪个好？
	//看使用场景：如果分支少使用if，分支多用switch
	}
}

循环结构

天黑要加班

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java基础

1.进制转换2.数据类型3.运算符4.流程控制语句进制转换：进制：遇几进一就是几进制常用的进制：二进制，八进制，十进制，十六进制二进制：遇二进一，是计算机能够识别的一种形式八进制，十六进制：可以更好的表示二进制计算机的存储单位：1 Byte = 8 bit1 kb = 1024 Byte1 MB = 1024 KB1 GB = 1024 MB1 TB = 10...
复制链接

扫一扫

专栏目录