精华内容
下载资源
问答
  • 变量

    2020-10-12 20:42:34
    数值 byte 字节 1 byte = 8 bit 布尔 一般用于定于开关 开启状态或者关闭状态,该类型只有两种 true 真 false 假 当...双精度 double类型值可以只有选择在小数后面添加字母d(不区分大小写) -1.798E308到1.

    数值型 byte 字节 1 byte = 8 bit
    布尔型 一般用于定于开关 开启状态或者关闭状态,该类型只有两种 true 真 false 假 当满足某一种情形时,走true结果值
    浮点型(小数)
    单精度 float 当在程序中定义一个浮点数时,程序会解析成double类型,此时需要声明float类型,那么需要转换格式 在后面加上f(大小写都可以) -3.403E38到3.403E38

    双精度 double类型的值可以只有选择在小数的后面添加字母d(不区分大小写) -1.798E308到1.798E308
    字符型: char 只能填写一个字符 不能为空 语法格式 ‘字符值’
    引用型: String 字符串
    String 变量名 = “文本信息值”;
    对于String字符串来说,字符串变量值中的双引号内容可以为空,当双引号里面无任何信息时,表示的是空字符串,它是字符串值的其中一种
    String 变量名 = “”;空字符串
    String 变量名 = “ ”;空格字符串
    对于lang类的类型整数,需要在数字后面添加L字母,大小写都可以

    展开全文
  • 变量 变量就是内存中一块存储空间 ...double 双精度浮点数 bool 布尔(在C语言中无法使用) 变量名 命名规则: 1.由字母,数字,下划线组成,不能以数字开头 2.c语言区分大小写 3.不能使用c语

    变量

    变量就是内存中的一块存储空间


    声明变量

    基本格式:变量类型 变量名;

    变量必须先声明,再使用。


    变量类型:

    int 整型

    char 字符型

    float 单精度浮点数

    double 双精度浮点数

    bool  布尔型(在C语言中无法使用)


    变量名

    命名规则:

    1.由字母,数字,下划线组成,不能以数字开头

    2.c语言区分大小写

    3.不能使用c语言关键字做变量名

    4.不要用中文做变量名


    变量的大小

    char1字节

    int 4字节

    float4字节

    double8字节


    变量的初始化

    三种方式

    1.声明的同时初始化;int a=1;

    2.先声明,再初始化;int a; a=1;

    3.使用scarf函数初始化;int a; scanf(“%d”,&a);


    scanf函数:

    scanf(“%d”,&a);

    scanf(格式化字符串,变量地址列表)

    在格式化字符串中除了输入格式之外的其它字符需要原样输入;

    如果用scanf接受的多个数字,可以用回车,空格来间隔

    如果要接受的有字符,不能使用间隔符,否则会把间隔符读入内存。


    scanf 函数接受的数据会被接受到缓存中,cpu会从缓存中读数据

    数据流程:键盘→缓存→内存


    格式化字符串

    输入格式:

    int %d

    char %c

    float %f

    double %lf



    &:取地址符,用来获得变量的地址


    printf()函数:

    ptintf(格式化字符串,待输出的数据列表)

    待输出的数据列表可以省略


    输出格式:

    int %d

    char %c

    float %f

    double %f%lf



    const ”常量其实还是变量,只不过是只读的

    const 变量类型 变量名

    const意味着只读

    const 修饰的变量只能在声明的同时初始化,之后不能再被修改


    枚举类型:自定义类型

    枚举类型可以定义在函数中,也可以定义在函数外。

    enum [标识符]{ 枚举项1,枚举项2……} [ ]被方括号标识,可选的,可有可无,但一般要有

    枚举类型名:enum 标识符

    枚举项的本质是整数


    枚举项:每个枚举项实际上代表一个整数值,默认情况下,第一个枚举项代表0,后一个枚举项代表前一项+1

    可以手动为枚举项赋值,有自赋值的枚举项时,枚举项的递增规则不变


     声明枚举类型的变量


    1,枚举类型名 变量名    

    1>既可以在定义类型的同时声明变量

    enum City{beijing,shanghai ,guangzhou}c1,c2;

    2>也可以定义好类型后,单独声明变量

    enum City{beijing,shanghai,guangzhou};

    enum City c;

    2,不含标识符,在定义类型的同时声明两个变量

    enum {beijing,shanghai ,guangzhou}c1,c2;


    枚举项输入和输出,可以采用%d

    枚举的好处:增加了程序的可读性


    展开全文
  • javaEE - 03变量类型

    2021-01-11 15:11:00
    转载菜鸟教程 Java 变量类型 格式说明:可以使用逗号隔开来声明多个同类型变量。 以下列出了一些变量的声明实例。注意有些包含了初始化过程。 int a, b, c; // 声明三个int整数:a、 b、c ... // 声明双精度浮点

    转载菜鸟教程

    Java 变量类型

    格式说明:可以使用逗号隔开来声明多个同类型变量。

    以下列出了一些变量的声明实例。注意有些包含了初始化过程。

    int a, b, c;         // 声明三个int型整数:a、 b、c
    int d = 3, e = 4, f = 5; // 声明三个整数并赋予初值
    byte z = 22;         // 声明并初始化 z
    String s = "runoob";  // 声明并初始化字符串 s
    double pi = 3.14159; // 声明了双精度浮点型变量 pi
    char x = 'x';        // 声明变量 x 的值是字符 'x'。
    

    Java语言支持的变量类型有:

    • 类变量:独立于方法之外的变量,用 static 修饰。
    • 实例变量:独立于方法之外的变量,不过没有 static 修饰。
    • 局部变量:类的方法中的变量。
      实例
    public class Variable{
        static int allClicks=0; // 类变量(也叫静态变量)static 是***C++***中很常用的修饰符,它被用来控制变量的存储方式和可见性
     
        String str="hello world";  // 实例变量
     
        public void method(){
     
            int i =0;  // 局部变量
     
        }
    }
    

    Java 局部变量

    • 局部变量声明在方法、构造方法或者语句块中;
    • 局部变量在方法、构造方法、或者语句块被执行的时候创建,当它们执行完成后,变量将会被销毁;
    • 访问修饰符不能用于局部变量;
    • 局部变量只在声明它的方法、构造方法或者语句块中可见;
    • 局部变量是在栈上分配的。局部变量没有默认值,所以局部变量被声明后,必须经过初始化,才可以使用。

    实例变量

    1. 实例变量声明在一个类中,但在方法、构造方法和语句块之外; 当一个对象被实例化之后,每个实例变量的值就跟着确定;
    2. 实例变量在对象创建的时候创建,在对象被销毁的时候销毁;
    3. 实例变量的值应该至少被一个方法、构造方法或者语句块引用,使得外部能够通过这些方式获取实例变量信息; 实例变量可以声明在使用前或者使用后;
    4. 访问修饰符可以修饰实例变量;
    5. 实例变量对于类中的方法、构造方法或者语句块是可见的。一般情况下应该把实例变量设为私有。通过使用访问修饰符可以使实例变量对子类可见;
    6. 实例变量具有默认值。数值型变量的默认值是0,布尔型变量的默认值是false,引用类型变量的默认值是null。变量的值可以在声明时指定,也可以在构造方法中指定;
    7. 实例变量可以直接通过变量名访问。但在静态方法以及其他类中,就应该使用完全限定名:ObejectReference.VariableName。
    import java.io.*;
    public class Employee{
       // 这个实例变量对子类可见
       public String name;
       // 私有变量,仅在该类可见
       private double salary;
       //在构造器中对name赋值
       public Employee (String empName){
          name = empName;
       }
       //设定salary的值
       public void setSalary(double empSal){
          salary = empSal;
       }  
       // 打印信息
       public void printEmp(){
          System.out.println("名字 : " + name );
          System.out.println("薪水 : " + salary);
       }
     
       public static void main(String[] args){
          Employee empOne = new Employee("RUNOOB");
          empOne.setSalary(1000.0);
          empOne.printEmp();
       }
    }
    

    以上实例编译运行结果如下:

    名字 : RUNOOB
    薪水 : 1000.0

    类变量(静态变量)

    类变量也称为静态变量,在类中以 static 关键字声明,但必须在方法之外。
    无论一个类创建了多少个对象,类只拥有类变量的一份拷贝。
    静态变量除了被声明为常量外很少使用,静态变量是指声明为 public/private,final 和 static 类型的变量。静态变量初始化后不可改变。
    静态变量储存在静态存储区。经常被声明为常量,很少单独使用 static 声明变量。
    静态变量在第一次被访问时创建,在程序结束时销毁。
    与实例变量具有相似的可见性。但为了对类的使用者可见,大多数静态变量声明为 public 类型。
    默认值和实例变量相似。数值型变量默认值是 0,布尔型默认值是 false,引用类型默认值是 null。变量的值可以在声明的时候指定,也可以在构造方法中指定。此外,静态变量还可以在静态语句块中初始化。
    静态变量可以通过:ClassName.VariableName的方式访问。
    类变量被声明为 public static final 类型时,类变量名称一般建议使用大写字母。如果静态变量不是 public 和 final 类型,其命名方式与实例变量以及局部变量的命名方式一致。
    实例:

    Employee.java 文件代码:

    import java.io.*;
     
    public class Employee {
        //salary是静态的私有变量
        private static double salary;
        // DEPARTMENT是一个常量
        public static final String DEPARTMENT = "开发人员";
        public static void main(String[] args){
        salary = 10000;
            System.out.println(DEPARTMENT+"平均工资:"+salary);
        }
    }
    

    注意:如果其他类想要访问该变量,可以这样访问:Employee.DEPARTMENT。

    展开全文
  • 对于浮点类型数据采用单精度类型(float)和双精度类型(double)来存储,float数据占用 32bit,double数据占用 64bit,我们在声明一个变量float f = 2.25f时候,是如何分配内存呢?其实不论是float类型还是double...

    浮点数在计算机内存中的存储格式

    对于浮点类型的数据采用单精度类型(float)和双精度类型(double)来存储,float数据占用 32bit,double数据占用 64bit,我们在声明一个变量float f = 2.25f的时候,是如何分配内存的呢?其实不论是float类型还是double类型,在计算机内存中的存储方式都是遵从IEEE的规范的,float 遵从的是IEEE R32.24 ,而double 遵从的是R64.53。

    无论是单精度还是双精度,在内存存储中都分为3个部分:

    1) 符号位(Sign):0代表正,1代表为负;

    2) 指数位(Exponent):用于存储科学计数法中的指数数据,并且采用移位存储;

    3) 尾数部分(Mantissa):尾数部分;

    R32.24(1bit符号位+8bit指数位《指数+127》+23bit位数部分)和R64.53的存储方式都是用科学计数法来存储数据的,比如8.25用十进制 的科学计数法表示就为:8.25* 10^0,而120.5可以表示为:1.205*10^2。而计算机不认识十进制的数据,它只认识0和1,所以在计算机内存中,首先要将上面的数更改为二进制的科学计数法表示,8.25用二进制表示可表示为1000.01,120.5用二进制表示为:1110110.1。 用二进制的科学计数法表示1000.01可以表示为1.00001*2^n ,1110110.1可以表示为 1.1101101*2^n,任何一个数的科学计数法表示都为1.xxx*2^n,尾数部分就可以表示为xxx,指数部分为n,第一位都是1可以将小数点前面的1省略,所以23bit的尾数部分,可以表示的精度却变成了24bit,道理就是在这里,那24bit能精确到小数点后几位呢,我们知道9的二进制表示为1001,所以4bit能精确十进制中的1位小数 点,24bit就能使float能精确到小数点后6位,而对于指数部分,因为指数可正可负,8位的指数位能表示的指数范围就应该为:-127-128了, 所以指数部分的存储采用移位存储,存储的数据为元数据+127。

    下面就看看8.25和120.5在内存中真正的存储方式:

    首先看下8.25,用二进制的科学计数法表示为:1.0001*2^3

    按照上面的存储方式,符号位为0,表示为正;指数位为3+127=130,位数部分为 1.00001,故8.25的存储方式如下:

    0xbffff380:    0100 0001 0000 0100 0000 0000 0000 0000

    分解如下:0--10000010--00001000000000000000000

    符号位为0,指数部分为10000010,位数部分为 00001000000000000000000

    同理,120.5在内存中的存储格式如下:

    0xbffff384:    01000010111100010000000000000000

    分解如下:0--10000101--11100010000000000000000

    那么如果给出内存中一段数据,并且告诉你是单精度存储的话,你如何知道该数据的十进制数值 呢?其实就是对上面的反推过程,比如给出如下内存数据:

    01000001001000100000000000000000

    第一步:符号位为0,表示是正数;

    第二步:指数位为10000010,换算成十进制为130,所以指数为130-127=3;

    第三步:尾数位为01000100000000000000000,换算成十进制为 (1+1/4+1/64);

    所以相应的十进制数值为:2^3*(1+1/4+1/64)=8+2+1/8=10.125

     

    /**
         * 十进制浮点型转为十六进制浮点型
         * write by dzs
         * @param String $valueDec 十进制浮点型
         * @return 十六进制浮点数
         */
        public static function decFloatToHex($valueDec){
            $singStr = '0';
            if ($valueDec != 0){
                if ($valueDec < 0){
                    $singStr = '1';
                    $valueDec  = abs($valueDec);
                }
                $valueDecBin = decbin(intval($valueDec));  // 将整数部分变为2进制
                $valueZhiShu   =  strlen($valueDecBin) ; //2的n次方
                $valueFloat  = $valueDec  - intval($valueDec); //取小数部分
                $valueFloat  = round($valueFloat, 4);
                if (intval($valueDec) == 0){
                    $temp = self::decimalToBin($valueFloat,24,0);
                    $valueZhiShu = strpos($temp, '1') + 1;
                    $precisionStr  = substr($temp,$valueZhiShu,23); //位数
                    $precisionStr  = str_pad($precisionStr, 23, 0, STR_PAD_RIGHT); // 补齐23位位数
                    $zhiShuStr  =  str_pad(decbin(127 - $valueZhiShu ), 8, 0, STR_PAD_LEFT); // 补齐8位指数
                }
                else{
                    $precisionStr  = substr($valueDecBin, 1, $valueZhiShu ) . self::decimalToBin($valueFloat,15,0); //位数
                    $precisionStr  = str_pad($precisionStr, 23, 0, STR_PAD_RIGHT); // 补齐23位位数
                    $zhiShuStr  =  str_pad(decbin(127 + ($valueZhiShu -1) ), 8, 0, STR_PAD_LEFT); // 补齐8位指数
                }
                $hexStr = $singStr . $zhiShuStr.$precisionStr;
                $hexStr = strtoupper(dechex(bindec($hexStr)));
                return substr($hexStr,6,2) . substr($hexStr,4,2) . substr($hexStr,2,2) . substr($hexStr,0,2) ;
            }
            elseif ($valueDec == 0){
                return '00000000';
            }
        }
        /**
         * 小数点数转换为二进制
         * write by dzs
         * @param float $value 小数点数
         * @param integer $maxPrecision 最大精度
         * @param integer $loopCount 当前循环次数
         * @return 二进制
         */
        public static function decimalToBin($value, $maxPrecision, $loopCount){
            $loopCount ++ ;
            if ($loopCount > $maxPrecision ){
                return ;
            }
            if ( $value > 0 ){
                $value = $value * (1<<1) ;
                if ($value >= 1){
                    return '1' . self::decimalToBin($value - 1,$maxPrecision,$loopCount);
                }
                elseif ( $value >0){
                    return '0' . self::decimalToBin($value,$maxPrecision,$loopCount);
                }
            }
        }

     

    转载于:https://www.cnblogs.com/Rampage/p/11196152.html

    展开全文
  • Java基本语法笔记

    2021-03-07 20:48:25
    *采用long进行定义变量的格式比较特殊:必须以“l”或者“L”结尾 long a = 12656780997L; 2、浮点:double and float 单精度float:4字节 双精度double:8字节 double的精度是float的两倍。通常采用此类型 Java ...
  • c语言 三种方法求二次方程的根 默认△>0 #include <stdio.h> #include <stdlib.h> #include <math.h> int main() { double a,b,c,disc,x1,x2,p,q;... //输入双精度型变量的值要用格式声明%lf d
  • 学习日志——2019/06/30

    2019-06-30 16:01:07
    java语言基础 基本数据类型 变量 数据类型的转换 运算符和表达式 字符 char letter="a";...布尔 ...数值 ...|byte|字节 | ...|float|单精度浮点| ...声明变量的语法格式如下: 数据类型 变量名; ...
  • 双精度浮点型的声明用double,如:double c; C语言基本输入输出 输出数据到屏幕用printf() 调用格式为:printf(“%d %f %lf”,a,b,c); 输出“hello world” #include<stdio.h> int main() { printf("hello...
  • C语言简单入门教程(初学者用)

    万次阅读 多人点赞 2018-08-08 20:05:26
    双精度浮点型的声明用double,如:double c; C语言基本输入输出 从键盘输入数据用scanf(), 调用格式为:scanf(“%d”, &amp;a);scanf(“%f”, &amp;b);scanf(“%lf”, &amp;c)...
  • C学习笔记

    2020-09-22 18:53:43
    目录变量、常量声明打印, 转义... double双精度浮点; char字符(1个字节也就是8位/8比特) 例子: char=‘A’ 字符要记得单引号,char在存储本质也是int ASCC码 _Bool类型:1表示真true 0表示假false
  • n(-84~127) 可以存储正数、负数、零、定点数和精度为38位浮点数,其中,M表示精度,代表数字总位数;N表示小数点右边数字位数 日期类型 date 7字节 用于存储表中日期和时间数据,取值范围是公元前4712年1月...
  • 4.1 #include <stdio.h> #include <math.h> int main() { double a, b, c, disc, x1, x2, p ,q; //disc是判别式 while(1){ ... //输入双精度浮点型变量的值要用格式声明“%lf” ...
  • 第四章 选择结构程序设计 C语言有两种选择语句:(1)if语句,用来实现两个分支的选择结构;(2)switch语句,用来实现多分支的选择结构...//输入双精度浮点型变量的值要用格式声明%lf disc=b*b-4*a*c;//disc是判别式
  • C语言学习笔记——选择结构 求一元二次方程的根 简约版 #include<stdio.h> #include<math.h> //程序中要调用求平方根函数sqrt ... //输入双精度浮点型变量的值要用格式声明"%lf" disc=b*b-4*a*c; if
  • C语言复习笔记

    2020-10-19 21:14:45
    上取整函数ceil(),下取整函数floor(),传入双精度浮点数参数,返回整形 幂指函数pow(a,n)=a^n,a整形/浮点 平方根函数sqrt(),传入双精度浮点数参数,返回浮点数 printf %g,实数格式占位符 %p,输出指针值/...
  • Flex基础-----之Flex中数据类型

    千次阅读 2010-08-24 19:52:00
    关于数据类型一个变量或者常量被声明时,必须指定其数据类型:原生数据类型:语言本身提供:...Number:整数和浮点,使用64位双精度格式存放数据,没有小数点时自动转换成整数。最小值和最大值分别存放在Number
  • 调用格式: 〈对象〉 ocx_创建对象 (整数型 窗口句柄,文本型 数字签名,整数型 左边,整数型 顶边,整数型 宽度,整数型 高度,[逻辑型 是否带滚动条],[整数型变量 对象窗口句柄]) - 蒋勇API支持库->系统...
  • double 双精度浮点 double val2 = ±5.0 × 10?324 ±1.7 × 10 308 0 到 255 0 到 65,535 0 到 4,294,967,295 0 到 18,446,744,073,709,551,615 ±1.5 × 10?45 ±3.4 × 10 38 到 到 4.56D;15-16 布尔;bool ...
  • 4.5 wchar_t字节型变量 25 4.6 整型概述 26 4.7 整型变量的定义 28 4.8 浮点型变量 29 4.9 常量 30 4.10 枚举型常量 30 第5章 if语句与逻辑运算符 32 5.1 语句的定义 32 5.2 块的定义 32 5.3 表达式的...
  • 公开声明调试方法 299 优化 300 答案 309 编程练习 309 第十六章 浮点数 310 浮点数格式 310 浮点数加法/减法 312 乘法 313 除法 313 上溢和下溢 314 舍入误差 314 精度 315 舍入误差最小化 316 判定...
  • 子程序 取汇编指令长度, 整数, 公开, 返回指定进程指定地址处首条汇编指令长度。注:计算方法使用是LDX32 .参数 进程ID, 整数, , 进程ID .参数 地址, 整数, , 指令地址,如Hex2Dec("00401000") .子程序 ...
  •  5.3 双精度浮点   5.4 复数   5.5 操作符   5.5.1 混合模式操作符   5.5.2 标准类型操作符   5.5.3 算术操作符   5.5.4 *位操作符(只适用于整型)   5.6 内建函数与工厂函数   5.6.1 ...
  • Python核心编程第二版(中文)

    热门讨论 2015-04-23 16:40:13
    5.3 双精度浮点 5.4 复数 5.5 操作符 5.5.1 混合模式操作符 5.5.2 标准类型操作符 5.5.3 算术操作符 5.5.4 *位操作符(只适用于整型) 5.6 内建函数与工厂函数 5.6.1 标准类型函数 5.6.2 数字类型函数 ...
  • 深入理解Python中文版高清PDF

    热门讨论 2012-09-04 19:37:04
     5.3 双精度浮点   5.4 复数   5.5 操作符   5.5.1 混合模式操作符   5.5.2 标准类型操作符   5.5.3 算术操作符   5.5.4 *位操作符(只适用于整型)   5.6 内建函数与工厂函数  ...
  • Python核心编程(中文第二版)

    热门讨论 2009-10-02 12:08:14
     5.3 双精度浮点   5.4 复数   5.5 操作符   5.5.1 混合模式操作符   5.5.2 标准类型操作符   5.5.3 算术操作符   5.5.4 *位操作符(只适用于整型)   5.6 内建函数与工厂函数   5.6.1 ...
  • Python核心编程第二版

    热门讨论 2009-07-30 17:07:20
     5.3 双精度浮点   5.4 复数   5.5 操作符   5.5.1 混合模式操作符   5.5.2 标准类型操作符   5.5.3 算术操作符   5.5.4 *位操作符(只适用于整型)   5.6 内建函数与工厂函数   5.6.1 ...
  • 宣告变量名称同时,加上“final”关键词来限定,这个变量一但指定了值,就不可以再改变它值 如:final int n1= 10; n1=20; 这就会报错 输出命令: System.out.println() 会自动换行打印 System.out....
  • 修改BUG:高级表格在列类型为数值时,添加新行且省略标题情况下,会导致程序异常。 16. 修改BUG:数值计算支持库“大数.四舍五入()”命令在最高位进位时,会导致程序异常。 17. 修改BUG:办公组件支持库打印...

空空如也

空空如也

1 2
收藏数 28
精华内容 11
关键字:

双精度型变量的格式声明