2-Java标识符~变量~类型~运算符等

2021/4/10 20:11:34

编程Tag： string 运算符 Java int 标识符 out system public println

本文主要是介绍2-Java标识符~变量~类型~运算符等，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

注释

书写注释是一个非常好的习惯，平时写代码要注意规范

三种注释方法

/**
 * 文档注释<<<<<<
 * @author luffy
 * @create 2021-04-08 22:18
 */
public class HelloWorld {
    public static void main(String[] args) {
        //单行注释<<<<<<
        System.out.println("Hello World!");
        /*
            多行注释<<<<<<
            多行注释<<<<<<
            多行注释<<<<<<
         */
    }
}


/***
 *  有趣的代码注释
 *                    _ooOoo_
 *                   o8888888o
 *                   88" . "88
 *                   (| -_- |)
 *                    O\ = /O
 *                ____/`---'\____
 *              .   ' \\| |// `.
 *               / \\||| : |||// \
 *             / _||||| -:- |||||- \
 *               | | \\\ - /// | |
 *             | \_| ''\---/'' | |
 *              \ .-\__ `-` ___/-. /
 *           ___`. .' /--.--\ `. . __
 *       | | : `- \`.;`\ _ /`;.`/ - ` : | |
 *         \ \ `-. \_ __\ /__ _/ .-` / /
 * ======`-.____`-.___\_____/___.-`____.-'======
 *                    `=---='
 *
 * .............................................
 *          佛祖保佑             永无BUG
 */

标识符

Java所有组成部分都需要名字。类名、变量名以及方法都被成为标识符。
不能使用关键字作为变量名或方法名
大小写强烈敏感
可以使用中文命名，但一般不建议这样，也不建议使用拼音，很low

数据类型

强类型语言（安全性高，速度慢）（要求变量使用要严格符合规定，所有变量必须先定义后才能使用）
弱类型语言（安全性低，速度快）（例如Python，VbScritpt，JavaScritpt）

什么是字节

位（bit）：计算机内部存储最小单元，11001100是一个八位二进制数
字节（byte）：计算机数据处理的基本单位，用B表示
1B（byte，字节）= 8bit（位），1KB = 1024B
字符：计算机中使用的字母、数字、字和符号

Java的数据类型分为以下两大类

基本类型（primitive type）
- 整数类型
  - byte：占用1个字节
  - short：占2个
  - int：占4个
  - long：占8个
- 浮点类型
  - float：占4个
  - double：占8个
- 字符类型char：占2个
- boolean类型：占1位其值只有true和false两个

/**
 * @author luffy
 * @create 2021-04-09 9:59
 */
public class Demo02 {
    public static void main(String[] args) {
        //八大基本数据类型
        
        //整数
        int num1 = 10;
        byte num2 = 20;
        short num3 = 30;
        long num4 = 30L;    //long类型要在数字后面加个L

        //小数：浮点数
        float num5 = 50.1F;     //float类型要在数字后面加个F
        double num6 = 3.141592653589793238;

        //字符
        char name = '看';
        //字符串，String不是关键字，是类
        String name2 = "炫龙笔记本";

        //布尔值：是非
        boolean flag = true;
        //boolean flag = false;
        
        //当需要看每种类型的取值范围时，在idea中打开该类型的源代码
    }
}

引用类型（reference type）
- 类
  - String类型
- 接口
- 数组

扩展和一般的面试内容

整数进制、浮点数与银行业务、转义字符、布尔值与if()方法

/**
 * @author luffy
 * @create 2021-04-09 10:47
 */
public class Demo03 {
    public static void main(String[] args) {
        //整数拓展
        int i = 0b101;  //二进制0b
        int i1 = 10;    //十进制
        int i2 = 010;   //八进0
        int i3 = 0x10;  //十六进制0x    0~9 A~F

        System.out.println(i);
        System.out.println(i1);
        System.out.println(i2);
        System.out.println(i3);
        System.out.println("================================");

        //================================
        //浮点数拓展?    银行业务怎么表示？钱
        //BigDecimal    数学工具类
        //================================
        //float     有限  离散  舍人误差    大约  接近但不等于
        //double
        //***最好完全避免使用浮点数进行比较***
        //***最好完全避免使用浮点数进行比较***
        //***最好完全避免使用浮点数进行比较***

        float f = 0.1f;     //0.1
        double d = 1.0/10;  //0.1
        System.out.println(f == d);     //false

        float d1 = 23154545184245485f;
        float d2 = d1 + 1;
        System.out.println(d1 == d2);   //true

        //================================
        //字符拓展？
        //================================
        char c1 = 'a';
        char c2 = '中';

        System.out.println(c1);
        System.out.println((int)c1);        //强制转换

        System.out.println(c2);
        System.out.println((int)c2);        //强制转换

        //***所有的字符本质还是数字***
        //编码    Unicode 表：（97 = a  65 = A）    占2字节     65536(早些年是这样)
        //常用表示方法    U0000 - UFFFF

        char c3 = '\u0061';
        System.out.println(c3);     //a

        //转义字符
        // \t   制表符
        // \n   换行

        System.out.println("Hello\nWorld");

        System.out.println("================================");
        String sa = new String("hello world");
        String sb = new String("hello world");
        System.out.println(sa == sb);   //false

        String sc = "hello world";
        String sd = "hello world";
        System.out.println(sc == sd);   //true
        //对象    从内存分析

        //布尔值扩展
        boolean flag = true;
        if (flag == true) {}    //新手
        if (flag) {}    //老手
        //Less is More!     代码要精简易读

    }
}

