JavaSE基础-第二章

最新推荐文章于 2023-11-02 00:15:07 发布
最新推荐文章于 2023-11-02 00:15:07 发布
阅读量437 收藏
点赞数
分类专栏： JavaSE 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45402023/article/details/125893032
版权
本文详细介绍了Java语言的基础知识，包括标识符的命名规则和规范，关键字的分类和作用，以及数据类型的存储和取值范围。内容涵盖变量的声明、赋值以及类型转换，特别强调了整数和浮点型数据的精度问题。此外，还讲解了运算符的种类，如算术、关系、逻辑和赋值运算符，以及字符串连接运算符。最后，简述了选择结构的if语句和switch语句的使用方法，以及for循环的基本语法和执行流程。
摘要由CSDN通过智能技术生成

第二章 Java语言基础

2.1 标识符

  • 什么是标识符？

    在java源程序当中凡是程序员有权利自己命名的单词都是标识符

    类名、方法名、变量名、接口名、常量名…

  • 标识符的命名规则？

    一个合法的标识符只能由数字、字母、下划线、美元符号组成，不能含有其他符号

    • 不能以数字开头

    • 严格区大小写

    • 关键字不能做标识符

    • 理论上无长度限制，最好不要太长

  • 标识符的命名规范？

    • 标识符的起名最好见名知意
    • 遵守驼峰命名方式：UserService、SystemService
    • 类名、接口名：首字母大写，后面每个单词首字母大写
    • 变量名、方法名：首字母小写，后面每个单词首字母大写
    • 常量名：全部大写

2.2 关键字

  • 1）48个关键字：

    abstract、assert、boolean、break、byte、case、catch、char、class、continue、default、do、double、else、enum、extends、final、finally、float、for、if、implements、import、int、interface、instanceof、long、native、new、package、private、protected、public、return、short、static、strictfp、super、switch、synchronized、this、throw、throws、transient、try、void、volatile、while

  • 2）2个保留字（现在没用以后可能用到作为关键字）：

    goto const

  • 3）3个特殊直接量：true false null

Java中的关键字有哪些？「Java中53个关键字的意义及使用方法」

2.3 字面值

image-20220331184504624

2.4 变量

2.4.1什么是变量？
  • 变量本质上是内存中的一块空间，这块空间“有数据类型”，“有名字”，“有字面值”。
  • 变量包含三个部分：数据类型、名称、字面值[数据]
  • 变量是内存中存储数据的最基本的单元
2.4.2 数据类型的作用
  • 不同的数据类型有不同的类型，不同的数据类型底层会分配不同大小的空间
  • 数据类型指导程序在运行阶段应该分配多大的空间
2.4.3 变量要求

变量中存储的具体的”数据“必须和变量的”数据类型“一致，当不一致的时候编译报错。

2.4.4 声明/定义变量的语法格式

数据类型 变量名;

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PFeM797r-1658301427362)(C:\Users\李\AppData\Roaming\Typora\typora-user-images\image-20220402164635956.png)]

2.4.5 变量声明之后怎么赋值

语法格式：

​ 变量名 = 字面值 ;

要求：字面值的数据类型必须和变量的数据类型一致。

= 等号是一个运算符，叫做赋值运算符，赋值运算符先运算等号右边的表达式，表达式执行结束之后的结果赋给左边的变量。

声明和赋值可以放到一起完成

int i = 10 ;
2.4.6变量赋值后，可以重新赋值，变量的值可以变化
int i = 10 ;
System.out.println(i); //10
i = 100 ;
System.out.println(i); //100
i = 200 ;
System.out.println(i); //200

有了变量的概念后，内存空间得到了重复的使用

int i = 10 ;
System.out.println(i);
...
....
System.out.println(i);
2.4.7通常访问一个变量包括两种访问形式

  • 第一种：读取变量中保存的具体数据 get/获取

  • 第二种：修改变量中保存的具体数据 set/设置

    i = 20 ;  //set

System.out.println(i) ; //get
2.4.8 变量在一行上可以声明多个
int  a , b , c ;

变量必须先声明，再赋值，才能访问 。只声明，不赋值，会出现编译错误。

2.4.9 在方法体中的java代码，是遵守自上而下的顺序执行的。

java代码逐行执行。在同一个作用域中，变量名不可以同名，但是可以重新赋值。

2.4.10 变量的作用域

什么是作用域？

​ 变量的作用域，其实描述的是变量的有效范围。

​ 在什么范围之内是可以被访问的，只要出了这个范围该变量就无法访问了。

2.4.11 关于变量的分类

根据变量声明的位置来分类：

  • 局部变量

在方法体当中声明的变量叫做局部变量

  • 成员变量

在方法体外[类体内]声明的变量叫做成员变量

2.5 数据类型

2.5.1 数据类型的作用？

程序中有很多数据，每一个数据都有相关的数据类型，不同的数据类型的数据占用空间大小不同。数据类型的作用是指导JVM在运行内存的时候给该数据分配多大的内存空间。

2.5.2 java中的数据类型

基本数据类型

引用数据类型

类、接口、数组…

  • 基本数据类型包括四大类八小种

​ 1、整数型

byte short int long

​ 2、浮点型

float double

​ 3、布尔型

boolean

​ 4、字符型

char

字符串String属于引用类型

2.5.3 八种数据类型占用空间大小
类型描述基本数据类型占用空间大小[字节]取值范围默认值
字节型byte1-128~1270
短整型short2-32768~327680
整型int4-2^31~ 2^31-10
长整型long8-2^63 ~2^63-10
单精度浮点型float43.4e-45~1.4e380.0f
双精度浮点型double84.9e-324~1.8e3080.0d
字符型char20~65535‘\u0000’
布尔型boolean1true/falsefalse

*关于默认值：成员变量没有手动赋值，系统会默认赋值，局部变量则不会。八种数字类型的默认值是一切向0看齐。

2.5.4 取值范围

二进制：数据的一种表现形式，十进制表示满十进一，二进制表示满二进一。

1 Byte = 8 bit [一个字节 = 8个比特位，一个比特位表示一个二进制位：0/1]

