精华内容
下载资源
问答
  • JAVA打印变量类型

    万次阅读 2018-11-25 09:41:38
    public class getType { public static String getType(Object test) { return test.getClass().getName().toString(); } public static void main(String[] args) { int i = 1; System.out.printl.....
    
    public class getType {
    	public static String getType(Object test) {
    		return test.getClass().getName().toString();
    					
    	}
    	public static void main(String[] args) {
    		int i = 1;
    		System.out.println(getType(i));
    		
    	}
    
    }
    

     

    展开全文
  • 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输出变量数据类型At SitePoint we’re always looking to expand the range of topics we cover. Lately, we’ve set our sights on exploring the world of Java. If you’re a strong Java developer who ...

    java输出变量数据类型

    At SitePoint we’re always looking to expand the range of topics we cover. Lately, we’ve set our sights on exploring the world of Java. If you’re a strong Java developer who wants to contribute to our coverage, get in touch with a few ideas for articles you’d like to write.

    在SitePoint,我们一直在寻求扩大我们涵盖的主题范围。 最近,我们将目光投向了探索Java的世界。 如果您是一名强大的Java开发人员,想为我们的报道做出贡献,请与您想写的文章的一些想法保持联系

    Java variables enable programmers to store single data points, bits of information, for later use. For efficiency in later use, Java variables have types. Those types are referred to as data types because they allow us to store different types of data respectively for convenience and predictability. It’s necessary for any Java programmer to understand the basics of variables and data types in Java before moving on to more advanced topics.

    Java变量使程序员能够存储单个数据点和信息位,以备后用。 为了提高以后使用的效率,Java变量具有类型。 这些类型被称为数据类型,因为它们使我们分别为了方便和可预测性而存储不同类型的数据。 任何Java程序员都必须先了解Java中变量和数据类型的基础,然后再转向更高级的主题。

    To illustrate how Java variables work, let’s imagine a photo sharing application. The app would store a whole bunch of information about the state of our application and the photos its users share: the number of users, the number of photos shared, and the total number of comments shared. That data has to be stored in order for us to manipulate and display them to our users when necessary. Enter Java variables.

    为了说明Java变量如何工作,让我们想象一个照片共享应用程序。 该应用程序将存储有关我们的应用程序状态及其用户共享的照片的所有信息:用户数量,共享的照片数量以及共享的评论总数。 必须存储该数据,以便我们在必要时进行操作并将其显示给我们的用户。 输入Java变量。

    Java变量 (Java Variables)

    Variables can hold data and that data can be changed over the lifetime of our program. A variable must have a type, a name, and be provided some sort of data to hold. The most widely used type of data in Java is the character string, represented by Java’s String class. A string, such as “SitePoint” is simply an instance of the String class.

    变量可以保存数据,并且可以在程序的生命周期内更改数据。 变量必须具有类型,名称,并提供某种数据来保存。 Java中使用最广泛的数据类型是字符串,由Java的String类表示。 诸如“ SitePoint”之类的String只是String类的一个实例。

    命名变量 (Naming Variables)

    There are a few rules you must follow and a few you should. Java’s variable names are case senstive and can be an unlimited number of letters and numbers. However, variable names must start with a letter, underscore character _ , or a dollar sign $.

    必须遵循一些规则,而您应该遵循一些规则。 Java的变量名区分大小写,并且可以是字母和数字的任意数量。 但是,变量名必须以字母,下划线字符_或美元符号$开头。

    When creating variables in Java, it is best to follow the convention of using numbers and full words that are descriptive of the purpose of the variable while avoiding use of the underscore character and dollar sign. Finally, variables should be in lower camel case, a popular programming convention that dictates that the first letter of the first word should be in lower case and the following words should be capitalized.

    在Java中创建变量时,最好遵循使用描述变量目的的数字和完整单词的约定,同时避免使用下划线字符和美元符号。 最后,变量应使用小写驼峰,这是一种流行的编程约定,规定第一个单词的第一个字母应小写,随后的单词应大写。

    beans

    使用变量 (Using Variables)

    Let’s create the skeleton of our application’s main class to see how we can store each of the aforementioned data points about our application in String variables:

    让我们创建应用程序主类的框架,以了解如何在String变量中存储有关应用程序的上述每个数据点:

    public class SitePointGram {
        public static void main(String[] args) {
            String nameOfApp = "SitePointGram";
            String numberOfUsers = "";
            String numberOfPhotos;
            String numberOfComments = null;
            //...
        }
    }

    So what’s going on there? Let’s skip to the third line of that block of Java code. On each line, we create a new variable of type String to store a single point of information about our application. Observe that to create a variable in Java, we start by stating the type of the data to be stored in the variable, followed by the name of the variable in lower camel case, then the assignment operator =, and finally the data to be stored in the variable.

    那到底是怎么回事? 让我们跳到该Java代码块的第三行。 在每一行上,我们创建一个String类型的新变量来存储有关我们应用程序的单点信息。 观察到要在Java中创建一个变量,首先要说明要存储在该变量中的数据的类型,然后是小写驼峰变量的名称,然后是赋值运算符= ,最后是要存储的数据在变量中。

    In the first line of our main method, we store the name of our application in the nameOfApp String variable and the data stored in it is “SitePointGram”. The next line has a String variable that will store the number of users on our application. Notice that it stores an empty string "". Hold that thought as we move to the next two lines.

    main方法的第一行中,我们将应用程序的名称存储在nameOfApp String变量中,并且其中存储的数据为“ SitePointGram”。 下一行有一个String变量,它将存储我们应用程序上的用户数。 请注意,它存储了一个空字符串"" 。 当我们移至下两行时,请保持该思想。

    Every variable in Java has a default value; the default value for String variables is null, “nothing”. If we don’t know the value of a variable at the time of declaration, we can omit explicitly initializing it with a value and allow Java to implicitly provide it an appropriate default value. That is exactly what we do with the numberOfPhotos variable. Similarly, on the fourth line, we initialize the numberOfComments String variable to null explicitly, although we do not have to. It’s important to understand that an empty string is an actual character string, albeit an empty one, while null means the variable does not yet have valid data. Let’s continue.

    Java中的每个变量都有一个默认值。 String变量的默认值为null ,即“ nothing”。 如果在声明时不知道变量的值,则可以省略使用值显式初始化它,并允许Java隐式为其提供适当的默认值。 这正是我们使用numberOfPhotos变量进行的操作。 同样,在第四行中,尽管不必这样做,但我们将numberOfComments String变量显式初始化为null 。 重要的是要理解一个空字符串是一个实际的字符串,尽管它是一个空字符串,而null表示变量尚没有有效数据。 让我们继续。

    SitePointGram is becoming popular and people are flocking to it. Let’s represent the growth of our application in Java:

    SitePointGram变得越来越流行,人们蜂拥而至。 让我们代表我们的Java应用程序的增长:

    public static void main(String[] args) {
        //...
        numberOfUsers = "500";
        numberOfPhotos = "1600";
        numberOfComments = "2430";
        //..
    }

    After initializing our String variables, it is now apparent that our application has 500 users, 1600 shared photos, and a whopping 2430 total comments across those photos. We’re doing well, so it’s time we learn how to use data types in Java.

    初始化我们的String变量后,现在很明显,我们的应用程序有500个用户,1600张共享照片,以及这些照片上总共有2430条评论。 我们做得很好,所以现在该学习如何在Java中使用数据类型了。

    Java数据类型 (Java Data Types)

    We currently have all of our data points stored in String variables even though some of them are numbers. Strings are good for representing character strings such as text, but when we want to represent numbers and other types of data (and perform operations on that data), we can use the data types provided by Java or create our own.

    我们目前将所有数据点存储在String变量中,即使其中一些是数字。 字符串非常适合表示诸如文本之类的字符串,但是当我们想要表示数字和其他类型的数据(并对这些数据执行操作)时,我们可以使用Java提供的数据类型或创建自己的数据类型。

    Let’s see how we can more appropriately store our numerical data points in variables so we can use them as we would expect:

    让我们看看如何将数字数据点更适当地存储在变量中,以便我们可以像预期的那样使用它们:

    public static void main(String[] args) {
        String appName = "SitePointGram";
        boolean appIsAlive = true;
    
        int numUsers = 500;
        int numPhotos = 1600;
        int numComments = 2430;
        //...
    }

    Moving away from our original main method, we have a new block of code with new variables of appropriate data types. In the first line of our main method’s body, the variable holding our application’s name is now more precise: instead of nameOfApp, we have appName. On the next line, we have a boolean variable which stores the status of our application. A boolean can only be true or false and therefore is best when you want to store a data point that represents validity; in our case, it is true that our app is alive until we need to shut it down for maintenance. The next three variables are of type int. The int data type represents integer values in Java. Following the same pattern as appName, instead of naming our number variables along the lines of numberOfX, we should do numX to be precise while maintaining readability.

    远离原始的main方法,我们有了一个新的代码块,其中包含具有适当数据类型的新变量。 在main方法主体的第一行中,保存应用程序名称的变量现在更加精确:我们使用appName代替了nameOfApp 。 在下一行,我们有一个boolean变量,用于存储应用程序的状态。 boolean只能是truefalse ,因此,当您要存储表示有效性的数据点时, boolean是最好的; 在我们的情况下,确实是我们的应用程序仍然存在,直到需要关闭它进行维护之前。 接下来的三个变量的类型为intint数据类型表示Java中的整数值。 遵循与appName相同的模式,而不是像numberOfX命名我们的数字变量,我们应该在保持可读性的同时做numX以便精确。

    The data types int, boolean, and double are three of the eight primitive data types in Java. Primitive data types are special values, not objects constructed from a class, provided by Java. Remember that strings are instances of the String class and so they are objects, not primitives. The default value for numerical data types is 0 and false for the boolean.

    数据类型intbooleandoubleJava八种原始数据类型中的三种 。 原始数据类型是特殊值,而不是Java提供的从类构造的对象。 请记住,字符串是String类的实例,因此它们是对象,而不是基元。 数字数据类型的默认值为0boolean值的默认值为false

    Unlike in our previous main method, our new set of variables store numbers appropriately, so we are able to manipulate them as we would expect. With our numerical data points stored in variables of types that represent numbers, we can execute mathematical operations on them:

    与以前的main方法不同,我们的新变量集适当地存储了数字,因此我们能够按预期操作它们。 将我们的数值数据点存储在代表数字的类型的变量中,我们可以对它们执行数学运算:

    //a new user joined, increase the number of users by 1
    numUsers += 1;
    //multiply the number of photos by 2
    numPhotos = numPhotos * 2;
    //get the average number of photos by doing division
    double avgPhotosPerUser = 1.0 * numPhotos / numUsers;

    The last variable in our main method holds a floating point value of the average number of photos per user and this is represented by the double data type. We obtained this by dividing the number of photos by the number of users. Notice we multiplied the first number by 1.0 so that the result isn’t rounded to the nearest whole number. We can store a floating point number as either a float or a double; the only difference here is that a double (64 bit) can hold a much larger range of numbers than a float (32 bit) and is used more often for that reason.

    我们main方法中的最后一个变量包含每个用户的平均照片数量的浮点值,这由double数据类型表示。 我们通过将照片数量除以用户数量来获得此结果。 注意,我们将第一个数字乘以1.0,这样结果就不会四舍五入到最接近的整数。 我们可以将浮点数存储为floatdouble ; 唯一的区别是, double精度数(64位)可以容纳比float (32位)大得多的数字范围,并且由于这个原因,它的使用频率更高。

    The last thing to do is see how we can represent our data in our own data types.

    最后要做的是查看如何以自己的数据类型表示数据。

    String user1 = "id: 1, username: LincolnWDaniel, isOnline: true";

    While it would be easy to make a bunch of strings that hold information about users like we have in user1, it would be better to create a class to construct user objects from:

    虽然很容易像使用user1那样使一堆字符串包含有关用户的信息,但最好创建一个类来从以下对象构造用户对象:

    自定义Java数据类型(类) (Custom Java Data Types (Classes))

    public class User {
        public static int numUsers = 0;
    
        private int id;
        private String username;
        private boolean isOnline;
        /*other information about this user,
        perhaps a list of associated photos*/
    
        public User(String username) {
            id = numUsers++;
            this.username = username;
            this.isOnline = true;
            System.out.println(username + " signed up!");
        }
    
        public void logOn() { 
            isOnline = true; 
            printOnlineStatus();
        }
    
        public void logOff() { 
            isOnline = false; 
            printOnlineStatus();
        }
    
        private void printOnlineStatus() {
            System.out.println(username + " is online: " + isOnline);
        }
        //...
    }

    There, we have a class called User. This class simply defines properties and behaviors instances created from it can exhibit. The properties of this class are simply variables of varying data types that will hold information about a user in our application. An instance of the User class can have information about itself from its identification number to its username, and its online status is held in a boolean variable that can be updated when the user logs on or off. When a user is created, or logs on or off, we print that information to the console.

    在那里,我们有一个名为User的类。 此类仅定义通过其创建的实例可以显示的属性和行为。 此类的属性只是不同数据类型的变量,这些变量将保存有关我们应用程序中用户的信息。 User类的实例可以具有有关其自身的信息(从其标识号到其用户名),并且其在线状态保存在boolean变量中,可以在用户登录或注销时进行更新。 创建用户或登录或注销用户后,我们会将这些信息打印到控制台。

    Every time a new user is created in our application, the numUsers variable’s value is increased by one so that our application knows how many users there are at all times. You could add more information to this class by adding more instance variables. Now, let’s create an instance of our new data type, User, in our application’s main method:

    每次在我们的应用程序中创建一个新用户时, numUsers变量的值都会增加一,以便我们的应用程序始终知道有多少个用户。 您可以通过添加更多实例变量来向此类添加更多信息。 现在,让我们在应用程序的主要方法中创建新数据类型User的实例:

    public static void main(String[] args) {
        String appName = "SitePointGram";
        boolean appIsAlive = true;
    
        /*declare a new variable of type User 
        and store a new User instance with the name of "Lincoln" in it*/
        User lincoln = new User("Lincoln");
    
        //log lincoln off
        lincoln.logOff();
    
        //print out the number of users in our app
        System.out.println("Number of users: " + User.numUsers);
        //...
    }

    In that block of code, we changed up our main method again. The first two lines remained unchanged, but we now have three new lines. The third line in the method creates a new User instance, or object, and stores it in a variable called “lincoln”, the next line logs lincoln off our application, and the next line prints out the number of User instances in our application by accessing the public static numUsers variable from the User class. It’s important to note that static variables of a class belong to the class and not instances of that class, so we did not need an instance of User to access numUsers.

    在那段代码中,我们再次更改了main方法。 前两行保持不变,但是我们现在有了三行。 方法的第三行创建一个新的User实例或对象,并将其存储在名为“ lincoln”的变量中,下一行将lincoln从我们的应用程序中注销,而下一行则通过以下方式打印出我们应用程序中的User实例数从User类访问public static numUsers变量。 重要的是要注意,类的static变量属于该类,而不属于该类的实例,因此我们不需要User实例即可访问numUsers

    结论 (Conclusion)

    That’s it! You now know all you need to know about Java variables and data types to get started building your own data types, or classes. Take a look at the source code for this tutorial on our GitHub repository and see how you can build upon it.

    而已! 现在,您已经了解了有关Java变量和数据类型的所有知识,从而可以开始构建自己的数据类型或类。 在我们的GitHub存储库上查看本教程的源代码,并了解如何在此基础上构建。

    References:Oracle Documentation on Java StringsOracle Documentation on Java’s Primitive Data Types

    参考: 有关Java字符串的 Oracle文档有关Java的原始数据类型的Oracle文档

    翻译自: https://www.sitepoint.com/understanding-java-variables-and-data-types/

    java输出变量数据类型

    展开全文
  • Java数据类型打印

    千次阅读 2019-09-07 21:17:26
    定义出所有数据类型变量 四类八种 */ public class Variable{ public static void main(String[] args){ //定义整数类型,字节类型byte类型 //内存中1个字节,-128 127 byte b = 100; System.out.println(b); //...

    /*
    定义java中的变量
    定义出所有数据类型变量
    四类八种
    */
    public class Variable{
    public static void main(String[] args){
    //定义整数类型,字节类型byte类型
    //内存中1个字节,-128 127
    byte b = 100;
    System.out.println(b);

    	//定义整数类型,短整形,short类型
    	//内存中2个字节, -32768 32767
    	short s = 200;
    	System.out.println(s);
    	
    	//定义整数类型, 整形, int类型
    	//内存中4个字节, -2147483648 2147483647
    	int i = 50006;
    	System.out.println(i);
    	
    	//定义整数类型, 长整型, long类型
    	//内存中8个字节 超长为了区分,int类型所以后边+L
    	long l = 2147483647L;
    	System.out.println(l);
    	
    	//定义浮点数据, 单精度 float类型
    	//内存中4个字节,float默认都是double类型的,将1.0变成float类型就在后边+F
    	float f = 1.0F;
    	System.out.println(f);
    	
    	//定义浮点数,  双精度 double类型
    	//内存中8个字节
    	double d = 2.2;
    	System.out.println(d);
    	
    	//定义字符类型,char
    	//内存中2个字节,,必须单引号包裹,只能写1个字符
    	char c = '我';
    	System.out.println(c);
    	
    	//定义布尔类型, boolean
    	//内存中一个字符,数据值,true false
    	boolean bool = true;
    	System.out.println(bool);
    	
    }
    

    }
    总结:
    1.数据类型一定与定义完美匹配:例如byte b = 100; 100一定与byte完美匹配。
    2.java与python不同的是 java boolean 只有true 、false,python是非零即为true:true 、false、1、0

    展开全文
  • java打印数据类型

    千次阅读 2020-11-17 16:34:46
    使用getType方法 主要方法: private static String getType(Object a) { return a.getClass().toString(); } 写法: public class hello { public static void main(String[] args) { byte a1=2;...
  • Java中,我们需要标识代码的很多元素,包括类名、方法、字段、变量、包名等等。我们选择的那个名称就称为标识符,一个正确的标识符需要遵循以下规则: 1. 标识符可以由字母、数字、下划线(_)、美元符($)组成,...
  • Java变量数据类型

    2019-09-04 23:35:31
    变量 变量就是初中数学的代数的概念,例如一个简单的方程,x,y都是变量
  • Java基础:Java Date数据类型

    万次阅读 2018-08-14 20:06:26
    Java数据类型中Date数据类型在处理一些日常应用问题常常被人们使用。  然而在使用过程中许多人却没有真正的去了解有关于Java 数据类型中Date数据类型。  通常在这使用某一种数据类型过程中并不一定就会有哦相应...
  • java获取变量类型

    千次阅读 2019-02-21 15:22:35
    对于基本类型变量,是无法直接获得变量类型的; 对于包装类型变量,是可以直接获得的,变量名称.getClass().getName(); String b = "hello"; System.out.println(b.getClass().getName()); 基本类型变量...
  • // 基本数据类型类型变量 System.out.println("基本数据类型类型变量" + getType(i)); //打印变量类型为int Color c1 = Color.RED; // 包装类型变量 System.out.println("包装类型变量" + c1 + c1.getClass()....
  • java中基本数据类型打印

    千次阅读 2014-12-30 15:59:01
    注意Boolean是1个字节,(毕竟字节是最小的内存单元)因为没有SIZE这个方法,所以打印不出来 。 System.out.println("Integer: " + Integer.SIZE ); System.out.println("Short: " + Short.SIZE ); System.out...
  • JAVA 获取变量类型代码

    千次阅读 2017-01-26 12:01:57
    public class GetTypeDemo { public static String getType (Object o) { return o.getClass().getName().toString(); } public static void main ...//java.lang.Integer } }
  • Java 打印Map和List等复杂类型

    万次阅读 2019-03-10 09:59:42
    Java打印一些复杂的数据类型时,往往没有python那样的方便,要写不少代码,现在发现有两个方法可以比较简单的实现类似python的便捷。 以下代码是测试用的数据 Map&lt;String,Object&gt; map=new HashMap&...
  • Java 变量类型

    千次阅读 2017-01-04 21:18:38
    Java 变量类型在Java语言中,所有的变量在...格式说明:type为Java数据类型。identifier是变量名。可以使用逗号隔开来声明多个同类型变量。 以下列出了一些变量的声明实例。注意有些包含了初始化过程。int a, b, c;
  • Java获取变量类型

    万次阅读 2019-05-13 16:14:51
    对于简单类型变量,是无法直接获得变量类型的,要想获取,必须自定义...java中获取变量类型可以使用每个类型的getClass()方法来获得,示例如下: class Test { public static void main(String[] args) { ...
  • Java变量的说明,常量的表示方式,个别逻辑运算符的说明
  • Java变量类型,输入输出

    千次阅读 2018-08-25 23:41:38
    输入 Java程序开发过程中,需要从键盘获取输入值是常有的事,但Java它偏偏就没有像c语言给我们提供的scanf(),C++给我们提供的cin...方法一:从控制台接收一个字符,然后将其打印出来 import java.io.*; public st...
  • Java数据类型以及变量的定义

    千次阅读 2017-11-28 19:57:01
    什么是数据类型呢? 数据类型的分类: 1.基本数据类型 1.整型 int short long int 4个字节 short 2个字节 long 8个字节 2.浮点型 float(单精度浮点型) double(双精度浮点型) float 4个字节 ...
  • Java 中三种变量类型

    千次阅读 2019-09-26 16:02:46
    前言 Java语言中,所有的变量在使用...格式说明:type为Java数据类型。identifier是变量名。可以使用逗号隔开来声明多个同类型变量。 以下列出了一些变量的声明实例。注意有些包含了初始化过程。 int a, b, c; ...
  • 下面是java中八种基本类型和1种引用类型定义的数组,并进行打印当前数组操作代码: package StringStudy; public class charList { public static void main(String[] args) { char[] charList = new char[]{'1',...
  • java学习笔记】变量数据类型Java中,变量分为两种:基本类型的变量和引用类型的变量。 一、基本类型的变量Java中,变量必须先定义后使用,在定义变量的时候,可以给它一个初始值。例如: int x = 1; 上述...
  • 1、Java基本数据类型各占多少字节 1.1、怎么区分byte和char? 2、将Int 或者 byte 数据用二进制或者16进制打印出来 2.1、int 类型,打印成二进制数据 2.2、int 类型,打印成16进制 2.3、byte类型的数据打印成二...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 338,575
精华内容 135,430
关键字:

java打印变量类型

java 订阅