类型转换

Java是强类型语言，所有在有些运算时，需要类型转换
- 低 ----------> 高
- byte, short, char -> int -> long -> float -> double
运算中，不同类型数据先转化为同一类型，后运算
转换方式
- 强制类型转化
- 自动类型转换

/**
 * @author luffy
 * @create 2021-04-09 12:24
 */
public class Demo05 {
    public static void main(String[] args) {
        int i = 128;
        byte b = (byte)i;   //强制转换  (类型)变量名     高--低
        double d = i;   //自动转换      低--高

        System.out.println(b);  //-128  内存溢出
        System.out.println(d);  //128.0g

        /*
        注意点：
        1.不能对布尔值进行转换
        2.不能把对象类型转换为不相干的类型
        3.高容量--低容量，强制转换
        4.可能存在内存溢出，或是精度问题
         */

        System.out.println("================================");
        System.out.println((int)23.7);      //23
        System.out.println((int)-45.89F);   //-45   默认靠0取整

        System.out.println("================================");
        char c = 'a';
        int e = c + 1;
        System.out.println(c);      //a
        System.out.println((char)e);    //b

        //操作比较大的数时，注意溢出问题
        //JDK7新特性，数字之间可以用下划线分割
        int money = 10_0000_0000;
        int years = 20;
        int total = money * years;  //-1474836480，计算的时候溢出了
        long total2 = money * years;     //-1474836480，默认是int，转化之前就已经存在问题

        long total3 = money * (long)years;
        System.out.println(total3);

        //  L   l   表示long类型时，尽量用大写的L，小写的l与数字1很像
    }
}

变量常量作用域

Java是强类型语言，每个变量都必须声明其类型

Java变量是程序中最基本存储单元，要素包括 变量名 变量类型 作用域

type varName = value;
type varName1 = value1, varName2 = value2;
//数据类型 变量名 = 值;     可以使用逗号隔开来声明多个同类型变量

注意事项：
- 每个变量都有类型，可以是基本类型，也可以是引用类型
- 变量名必须是合法标识符
- 建议一行定义一个变量，不建议定义多个
变量的作用域

/**
 * @author luffy
 * @create 2021-04-10 16:17
 */
public class Demo07 {
    
    //** 类变量 static **
    static double salary = 2500;

    //属性：变量

    //** 实例变量 **
    //从属于对象；如果不自行初始化，这个类型默认值  0  0.0
    //布尔值：默认是false
    //除了基本类型，其余默认值都是null
    String name;
    int age;

    //** main方法 **
    public static void main(String[] args) {
        //局部变量：必须声明和初始化值
        int i = 10;
        System.out.println(i);

        //变量类型（可以是其他类型，也可以是自己）  变量名字 = new Demo07();
        Demo07 demo07 = new Demo07();
        System.out.println(demo07.age);     // 0
        System.out.println(demo07.name);    // null

        //类变量 static
        System.out.println(salary);
    }

    //** 其他方法 **
    public void add() {

    }
}

常量（Constant）
- 初始化（initialize）后不能改变的值
- 常量名一般使用大写字符
- 定义（final 常量名 = 值）

/**
 * @author luffy
 * @create 2021-04-10 16:46
 */
public class Demo09 {

    //常量 final
    //修饰符，不存在先后顺序
    static final double PI = 3.14;
    //final static double PI = 3.14;

    public static void main(String[] args) {
        System.out.println(PI);
    }
}

变量命名规范
- 所有变量、方法、类名：见名知意
- 类成员变量、局部变量、方法名：首字母小写和驼峰原则，例如monthSalary
- 常量：大写字母和下划线，例如MAX_VALUE
- 类名：首字母大写驼峰原则：Man，GoodMan

运算符

Java语言支持的运算符优先级 ()

算术运算符：+ - * / %(模运算) ++ –