1 KB = 1024 Byte

1 MB = 1024 KB

1 GB = 1024 MB

1 TB = 1024 GB

例子：整数型当中的byte类型占用一个字节，即byte类型的数据占用8个比特位。那么byte类型的取值范围是什么？

关于java中的数据类型，数字都是有正负之分的，所以在数字的二进制当中有一个二进制位叫做”符号位“，这个符号位在所有二进制位的最左边，0表示正数，1表示负数。如果是浮点数，除符号位还有阶符。

image-20220404171451575 image-20220404171536458 image-20220404171619141 
byte：8位，最大存储数据量是255，存放的数据范围是-128~127之间。

short：16位，最大数据存储量是65536，数据范围是-32768~32767之间。

int：32位，最大数据存储容量是2的32次方减1，数据范围是负的2的31次方到正的2的31次方减1。

long：64位，最大数据存储容量是2的64次方减1，数据范围为负的2的63次方到正的2的63次方减1。

float：32位，数据范围在3.4e-45~1.4e38，直接赋值时必须在数字后加上f或F。

double：64位，数据范围在4.9e-324~1.8e308，赋值时可以加d或D也可以不加。

boolean：只有true和false两个取值。

char：16位，存储Unicode码，用单引号赋值。

具体的数值怎么在计算机中存储，详见计算机组成原理中原码、反码、补码概念。

2.5.5 字符编码

为什么要使用字符编码？

为了让计算机可以表示现实世界中的文字，需要制定文字和二进制之间的对照关系。这种对照转换关系被称为字符编码。

计算机最初只支持英文，最先出现的字符编码是ASCII码[采用一个字节编码]

‘a’ —>97 [01100001]

‘A’—>65

‘0’—>48

‘a’ --(按照ASCII解码)–>01100001

01100001–(按照ASCII编码)–>‘a’

编码和解码的时候采用同一套字典/对照表时，不会出现乱码。

当编码和解码的时候采用的不是同一套字典/对照表时，就会出现乱码问题。

*随着计算机的发展，后来出现了一种编码方式，是国际化标准组织ISO制定的，这种编码方式支持西欧语言，向上兼容ASCII码，但仍不支持中文。这种编码方式是：ISO-8859-1，又被称为 latin-1。随着计算机发展，支持中文的编码方式有：GB2312 < GBK < GB18030 ，其中GB18030可以表示的汉字最多，GB2312最少。

*支持繁体中文：大五码 < big5 >

*后来出现了一种编码方式，同一了全球的文字，容量较大，这种编码方式叫做：Unicode编码，Unicode编码方式有很多具体的实现：

UTF-8 UTF-16 UTF-32

实际开发中一般使用 utf-8 [统一编码方式]。java语言采用的是Unicode编码方式，因此标识符可以用中文。

2.5.6 数据类型详解
1.字符型（char）

例子1

public class HelloWorld {
    
    public static void main(String args[]){
        
        //定义一个char型的变量，起名为c，同时赋值为‘a’
        char c = 'a';
        System.out.println(c);
        //一个中文占用两个字符，char类型正好是2个字节
        //所以java中的char类型可以存储一个中文字符
        char x = '国';
        System.out.println(x);

        //编译错误 ab是字符串，不能用单引号括起来
        //char y = 'ab';

        //"a"是字符串类型，k变量是char类型，类型不兼容，编译错误。
        //char k = "a";

        char e ;
        e ='e';
        System.out.println(e);
        e='f';//再次赋值
        System.out.println(e);

    }
}
image-20220405171301641

  • 转义字符
    反斜杠在java语言中具有转义功能

    转移字符出现在特殊字符前，会将特殊字符转换成普通字符。

    *JDK中自带的native2ascii.exe命令，可以将文字转换成unicode编码形式。

    例子2

    public class HelloWorld {
    public static void main(String args[]){

        char c2 = '\\';//在java中输出一个反斜杠字符\
        System.out.println(c2);

        char c3 = '\'';//反斜杠具有转义功能，将第二个单引号转换成普通的单引号字符
        System.out.println(c3);

        //转移字符出现在特殊字符前，会将特殊字符转换成普通字符
        System.out.println("\"HelloWorld!\"");

        //*JDK中自带的native2ascii.exe命令，可以将文字转换成unicode编码形式。
        char c6 = '\u4e2d';
        System.out.println(c6);

    }
}
2.整数型(byte short int long)

  • java语言中的整数型字面值被默认当做int类型来处理。要让这个“整数型字面值”被当做long类型来处理的话，需要在“整数型字面值”后面添加 l或者L，建议使用大写的L

  • java语言中的整数型字面值有三种表示形式：

    • 第一种：十进制[缺省默认的方式]

    • 第二种：八进制[在编写八进制整数型字面值的时候需要以0开始]

    • 第三种：十六进制[在编写十六进制整数型字面值的时候需要以0x开始]

      public class HelloWorld {
    public static void main(String args[]){

      int a = 10;
      int b = 010;
      int c = 0x10;
      System.out.println(a);//10
      System.out.println(b);//8
      System.out.println(c);//16

    }
}
      image-20220405183033644
3.精度损失

自动类型转换机制

例子1

public class HelloWorld {
    public static void main(String args[]){
        //int类型的字面值456赋值给long类型的变量x，存在类型转换
        //int类型装换成long,小容量转换成大容量,小容量可以自动转换成大容量,称为自动类型转换机制。
        long x = 456 ;
        System.out.println(x);
    }
}
image-20220407163449784

例子2

public class HelloWorld {
    public static void main(String args[]){
        //2147483647字面值是int类型,占用4个字节
        //y是long类型,占用8个字节,自动类型转换
        long y = 2147483647 ;
        System.out.println(y);
    }
}
image-20220407163839710

错误例子3

public class HelloWorld {
    public static void main(String args[]){
        //编译错误：过大的整数：2147483648
        //2147483648被当做int类型4个字节处理，但是这个字面值超出int范围类型
        long z = 2147483648 ;
        System.out.println(z);
    }
}

编译错误：过大的整数：2147483648

image-20220407164427098

改正过后的例子3

