/**
 * 演示java中的注释
 * 演示java中的注释
 * 演示java中的注释
 *
 * 文档注释,  用于为类,方法,变量进行说明 鼠标放在类,方法,变量上时会进行功能提示
 */
public class Demo1{
    //以特定的符号作为标记,对程序功能进行说明,程序运行时,不会执行注释的.
    // main方法是java程序的入口  ctrl+/
    public static void main(String[] args) {
        //年龄
        int age  = 10;
       /*
          注释1
          注释2
        */

       /*
         ctrl+shift+/  添加多行注释  取消多行注释
        System.out.println("111111");
        System.out.println("222222");*/

      /*
         保留字 : java中未正式定义为关键字的,但是还不能再java语言中使用的单词,  在后期版本中可能会被定以为关键字
         int const = 10;
         int   goto  = 10;*/

    }
       
}

关键字

语言中被赋予特定含义的单词，用来修饰某些内容（类，方法，变量）

关键字都是小写的

标识符

标识符：java为类，方法，变量等命名时，使用的字符序列称为标识符

自己可以命名名称

标识符的命名规则：

1、语法强制规范

标识符由26个英文字母大小写，数字，_,$组成

数字不能开头，不能是关键字和保留字，可以包含关键字

区分大小写

长度无限制

标识符不能包含空格

2、约定俗称

见名知意

包名：全部小写

类名：首字母大写，多单词组成时，所有单词首字母大写 XxxYyyZzz 为了区分类名和变量名

变量名和方法名：首字母小写多单词组成时，首字母小写，其余字母大写 xxxYyyZzz

常量：全部大写多单词之间用_连接 MAX_VALUE OP

变量

public class Demo2 {


    public static void main(String[] args) {
        int age1 = 10;
        int int1  = 10;
        int a  = 10;
        int A  = 10;

        int b  = 13; //声明变量 申请内存空间, 然后在使用前必须赋值, 赋值必须与类型一致
        //b = 10;
        System.out.println("变量:"+b);

        //声明语法  数据类型  变量名1,变量名2
        int x,y,z;
        x = 10;
        y = 20;
        z = 30;

    }

}

数据类型

java中的数据类型

基本数据类型（8个关键字说明的）

 public class Demo3 {  
          public static void main(String[] args) {
        //整数  byte  short int long
          byte a = 127;
          short b = 32767;
          int c = 1000000;
          long d = 2222222222L; //整数字面量默认是int

        //浮点 float  double
          float e = 1022.222f;
          double  f = 100.3333; //浮点数字面量默认是double
        //字符 char  只能表示一个字符   如何想表示一个字符串请用String
          char g = 'a';
          String h = "abcd";

         //布尔型  boolean
          boolean j = true;
          boolean j1 = false;
          System.out.println(a>b);


    }

整数

byte 1byte=8bit位 127

short 2byte

int 4byte

long 8byte

 public class demo1{
     public static void main(String[] args) {
        System.out.println(10);//10 常量（有歧义） 一般称为字面量
        //byte 1字节
        byte a = 127;
        System.out.println(a);

        //short 2字节
        short b = 32767;

        //int 4字节
        int c = 2147483647;

        //long 8字节
        long d = 2147483648L;//Java中整数字面量类型位int类，一般在声明long类型时，在字面量类型后面加L
        long e = 9223372036854775807L;

        int x = 0b11;//0b开头的数是二进制的
        System.out.println(x);
        int y = 0x11;//0x开头的数是16进制的
        System.out.println(y);
        int z = 011;//0开头的数是八进制的
        System.out.println(z);

        System.out.println(Integer.toBinaryString(i:7));//111
        String s="abcd";

    }
}

Integer.toBinaryString 输入数字，输出二进制转化

浮点

float 4byte

double 8byte

import java.math.BigDecimal;

public class demo2 {
    public static void main(String[] args) {
        //float 4字节 单精度 只能表示8位有效数字
        float a = 10.333F;//java中浮点数字面量默认是double类型，声明float类型时，需要在字面量后面加f/F
        System.out.println(a);
        //double 8字节 双精度 精度是float的两倍
        double b = 10.333333333;
        System.out.println(b);

        //在Java的实际开发中，float和double用的比较少
        System.out.println(1.0-0.7==0.3);//false
        //因为小数转2进制时，采用乘二取整，例如0.36是无限不循环的，只能以近似值进行表示了

        //Java中浮点数计算的类
        BigDecimal bigDecimal1=new BigDecimal("1.0");
        BigDecimal bigDecimal2=new BigDecimal("0.7");
        System.out.println(bigDecimal1.subtract(bigDecimal2));
    }
}

字符

char

public class demo4 {
     public static void main(String[] args) {
        /*
         java中char类型，只能表示一个字符，大小是二字节，可以表示世界上任意字符
         计算机底层只认识二进制，不认识字符，所以每个字符在底层的编码表中有一个对应的整数编号 a-97-0111101
        */
         char c = 'a';
        char c1 = 'b';
        char c2 = '中';
        /*
        编码表
        ASCII 包含英文字母 其他符号
        GBK GB2312
        Unicode 后来国际上发明了一种编码，可以包含全球任何国家的语言符号,兼容了ASCII码的那一部分
        Java中采用的是Unicode编码表
        */
        /*
        char类型，可以进行算数运算
        在运算时，实际上用的是此字符在编码表中对应的十进制编号进行运算的
        */
         System.out.println(c2+0);//中-20013
         System.out.println(c+0);//a-97
     }
}

布尔值（逻辑值）ture false

boolean

 public class demo03 {
    public static void main(String[] args) {
        boolean a = true;
        boolean b = false;
        if(a){

        }
        int c = 0;
        int d = 5;
        System.out.println(c>d);
        //java中不能用0/非0表示假/真
        if(c>d){

        }
    }

}

引用类型（String):用类声明的类型

