精华内容
下载资源
问答
  • Java 变量数据类型

    千次阅读 2016-08-26 15:05:00
    Java 变量变量数据类型Java数据类型图: 1.基本数据类型 基本数据类型,也称内置类型,是可以在栈直接分配内存的,Java保留基本数据类型最大的原因也在此:性能。关于这一点可以参考:Java为什么需要保留基本...

    Java 变量之变量数据类型

    Java数据类型图:
    这里写图片描述

    1.基本数据类型

      基本数据类型,也称内置类型,是可以在栈直接分配内存的,Java保留基本数据类型最大的原因也在此:性能。关于这一点可以参考:Java为什么需要保留基本数据类型
      另外,要注意,Java是基于JVM的,所以,其所占字节固定,与机器平台无关,所有地方统一占用内存大小(除了boolean,以及byte/short/boolean数组的时候每个单元所占的内存是由各个JVM自己实现的)。
      总共有四类八种基本数据类型(注1):
    1).整型:全部是有符号类型。
    1.byte:1字节(8bit),高位为符号位,其余7位为数据位,范围:-2的7次方~2的7次方-1(1111,1111~0111,1111),即-128~127(下面的计算方式相同);

    注意:byte类型虽然在语义(逻辑)上是占用1字节,但实际上,JVM中是将其当做int看
    的,也就是事实上是占用了32位,4字节的,所以其运算效率和int没区别,short也一样。
    之所以要有byte/short类型,一是因为某些地方要明确使用这些范围类型,二是,
    在byte[]数组中,JVM存储的则是真的1字节,short[]2字节。(但也有的JVM其byte[]
    数组也是4字节1位)

    2.short:2字节(16bit),高位为符号位,其余15位为数据位,范围:-2的15次方~2的15次方-1,即-32768~32767;

    3.int:4字节(32bit),范围-2的31次方~2的31次方-1;Java默认的整型类型,即:

    long l = 0xfffffffffff;//0x表示这个数是16进制数,0表示8进制。
    //编译器报错,因为右边默认是int,但其超出了范围(没超出int范围的话
    //编译器会隐式将int转为long),故报错(同样的错误也会出现在float)。

    同样的还有:

    short s = 123;//(这个123也是int类型,这里,= 操作编译器能隐式转换) 
    s = s + 123;//编译器报错,那是因为s+1是int类型(编译器先将s转化为int,再+1),
    //这里,+ 操作编译器不能隐式转换(会提示失真,即精度可能会受损),正确的做法:
    s = (short)(s + 123)//注意,不是(short)s + 123。

    类型转化详见:Java 数据类型转化
    4.long:8字节(64bit),范围:-2的63次方~2的63次方-1;声明大的long方法:

    long l = 0xfffffffffffL;//即在后面加上L或l。
    //(强制转化:long l = (long)0xfffffffffff也没用)

    2).浮点型
    5.float:4字节(32bit),单精度,数据范围:(-2^128)~(-2^(-23-126))-(0)-(2^-149)~2^128。浮点数,通俗来说就是小数,但是,这是有精度要求的,即在这区间float可不是能表达任意小数的,而是在一定精度下,比如float有效位7~8位(包括整数位和小数位,有效小数位是6~7位,这里为什么是7~8(6~7),参考:Java中float/double取值范围与精度),即0.123456789后面的9JVM是不认识的(8能认识,整数位为0则不算是有效位,例如12.1234567后面的7也不认识,只有6位有效小数位(注意,看的是有效位,不是有效小数位,float有7~8位有效位)),即:

    if(0.123456781f == 0.123456789f){//注意后面加f/F,否则就是double
        System.out.println("true");
    }else{
        System.out.println("false");
    }
    //打印结果:true
    //事实上,浮点数值的比较是不能直接用==判断的,这里原因就要追究到浮点数的内存结构
    //浮点数比较可以用一个差值,但这种情况只是近似的比较
    //如果想要精确,可以使用BigDecimal
    System.out.println(Float.MIN_VALUE);//1.4E-45 = 2^-149
    //这里的“最小值”意味float能表示的最小小数,实际上float最小值等于最大值取负
    System.out.println(Float.MAX_VALUE);//3.4028235E38 = 2^128

    6.double:8字节(64bit),双精度,范围:-2^1024~(-2^(-1022-52))-0-(2^-1074)~2^1024,Java默认的浮点类型,即若后面不加f/F,默认是double类型,即:

    float f = 1.23;//编译报错,因为
    float f = 1.23f;//或float f = 1.23F;
    //默认是double,1.23(double)转成float,做隐式转换,但是double转成float是
    //取值范围大的转成取值范围小的会损失精度,因此不能转换(详见Java数据类型转换)
    //那为什么,int可以转换成byte、short,int范围更大不是?
    //前面已经说过了,byte、short实际在JVM上就是int,因此编译器是不会认为会损失精度的
    //但是int是不能转换成boolean,虽然boolean也是4字节(一般JVM),但在JVM认为这
    //两者完全是两个东西,当然不能转换(强制也不行,你不能把猫强制转换成鸟,完全两个物种),而byte、short都是整型,同int是一个类型

    3).字符型
    7.char:2字节(16bit),表示一个字符(可以是汉字),字符编码采用Unicode(说的更准确点,字符集(charset)采用UCS-2,编码(encoding)采用UTF-16),实际上就是一个16位的无符号整型,但是,要注意的是,因为随着发展,char所能代表的字符个数(UCS-2字符集)被限定死了,所以并不推荐使用。(更多内容,以及关于Unicode、UTF8/16参考:Unicode、UTF8以及Java char。)

    char c = 3+5;//正确,char是无符号整型,但不能这样
    int a1 = 3;int a2 = 5;char c0 = a1+a2;//这里需要强制转换才行
    char c1 = -3;//编译错误,char不能表示负数,即使
    char c2 = (char)-3;//编译正确,但无意义(乱码)
    char c3 = '3';//正确,输出字符3
    char c4 = "3";//编译错误,双引号,表示的是字符串
    char c5 = '65';//编译错误,这里65是两个字符

    4).布尔型
    8.boolean:逻辑上:1bit,但是实际上,boolean并没有具体规定,完全是看各个JVM实现,不过《Java虚拟机规范》给出了4个字节(同byte解释)和boolean数组一个字节的定义。

    注1:
    (1).这种分法是一种比较流行的分法,事实上应该为两种:数值类型与布尔型。数值类型分为整型和浮点型。整型包括:byte、short、int、long、char;浮点型:float、double;布尔型boolean。之所以将char认为是整型是因为char在JVM就是以无符号整型存在的。
    (2).事实上Java中除去这8种以及对象类型,还有一种比较特殊的类型存在,那就是Void。java.lang.Void,是一个占位符类,不可实例化,保存着Java关键字void的Class对象。为什么说它特殊呢?明明是一个类,难道不是对象类型?那是因为void.class.isPrimitive()(这个方法是用来判断一个Class对象是否是基本类型的)返回的是true,所以Void也算是基本类型的一个了(错了),只不过它比较特殊,不能算是一种数据,只是一种象征。
    20160921 改:上面弄错了,把Void和void两个混为一体了,事实上,可以简单的把这两者的关系看成类似包装类和基本类型的关系,像Integer和int的关系,java.lang.Void是一个不可实例化的占位符类来保存一个引用代表了Java关键字void的Class对象:

    public static final Class<Void> TYPE = Class.getPrimitiveClass("void");

    而Integer也有类似的语句:

    public static final Class<Integer>  TYPE = (Class<Integer>) Class.getPrimitiveClass("int");

    区别只是,Void仅仅是为void服务,即所谓的占位符类,不做他用。所以Void类只是一个普通类,而void则可以认作为如同int一样的基本类型。

    2.引用数据类型

      也称对象变量类型,复合数据类型,包含类、接口、数组(除了基本类型外,就是引用类型)。引用类型与基本类型最大的区别在于:

    int a = 5;//这里的a是对象(严格来说不算是对象,只是个符号标识),5是数值
    Integer a = 5;//这里的a是一个引用,5才是一个对象,更形象常见的是:
    Object o = new Object();//o是引用(栈中),new Object()是对象(堆中)
    //第二行代码中,5被自动包装成Integer对象

      这里的引用有点像C/C ++中的指针,但是同指针不同的是,你不能通过改变它的值从而去改变它所指向的值。即

    ClassA p = new ClassA();//C++中,这个时候是可以这样操作的:
    p = p + 1;//向前移动一个单元,Java则不能
    //这种操作,其实是对内存直接的操作,很显然,Java是不允许程序员做这种操作的

      其实质就是,Java的引用不支持对内存直接操作,而指针则可以,所以,Java用起来更安全,但不够灵活,而指针,自由度大,但同时,要更加小心因为指针操作不当而引起的各种内存问题。在Java中,任何对象都需要通过引用才能访问到,没有引用指向的对象被视为垃圾对象,将会被回收。
      引用,其实质同指针一样(可以理解为受限制的指针),存放的是一个地址,至于是实例对象的地址,还是一个指向句柄池的地址(这里可以参考:(3) Java内存结构),完全是看各个JVM的实现了。
      Java中的枚举类型,都是Enum类的子类,算是类中的一种,也是引用类型。
      引用类型又称为对象变量类型,是相对于基本数据类型来说的(基本数据类型不是对象),而又被称为复合数据类型,可以这样理解,引用类型的数据最终都是由基本数据类型构成的。而像接口,接口是不能实例化的,最终的实现还是由类实现的;数组在JVM中的实现也是通过类实现的,每个类型的一维数组,二维数组……都是一个类,只是这是一个特殊的类,它的对象头有别于一般对象的对象头(最主要的就是,数组对象头有对象长度)。
      另外,关于Java引用可以参考:Java中的引用

    展开全文
  • Java变量有三部分组成,变量数据类型,变量名(变量的标识符),变量的值; Java变量数据类型分为两大类, 一、是基本类型,直接包含值的类型。有boolean,byte,int,long,short,char,float,double; ...

    Java变量有三部分组成,变量的数据类型,变量名(变量的标识符),变量的值;


    Java变量的数据类型分为两大类,

    一、是基本类型,直接包含值的类型。有boolean,byte,int,long,short,char,float,double;

    boolean isFalse=false;


    二、是引用类型,除了上面8个基本类型,其余都是引用类型,可以使用new关键字来创建对象。

    例如包装类(Boolean,Byte,Integer,Long,Short,Character,Float,Double)、String、Object、Class、数组(如int[]、byte[]、char[]..)等等;

    String strName=new String("Hello World");



    展开全文
  • JAVA变量数据类型和运算符
     1、变量是什么呢?
     变量是一个数据存储空间的表示!变量是存储数据的一个基本单元,不同的变量是相互独立的。变量就好比旅馆中的房间,如下图:
    图片
    2、数据类型。
    数据类型总体来说分为2大类:一类是:数值型,如int、double 一类是:非数值型,如String、char。常见的java数据类型就是我们刚才说的4种,说明如下图:
    图片
     3、变量的声明以及使用。
    定义变量有2种方式:
       1>数据类型 变量名  // 先声明一个变量
       如:String name; // 先声明一个变量
         变量名=值   //给变量赋值
         name="张三"; //给变量赋值
    2>数据类型 变量名=值   //声明一个变量同时给该变量赋值
       String name="张三";   //声明一个变量同时给该变量赋值 
    使用存储的变量他们称之为”变量调用“:System.out.println(name); //输出变量name存储的值
    小札:使用声明的变量名就是在使用变量对应的内存空间中存储的数据。
    小结:变量都必须声明和赋值后才能使用
    4.java中变量的命名要符合一定的规则。
    一张图直观的了解下,如下图:
    图片
    从上图我们可以看出一下几点:
    1、变量必须以 字母、下划线 "_"或"$"符号开头
    2、变量名可以包括数字,但不能以数字开头
    3、变量名不能包含,除了下划线 "_"或"$"符号以外的任何特殊字符
    4、特殊情况 变量不能使用java语言的关键字,如:int、class、public等

    java中变量的长度没有任何限制,但是java区分大小写 如:name和Name是两个不同的变量
    小札:变量名要简短且能清楚的表达变量的作用,通常第一个单词的首字母小写,其后单词的首字母大写
    如:myScore
    5、运算符。
    1>赋值运算符
    变量名=表达式【在java里等号就是赋值运算符
    "="可以讲某个数值赋给变量,或是 某个表达式的值赋给等号左边的变量。
    表达式就是符号(如加号、减号)与操作数(如b、3等)的组合。
    如:int b;
    int a=(b+3) * (b-1) 

    小札:后一个语句将变量b的值取出后进行计算,然后再将计算结果存储到变量a中。
    小结:“=”的功能是将等号右边表达式的结果赋值给等号左边的变量。 
    2>算术运算符
    所谓的 “+”     加法运算符    求操作数的和    如:5+3等于8 
     
    所谓的 “-”     减法运算符    求操作数的差     如:5-3等于2 
    所谓的 “*”      乘法运算符    求操作数的乘积    如:5*3等于15

    所谓的 “/”       除法运算符    求操作数的商      如:5/3等于1 
    所谓的 “%”     取余运算符    求操作数相除的余数    如:5%3等于2 
    特殊:所谓的 “<<” 左移运算符   使指定值的所有位都左移规定的次数   它的通用格式如下所示 :value<<num 
    如:value=64 num=2 【先把64转化为二进制(01000 0000)然后再移动2次变为(10000 0000)所以value最终变为256】
    所谓的 “>>” 右移运算符 使指定值的所有位都右移规定的次数 它的通用格式如下所示 :value>>num
    如:value=256 num=2 【先把256转化为二进制(0001 0000 0000)然后再移动2次变为(01000 0000)所以value最终变为64】
    6、数据类型转换。
    一、自动数据类型转换【放大转换】
    1>如果一个操作数为double类型,那么整个表达式可提升为double型。
    2>满足自动类型转换的条件
      1.两种类型要兼容:数值类型(整型和浮点型) 
    互相兼容、
      2.目标类型大于源类型:double型可以存放int型数据,因为double类型变量分配的空间宽度足够存储int型变量。 
    如:double a=34.56;int b=1;
    double c=a+b;  
    b的结果是35.56

     二、强制数据类型转换【缩小转换】
    (数据类型) 表达式
    即:在变量前加上括号,括号中的类型就是你要强制转换成的类型
    如:double a=34.567
    int b=(int)a;  b的结果是34
    小札:自动类型转换是从宽度小的类型转换为宽度大的类型,所以称之为“放大转换”。 
    强制类型转换是从宽度大的类型转换为宽度小的类型,所以称之为“缩小转换”。 
    展开全文
  • 文章目录1.Java数据类型1.1 java的两大数据类型1.1.1 内置数据类型1.1.2 引用数据类型1.1.3 基本类型对应的包装类2.Java常量2.1 文本常量2.1.1 常量类型3.Java变量3.1声明变量的基本格式3.2Java变量类型3.2.1 局部...

    1.Java数据类型


    1.1 java的两大数据类型

    1. 内置数据类型(别名:简单类型,基本类型)

    2. 引用数据类型


    1.1.1 内置数据类型
    • Java语言提供了八种基本类型。六种数字类型(四个整数型,两个浮点型),一种字符类型,还有一种布尔型。

    • 简单类型(分以下两种)

      1. 数值类型(细分)

        整型:byte、short、int、long 和 char

        浮点型:float 和 double

      2. 布尔型:boolean

      简单类型 所占字节 最小值 最大值 默认值
      byte 1 -128(-2^7) 127(2^7-1) 0
      short 2 -32768(-2^15) 32767(2^15 - 1) 0
      char 2 \u0000(即为0) \uffff(即为65,535)
      int 4 (-2^31) (2^31 - 1) 0
      float 4 1.4E-45 3.4028235E38 0.0f
      long 8 (-2^63) (2^63 -1) 0L
      double 8 4.9E-324 1.7976931348623157E308 0.0d
      boolean 只true 和 false false
    1.1.2 引用数据类型
    • 在Java中,引用类型的变量非常类似于C/C++的指针。引用类型指向一个对象,指向对象的变量是引用变量。这些变量在声明时被指定为一个特定的类型, 量一旦声明后,类型就不能被改变了。

    • 引用类型

      分为:类类型、接口类型、数组类型、null类型

    • 所有引用类型的默认值都是null

    1.1.3 基本类型对应的包装类
    基本数据类型 包装类
    byte Byte
    int Integer
    short Short
    long Long
    float Float
    double Double
    boolean Boolean
    char Character

    2.Java常量

    定义:常量在程序运行时是不能被修改的

    在 Java 中使用 final 关键字来对局部变量声明,声明方式和变量类似:

    final double DI = 3.14;
    

    通常使用大写字母表示常量,且final修饰的常量只能被赋值一次

    2.1 文本常量

    代码中出现的文本形式常数,及文本常量,通常用来表示简单类型、String类型和null类型的值

    2.1.1 常量类型
    • 1.整数常量 : 所有整数

      //例如:
      int int1 = 123;                   //整形常量123为int型
      long long1 = 123L;                //整形常量123为long型
      //等等
      
    • 2.小数常量 : 所有小数

      //例如:
      double d1 = 12.3;                 //双精度浮点型
      double d2 = 12.3D;                //双精度浮点型
      double d3 = 0.123E2;              //双精度浮点型
      float f1 = 12.3f;                 //单精度浮点型
      float f2 = 0.123E2f;              //单精度浮点型
      
    • 3.布尔常量 : 只有true和false

      //例如:
      boolean b1 = true;
      
    • 4.字符常量 :使用单引号(‘)引起来的单个字符

      //例如:
      char ch1 = 'A';
      char ch2 = '\101';               //ASCII:65,即'A'
      char ch3 = '\u0041';             //ASCII:65,即'A'
      
    • 5.字符串常量 :使用“”引起来的字符序列

      String str1 = "哲";
      
      //字符串常量和字符常量都可以包含任何Unicode字符
      //例如:
      char a = '\u0001';
      String a = "\u0001";
      
      
    • ​ 6.null常量 : 只有一个值null

      //例如: 
      Object obj1 = bull;  
      

    3.Java变量

    3.1声明变量的基本格式

    在Java语言中,所有的变量在使用前必须声明。声明变量的基本格式如下:

    type identifier [ = value][, identifier [= value] ...] ;
    

    格式说明:type为Java数据类型。identifier是变量名。可以使用逗号隔开来声明多个同类型变量。

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

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

    3.2Java变量类型

    • 类变量:独立于方法之外的变量,用 static 修饰。
    • 实例变量:独立于方法之外的变量,不过没有 static 修饰。
    • 局部变量:类的方法中的变量。
    //例子:
    
    public class Variable{
        static int qzzBl=0;    // 类变量
     
        String str="hello world";  // 实例变量
     
        public void method(){
     
            int i =0;  // 局部变量
     
        }
    }
    
    3.2.1 局部变量
    • 局部变量声明在方法、构造方法或者语句块中
    • 局部变量在方法、构造方法、或者语句块被执行的时候创建,当它们执行完成后,变量将会被销毁
    • 访问修饰符不能用于局部变量
    • 局部变量只在声明它的方法、构造方法或者语句块中可见
    • 局部变量是在栈上分配的
    • 局部变量没有默认值,所以局部变量被声明后,必须经过初始化,才可以使用
    //以下实例中age是一个局部变量。定义在pupAge()方法中,它的作用域就限制在这个方法中。
    public class Test{ 
       public void pupAge(){
          int age = 0;//如果是 int age;  未初始化,则编译器会报错
          age = age + 7;
          System.out.println("小狗的年龄是: " + age);
       }
       
       public static void main(String[] args){
          Test test = new Test();
          test.pupAge();
       }
    }
    
    3.2.2 实例变量
    • 实例变量声明在一个类中,但在方法、构造方法和语句块之外;
    • 当一个对象被实例化之后,每个实例变量的值就跟着确定;
    • 实例变量在对象创建的时候创建,在对象被销毁的时候销毁;
    • 实例变量的值应该至少被一个方法、构造方法或者语句块引用,使得外部能够通过这些方式获取实例变量信息;
    • 实例变量可以声明在使用前或者使用后;
    • 访问修饰符可以修饰实例变量;
    • 实例变量对于类中的方法、构造方法或者语句块是可见的。一般情况下应该把实例变量设为私有。通过使用访问修饰符可以使实例变量对子类可见;
    • 实例变量具有默认值。数值型变量的默认值是0,布尔型变量的默认值是false,引用类型变量的默认值是null。变量的值可以在声明时指定,也可以在构造方法中指定;

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

    4.Java装箱和拆箱

    Integer中的装箱的代码

    public static Integer valueOf(int i){
          if(i>=IntegerCache.low && i<=IntegerCache.high){
              return IntegerCache.cache[i+(-IntegerCache.low)];
          }
        return new Integer(i);
    }
    

    基本类型自动封装到它相同类型的包装中,此过程调用valueOf方法

    4.1int 和Integer比较

    int 和Integer在进行比较的时候,Integer会进行拆箱,转为int值与int进行比较

    Integer a = 10;//装箱      本质操作:Integer a = new Integer(10);
    int i = a;//拆箱           本质操作:int i = new Integer (10).intValue();
    System.out.println(i == a);           //ture
    

    4.2Integer与Integer比较(牵扯缓存)

    Integer与Integer比较的时候(牵扯缓存)

    • == 比较的是变量(栈)内存中存放的对象的(堆)内存地址,用来判断两个对象的地址是否相同,即是否是指相同一个对象
    • equals 用来比较的是两个对象的内容是否相等
    /**需要注意两个问题,一个是-128<= x<=127的整数,将会直接缓存在IntegerCache中,当赋值在这个区间的时候,不会创建新的Integer对象,而是从缓存中获取已经创建好的Integer对象。二是当大于这个范围的时候,直接new Integer来创建Integer对象.
    */
    //例子:
    Integer i1 = 127;   //直接赋值的时候会进行自动的装箱
    Integer i2 = 127
    System.out.println(i1 == i2);           //true
    System.out.println(i1.equals(i2));      //true       
    
    //i1、i2是自动装箱产生的对象,其值都是127,127正好在-128<=i7<=127
    //这个范围内的,那么会去IntegerCache中取,该对象应该是一个对象,在堆中的
    //地址应该是一样的,所以在判断两个对象是不是==的时候,会输出相等。
    
    
     Integer i3 = 129;   //直接赋值的时候会进行自动的装箱
     Integer i4 = 129;
     System.out.println(i3 == i4);         //false
     System.out.println(i3.equals(i4));    //true
    //i3和i4是自动装箱产生的Integer的对象,但是其大小超过了范围:-128<=A <=127,
    //这里会直接自己创建该对象即:new Integer(128);显然这两个对象都是new出来,
    //在堆中的地址值是不同的,所以二者不相等。
    

    运行结果:

    true
    true
    false
    true
    
    Process finished with exit code 0
    
    
                                                             2018.10.13/周六
                                                             by 922
    
    展开全文
  • 成员变量Java中表示的是对象的属性。 而成员方法表示的是对象的行为。 二、数据成员 1、数据成员可以为任意的数据类型,如数组... 三、成员变量 1、在一个类中成员变量名是唯一的。变量分为类变量和实例变量...
  • Java的基本数据类型和Java变量类型

    千次阅读 2016-01-15 20:35:37
    一、Java 基本数据类型 1、什么是变量变量就是用来储存值而保留的内存位置。这就意味着当你创建一个变量时就会在内存中占用一定的空间。 基于变量数据类型,操作系统会进行内存分配并且决定什么将被储存在保留...
  • //byte是Java数据类型,z是变量名 double pi = 3.14159; char x = 'x'; 在声明变量类型时,一般都是这个结构,包含了初始化,代表着这些变量在整个应用中会用到。如果不会用到,在程序结束时,会被自动销毁。
  • java基本数据类型&java变量类型

    千次阅读 多人点赞 2015-12-05 11:01:50
    内存管理系统根据变量的类型为变量分配存储空间,分配的空间只能用来储存该类型数据。 因此,通过定义不同类型的变量,可以在内存中储存整数、小数或者字符。 Java的两大数据类型: 内置数据类型
  • Java变量

    千次阅读 多人点赞 2019-09-29 00:06:53
    文章目录定义分类按被声明的位置划分成员变量局部变量成员变量和局部变量的区别使用原则按所属的数据类型划分基本数据类型变量引用数据类型变量定义格式注意事项 定义 在程序执行的过程中,在某个范围内其值可以...
  • Java变量的说明,常量的表示方式,个别逻辑运算符的说明
  • java数据类型和变量

    2014-03-07 23:11:30
    java数据类型
  • Java定义变量

    千次阅读 2018-12-18 23:53:58
    3.5.1 基本数据类型变量的定义和使用 变量的定义格式: 数据类型 变量名 = 初始化值; 基本数据类型: byte,short,int,long,float,double,char,boolean 注意: 整数默认是int类型,定义long类型的数据时,要在数据...
  • Java编程语言学习:Java语言编程的基础知识之Java变量数据类型、符号、运算符、数组Array总结之详细攻略 目录 Java语言编程的基础知识之Java变量数据类型、符号、运算符、数组总结 变量 变量名称...
  • Java变量的使用

    2016-08-01 21:25:34
    定义变量是指设定变量数据类型和变量的名字,Java语言要求变量遵循先定义->再初始化->然后使用的规则。 变量的使用有一个作用域的问题,作用域是指它的存在范围,只有在这个范围内,程序代码才能访问它。 ...
  • java变量、注释、数据类型 变量的基本概念 当需要在程序中记录单个数据内容时,则应该声明一个变量变量本质上就是内 存中的一块存储单元,由于该存储单元中的数据内容可以变,因此得名 “变量”。 变量名 由于...
  • java.变量

    2015-05-31 21:35:56
     java中的每一个变量,都属于特定的数据类型,必须先进行声明,然后赋值,才能使用。  变量的命名:有一定命名规范,做到见名知意就好,不能与关键字重名(关键字:java语言中某些单词有特定的含义)  变量的...
  • 在类的方法中定义,在方法中用于临时保存数据 三、成员变量和局部变量的区别 1、作用域不同 局部变量的作用域仅局限于定义它的方法(即方法的开始和方法的结束) 成员变量的作用域在它整个类的内部是可见的(即该类...
  • Java中的变量数据类型

    千次阅读 2018-06-06 18:20:32
    一个变量是“在Java程序执行时持有值”的一个容器,一个变量会被分配一个数据类型,变量是一个内存位置的名字。 Java中有三种类型的变量:局部,实例和静态。在java中有两种类型的数据类型:原始类型和非原始类型。...
  • 一、关键字 1、关键字 Java内置的有特殊含义的单词。 注意: const,goto这两个词也是关键词...用于定义数据类型的关键字 class interface byte short int long float double char boolean void ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 55,208
精华内容 22,083
关键字:

java数据变量

java 订阅