public class HelloWorld {
    public static void main(String args[]){
        //解决错误：2147483648一上来就当做long类型处理，在字面值houmian加L
        long z = 2147483648L;
        System.out.println(z);
    }
}
image-20220407165249782

强制类型转换

大容量转换成小容量，需要进行强制类型转换，否则将会编译报错。强制类型转换需要添加“强制类型转换符”，虽然可以编译通过，但是运行阶段可能会损失精度，因此次强制类型转换谨慎使用，因为精度损失可能会很严重。

例子1

强转原理：

原始数据：00000000  00000000  00000000  00000000  00000000  00000000  00000000  01100100

强转之后的数据：                                   00000000  00000000  00000000  01100100

即将左边的二进制砍掉==[所有的数据强转的时候都是这样完成的]==

例子2

原始数据：00000000  00000000  00000000  00000000  10000000  00000000  00000000  00000000

强转之后的数据：                                   10000000  00000000  00000000  00000000

10000000 00000000 00000000 00000000是存储到计算机内部，计算机存储数据都是采用补码的形式存储，所以将补码10000000 00000000 00000000 00000000转变为原码就是最终的结果

public class HelloWorld {
    public static void main(String args[]){

        long k = 2147483648L;
        int e = (int)k;
        System.out.println(e);
    }
}

精度严重损失，结果变为负数：从2147483648变成了-2147483648

image-20220407171744357

另外：当一个整数型字面值没有超过byte、short、char类型的取值范围时，该字面值可以直接赋给byte、short、char类型的变量，这种机制sun允许了，目的是方便程序员的编程

计算机二进制有三种表示类型：原码 反码 补码

计算机在任何情况下底层表示和存储数据的时候采用了补码形式。

整数的补码：和原码相同

负数的补码：负数的绝对值对应的二进制码所有二进制位取反，再加1

image-20220405195221971

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rjUvwBY7-1658301427365)(C:\Users\李\AppData\Roaming\Typora\typora-user-images\image-20220405195455908.png)]image-20220405195805022

4.浮点型数据（float double）

float 单精度（4个字节）

double 双精度（8个字节，精度较高）

注意 : float和double在计算机内部二进制存储时存储的都是近似值。例如1/3

*double的精度太低，不适合做财务软件。财务涉及到钱的问题，要求精度较高，所以sun公司在基础SE类库当中为程序员准备了精度更高的类型，只不过这种类型是一种引用数据类型，不属于基本的数据类型，它是：java.math.BigDecimal

*其实java程序中sun提供了一套庞大的类库，java程序员是基于这套基础的类库来进行开发的。所以要知道java的SE类库的字节码在哪里。

-SE类库字节码：D:\apps\JDK\jre\lib\rt.jar

-SE类库源码：D:\apps\JDK\src.zip

例如：String.java和String.class

我们的（String[] args）中的String使用的就是String.class字节码文件

*在java语言中，所有的浮点型字面值都会被当做double类型来处理，要想该字面值被当做float类型来处理，需要在字面值后面加上 f/F

或者进行强制类型转换：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Fwhi7A32-1658301427366)(C:\Users\李\AppData\Roaming\Typora\typora-user-images\image-20220408102507523.png)]

5.布尔型（boolean）

在Java语言中boolean类型只有两个值：true、false，没有其他值。不像C语言当中，0和1可以表示假和真。

在底层存储的时候boolean类型占用1个字节，因为实际存储的时候false的底层是0，true的底层是1。

布尔类型在实际开发中经常使用在底层逻辑运算和条件控制语句中。

2.5.7 关于基本数据类型之间的相互转换

1.八种基本数据类型当中除了布尔类型之外剩下的7种数据类型之间都可以相互转换。

2.小容量向大容量转换，称为自动类型转换，容量从小到大排序：

byte<short/char<int<long<float<double

注：任何浮点类型不管占用多少个字节，都比整数型容量要大。

char和short可表示的种类数量相同，但是char可以取更大的正整数。

3.大容量转换成小容量，叫做强制类型转换，需要加强制类型转换符，程序才能编译通过，但是在运行阶段可能会损失精度，所以谨慎使用。

4.当整数字面值没有超过byte，short，char的取值范围，可以直接赋值给byte，short，char类型的变量。

5.byte，short，char做混合运算时，先各自转换成int类型在做运算。

6.多种数据类型混合运算，先转换成容量最大的那种类型再进行运算。

例子

public class DataTypeTest06 {
    public static void main(String[] args) {
        //出现错误，1000 超出了 byte 的范围
        //byte a = 1000;

        //正确，因为 20 没有超出 byte范围，因此可以赋值
        byte a = 20;

        //变量不能重名
        //short a = 1000;

        //正确，因为数值 1000 没有超出 short 类型的范围，所以赋值正确
        short b = 1000;

        //正确，因为默认就是 int，并且没有超出 int 范围
        int c = 1000;

        //正确，可以自动转换
        long d = c;

        //错误，出现精度丢失问题，大类型-->>小类型会出现问题
        //int e = d;

        //将 long 强制转换成 int 类型
        //因为值 1000，没有超出 int 范围，所以转换是正确的
        int e = (int)d;

        //因为 java 中的运算会会转成最大类型
        //而 10 和 3 默认为 int,所以运算后的最大类型也是 int
        //所以是正确的,结果为3
        int f = 10/3;
        System.out.println("f: "+f);

        //因为10、3默认为int类型，这里的10/3算出来已经是3了，再赋值给dd，因此结果是3.0
        double dd = 10/3;
        System.out.println("dd: "+dd);

        //因为10.0是double类型，3会自动转换成double再和10.0运算
        double cc = 10.0/3;
        System.out.println("cc: "+cc);

        //声明 10 为 long 类型
        long g = 10;
        //出现错误，多个数值在运算过程中，会转换成容量最大的类型
        //以下示例最大的类型为 double，而 h 为 int，所以就会出现大类型（long）到小类的转换，将会出现精度丢失问题
        //int h = g/3;

        //可以强制转换,因为运算结果没有超出 int 范围
        //int h = (int)g/3;

        //可以采用 long 类型来接收运算结果
        //long h = g/3;
        //出现精度损失问题，以下问题主要是优先级的问题
        //将 g 转换成 int，然后又将 int 类型的 g 转换成 byte,最后 byte 类型的 g 和 3 运算，
        // 它的运算结果类型就是 int，所以 int 赋值给 byte 就出现了精度损失问题
        //byte h = (byte)(int)g/3;

        //正确，优先级的问题，这里是byte赋给byte类型
        //byte h = (byte)(int)(g/3);

        //不能转换,还有因为优先级的问题
        //byte h = (byte)g/3;

        //可以转换，因为运算结果没有超出 byte 范围
        //byte h = (byte)(g/3);

        //可以转换，因为运算结果没有超出 short 范围
        short h = (short)(g/3);

        short i = 10;
        byte j = 5;
        //错误，short 和 byte 运算，首先会转换成 int 再运算
        //所以运算结果为 int，int 赋值给 short 就会出现精度丢失问题
        //short k = i + j;

        //可以将运算结果强制转换成 short
        //short k = (short)(i + j);
        
        //因为运算结果为 int，所以可以采用 int 类型接收
        int k = i + j;
        char l = 'a';
        System.out.println(l);
        //输出结果为 97，也就是 a 的 ascii 值
        System.out.println((byte)l);
        int m = l + 100;

        //输出结构为 197,取得 a 的 ascii 码值，让后与 100 进行相加运算
        System.out.println(m);
    }
}
image-20220408121019955