public class demo5 {
    public static void main(String[] args) {
        /*
        String是Java中提供的一个类
        用String类来表示一种类型

        String s = "abcd";
        */
        String s = "abcd";
        System.out.println(s.length());

        int a = 10;
        int b = 5;
        System.out.println("变量a:"+a+"\n变量b:"+b);

        String name = "chh";
        String address = "西安";
    }
}

强制类型转换

8种数据类型
byte int short long 整数
float double 浮点
char 一个字符---底层编码表对应一个整数编号
boolean 逻辑值 true false

基本数据类型转换（除boolean之外的7种类型之间进行转换）
转换分为：
默认转换：小容量类型转换为大容量类型

强制转换：大容量类型转换为小容量类型

package day2;

public class demo6 {
    public static void main(String[] args) {
        //小容量类型转为大容量类型，可以自动的进行转换
        //byte,short,char->int->long->float->double
        byte a = 127;
        int b = a;
        long c = b;
        float e = c;//4个字节的float类型 容量大于8个字节的long类型，原因是小数和整数在底层的二进制存储计算方式不同
        double d = c;
        char f = 'a';//char--int--97
        int g = f;

        //大容量类型转换为小容量,可能会出现问题
        //问题一：溢出;问题二：精度降低了
        int x = 10;
        byte y = (byte)x;
        System.out.println(y);

        float z = 10.55f;
        int zz = (int)z;
        System.out.println(zz);


        //test(a);
    }

   /* public static void test(int a){

    }*/
}

（test是用于调试能被函数调用的数据类型，这里能调用的只有容量小于等于int类型的，调用其他类型的会报错）

运算符

算术运算符

运算符
算术运算符
+ :1、加法运算（数值+数值）2、连接功能（数值+字符串字符串+字符串）3、正号
- :1、减法2、负号
*
/
%
++:自增1
--:自减1

public class demo7 {
    public static void main(String[] args) {
        int a = -10;
        int b = 5;
        char c = 's';
        String d = "abcd";
        System.out.println(a+b);//加法
        System.out.println(a+c);//加法
        System.out.println(a+d);//连接  最终得到了字符串

        //++每次自增1
        int e = 5;
        e++;
        ++e;
        /*int f = e++ + 2; 先运算，后自增
        System.out.println(f);//9
        System.out.println(e);//8*/

        int f = ++e + 2;  //先自增，后运算
        System.out.println(f);//10
        System.out.println(e);//8
    }
}

比较运算符

运算符
比较运算符
==，!= :用于数值与数值之间比较还可以用布尔型和布尔型还可以用于引用类型和引用类型
>,<,>=,<= :只能比较数值与数值（char）大小

public class demo8 {
    public static void main(String[] args) {
        int a = 10;
        int b = 5;
        System.out.println(a==b);//false
        System.out.println(a!=b);//true

        boolean c = true;
        boolean d = false;
        System.out.println(c==d);//false
        System.out.println(c!=d);//true

        String s1 = "abcd";
        String s2 = "abcd";
        System.out.println(s1==s2);//true
        System.out.println(s1!=s2);//false

        System.out.println(a>'a');//false
    }
}

逻辑运算符

运算符
逻辑运算:逻辑值（true，false）与逻辑之间的运算
&:逻辑与
&&:逻辑与（短路与）
|:逻辑或
||:逻辑或（短路或）
!:逻辑非取反
^:逻辑异或相同为假，不同为真

