java基础

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);
  

运算符

• 从功能来分

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

  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
   */
  

  2. 赋值运算符 = *= -= += /=
     • 都是将右边的值赋值给左边
  3. 关系运算符 < > <= >= != ==
     • 注意：结果只有true 和 false
  4. 逻辑运算符 与&& 或|| 非!
     • 注意：结果只有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);
  

  5. 位运算符 直接操作二进制的位 ~按位取反 ^按位异或 &按位与 |按位或
     • ~按位取反：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);
  

  6. 移位运算符 直接操作二进制的位 <<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
  	}
  }
  
  

• 循环结构