2.6 运算符

算数运算符、关系运算符、逻辑运算符（布尔运算符）、位运算符、赋值类运算符、字符串连接运算符、条件运算符、三元运算符等

2.6.1 算数运算符
+		//求和
-		//相减
*		//乘积
/		//商
%		//求余数[取模]
++		//自加1
--		//自减1

/*注意：一个表达式当中有多个运算符时，运算符有优先级，不确定的加小括号，优先级得到提升。没有必要专门记忆运算符。*/

例子1 运算符++的使用

public class App {
    public static void main(String[] args)  {
         int k = 10 ;
        //++运算符可以出现在变量后面(单目运算符)
        k++ ;
        System.out.println("k： "+k);

        int y = 10;
        //++运算符可以出现在变量前面[单目运算符]
        ++y;
        System.out.println("y： "+y);
        //++运算符可以出现在变量前面或者后面，作用是使变量加1

        //++出现在变量后，先做赋值运算，在对变量中的值进行自加1
        int a = 100;
        int b = a++;
        System.out.println("a： "+a);//101
        System.out.println("b： "+b);//100

        //++出现在变量前
        int m = 20 ;
        int n = ++m ;
        System.out.println("m： "+m);//21
        System.out.println("n： "+n);//21
        
        //出现在变量后
        int x=99;
        System.out.println("x： "+x++);//99

        //前
        int s=99;
        System.out.println("s： "+ ++s);//100
        
        int p = 100;
        System.out.println("++p： "+ ++p);//101
        System.out.println("p： "+p);//101
    }
}
image-20220408192142117
2.6.2 关系运算符
	
	>		大于
    >=		大于等于
    <		小于
    <=		小于等于
    ==		等于
    !=		不等于
    
    =	是赋值运算符
    ==  是关系运算符
    
关系运算符的结果一定是布尔类型：true / false

例子1

package test;
public class App {
    public static void main(String[] args)  {
        int a=10;
        int b=10;

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

}

关系运算符的运算原理：

int a=10；

int b=10；

a>b 比较的时候，比较的是a中保存的10这个值和b中保存的10的这个值之间的大小比较。a>=b、a==b等亦是如此。

2.6.3 逻辑运算符（布尔运算符）
    &		//逻辑与（bingqie）
    |		//逻辑或（或者）
    !		//逻辑非（取反）
    ^		//逻辑异或(两边的算子只要不一样，结果就是true)
        
    &&		//短路与
    ||		//短路或

  1. 逻辑运算符要求两边的算子都是布尔类型，并且逻辑运算符最终的运算结果也是一个布尔类型。

  2. 短路与和逻辑与最终运算结果是相同的，只不过短路与存在短路现象。

  3. 短路或和逻辑或最终运算结果是相同的，只不过短路或存在短路现象。

    image-20220408200332132

逻辑与和短路与的区别

image-20220408200725480

从某个角度来看，短路与更加智能，由于后面的表达式可能不执行，效率会更高。这种方式在实际的开发中使用较多。因此短路与更加常用。

但是，在某些特殊的业务逻辑当中，要求运算符两边的式子必须全部执行，此时必须使用逻辑与。

什么情况下会发生短路或？

第一个表达式的执行结果为true，会发生短路或

什么情况下会发生短路与？

第一个表达式的执行结果为false，会发生短路与

2.6.4 赋值运算符

基本的赋值运算符 =

扩展的赋值运算符 += 、-=、*=、/=、%=

1.赋值类的运算符优先级：先执行等号右边的表达式，将执行结果赋值给左边的变量。

int i=10;
//扩展的赋值运算符[+=运算符可以翻译为“追加/累加”]
i+=5;
System.out.println(i);//15

***********
int i=10;
i-=5;
System.out.println(i);//5

注意：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8kNHaFRD-1658301427368)(C:\Users\李\AppData\Roaming\Typora\typora-user-images\image-20220409105406092.png)]

但是：

byte x=10;
x+=5;//等同于：x=(byte)(x+5),并不等同于X=X+5
System.out.println(x);

2.注意以下代码：

byte i=0;
i+=128;//等同于：i=(byte)i+128;
//注意：这里的i可以编译运行，只不过会损失精度，结果为-128

int k=10;
k+=5;//等同于：k=(int)k+5;

long x=10L;
int y=20;
y+=x;//等同于y=(int)(y+x);

重要结论：扩展类的赋值运算符不改变运算结果类型，假设最初这个变量的类型是byte类型，无论怎么进行追加或者追减，最终该变量的数据类型还是byte类型。

2.6.5 字符串连接运算符

+运算符在java语言中有两个作用：1.加法运算，求和 2.字符串的连接运算

  • 当“+”运算符两边的数据都是数字的话，一定是进行加法运算。