public class demo9 { 
    public static void main(String[] args) {
        int a = 10;
        int b = 5;
        int c = 1;

        //&:左右两边都是true结果为true，有一个false，结果为false
        //&:当遇到false后还会执行后面的表达式
        System.out.println(a>b & b>c);//true & true-true
        System.out.println(a>b & b<c);//true & false-false
        System.out.println(a<b & ++b<c);//false & false-false
        System.out.println(b);//6

        System.out.println("-----------------------------------");

        //&&:左右两边都是true结果为true，有一个false，结果为false
        //&&:当遇到false后不会执行后面的表达式
        System.out.println(a>b && b>c);//true && true-true
        System.out.println(a>b && b<c);//true && false-false
        System.out.println(a<b && ++b<c);//false && false-false
        System.out.println(b);//6

        int x = 10;
        int y = 5;
        int z = 1;
        //|:左右两边有一个true，结果为true
        //|:当遇到true后，仍然会继续执行后面的表达式
        System.out.println(x>y | y>z);//true | true-true
        System.out.println(x>y | ++y<z);//true | false-true
        System.out.println(x<y | y<z);//false | false-false
        System.out.println(y);//6

        System.out.println("-----------------------------------");

        //||:左右两边有一个true，结果为true
        //||:当遇到true后，不会继续执行后面的表达式
        System.out.println(x>y || y>z);//true || true-true
        System.out.println(x>y || ++y<z);//true || false-true
        System.out.println(x<y || y<z);//false || false-false
        System.out.println(y);//6

        //!=:逻辑非 取反
        System.out.println(!(x>y));//false
        //^:逻辑异或 相同为假，不同为真
        System.out.println(true^true);//false
        System.out.println(true^false);//true
    }
}

赋值运算符

运算符
赋值运算符
= ，赋值时，注意左右两边的数据类型要一致，不同时，要遵循数据类型转换规则
注意（=，==）之间的区别

+= 会隐式类型转换
-=
/=
%=

public class demo10 { 
    public static void main(String[] args) {
        int a = 10;
        long b = a;

        a+=5;//a=a+5
        int c = a+2;
        System.out.println(a);//15
        System.out.println(c);//17

        short s = 3;//隐式类型转换 int -->byte short
        //s=s+2;//short=short+int-->int
        s+=2;//会隐式类型转换short=(short)int
    }
}

条件运算符

运算符
条件运算符：
结果 = （条件表达式）？表达式1:表达式2

public class demo11 { 
    public static void main(String[] args) {
        int a = 60;
        String result =(a>=60)?"及格":"不及格";
        System.out.println(result);

        int b = 10;
        int c = 5;
        int max = (b>=c)?a:b;
        System.out.println(max);
    }
}

位运算符

运算符
位运算符日常开发中位运算符运用较少，巧妙的使用位运算可减少运行开销，优化算法
<< 左移左移一位，相当于乘二
>> 右移右移一位，相当于除二
<< >> 带符号位移高位移动后（正数补0，负数补1）
>>> 无符号右移 <<< 无符号左移
>>> <<< 不带符号的位移，高位移动后，默认位0
& 与
| 或
^ 异或
& | ^ 可进行逻辑运算（左右两边是逻辑值），也可进行位运算（数值）
~ 非

package day2;

public class demo13 { 
    public static void main(String[] args) {
    /*    int a = 2;
        //0010 ----> 0100
        a = a<<1;
        System.out.println(a);
        int b = 8;
        //1000 ----> 0100
        b = b>>1;
        System.out.println(b);
        int c = 8;
        c = c>>>1;
        System.out.println(c);*/
        int a = 3;
        int b = 4;
        /*
        0000 0011 3
        0000 0100 4
        0000 0000 0
        */
        System.out.println(a&b);
        /*
        0000 0011 3
        0000 0100 4
        0000 0111 7
        */
        System.out.println(a|b);
        /*
        0000 0011 3
        0000 0100 4
        0000 0111 7
        */
        System.out.println(a^b);
        /*
        0000 0100 4
        1111 1011 -5
        */
        System.out.println(~b);
    }
}

AtomGit 开源协作平台测评赛

瓜分20万奖金获得内推名额丰厚实物奖励易参与易上手

更多推荐

ADS1292R 使用过程心电图高精度ADC模块

文章目录1 Fundamentals ofPrecision ADC Noise Analysis 精密模数转换器噪声分析基础1 Fundamentals ofPrecision ADC Noise Analysis 精密模数转换器噪声分析基础https://www.ti.com.cn/cn/lit/wp/slyy192/slyy192.pdf?ts=1600659610730&ref_u

开放原子开发者工作坊

实现一个家庭安防与环境监测系统（一）

开放原子开发者工作坊

【cf】Codeforces Round #774 (Div. 2) 前4题

题目A. Square Counting 简单数学题目大意题解代码B. Quality vs Quantity 排序题目大意题解代码C. Factorials and Powers of Two 状态压缩dp+位运算题目大意题解代码D. Weight the Tree 树形dp+dfs题目大意题解代码E. Power Board 看起来像是数论？许多年没打cf了，偶尔打了一盘，恢复紫名了。A. S