• 2022年0701-Com.Java.Basis第二课《Java的八大基本数据类型》

    5523d50a501543cbab6b343b71b6d3a0.png

     

    第一点:JAVA中的APL文档
    https://docs.oracle.com/en/java/javase/18/docs/api/index.html


    第二点:Java的主类结构


    Java语言是面向对象的程序设计语言，Java程序的基本组成单元是类，类体中又包括属性与方法两部分。每一个应用程序都必须包含一个main()方法，含有main()方法的类称为主类。
    1.包声明：一个Java应用程序是由若干个类组成。
    2.声明成员变量和局部变量：类的属性称为类的全局变量（成员变量），将方法中的属性称为局部变量。全局变量声明在类体中，局部变量声明在方法体中。全局变量和局部变量都有各自的应用范围。
    3.编写主方法
    4.导入API类库


    第三点:包的声明


    //包的声明: package com.JavaBasicsDemo2.com.Class;

    第四点: 标识符的定义:

    1.只能由数字，字符，_(下划线)，$组成【不能以数字开头】

    2.不能说java中的关键字（在java中赋予了特殊含义的一些单词）

    Java的基础——>八大基本数据类型.

    1. 1、4种整数类型（byte、short、int、long）；

    2. 2、2种浮点类型（float、double）；

    3. 3、1种字符类型“char”；

    4. 4、1种布尔类型“boolean”.

    第五点:八大基本数据类型具体的作用:

    • 1 .整数数据类型：（int是高频使用的）     byte：字节         占1个字节   -128~127     short：短整型     占2个字节   -2^15~     int：整型        4    -2^31~2^31-1     long：长整型    8    -2^63~2^63-1   初始值末尾要加l

    •  2. 浮点数据类型：     float：单精度     占4个字节精确到小数点后15位  要在初始值末尾加f（范围巨大）     double：双精度 占8个字节   要精确到小数点后15位
    •   3  字符数据类型：     char：字符类型   占2个字节   要将字符用单引号（' '）引起来
    •    4 布尔数据类型：     boolean：1个字节  只能为true或者false
    • 5.引用数据类型： 
    •   6.  变量的声明和初始化     //变量的声明：数据类型 变量名称；     int age;     //变量的初始化（给变量赋值）：变量名称=值     age = 18；

    439d1f786cf14072b356ba276da872ba.png

    第六点:Demo实操:

    1. package com.JavaBasicsDemo2.com.Class;
    2. //包的声明: package com.JavaBasicsDemo2.com.Class;
    3. public class Test1 {
    4.     static String s1="Hellow Java 你好呀java";
    5.     //每一个程序中要定义main() 含有main 方法的的主类称为主类
    6.     public static void main(String[] args) {
    7.         String s2="欢迎来到java程序设计";
    8.         System.out.println(s1);
    9.         System.out.println(s2);
    10.         //声明一个变量去存储我的年龄   语法：数据类型   变量名称
    11.         int age;
    12.         //变量的初始化（给变量赋值）  语法：变量名称=值；
    13.         age=19;
    14.         System.out.println(age);
    15.  
    16.     }
    17. }

    a6c5c3d1187a4c9cb887cca39b021ac8.png

     

    1. package com.JavaBasicsDemo2.com.Class;
    2.  
    3. public class Test2 {
    4.     public static void main(String[] args) {
    5. /**
    6.  * 2. int类型
    7.  * 2.1. int类型
    8.  * int是最常用的整数类型，一个int类型的变量占用4个字节，即32位的内存空间。Int的最大表示范围为：-231～231-1，即-2147483648 ~2147483647，大约正负21个亿多些。
    9.  *
    10.  * 2.2. 整数直接量是int类型
    11.  * 所谓整数直接量（literal）就是直接写出的整数，例如：下面的语句中，100就是直接量。
    12.  */
    13.         int a = 100;
    14.  
    15.         int b = 100;
    16.         System.out.println("运行结果为" + a + b);
    17.  
    18.         //int c  = 10000000000; // 编译错误10000000000这个数值写出来就是错误的，因为Java认为所有直接写出的整数都是int类型，而这个数值超过了int的表达范围。
    19.         int aa = 100000; // 10进制
    20.         System.out.println(aa);
    21.  
    22.         int bb = 0x186a0; // 16进制
    23.         System.out.println(bb);
    24.         int cc = 0303240; // 8进制
    25.         System.out.println(cc);
    26.         int aaa = 100000; // 10进制
    27.         System.out.println(aaa);
    28.         int bbb = 0x186a0; // 16进制
    29.         System.out.println(bbb);
    30.         int ccc = 0303240; // 8进制
    31.         System.out.println(ccc);
    32.         System.out.println("--------------------------------------------");
    33.         int c = 5/3;
    34.  
    35.         System.out.println(c);  // c的值为1，取整
    36.  
    37.         int total = 87;
    38.  
    39.         int error = 23;
    40.  
    41.         int percent = error / total * 100;
    42.  
    43.         System.out.println(percent+"%");  //结果为0%，23除以87整数部分为0，乘以100，为0
    44.  
    45.         percent = 100 * error / total;
    46.  
    47.         System.out.println(percent + "%");  // 结果为26%，230除以87整数部分为26
    48.  
    49.         int cccc = 5/3;
    50.  
    51.         System.out.println(cccc);  // c的值为1，取整
    52.  
    53.         int total1 = 87;
    54.  
    55.         int error1 = 23;
    56.  
    57.         int percent1 = error1 / total1 * 100;
    58.  
    59.         System.out.println(percent1+"%");  //结果为0%，23除以87整数部分为0，乘以100，为0
    60.  
    61.  
    62.  
    63.         percent = 100 * error / total;
    64.  
    65.         System.out.println(percent + "%");  // 结果为26%，230除以87整数部分为26
    66.  
    67.     }
    68. }

    50a35d6bad3e4a649b3b77bc1796a341.png

     

    1. package com.JavaBasicsDemo2.com.Class;
    2.  
    3. /**
    4.  * 3. long类型
    5.  * 3.1. long类型
    6.  * 在表示整数时，如果int类型的范围不够，可以使用long类型，一个long型的变量占用8个字节（即64位），最大表示范围为：-263 ~ 263-1，即 -9223372036854775808 ~ 9223372036854775807。
    7.  *
    8.  * 如果要表示long直接量，需要以 L 或 l 结尾。示例代码如下：
    9.  *
    10.  *
    11.  */
    12.  
    13. public class Test3 {
    14.     public static void main(String[] args) {
    15.         // a = 10000000000;   //会有编译错误，因为10000000000编译器认为是int类型，而这个值，已经超出了int的范围
    16.  
    17.         long b = 10000000000l;   //正确
    18.         System.out.println(b);
    19.  
    20.         //long a = 10000000000;   //会有编译错误，因为10000000000编译器认为是int类型，而这个值，已经超出了int的范围
    21.  
    22.         long bb = 10000000000l;   //正确
    23.         System.out.println(bb);
    24.  
    25.         /**
    26.          * 3.2. 使用long类型进行较大整数的运算
    27.          * 对于较大的整数运算（超过int的表达范围），可以使用long型。示例代码如下：
    28.          */
    29.         long distance1 = 10000 * 365 * 24 * 60 * 60 * 299792458l;
    30.  
    31. //必须有一个long型数据参与的运算结果才是long型
    32.  
    33.         System.out.println("distance1="+distance1);//distance1=547836957965889536 结果正确
    34.  
    35.         long distance2 = 10000 * 365 * 24 * 60 * 60 * 299792458;
    36.  
    37.         System.out.println("distance2="+ distance2);  //distance2=-1973211136 溢出，=号后面的数据默认为int类型，超出了范围，发生溢出。
    38.  
    39.        // long cc = 10000 * 365 * 24 * 60 * 60 * 299792458l;
    40.  
    41. //必须有一个long型数据参与的运算结果才是long型
    42.  
    43.         System.out.println("distance1="+distance1);//distance1=547836957965889536 结果正确
    44.  
    45.  
    46.  
    47.         //long dd = 10000 * 365 * 24 * 60 * 60 * 299792458;
    48.  
    49.         System.out.println("distance2="+ distance2);  //distance2=-1973211136 溢出，=号后面的数据默认为int类型，超出了范围，发生溢出。
    50.  
    51.  
    52.     }
    53. }

    32ba1645e339488e9be10cd144b430ee.png

     

    1. package com.JavaBasicsDemo2.com.Class;
    2.  
    3. public class Test4 {
    4.     public static void main(String[] args) {
    5.         /**
    6.          *    4. double类型
    7.          *         4.1. 使用double进行浮点数的运算
    8.          *         前面所学习的int、long都是用于存储整数的，小数即为浮点数，包括： float（单精度）和double（双精度），
    9.          *         double类型的精度值是float类型的两倍，因此而得名双精精，在实际的应用开发中，float应用极少，
    10.          *         大多数场合使用double表示浮点数。示例代码如下：
    11.          */
    12.         double pi = 3.14;
    13.  
    14.         double r = 8;
    15.  
    16.         double s = pi * r * r;
    17.  
    18.         System.out.println("s=" + s);   // 输出的结果为：s=200.96
    19.  
    20.         double pis = 3.14;
    21.  
    22.         double rr = 8;
    23.  
    24.         double ss = pis * r * r;
    25.  
    26.         System.out.println("s=" + ss);   // 输出的结果为：s=200.96
    27.         /**
    28.          * 4.2. 浮点数直接量是double类型
    29.          * 浮点数的直接量有两种写法：1）通常写法，如：3.14、314、0.1、.5。 2）科学计数法，
    30.          * 如：1.25E2、1.25e2、1.25E-2。其中，1.25E2表示1.25乘以10的2次方。
    31.          * 默认的浮点直接量为double型，如果需要表示float类型的直接量，需要加“f”或“F”后缀。例如：
    32.          */
    33.  
    34.         float f1 = 3.14f;   //编译错误，应该写成3.14f
    35.         System.out.println(f1);
    36.        // float f1 = 3.14   //编译错误，应该写成3.14f
    37.  
    38.         /**
    39.          *   4.3. double运算时会出现舍入误差
    40.          *   2进制系统中无法精确的表示1/10，就好像十进制系统中无法精确的表示1/3一样，
    41.          *所以，2进制表示10进制会有一些舍入误差，对于一些要求精确运算的场合会导致代码的缺陷。示例代码如下所示：
    42.          */
    43.  
    44.         double money = 3.0;
    45.  
    46.         double price = 2.9;
    47.  
    48.         System.out.println(money - price);   //输出的结果是： 0.10000000000000009
    49.  
    50.         double moneys = 3.0;
    51.  
    52.         double prices = 2.9;
    53.  
    54.         System.out.println(moneys - prices);   //输出的结果是： 0.10000000000000009
    55.  
    56.  
    57.  
    58.     }
    59. }

    08cce7749d1a41be9b8546ccda96d0e8.png

     

    1. package com.JavaBasicsDemo2.com.Class;
    2.  
    3. public class Test5 {
    4.     public static void main(String[] args) {
    5.         /**
    6.          *  5. char类型
    7.          *         5.1. char类型
    8.          *         字符类型char事实上是一个16位无符号整数（都是正数），这个值是对应字符的编码，
    9.          *         Java字符类型采用Unicode字符集编码（通用码、统一码、万国码），而Unicode是世界通用的定长字符集，所有的字符都是16位来表示。例如：字符a实际的值为97，字符A实际的值为65，字符0实际的值为48。
    10.          *
    11.          *         字符直接量可以采用诸如：‘中’的形式，也可以采用16进制的表示形式，例如： ‘\u4e2d’，代码如下所示：
    12.          */
    13.  
    14.  
    15.  
    16.         //char c1 = ‘中’;   //c1中存的是”中”的编码
    17.  
    18.         char c2 = '\u4e2d';   //‘4e2d’为‘中’所对应的16位Unicode编码的16进制表示形式
    19.  
    20.         //System.out.println(c1);
    21.  
    22.         System.out.println(c2);
    23.  
    24.         //char c1 = ‘中’;   //c1中存的是”中”的编码
    25.  
    26.         //char c2 = '\u4e2d';   //‘4e2d’为‘中’所对应的16位Unicode编码的16进制表示形式
    27.  
    28.         //System.out.println(c1);
    29.  
    30.         //System.out.println(c2);
    31.  
    32. //        如上代码的输出结果：c1的值为中，c2值也为中，但c1和c2内部存储的其实是”中”这个字符所对应的Unicode码，即：一个无符号的整数。
    33.  
    34.         /**
    35.          *  5.2. 对char型变量赋值
    36.          *         在对char型变量赋值时，可以采用如下三种方式：
    37.          *
    38.          *         方式一：
    39.          *
    40.          *         字符直接量：形如‘A’，变量中实际存储的是该字符的Unicode编码（无符号整数值），一个char型变量只能存储一个字符。示例如下：
    41.          */
    42.         char c1 = 'A';
    43.  
    44.         //char c1 = 'A';
    45.  
    46.         /**
    47.          *  方式二：
    48.          *
    49.          *         整型直接量：范围在0~65535之间的整数，变量中实际存储的即该整数值，但表示的是该整数值所对应的Unicode字符。示例如下：
    50.          */
    51.  
    52.  
    53.  
    54.         //char c2 = 65;
    55.  
    56.         //char c2 = 65;
    57.  
    58.         //Unicode形式：形如‘\u0041’,Unicode字符的16进制形式。示例如下：
    59.  
    60.  
    61.  
    62.         //char c3 = '\u0041';
    63.  
    64.  
    65.         /**
    66.          *   5.3. 使用转义字符
    67.          *         字符直接量需要包含在一对’’单引号之中，那如果想表示单引号’的字符时，需要怎么表示？想表示回车、换行符时，怎么表示？
    68.          *
    69.          *         因为单引号为特殊意义的字符， 那么，对于不方便输出的字符可以采用转义字符来表示，示例代码如下：
    70.          */
    71.  
    72.  
    73.         char c = '\\';
    74.  
    75.         System.out.println(c);  //输出的结果为：\
    76.  
    77.         char cc = '\\';
    78.  
    79.         System.out.println(c);  //输出的结果为：\
    80.  
    81.     }
    82. }

    cafaed2b82d84a3b8ab59f75037c5abb.png

     

    1. package com.JavaBasicsDemo2.com.Class;
    2.  
    3. public class Test6 {
    4.     public static void main(String[] args) {
    5.         /**
    6.          *  6. boolean类型
    7.          *         6.1. 使用boolean变量进行关系运算
    8.          *         boolean类型适用于关系、逻辑运算， 表示某个条件是否成立， 只允许取值true或false，true表示条件成立， 而false表示条件不成立。
    9.          *
    10.          *         boolean型变量经常用于存储关系运算的结果，所谓关系运算就是比较两个变量的大小相等等关系（此知识点，后续详细介绍）。boolean示例代码如下所示：
    11.          */
    12.  
    13.  
    14.         int age = 18;
    15.  
    16.         boolean isChild = age<16;
    17.  
    18.         System.out.println(isChild);   // isChild的值为false
    19.  
    20.         boolean running = true;
    21.  
    22.         boolean closed = false;
    23.  
    24.         int ages = 18;
    25.  
    26.         boolean isChilds = age<16;
    27.  
    28.         System.out.println(isChilds);   // isChild的值为false
    29.  
    30.         boolean runnings = true;
    31.  
    32.         boolean closeds = false;
    33.     }
    34. }

    9d1c5db0589c4905a9486da2999f6a7a.png

     

    （驼峰式命名）：如果命名有多个单词，那么首个单词首字母小写，后面的首字母都大写 注意：      数据类型小到大排列：byte<short<int<<long<float<double     整数数据类型要小于浮点数     如果多个数据类型的数据参与运算，最终结果会是多个类型中最大的数据类型 将小的数据类型的变量赋值给大的数据类型的变量 我们称为“自动类型转换”     大的 数据类型无法赋值给小的数据类型（强制类型转换：格式“小数据类型变量 = 大数值类型变量” 可将大类赋值给小类，但会出现各种问题）

    1. package com.JavaBasicsDemo2.com.Class;
    2.  
    3. public class Test7 {
    4.     public static void main(String[] args) {
    5.         /**
    6.          *   7. 基本类型间转换
    7.          *         7.1. 类型间转换
    8.          *         不同的基本类型直接可以相互转化，主要有两种方式：
    9.          *
    10.          *         自动类型转化（隐式类型转换）：从小类型到大类型可以自动完成。类型的大小关系如下图 - 3所示：
    11.          *         强制转化：从大类型到小类型需要强制转换符，语法如下：
    12.          *
    13.          *
    14.          * （需要转换成的类型）变量
    15.          *
    16.          *         因为大类型的精度值大于小类型，取值范围大于小类型，所以，当使用强制转化时，有可能会造成精度的损失或者溢出，所以，在使用强制转化时要求显式的告诉编译器，正在进行强制转换。
    17.          *
    18.          *         7.2. 强制转换时的精度丧失和溢出
    19.          *         基本类型转化如下示例所示，注意强制转换时可能会造成的精度丧失和溢出。
    20.          */
    21.  
    22.  
    23.  
    24.         int a = 100;
    25.  
    26.         int b = 200;
    27.  
    28.         long c = a + b;  //自动将int转化为long
    29.  
    30.         long l1 = 1024l;
    31.  
    32.         int i = (int) l1;  //需要加强制转化符由于1024在int的范围内，所以没有产生溢出
    33.  
    34.         long l = 1024L * 1024 * 1024 * 4;
    35.  
    36.         int j = (int) l;    //会产生溢出
    37.  
    38.         System.out.println(j);  // 结果为：0
    39.  
    40.         double pi = 3.1415926535897932384;
    41.  
    42.         float f = (float) pi;   //会造成精度的损失，因为单精度的精确度小于double
    43.  
    44.         System.out.println(f);  //结果为：3.1415927
    45.  
    46.         int aa = 100;
    47.  
    48.         int bb = 200;
    49.  
    50.         long cc = aa + bb;  //自动将int转化为long
    51.  
    52.         long l11 = 1024l;
    53.  
    54.         int s = (int) l11;  //需要加强制转化符由于1024在int的范围内，所以没有产生溢出
    55.         System.out.println(s);
    56.         long ls = 1024L * 1024 * 1024 * 4;
    57.  
    58.         int js = (int) ls;    //会产生溢出
    59.  
    60.         System.out.println(js);  // 结果为：0
    61.         double pis = 3.1415926535897932384;
    62.  
    63.         float fs = (float) pis;   //会造成精度的损失，因为单精度的精确度小于double
    64.  
    65.         System.out.println(fs);  //结果为：3.1415927
    66.         /**
    67.          *  7.3. 数值运算时的自动转换
    68.          *         如果在一个表达式中出现了多种数据类型，则运算结果会自动的向较大的类型进行转化，
    69.          *
    70.          *         示例如下：
    71.          */
    72.  
    73. //由于有long型的直接量参与，整个表达式的结果为long
    74.  
    75.         long distance = 10000 * 365 * 24 * 60 * 60 * 299792458l;
    76.  
    77.  
    78.  
    79. //由于有double型的直接量599.0参与，整个表达式的结果为 double
    80.  
    81.         double change = 800 - 599.0;
    82.  
    83.  
    84.  
    85. //结果为0.0，右边都是int型数据运算结果也为int类型，结果为0，再赋值给double
    86.  
    87.        //将0转化为 0.0
    88.  
    89.         double persent1 = 80 / 100;
    90.  
    91. //结果为0.8，右边表达式有double型直接量参与， 运算结果为double型
    92.  
    93.         double persent2 = 80.0 / 100;
    94.  
    95. //由于有long型的直接量参与，整个表达式的结果为long
    96.  
    97.         long distancew = 10000 * 365 * 24 * 60 * 60 * 299792458l;
    98.         System.out.println(distancew);
    99. //由于有double型的直接量599.0参与，整个表达式的结果为 double
    100.  
    101.         double changes = 800 - 599.0;
    102.         System.out.println(changes);
    103. //结果为0.0，右边都是int型数据运算结果也为int类型，结果为0，再赋值给double
    104.  
    105.         //型，将0转化为 0.0
    106.  
    107.         double persent = 80 / 100;
    108. //结果为0.8，右边表达式有double型直接量参与， 运算结果为double型
    109.  
    110.         double persents = 80.0 / 100;
    111.  
    112.         /**
    113.          *   7.4. byte、char、short转换为int
    114.          *         在前面所介绍的8种数据类型中，byte、char、short、int、long都表示整数类型，而整型的直接量为int，在实际使用中，为了方便使用，遵循了如下的规则：
    115.          *
    116.          *         int直接量可以直接赋值给byte、char和short，只要不超过其表示范围。示例如下：
    117.          */
    118.  
    119. //        byte  bb  = 97;
    120.  
    121.         short  ss  = 97;
    122.  
    123.         char  ccc  = 97;
    124.  
    125.         byte  bbb  = 97;
    126.  
    127.         short  ssss  = 97;
    128.  
    129.         char  cccc  = 97;
    130.  
    131.     //    byte、char、short三种类型参与运算时，先一律转换成int类型再进行运算。示例如下：
    132.  
    133. //        byte  b  =  97;
    134.  
    135.         int  num = b + b;   //num的值为194
    136.  
    137.  
    138.     }
    139. }

    d90a4f348f16447a9663a2b56e9c29a6.png

     

     

     

  • 相关阅读:
    【sgTileImage】自定义组件：瓦片图拖拽局部加载、实现以鼠标为中心缩放
    软件设计师学习笔记10-死锁资源数计算+进程资源图+段页式存储
    分类任务评价指标
    FTP后门
    [附源码]Python计算机毕业设计Django新能源汽车租赁
    【Spring AOP】暴力打通两个切面之间的通信
    【LeetCode】1282. 用户分组
    C#冬令时夏令时判断
    门店如何设置多个联系电话和营业时间
    云计算实验2 Spark分布式内存计算框架配置及编程案例
  • 原文地址：https://blog.csdn.net/qq_56248592/article/details/125551494