​ 当“+”运算符两边的数据只要有一个数据是字符串，一定会进行字符串连接运算。并且连接运算之后的结果还 是一个字符串类型。

​ 数字+数字—>数字[求和]

​ 数字+“字符串”—>“字符串”[字符串]

  • 在一个表达式当中可以出现多个“+”，在没有添加小括号的前提下，遵循自左向右的顺序依次运算。

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gVm5BmsD-1658301427369)(C:\Users\李\AppData\Roaming\Typora\typora-user-images\image-20220409112330117.png)]

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TM6cZxch-1658301427369)(C:\Users\李\AppData\Roaming\Typora\typora-user-images\image-20220409112647848.png)]

    注意加号运算符什么时候是做字符串连接，什么时候是做求和

2.6.6 三元运算符（三目运算符/条件运算符）

语法规则：

​ 布尔表达式 ? 表达式1 : 表达式2

当布尔表达式的结果为true时，选择表达式1作为整个表达式的执行结果当布尔表达式的结果为false时，选择表达式2作为整个表达式的执行结果

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RSdt4DkK-1658301427370)(C:\Users\李\AppData\Roaming\Typora\typora-user-images\image-20220409113710477.png)][外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eQh5mckM-1658301427371)(C:\Users\李\AppData\Roaming\Typora\typora-user-images\image-20220409113841452.png)]

2.7 控制语句

选择结构

if     if..else    switch

循环结构

for     while     do...while

控制循环结构

break    continue
2.7.1 选择结构-if 语句

if语句属于选择结构，if语句又被称为分支语句/条件控制语句：

四种编写方式：

if(布尔表达式){
    ...java语句;
    ...java语句;
}

if(布尔表达式){
    ...java语句;
    ...java语句;
}else{
    ...java语句;
    ...java语句;
}

if(布尔表达式){
    ...java语句;
    ...java语句;
}else if(布尔表达式){
    ...java语句;
    ...java语句;
}else if(布尔表达式){
    ...java语句;
    ...java语句;
}...

if(布尔表达式){
    ...java语句;
    ...java语句;
}else if(布尔表达式){
    ...java语句;
    ...java语句;
}else if(布尔表达式){
    ...java语句;
    ...java语句;
}else{
    ...java语句;
    ...java语句;
}
  • 对于if语句而言，只要有一个分支执行，整个if语句全部结束。
  • 带有else分支的编写方式可以保证100%会有分支执行。
  • 所有的控制语句都可以嵌套使用，注意代码格式，该缩进的缩进。
  • if语句分支中只有一条java语句时，大括号可以省略不写。

例子1

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xCoEQxky-1658301427372)(C:\Users\李\AppData\Roaming\Typora\typora-user-images\image-20220409122158326.png)]

image-20220409122253461

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fzqNHAtw-1658301427373)(C:\Users\李\AppData\Roaming\Typora\typora-user-images\image-20220409122321146.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PxNB5nSc-1658301427374)(C:\Users\李\AppData\Roaming\Typora\typora-user-images\image-20220409161924761.png)]

例子2

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-J2OqqeS0-1658301427375)(C:\Users\李\AppData\Roaming\Typora\typora-user-images\image-20220409160950646.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-E0kWeCM3-1658301427376)(C:\Users\李\AppData\Roaming\Typora\typora-user-images\image-20220409161346645.png)]

例子3 if 的嵌套

image-20220409164220696

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zNYJzBhw-1658301427376)(C:\Users\李\AppData\Roaming\Typora\typora-user-images\image-20220409164608755.png)]

image-20220409165319148 image-20220409165524068
2.7.2 接受用户键盘输入

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ejflyW8F-1658301427377)(C:\Users\李\AppData\Roaming\Typora\typora-user-images\image-20220409160235561.png)]

第一步：
	java.util.Scanner s= new java.util.Scanner(System.in);
第二步：
    String str = s.next();
或者 
    int num = s.nextInt();
2.7.3 选择结构-switch语句

关于switch：

  • 1.switch语句也属于选择结构，也是分支语句

  • 2.switch语句的语法结构：一个比较完整的switch语句应该这样写：

    switch (int或String类型的字面值或者变量){
        case int或者String 类型的字面值或者变量：
            java 语句; 
            ...
            break;
        case int或者String类型的字面值或者变量：
            java 语句; 
            ...
            break;
        case int或者String类型的字面值或者变量 ：
            java 语句; 
            ...
            break;
        ...
        default:
             java语句;
             ...        
}

  • 3.switch语句执行原理：

    switch后面的小括号当中的数据和case后面的数据进行一一匹配，匹配成功的分支执行。怎么匹配？按照自上而下的顺序依次匹配。

  • 4.匹配成功的分支执行，分支当中最后有"break；"语句的话，整个switch语句终止。

  • 5.匹配成功的分支执行，分支当中没有"break;"语句的话，直接进入下一个分支执行（不进行匹配），这种现象称为case穿透现象。[提供break语句可以避免穿透]

  • 6.所有的分支都没有匹配成功的话，当有default语句的话就会执行default分支当中的程序。

  • 7.switch或者case后面只能是int或者string类型的数据，不能是其他类型

    *当然byte、short、char也可以直接写到switch和case后面，因为它们可以进行自动类型转换，byte、short、char可以自动转换成int类型

    *JDK6中switch和case只能探测int类型，JDK7及之后的jdk版本，引入新特性，switch关键字后面可以探测int类型和string类型的数据。

  • 8.case可以合并：

    int i = 10 ;
switch(i){
    case 1: case 2: case 3: case 10:
        System.out.println("Test Code!");
}
/*在这里i的值为1、2、3、10都会执行System.out.println("Test Code!");语句*/

    例子1:

public class App {
    public static void main(String[] args) throws Exception {
        /*较完整的switch语句*/
        //接收用户的输入：
        //1 表示星期一
        //2 表示星期二
        //3 表示星期三
        //...
        //7 表示星期日
        java.util.Scanner s = new java.util.Scanner(System.in);
        System.out.println("请输入数字：");
        int num = s.nextInt();
        switch(num){
            case 1:
                System.out.println("星期一");
                break;
            case 2:
                System.out.println("星期二");
                break;
            case 3:
                System.out.println("星期三");
                break;
            case 4:
                System.out.println("星期四");
                break;
            case 5:
                System.out.println("星期五");
                break;
            case 6:
                System.out.println("星期六");
                break;
            case 7:
                System.out.println("星期日");
                break;
        }
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xDYvTXU5-1658301427378)(C:\Users\李\AppData\Roaming\Typora\typora-user-images\image-20220510142103258.png)]

例子2：case穿透

public class App {
    public static void main(String[] args) throws Exception {
        java.util.Scanner s = new java.util.Scanner(System.in);
        System.out.println("请输入数字：");
        int num = s.nextInt();
        switch(num){
            case 1:
                System.out.println("星期一");
            case 2:
                System.out.println("星期二");
            case 3:
                System.out.println("星期三");
            case 4:
                System.out.println("星期四");
            case 5:
                System.out.println("星期五");
            case 6:
                System.out.println("星期六");
            case 7:
                System.out.println("星期日");
        }
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pMS8fQGY-1658301427379)(C:\Users\李\AppData\Roaming\Typora\typora-user-images\image-20220510142255548.png)]

例子3：case合并

public class App {
    public static void main(String[] args) throws Exception {
        java.util.Scanner s = new java.util.Scanner(System.in);
        System.out.println("请输入数字：");
        int num = s.nextInt();
        switch(num){
            case 1:case 0:
                System.out.println("星期一");
                break;
            case 2:
                System.out.println("星期二");
                break;
            case 3:
                System.out.println("星期三");
                break;
            case 4:
                System.out.println("星期四");
                break;
            case 5:
                System.out.println("星期五");
                break;
            case 6:
                System.out.println("星期六");
                break;
            case 7:
                System.out.println("星期日");
                break;
        }
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mdQl7szi-1658301427380)(C:\Users\李\AppData\Roaming\Typora\typora-user-images\image-20220510142537518.png)]

例子4：String类型

public class App {
    public static void main(String[] args) throws Exception {
        java.util.Scanner s = new java.util.Scanner(System.in);
        System.out.println("请输入星期几：");
        String num = s.next();
        switch(num){
            case "星期一":
                System.out.println(1);
                break;
            case"星期二":
                System.out.println(2);
                break;
            case"星期三":
                System.out.println(3);
                break;
            case"星期四":
                System.out.println(4);
                break;
            case "星期五":
                System.out.println(5);
                break;
            case "星期六":
                System.out.println(6);
                break;
            case "星期日":
                System.out.println(7);
                break;
        }
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-55kGwMB9-1658301427380)(C:\Users\李\AppData\Roaming\Typora\typora-user-images\image-20220510143359399.png)]

例子5：short、byte、char转换成int

public class App {
    public static void main(String[] args) throws Exception {
        char c = 66 ;
        switch(c){
            case 'A':
            System.out.println("高级");break;
            case 'B':
            System.out.println("中级");break;
            case 'C':
            System.out.println("初级");break;
           default:
           System.out.println("出错了！");
        }
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-N7DApmtN-1658301427381)(C:\Users\李\AppData\Roaming\Typora\typora-user-images\image-20220510144104879.png)]

练习1：实现计算机当中的加减乘除

实现思路：

1.选择所有数据从键盘输入

2.使用switch语句进行判断

3.需要从控制台输入三次：* 第一个数字 * 运算符 * 第二个数字

最终在控制台上是这样一个场景：

​ 欢迎使用简单计算器系统：

​ 请输入第一个数字：10

​ 请输入运算符：+

​ 请输入第二个数字：20

​ 运算结果：10+20=30

public class App {
    public static void main(String[] args) throws Exception {
        java.util.Scanner s=new java.util.Scanner(System.in);
        System.out.println("欢迎使用简单计算器系统:");
        System.out.println("请输入第一个数字:");
        int num1 = s.nextInt();

        System.out.println("请输入运算符:");
        String operateor = s.next();

        System.out.println("请输入第二个数字:");
        int num2 = s.nextInt();

        int result = 0;
        switch(operateor){
            case "+":
            result = num1 + num2; break;
            case "-":
            result = num1 - num2; ;break;
            case "*":
            result = num1 * num2; ;break;
            case "/":
            result = num1 / num2;break;
            case "%":
            result = num1 % num2; break;
           default:
           System.out.println("出错了！");
        }
        System.out.println("运算结果为:" + num1 + operateor 
        + num2 + "="+ result);
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fLB2lQlM-1658301427382)(C:\Users\李\AppData\Roaming\Typora\typora-user-images\image-20220510150104190.png)]

练习2：判断考生成绩

要求：假设系统给定考生成绩，请判断该考生的成绩等级

​ 1.有效成绩范围[0~100]

​ 2.考试成绩可能带有小数

​ 3.考试成绩和等级之间的对照关系：

​ [90-100] A

​ [80-90) B

​ [70-80) C

​ [60-70) D

​ [0-60) E

​ 4.限定只能只用switch语句，不能用if

思路:先将 成绩/10 转换成 0-10 的整数，再判断

public class App {
    public static void main(String[] args) throws Exception {
        java.util.Scanner s=new java.util.Scanner(System.in);
        System.out.println("欢迎使用成绩转换系统:");
        System.out.println("请输入成绩:");
        int score = s.nextInt();
        //转换成int
        int grade = (int)(score/10);

        switch(grade){
            case 9:case 10:
                System.out.println("A") ; break;
            case 8:
                 System.out.println("B") ; break;
            case 7:
                System.out.println("C") ; break;
            case 6:
                 System.out.println("D") ; break;
            default:
                System.out.println("E");
        }
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DqUMVad3-1658301427382)(C:\Users\李\AppData\Roaming\Typora\typora-user-images\image-20220510152058918.png)]