public static void main(String[] args) {
        //二元运算符
        int a = 10;
        int b = 20;
        int c = 25;
        int d = 25;
        int e = 21;

        System.out.println(a+b);    // 30
        System.out.println(a-b);    // -10
        System.out.println(a*b);    // 200
        System.out.println(a/b);    // 0 （有问题！！）
        System.out.println(a/(double)b);    // 0.5 （正确）
        System.out.println(e%a);    // 1  取余运算（模运算）
    }

public static void main(String[] args) {
        long a = 1213131313131L;
        int b = 123;
        short c = 10;
        byte d = 8;
        double e = 123.45;

        System.out.println(a+b+c+d);    // 1213131313272  Long
        System.out.println(b+c+d);      // 141  Int
        System.out.println(c+d);        // 18  Int
        System.out.println(a+b+c+d+e);        // 1.21313131339545E12  Double
    }

public static void main(String[] args) {
        //++    --  自增，自减   一元运算符
        int a = 3;
        int b = 4;

        b = a++;    //执行完这行代码后，先给b赋值，再自增
        System.out.println(a);      // 4
        System.out.println(b);      // 3

        //====================
        System.out.println("====================");

        int c = 3;
        int d = 4;

        d = ++c;
        System.out.println(c);      // 4
        System.out.println(d);      // 4

        //幂运算 2^3   2*2*2 = 8   很多运算，需要使用一些工具类操作！
        double pow = Math.pow(2,3);
        System.out.println(pow);    // 8.0
    }

赋值运算符：=

关系运算符：> < >= <= == != instanceof

public static void main(String[] args) {
        //关系运算符返回的结果：true, false    布尔值
        // if() 中经常用
        int a = 10;
        int b = 20;

        System.out.println(a>b);    // false
        System.out.println(a<b);    // true
        System.out.println(a==b);   // false
        System.out.println(a!=b);   // true
    }

逻辑运算符：&& || ！

public static void main(String[] args) {
        // 与（and） 或（or） 非（取反）
        boolean a = true;
        boolean b = false;

        //逻辑与运算：两个变量都为true，结果才为true
        System.out.println("a && b: " + (a && b));

        //逻辑或运算，两个变量有一个为true，结果就为true
        System.out.println("a || b: " + (a || b));

        //如果是true，则变为false，反之则相反
        System.out.println("! (a && b): " + ! (a && b));

        //短路运算
        int c = 5;
        boolean d = (c<4)&&(c++>4);     // 因为(c<4)为false，所以“&&”后面的代码(c++>4)不会被执行
        System.out.println(d);      // false
        System.out.println(c);      // 5    c++>4 没有被执行
    }

位运算符：& | ^ ~ >> << >>> (了解！！！)

public static void main(String[] args) {
        /*
        A   = 0011 1100
        B   = 0000 1101
        ---------------------
        A&B = 0000 1100
        A|B = 0011 1101
        A^B = 0011 0001
        ~B  = 1111 0010

        2*8 = 16    计算机底层的转化-->    2*2*2*2
        计算机处理二进制数据，效率极高

        位运算：
        <<  *2
        >>  /2

        0000 0000   0
        0000 0001   1
        0000 0010   2
        0000 0011   3
        0000 0100   4
        0000 1000   8
        0001 0000   16
         */

        System.out.println(2<<3);   // 16   相当于 2*(2^3)
    }

条件与算法：？ :

//三元运算符
    public static void main(String[] args) {
        // x ? y:z
        // 如果 x == true ，则结果为 y，否则结果为 z

        int score = 80;
        String type = score < 60 ? "不及格":"及格";      //必须掌握
        // if
        System.out.println(type);
    }

扩展赋值运算符：+= -= *= /=

public static void main(String[] args) {
        int a = 10;
        int b = 20;
        double c = 30.55;

        a+=b;   //a = a+b;
        System.out.println(a);      // 30

        a-=b;   //a = a-b;
        System.out.println(a);      // 10

        //字符串连接符    +   String类型后面的 数字类型 会转化成 String类型
        System.out.println("" + a + b);     // 1024
        System.out.println(a + b + "");     // 30
        System.out.println("" + a + c);     // 1030.5
    }

这篇关于2-Java标识符~变量~类型~运算符等的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！

2-Java标识符~变量~类型~运算符等

注释

书写注释是一个非常好的习惯，平时写代码要注意规范

三种注释方法

标识符

数据类型

什么是字节

Java的数据类型分为以下两大类

扩展和一般的面试内容

类型转换

变量 常量 作用域

变量的作用域

常量（Constant）

变量命名规范

运算符

Java语言支持的运算符 优先级 ()

相关编程文章

变量常量作用域

Java语言支持的运算符优先级 ()