java day03

Java基础语法

注释

• 平时编写代码，在代码比较少的时候，可以看懂自己写的，但是当项目结构复杂起来，我们就需要用到注释

• 注释并不会被执行，是写个我们自己看的

• 书写注释是一个非常好的习惯

• Java中的注释有三种：

  1. 单行注释   //
  2. 多行注释   /**/
  3. 文档注释   /**
  			 * 
  			 */
  

标识符

关键字

Java所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符。

注意点

• 所有的标识符都是以字母，美元符，下划线开始
• 首字母之后可以是字母，美元符，下划线或者数字的任何字符组合
• 不能使用【关键字】作为变量名或者方法名
• 标识符是大小写敏感的
• 可以使用中文命名，但是一般不建议去使用。

数据类型

强类型语言

​ 要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用

弱类型语言

​ 变量的使用可以不符合规定

Java的数据类型分为两大类

1. 基本类型（primitive type）

   a.数值类型

   • 整数 ：byte (1字节)、short（2字节）、int（4字节）、long（8字节）
   • 浮点 ：float (4字节)、double（8字节）
   • 字符 ：char (2字节)

   b.boolean类型

       public static void main(String[] args) {
           /*八大借本数据类型*/
   
           //整数
           int a = 10; //最常用
           byte b = 20;
           short c = 30;
           long d = 30L; // long类型在数字后加上L
   
           //小数：浮点数
           float q = 50.1f; //float类型要在数字后面价格
           double w = 3.1415926;
   
           //字符
           char name = 'A';
           //字符串,String不是关键字，是类
           String nameStr = "菜鸟起飞";
   
           //布尔值 : true/false
           boolean flag = false;
       }
   

2. 引用类型 （reference type）

   • 类
   • 接口
   • 数组

       public static void main(String[] args) {
       //整数拓展 ：进制 二进制0b 十进制 八进制0 十六进制0x
       int n = 10; // 十进制
       int n1 = 010; // 八进制0
       int n2 = 0x10; // 十六进制0x  0-9 A-F (10-16)
   
       System.out.println("n:" + n);
       System.out.println("n1:" + n1);
       System.out.println("n2:" + n2);
       
       //浮点数拓展：银行业务钱的表示？
       // BigDecimal 类
       // float 有限 离散 舍入误差 大约 接近但不等于
       // 最好完全使用浮点数进行比较！ 最好完全使用浮点数进行比较！最好完全使用浮点数进行比较！
       float f = 0.1f; //0.1
       double d = 1.0 / 10; //0.1
       System.out.println(f == d);
   
       float d1 = 12343444f;
       float d2 = d1 + 1;
       System.out.println(d1==d2);
   }
   

字节

1. 位（bit）:是计算机内部数据存储的最小单位，11001100是一个八位二进制数
2. 字节（byte）:是计算机中数据处理的最基本单位，习惯上用大写的B来表示
3. 1B（byte,字节）=8bit(位)
4. 字符：是指计算机中使用的字母、数字、字和符号

• 1bit 表示1位
• 1Byte表示一个字节 1B=8b
• 1024B = 1KB ,1024KB = 1M , 1024M = 1G

类型转换

由于Java是强类型语言，所以要进行有些运算时需要类型转换

​ 低 -----------------------------------> 高

​ byte,short,char -> int ->long -> float -> double

运算中，不同类型的数据先转换为同一类型，然后进行运算

强制转换类型

自动类型转换

public static void main(String[] args) {
        int i = 128;
        byte b = (byte) i; // 内存溢出
        double d = (double)i;
        //强制转换 （类型）变量名 高 》 低
        //自动转换 低 》 高
        System.out.println(i); // 128
        System.out.println(b); //-128
        System.out.println(d); //128.0
        /*
        注意：
        1、不能对布尔值进行转换
        2、不能把对象类型转换为不相干的类型
        3、把高容量转换到低容量的时，强制转换
        4、转换时可能存在内存溢出，或者精度问题
         */
        System.out.println("==============================");
        System.out.println((int)23.7); //23
        System.out.println((int)-45.89f); //-45

        System.out.println("==============================");
        //操作比较大的数，注意溢出
        //JDK7新特，数字之间可以用下划线
        int m = 10_0000_0000;
        int y = 20;
        int t = m*y;//-1474836480
        long t1 = m*y; // 默认时int,转换前已经存在问题
        long t2 = m*((long)y); //先把一个转换为long,20000000000

        System.out.println(t);
        System.out.println(t2);
    }

运算符

二元运算

	public static void main(String[] args) {
        //二元运算
        int a = 10;
        int b = 15;
        int c = 25;
        int d = 25;
        System.out.println(a+b);
        System.out.println(a-b);
        System.out.println(a*b);
        System.out.println(a/(double)b);//不强转b，结果将为0
    }
    结果 ：
    25
    -5
    150
    0.6666666666666666

关系运算

   public static void main(String[] args) {
        //关系运算符返回的结果：正确、错误 布尔值
        int a = 10;
        int b = 15;
        System.out.println(a>b);
        System.out.println(a<b);
        System.out.println(a==b);
        System.out.println(a!=b);
       
       // 取模
       System.out.println(a%b);
    }

结果：
    false
    true
    false
    true
    
    10

一元运算符、Math

   public static void main(String[] args) {
        //一元运算符 ++ -- 自增、自减
        int x = 3 ;
        int y = x++; //执行完这行代码后，先给y赋值，再自增
        // x = x+1
        System.out.println(x); //4
       
        int z = ++x;  //执行完这行代码前，先自增，在给c赋值
       
        System.out.println(x); //5
        System.out.println(x); //5
        System.out.println(y); //3
        System.out.println(y); //3
        System.out.println(z); //5
        System.out.println(z); //5
       
        //幂运算 2^3
       double pow = Math.pow(2,3);
       System.out.println(pow); 
    }

逻辑运算符

public static void main(String[] args) {
        //与（and） 或(or) 非(取反)
        boolean a = true;
        boolean b = false;
        System.out.println("a && b" + (a && b));//与运算，两个变量都为真，结果才为true
        System.out.println("a || b" + (a || b));//或运算，两个变量有一个变量为真，结果就为true
        System.out.println("!(a && b)" + !(a && b));// 真取反为假，反之取假则为真

        //短路运算
        int c = 5;
        boolean d = (c < 4) && (c++ < 4);
        System.out.println(d);//false
        System.out.println(c);//5
    }

位运算

a = 0011 1100
b = 0000 1101
----------------
a&b = 0000 1100
a|b = 0011 1101
a^b = 0011 0001
 ~b = 1111 0010

三元运算符

// x?y :z
//如果 x==true ，结果为y,否则为z
int score = 80;
String type = scroe < 60 ? "不及格":"及格";
// 结果 ：及格

扩展赋值运算符

        int f = 10;
        int h = 20;
        f += h; // f = f+h
        f -= h; // f =f-h
        System.out.println(f);

        //字符串连接符 + 出现String类型，将其他类型转为String拼接
        System.out.println(""+f+h);
		System.out.println(f+h+"");