2.7.4 for语句

  • 1.循环结构：在程序中总有一些需要反复/重复执行的代码，假设没有循环结构，那么这段需要重复执行的代码自然是需要重复编写的。代码无法得到重复使用。所以多数语言是支持循环结构的

  • 2.基本上所有的编程语言纸抽的循环结构包括三种：

    • for 循环
    • while循环
    • do…while循环

  • 3.当前示例主要讲解for循环。for循环的语法结构：

    for(初始化表达式;布尔表达式;更新表达式){
    //需要重复执行的代码片段（循环体：由java语句构成）
}

  • 4.for循环的执行过程/执行原理？

    • 初始化表达式、布尔表达式、更新表达式都不是必须的（但是两个分号是必须的）

    • 初始化表达式最先执行，并且在整个for循环中只执行一次

    • 布尔表达式必须是true或者false，不能是其他值

    • for的执行过程：

      1、先执行初始换表达式，并且该表达式只执行一次

      2、判断布尔表达式的结果是true还是false

      • 布尔表达式为true

        *执行循环体

        *执行更新表达式

        *判断布尔表达式的结果是true还是false

        ​ ** 布尔表达式为true

        ​ **执行循环体

        ​ **执行更新表达式

        ​ **判断布尔表达式的结果是true还是false

        ​ …

      • 布尔表达式为false

        *循环结束

例子1：循环输出1-10

public class App {
    public static void main(String[] args) throws Exception {
      for(int i = 1;i<=10;i++)
      {System.out.print(i+" ");}
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-g3XHEOGo-1658301427391)(C:\Users\李\AppData\Roaming\Typora\typora-user-images\image-20220510161516062.png)]

例子2：for循环中的作用域

public class App {
    public static void main(String[] args) throws Exception {
      //for循环中定义一个i，这个i的作用域在for循环中
        for(int i = 1;i<=10;i++)
      {System.out.print(i+" ");}
      System.out.println();
      for(int i = 0;i<10;i++){
          System.out.print(i+" ");
      }
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EABWsvHD-1658301427392)(C:\Users\李\AppData\Roaming\Typora\typora-user-images\image-20220510162011550.png)]

例子3：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-B82wwDhD-1658301427392)(C:\Users\李\AppData\Roaming\Typora\typora-user-images\image-20220510162725419.png)]

例子4：循环语句和条件判断语句嵌套使用[for和if的嵌套]

public class App {
    public static void main(String[] args) throws Exception {
      //找出1-100所有的奇数
      //第一种方案：从1开始，每次递增2
      for(int i=1;i<=100;i=i+2)
      {System.out.print(i+" ");}
      //第二种方案，从1开始，以1递增，每一个数据都进行判断，判断标准是该数字对2求余是否为0
      System.out.println();
      for(int i=1;i<=100;i++){
          if(i%2!=0)
          System.out.print(i+" ");
        }
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rXJ9bxy2-1658301427393)(C:\Users\李\AppData\Roaming\Typora\typora-user-images\image-20220510163806720.png)]

例子5：在前一个程序上计算1-100所有奇数之和

public class App {
    public static void main(String[] args) throws Exception {
        int sum=0;
      for(int i=1;i<=100;i=i+2)
         { sum=i+sum;}
    System.out.print(sum);
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7JMuBLf9-1658301427394)(C:\Users\李\AppData\Roaming\Typora\typora-user-images\image-20220510170148780.png)]

例子6：for循环中嵌套for循环

public class App {
    public static void main(String[] args) throws Exception {
      for(int i=1;i<=10;i++)
            for(int j=1;j<=10;j++)
                System.out.print(j+" ");        
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-am5riU6U-1658301427394)(C:\Users\李\AppData\Roaming\Typora\typora-user-images\image-20220510171435366.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-F6JiLWBU-1658301427395)(C:\Users\李\AppData\Roaming\Typora\typora-user-images\image-20220510171835952.png)]

一刀一个小西瓜
关注
专栏目录
java数据类型之浮点型
weixin_38708438的博客
04-17 504
关于浮点型数据类型： float 单精度【4个字节】 double 双精度【8个字节，精度较高】 double的精度太低【相对来说】，不适合做财务软件 财务涉及到钱的问题，要求精度较高，所以SUN在基础SE类库当中为程序员准备了精确度更高的类型，只不过这种类型是一种引用数据类型，不属于基本数据类型，它是：java.math.BigDecimal 其实jav程序中SUN提供了一套庞大的类库，java程序员是基于这套基础的类库来进行开发的，所以要知道java的SE类库的字节码在哪儿，要知道java的S
java基础--第二章数据类型
weixin_39291458的博客
07-10 476
java基础的数据类型部分：标识符、关键字、常量、变量、变量数据类型，数字类型转换以及fanal和Scanner的用法
Java17-20新特性
最新发布
杀神lwz的博客
11-02 941
Java17是一个LTS(long term support)长期支持的版本，根据计划来看会支持到2029年(java8会支持到2030年)，同时Oracle提议下一个LTS版本是java21，在2023年9月发布，这样将LTS版本的发布周期由之前的3年变为了2年。Java版本支持时间。
jdk设置编码格式utf-8
AdleyTales的技术博客
10-03 2432
经查，是因为在windows中安装的jdk默认编码格式是GBK，需要修改为utf-8.在系统中添加系统变量 设置环境变量 变量名：JAVA_TOOL_OPTIONS 变量值：-Dfile.encoding=UTF-8
JDK20正式发布了GA版本，短期维护支持，以及JDK21预览
mxt51220的博客
03-23 887
最近，Oracle发布了JDK20，相比对于Java开发者来说，JDK的发版是比较收关注的事情了，小简也来和大家一起了解了解JDK20发生了什么变化呢？JDK20LTSJDK21目前JDK21也是推出了早期预览版本。JDK 20提供了来自OpenJDK项目Amber的语言改进（Switch的记录模式和模式匹配），OpenJDK巴拿马项目的增强功能，以互连Java虚拟机（JVM）和本机代码（外部函数和内存API和矢量API），以及与相关的功能（作用域值、虚拟线程和结构化并发），。Oracle。
JAVA se 常用类库（一）笔记
qq_44899249的博客
04-23 228
@菜 ** JAVASE常用类库** （一）Date类 DateFormat对象的创建： DateFormat df=DateFormat.getDateInstance();//DateFormat 为静态类 Date date=df.parse(String str) //字符串转换到Date 数据类型 SimpleDateFormat对象的...
javaSE--第二章（java300集）
12-16
Java SE，全称为Java Standard ...本章内容涵盖了Java编程的基石，理解并掌握这些知识点是进一步学习Java面向对象编程、类和对象等高级主题的前提。通过不断练习和应用，初学者可以逐步建立起扎实的Java编程基础。
北京圣思园张龙老师JavaSE 01-11章的课堂笔记 pdf文件
03-16
10. **Java SE 第十一讲（面向对象之封装） 续二**： - 继续探讨封装主题，可能涉及接口（interface）、枚举（enum）以及访问者模式等设计模式。 以上是根据提供的文件名推测出的JavaSE课程的主要内容。通过这些...
JavaSE基础 第十二章 继承
日天家的猫
08-05 231
第十二章 继承 目录第十二章 继承1.继承的作用2.继承的相关特性3.继承需要满足的条件4.JDK源代码 1.继承的作用 基本作用：子类继承父类，代码得到了复用 重要作用：有了继承关系，才有了后期的方法覆盖和多态机制 2.继承的相关特性 B类继承A类，则称A类为超类（superclass）、父类、基类 B类则成为子类（subclass）、派生类、扩展类 java只支持单继承 java有时候会产生简介继承的效果（class C extends B, class B extends A） 子类可以继承父类
JavaSE第二章基础知识
m0_57099942的博客
07-10 207
JavaSE学习
Java字节码操作开源框架简介
weixin_33994444的博客
07-15 437
avassist Javassist是一个开源的分析、编辑和创建Java字节码的类库。是由东京技术学院的数学和计算机科学系的 Shigeru Chiba 所创建的。它已加入了开放源代码JBoss 应用服务器项目,通过使用Javassist对字节码操作为JBoss实现动态AOP框架。 BCEL Byte Code Engineering Library (BCEL)，这是Apach...
java se的基础类库_JavaSE基础
weixin_42360953的博客
03-06 248
1，Java虚拟机以及jdk和jre的介绍为什么JAVA可以跨平台？和C++ 相比，很重要的一点就是：C++ 编译生成的是纯二进制的机器指令，而JAVA编译生成的是非纯二进制的字节码。而这种基于Unicode的字节码是不依赖于特定的计算机硬件架构而存在的——这就意味着只要有JVM环境，你的字节码就可以在任何平台上运行。其次，JAVA字节码的二进制数据以固定的格式进行存储和传输，消除了字节顺序的干扰...
java数据类型（6）浮点型
m0_59949484的博客
09-02 191
/* 关于浮点型数据类型： float 单精度【4个字节】 double双精度【8个字节，精度较高】 double的精度太低【相对来说的】，不适合做财务软件。 财务涉及到钱的问题，要求精度较高，所以SUN在基础SE类库当中 为程序员准备了精确度更高的类型，只不过这种类型是一种引用 数据类型，不属于基本数据类型，它是：java.math.BigDecimal 其实java程序中SUN提供了一套庞大的类库...
java字节码文件学习
wuraox的博客
08-10 1254
字节码文件结构篇 java虚拟机规范——字节码文件官网：https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.1 源代码经编译后会生成字节码文件，字节码文件是一种二进制的类型文件，它的内容是jvm指令。 字节码指令：java虚拟机的指令又一个字节长度的、代表某种特定操作含义的操作码（opcode）以及跟随其后的零至多个代表此操作所需参数的操作数构成。 字节码文件整体结构： ClassFile { u4
浮点型、布尔型数据类型以及关于基本数据类型之间的相互转换规则
weixin_48826996的博客
05-05 927
public class DataTypeTest05 { public static void main(String[] args){ //100L是long类型字面值 x是long类型变量 //不存在类型转换，直接赋值 long x = 100L; //x变量是long类型，8字节 //y变量是int类型，4字节所以编译报错 //大容量不能直接赋值给小容量 int y = x; .
java语言中，一个汉字是几个字符？
xuexuexuexuexuex的博客
08-24 3420
java语言中，一个汉字是几个字符？
教妹学Java(十)：Unicode字符集简介
沉默王二
02-22 4762
大家好，我是沉默王二，一个和黄家驹一样身高，和刘德华一样颜值的程序员。本篇文章通过我和三妹对话的形式来谈一谈“Unicode字符集简介”。 教妹学 Java，没见过这么有趣的标题吧？“语不惊人死不休”，没错，本篇文章的标题就是这么酷炫，接受不了的同学就别点进来看了，所谓好奇心害死猫；能够接受的同学我只能说你赚到了，你不仅能在阅读的过程中感受到思维的乐趣，还真的能学习到知识。下面就由我来介绍一下故事...
知识单元二 Java编程基础
qq_64314976的博客
07-14 1142
1. 下面哪一个不是Java的关键字（ ） [单选题] *classmain(正确答案)intif2. 下面哪一个是合法的标识符（ ） [单选题] *program(正确答案)123abcA+Bbyte3. 下面哪一种数据类型能存储值1.75，请选择（ ） [单选题] *intBooleancharfloat(正确答案)4. 下面哪一个是合法的char类型的常量，请选择（ ） [单选题] *A'A'(正确答案)"A"'ab'5. 下列变量的定义中，错误的是(　　) [单选题] *int x=3;float
java查类_Java类查找 - 阿sing的博客 - OSCHINA - 中文开源技术交流社区
weixin_29843603的博客
02-12 848
How the Java Launcher Finds Classes * How the Java Launcher Finds Bootstrap Classes * How the Java Launcher Finds Extension Classes * How the Java Launcher Finds User Classes * How the Java Launcher F...
"JavaSE第二章学习笔记：注释、标识符、变量、常量、运算符和类型转换
总的来说，第二章的内容涵盖了JavaSE中非常基础和重要的知识点，对于初学者来说是非常有帮助的。通过本文的学习，初学者可以对JavaSE有一个全面的了解，并且能够自己动手编写一些简单的程序。希望本文的内容能够对...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值