首页 > 编程语言 >JAVA基础笔记1（变量与运算符+基本数据类型）

JAVA基础笔记1（变量与运算符+基本数据类型）

时间：2024-10-15 19:18:59浏览次数：10  
标签：JAVA int print 数据类型 System 运算符 类型 println out

目录

一.开发工具

1.快捷键常用

二.HelloWorld

案例：输出：心形

三：变量与运算符

3.1 关键字

3.2 标识符( identifier)

3.3变量

3.30变量的概念：

3.31 变量类型

3.32 引用数据类型：

    类：class    数组：array    接口：interface    枚举：enum    注解：annotation    记录：record

3.34 使用变量注意

3.4 变量的使用

3.4.1 步骤1：变量的声明

3.4.2 步骤2：变量的赋值

四. 基本数据类型

4.1 整数类型：byte、short、int、long

 

4.2 浮点类型：float、double

4.2.1 应用举例

案例1：定义圆周率并赋值为3.14，现有3个圆的半径分别为1.2、2.5、6，求它们的面积。

案例2：小明要到美国旅游，可是那里的温度是以华氏度为单位记录的。 它需要一个程序将华氏温度（80度）转换为摄氏度，并以华氏度和摄氏度为单位分别显示该温度。

4.3 字符类型：char

4.4 布尔类型：boolean

4.3,4.4,4.5 总结

 

五.自动类型提升与强制类型转换

5.1 自动类型提升

5.2 强制类型转换

5.3为什么标识符的声明规则里要求不能数字开头？

 

一.开发工具

5a30ca7618ce4577bcaafe73adce3e08.png

1.快捷键常用

快捷键
 * main/psvm，sout，快速插入相关代码
 * *CTRL+D：复制当行代码到下一行
 * *CTRL+Y:删除当行
 * *CTRL+alt+L：格式化

1.1 main/psvm，sout，快速插入相关代码；

如下：

main/psvm：        public static void main(String[] args) {

sout：                  System.out.println（）

1.2CTRL+D：复制当行代码到下一行
1.3CTRL+Y:删除当行
1.4CTRL+alt+L：格式化

2.下载链接

其他版本 - IntelliJ IDEA

 

二.HelloWorld

注意：public一个java类中只能有一个

public class foundation {                         //public一个java类中只能有一个
    public static void main(String[] args) {
        System.out.println("Hello World!!!!!!!"); //println中ln(\n)表示换行
    }
}

案例：输出：心形

结合\n(换行)，\t(制表符)，空格等在控制台打印出如下图所示的效果。

1a2b7540d7f24228ac24d14b9e1e67f2.png

方式一：

class Exercise2{
	public static void main(String[] args){
		System.out.print("\t");
		System.out.print("*");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		
		System.out.println("*");

		
		System.out.print("*");
		System.out.print("\t");
		//System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("I love java");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.println("*");

		
		System.out.print("\t");
		System.out.print("*");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		
		System.out.println("*");
        System.out.print("\t");
		System.out.print("\t");
		System.out.print("*");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		
		System.out.println("*");

		
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("*");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		
		System.out.println("*");
		
		
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("*");
		System.out.print("\t");
		
		System.out.println("*");

		
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("\t");
		System.out.print("   ");
		System.out.print("    ");
		System.out.print("*");

	}

结果：

1033aad0442540578dedff383744ae0a.png

方式二：

class Exercise3{

	public static void main(String[] args){                                                                                                   
		System.out.print("\t"+"*"+"\t\t\t\t\t\t\t\t\t\t\t\t"+"*"+"\t"+"\n");
		System.out.print("*"+"\t\t"+"*"+"\t\t\t\t"+"I love Java"+"\t\t\t\t"+"*"+"\t\t"+"*"+"\n");
		System.out.print("\t"+"*"+"\t\t\t\t\t\t\t\t\t\t\t\t"+"*"+"\t"+"\n");

		System.out.print("\t\t"+"*"+"\t\t\t\t\t\t\t\t\t\t"+"*"+"\t\t"+"\n");

		System.out.print("\t\t\t"+"*"+"\t\t\t\t\t\t\t\t"+"*"+"\t"+"\n");
		System.out.print("\t\t\t\t"+"*"+"\t\t\t\t\t\t"+"*"+""+"\t"+"\n");
		System.out.print("\t\t\t\t\t"+"*"+"\t\t\t\t"+"*"+""+"\t\t"+"\n");
		System.out.print("\t\t\t\t\t\t"+"*"+"\t\t"+"*"+""+"\t\t"+"\n");
		System.out.print("\t\t\t\t\t\t\t"+"*"+"\n");


	}

}

结果：

2b3cade0849d403484322757e129dea0.png 

方法三：

class StarPrinttest {
    public static void main(String[] args) {
        System.out.println("   *                           *");        //  \t=Tab
        System.out.println("*      *    I love JAVA   *       *");
        System.out.println("   *                          *");
        System.out.println("     *                      *");
        System.out.println("       *                  *");
        System.out.println("          *             *");
        System.out.println("            *         *");
        System.out.println("               *    *");
        System.out.println("                 **");
    }
}

结果：

90cc0797172f43bbab1b265caf731120.png 

 

三：变量与运算符

3.1 关键字

b7759e300f8e46d9925f0fe68381c84b.png

说明：

  1. 关键字一共50个，其中const和goto是保留字(reserved word)。

true，false，null不在其中，它们看起来像关键字，其实是字面量，不是关键字，表示特殊的布尔值和空值

81927388ee164abb9aae603363672d93.png

5b8f265b4474412aa40a42c234c5dd87.png

 

3.2 标识符( identifier)

标识符的命名规则（必须遵守的硬性规定）：

> 由26个英文字母大小写，0-9 ，_或 $ 组成  
> 数字不可以开头。
> 不可以使用关键字和保留字，但能包含关键字和保留字。
> Java中严格区分大小写，长度无限制。
> 标识符不能包含空格。

3.3变量

9324b36023b64eabbe7919ce05027878.png

  • 3.30变量的概念：

    • 内存中的一个存储区域，该区域的数据可以在同一类型范围内不断变化
    • 变量的构成包含三个要素：数据类型、变量名、存储的值
    • Java中变量声明的格式：数据类型 变量名 = 变量值

3.31 变量类型

2cd5d043d169490b9048fb34dee62962.png
    整形：byte \short \int \long
    浮点型：float \double
    字符型：char
    布尔型：boolean


3.32 引用数据类型：


    类：class
    数组：array
    接口：interface
    枚举：enum
    注解：annotation
    记录：record

3.34 使用变量注意

  • 使用变量注意：
    • Java中每个变量必须先声明，后使用。
    • 使用变量名来访问这块区域的数据。
    • 变量的作用域：其定义所在的一对{ }内。
    • 变量只有在其作用域内才有效。出了作用域，变量不可以再被调用。
    • 同一个作用域内，不能定义重名的变量。

3.4 变量的使用

3.4.1 步骤1：变量的声明

//例如：
//存储一个整数类型的年龄
int age; 

//存储一个小数类型的体重
double weight;

//存储一个单字符类型的性别 
char gender;

//存储一个布尔类型的婚姻状态
boolean marry;

//存储一个字符串类型的姓名
String name;

//声明多个同类型的变量
int a,b,c; //表示a,b,c三个变量都是int类型。

3.4.2 步骤2：变量的赋值

//举例1：可以使用合适类型的常量值给已经声明的变量赋值
age = 18;
weight = 109;
gender = '女';

//举例2：可以使用其他变量或者表达式给变量赋值
int m = 1;
int n = m;       
int x = 1;
int y = 2;
int z = 2 * x + y;

//变量可以反复赋值
//先声明，后初始化
char gender;
gender = '女';

//给变量重新赋值，修改gender变量的值
gender = '男';
System.out.println("gender = " + gender);//gender = 男

举例4：也可以将变量的声明和赋值一并执行
boolean isBeauty = true;
String name = "迪丽热巴";

四. 基本数据类型

4.1 整数类型：byte、short、int、long

6f91a2050f844302ace23c9e38b7b052.png

  • 定义long类型的变量，赋值时需要以"l"或"L"作为后缀。
  • Java程序中变量通常声明为int型，除非不足以表示较大的数，才使用long。
  •  Java的整型常量默认为 int 型。

 

class VariableTest1 {
    public static void main(String[] args) {
/*        整形：
        byte    (1字节）
        short   (2字节）
        int     (4字节）
        long    (8字节）
*/

        //long的错误点
        //long s=123123123;  //error,如果没有加L或l，Java编译器会默认将其视为int类型，可能会导致数据溢出或精度丢失
        //System.out.println(s);

        long a = 123123123L;//注意：long类型后面要加"L"或"l"
        long b = 123123123l;//注意：long类型后面要加"L"或"l"
        System.out.println(a);
        System.out.println(b);
    }
}

结果：

ecec5aeddc0f45bd9ea29f11cd28aa49.png 

4.2 浮点类型：float、double

8fa447f4500048c995b1cd770849eade.png

浮点型常量有两种表示形式：

    • 十进制数形式。如：5.12 512.0f .512 (必须有小数点）
    • 科学计数法形式。如：5.12e2 512E2 100E-2

float：单精度，尾数可以精确到7位有效数字。很多情况下，精度很难满足需求。

double：双精度，精度是float的两倍。通常采用此类型。

定义float类型的变量，赋值时需要以"f"或"F"作为后缀。

Java 的浮点型常量默认为double型。

class VariableTest2 {
    public static void main(String[] args) {
/*
        浮点型：
        float   (4字节）   单精度
        double  (8字节）   双精度
*/
        //浮点型精度不高，如果需要高精度，需要使用BigDecimal类替换浮点型

        //float
        //float a=1.1;//error,没有加f或F，Java编译器会默认将其视为double类型，可能会导致数据溢出或精度丢失
        float b = 1.1f;//注意：float类型后面要加"F"或"f"
        float c = 1.1F;//注意：float类型后面要加"F"或"f"
        //System.out.println(a);
        System.out.println(b);
        System.out.println(c);

        //double
        double d = 1.1;
        double e = 1.1d;//注意：double类型后面要加"D"或"d"
        double f = 1.1D;//注意：double类型后面要加"D"或"d"
        System.out.println(d);
        System.out.println(e);
        System.out.println(f);
    }
}

结果：

74a78274d8ea4268bc351e54f874496f.png 

 

4.2.1 应用举例

案例1：定义圆周率并赋值为3.14，现有3个圆的半径分别为1.2、2.5、6，求它们的面积。

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

        //定义圆周率赋值3.14
        double pi = 3.14;

        //3个半径为1.2,2.5,6
        double radius1 = 1.2;
        double radius2 = 2.5;
        int radius3 = 6;

        //求面积
        double area1 = pi * radius1 * radius1;
        double area2 = pi * radius2 * radius2;
        double area3 = pi * radius3 * radius3;

        System.out.println("圆1的半径为 " + radius1 + "，面积为 " + area1);
        System.out.println("圆2的半径为 " + radius2 + "，面积为 " + area2);
        System.out.println("圆3的半径为 " + radius3 + "，面积为 " + area3);
    }
}

结果：

3612c8dde05f4e2fb43f4718e831597b.png 

 

案例2：小明要到美国旅游，可是那里的温度是以华氏度为单位记录的。 它需要一个程序将华氏温度（80度）转换为摄氏度，并以华氏度和摄氏度为单位分别显示该温度。

/*案列2：转换华氏温度（80度）为摄氏度，并以华氏温度单位和摄氏度单位分别显示温度
        摄氏度 = （华氏度 - 32）/1.8
*/
class FloatDoubleExer2 {
    public static void main(String[] args) {
        //定义华氏温度
        double fahrenheit = 80;     //华氏温度：fahrenheit
        //double fahrenheit = 80.0;
        //double fahrenheit = 80.0d;
        //double fahrenheit = 80.0D;

        //定义摄氏温度
        double celsius = (fahrenheit - 32) / 1.8; //摄氏温度：celsius
        //double celsius = (fahrenheit - 32) / 1.8d;
        //double celsius = (fahrenheit - 32) / 1.8D;

        System.out.println("华氏温度为 " + fahrenheit);
        System.out.println("摄氏温度为 " + celsius);
    }
}

结果：

 10ba2b9afcd4413c8b287cc72e2e3263.png

4.3 字符类型：char

char 型数据用来表示通常意义上“字符”（占2字节）

Java中的所有字符都使用Unicode编码，故一个字符可以存储一个字母，一个汉字，或其他书面语的一个字符。

/*字符型变量的三种表现形式：

–形式1：使用单引号(' ')括起来的单个字符。
 例如：char c1 = 'a'; char c2 = '中'; char c3 = '9';

–形式2：直接使用 Unicode值来表示字符型常量：‘\uXXXX’。其中，XXXX代表一个十六进制整数。
 例如：\u0023 表示 '#'。

–形式3：Java中还允许使用转义字符‘\’来将其后的字符转变为特殊字符型常量。
 例如：char c3 = '\n'; // '\n'表示换行符
*/

3d48b15ecba54b37a173f5cec68b2409.png

8452ca16de1545d484ecca59e4eb8fce.png

4.4 布尔类型：boolean

19687175db2848a69a7fa0834835b7a1.png

ec5abf333ee740c589b5f2bc2bf8c353.png

举例

boolean isFlag = true;

                 if(isFlag){
                  //true分支
                    }else{  
                 //false分支
                  }

4.3,4.4,4.5 总结

class VariableTest3 {
    public static void main(String[] args) {
        //字符类型：
        // char   (2字节）

        //表示形式1 使用一对''表示，内部只可以有一个字符，不可以没有，字符不分地域
        char c1 = 'a';//单引号
        char c2 = '中';//单引号
        char c3 = '1';//单引号
        char c4 = '%';//单引号
        //char c5 = '';//error,不能没有
        //char c6 = 'ab';//error,不能有多个
        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c3);
        System.out.println(c4);
        //System.out.println(c5);
        //System.out.println(c6);

        //表示形式2 使用Unicode编码表示字符常量：'\ uXXX'
        char c7 = '\u0061';//单引号
        char c8 = '\u4e2d';//单引号
        char c9 = '\u0031';//单引号
        char c10 = '\u0025';//单引号
        System.out.println(c7);
        System.out.println(c8);
        System.out.println(c9);
        System.out.println(c10);

        //表示形式3 使用转义字符表示特殊字符：'\t' '\n' '\r' '\b' '\f' '\"' '\'' '\\' '\0'
        char c11 = '\t';//制表符
        char c12 = '\n';//换行符
        char c13 = '\r';//回车符
        char c14 = '\b';//退格符
        char c15 = '\f';//换页符
        char c16 = '\"';//双引号
        char c17 = '\'';//单引号
        char c18 = '\\';//反斜杠
        char c19 = '\0';//空字符
        System.out.println(c11);
        System.out.println(c12);
        System.out.println(c13);
        System.out.println(c14);
        System.out.println(c15);
        System.out.println(c16);
        System.out.println(c17);
        System.out.println(c18);
        System.out.println(c19);

        //表示形式4：Ascii码，字符类型变量在内存中存储的是字符的ASCII码值
        char c20 = 97;//=="a”
        char c21 = 65;//==“A"
        char c22 = 48;//==“0”
        System.out.println(c20);
        System.out.println(c21);
        System.out.println(c22);

        //布尔类型 ：
        //boolean   (1字节）
        //true     （空间占4字节） 因为ture，false分别为1,0，1，0为整形，占4字节
        //false    （空间占4字节） 因为ture，false分别为1,0，1，0为整形，占4字节
        //只有两个值：true，false，用来判断逻辑条件
        //true使用1表示，false使用0表示

        boolean bo1 = true;
        boolean bo2 = false;
        System.out.println(bo1);
        System.out.println(bo2);

        //编译不通过
        //boolean bo3 = 0;          //boolean只为ture，false
        //System.out.println(bo3);

        //常使用在流程控制语句中，如：条件判断，循环结构
        boolean isMarried = true;
        if (isMarried) {
            System.out.println("很遗憾，不能参加单身派对");
        } else {
            System.out.println("可以多几个女朋友");
        }
    }
}

结果：

 8f625e2fde9144098f9c339941f04691.png

 

五.自动类型提升与强制类型转换

5.1 自动类型提升

规则：将取值范围小（或容量小）的类型自动提升为取值范围大（或容量大）的类型 。

1.自动类型提升
byte \short\char ----> int ---> long ---> float ---> double
注意：特殊的
                *(byte+short)在运算时，会自动提升为int类型    怕溢出
                *(byte+byte)运算结果为int类型              怕溢出
                *(short+short)运算结果为int类型            怕溢出
规则：当容量小与容量大的变量运算时，结果自动转换为容量大的类型
注：容量大与容量小，并非是占用内存空间大小，而是数据范围大小

1）当把存储范围小的值（常量值、变量的值、表达式计算的结果值）赋值给了存储范围大的变量时

int i = 'A';//char自动升级为int，其实就是把字符的编码值赋值给i变量了
double d = 10;//int自动升级为double
long num = 1234567; //右边的整数常量值如果在int范围呢，编译和运行都可以通过，这里涉及到数据类型转换

//byte bigB = 130;//错误，右边的整数常量值超过byte范围
long bigNum = 12345678912L;//右边的整数常量值如果超过int范围，必须加L，显式表示long类型。否则编译不通过

（2）当存储范围小的数据类型与存储范围大的数据类型变量一起混合运算时，会按照其中最大的类型运算。

int i = 1;
byte b = 1;
double d = 1.0;

double sum = i + b + d;//混合运算，升级为double

（3）当byte,short,char数据类型的变量进行算术运算时，按照int类型处理

byte b1 = 1;
byte b2 = 2;
byte b3 = b1 + b2;//编译报错，b1 + b2自动升级为int

char c1 = '0';
char c2 = 'A';
int i = c1 + c2;//至少需要使用int类型来接收
System.out.println(c1 + c2);//113

（4）总结

/*基本数据类型运算规则
1.自动类型提升
byte \short\char ----> int ---> long ---> float ---> double
注意：特殊的
                *(byte,short)在运算时，会自动提升为int类型    怕溢出
                *(byte,byte)运算结果为int类型              怕溢出
                *(short,short)运算结果为int类型            怕溢出
规则：当容量小与容量大的变量运算时，结果自动转换为容量大的类型
注：容量大与容量小，并非是占用内存空间大小，而是数据范围大小


2.强制类型转换
*/
class VariableTest4 {
    public static void main(String[] args) {
        //1.自动类型提升
        byte b1 = 10;
        int i1 = b1;
        long l1 = b1;

        int i2 = b1 + i1;
        //byte b2 = b1 + i1; //编译不通过，因为b1(byte)+i1(int)结果为int类型，而b2为byte类型，int类型不能赋值给byte类型
        int i3 = b1 + i1; //编译通过，因为b1(byte)+i1(int)结果为int类型，而i3为int类型，int类型可以赋值给int类型
        System.out.println(i3);

        //**************************************************************************************************************
        //特殊的情况1；
        byte b3 = 12;
        short s1 = 10;
        //short s2 = b3 + s1;//编译不通过，因为b3(byte)+s1(short)结果为int类型，而s2为short类型，int类型不能赋值给short类型
        byte b4 = 10;
        //byte b5 = b3 + b4;//编译不通过，因为b3(byte)+b4(byte)结果为int类型，而b5为byte类型，int类型不能赋值给byte类型
        int i4 = b3 + s1;//编译通过，因为b3(byte)+s1(short)结果为int类型，而i3为int类型，int类型可以赋值给int类型
        System.out.println(i4);

        //**************************************************************************************************************
        //特殊的情况2；
        /*
        (char,byte,short)运算时，结果为int类型
        (char,char)运算时，结果为int类型
        (char,short)运算时，结果为int类型
       (char,byte)运算时，结果为int类型
        */

        char c1 = 'a';
        //char c2 = c1+b3;//编译不通过，因为c1(char)+b3(byte)结果为int类型，而c2为char类型，int类型不能赋值给char类型
        int i5 = c1 + b3;//编译通过，因为c1(char)+b3(byte)结果为int类型，而i5为int类型，int类型可以赋值给int类型
        System.out.println(i5);

        //**************************************************************************************************************
        //练习1：
        long l2 = 123L;
        long l3 = 123;//编译通过，自动类型提升，因为123为int类型，使123自动转换为long类型，而long类型可以赋值给long类型
        //long l4 = 123123123123;//编译不通过，因为123123123123超出int上限
        long l5 = 123123123123L;//编译通过，因为123123123123L为long类型，而long类型可以赋值给long类型
        System.out.println(l2);
        System.out.println(l3);
        System.out.println(l5);

        //练习2
        float f1 = 12.3f;
        //float f2 = 12.3;//不满足自动类型提升（double---->float)，编译不通过，因为12.3为double类型，而float类型不能赋值给double类型

        //练习3
        //规定整形常量为int类型，浮点型常量为double类型
        byte b6 = 10;
        //byte b7 = b6+1;//编译不通过，因为b6(byte)+1(int)结果为int类型，而b7为byte类型，int类型不能赋值给byte类型
        double d1 = b6 + 1.1;//编译通过，因为b6(byte)+1.1(double)结果为double类型，而d1为double类型，double类型可以赋值给double类型
        System.out.println(d1);

        //练习4:说明为什么变量名字为什么开头不能是数字，为了“自洽”
/*      int 123L =112;//编译不通过
        long l6 = 123L;
*/
    }
}

结果：

2c8ffe3f406d4dda8b95a7d40fcd05b0.png 

5.2 强制类型转换

规则：将取值范围大（或容量大）的类型强制转换成取值范围小（或容量小）的类型。

（1）当把存储范围大的值（常量值、变量的值、表达式计算的结果值）强制转换为存储范围小的变量时，可能会损失精度或溢出。

int i = (int)3.14;//损失精度

double d = 1.2;
int num = (int)d;//损失精度

int i = 200;
byte b = (byte)i;//溢出

（2）当某个值想要提升数据类型时，也可以使用强制类型转换。这种情况的强制类型转换是没有风险的，通常省略

int i = 1;
int j = 2;
double bigger = (double)(i/j);

（3）声明long类型变量时，可以出现省略后缀的情况。float则不同。

long l1 = 123L;
long l2 = 123;//如何理解呢？ 此时可以看做是int类型的123自动类型提升为long类型

//long l3 = 123123123123; //报错，因为123123123123超出了int的范围。
long l4 = 123123123123L;

//float f1 = 12.3; //报错，因为12.3看做是double，不能自动转换为float类型
float f2 = 12.3F;
float f3 = (float)12.3;

（4）总结

/*规则：
                          强制类型转换
1.如果需要将容量大的转换为容量小的类型，需要使用强制类型转换
2.强制类型转换需要使用强转符：()。在()内指明转换类型
3.强制类型转换可能导致精度损失，因为数据范围变小了
4.强制类型转换只对一次有效，如果需要多次转换，需要多次使用强制类型转换*/
class VariableTest5 {
    public static void main(String[] args) {
        double d1 = 12;//自动类型提升

        //强制类型转换
        //int i1 = d1;//编译不通过，因为double类型不能赋值给int类型
        int i1 = (int) d1;//编译通过，因为强制类型转换，将d1(double)强制转换为int类型，而int类型可以赋值给int类型
        System.out.println(i1);//12.0---->12
        long l1 = 123;
        //short s1 = l1;//编译不通过
        short s1 = (short) l1;//编译通过，因为强制类型转换，将l1(long)强制转换为short类型，而short类型可以赋值给short类型
        System.out.println(s1);//123---->123

        //练习1
        int i2 = 12;
        float f1 = i2;//自动类型提升
        System.out.println(f1);//12---->12.0
        float f2 = (float) i2;//强制类型转换,只不过可以省略()
        System.out.println(f2);//12---->12.0

        //练习2：精度损失
        double d2 = 12.3;
        double d3 = 12.9;
        int i3 = (int) d2;//强制类型转换
        int i4 = (int) d3;//不遵循4舍5入
        System.out.println(i3);//12.3---->12
        System.out.println(i4);//12.9---->12
        //练习3
        int i5 = 128;
        byte b1 = (byte) i5;//强制类型转换
        System.out.println(b1);//128---->-128
//**********************************************************************************************************************
        //实际开发案列：
        byte b2 = 12;
        methood(b2); //编译通过，因为byte类型可以自动类型提升为int类型，而methood(int)的参数为int类型，int类型可以赋值给int类型

        long l2 = 12L;
        //methood(l2);//编译通过，因为long类型可以自动类型提升为int类型，而methood(int)的参数为int类型，int类型可以赋值给int类型
        methood((int) l2);//编译通过，因为强制类型转换，将l2(long)强制转换为int类型，而methood(int)的参数为int类型，int类型可以赋值给int类型
    

}

结果：

5f88e96c4d9d4ba5856ba7c0c0f55c84.png 

5.3为什么标识符的声明规则里要求不能数字开头？

//如果允许数字开头，则如下的声明编译就可以通过：
int 123L = 12;
//进而，如下的声明中l的值到底是123？还是变量123L对应的取值12呢？ 出现歧义了。
long l = 123L;

 

 

 

标签：JAVA,int,print,数据类型,System,运算符,类型,println,out
From： https://blog.csdn.net/2403_87725694/article/details/142864967

相关文章

  • Java毕业设计 基于SpringBoot和Vue游戏商城网站
    Java毕业设计基于SpringBoot和Vue游戏商城网站这篇博文将介绍一个基于SpringBoot框架和Vue开发的游戏商城网站，适合用于Java毕业设计。功能介绍首页图片轮播游戏推荐游戏分类游戏详情添加购物车立即购买积分兑换评论收藏游戏论坛发布帖子游戏资讯......
  • Java中多线程的学习
    Java多线程学习总结目录Java多线程学习总结什么是进程什么是线程进程与线程的区别地址空间资源占用健壮性执行过程并发与资源消耗创建线程方式一：继承Thread类，并重写run()方法方式二：实现Runnable接口，并实现run()方法线程的状态线程暂停执行条件线程优先级多线程多线......
  • 四，Java面向对象
    Java面向对象：封装与构造方法笔记封装private关键字:概述:private是Java中的访问修饰符，用于隐藏类的内部细节，只通过公共方法（public）提供访问。特点:使用private修饰的成员变量或方法只能在同一个类内部访问，不能被类的外部直接访问。使用方式:成员变量:this.成员变量名，......
  • 前端原型链：探索 JavaScript 中的继承奥秘
    一、引言在前端开发领域，JavaScript是一门广泛应用的编程语言。而原型链作为JavaScript中一个重要的概念，对于理解JavaScript的面向对象特性和实现继承机制起着关键作用。它不仅影响着代码的组织和复用方式，还决定了对象之间的关系和属性访问规则。本文将深入探讨前端原型链......
  • 讨论java有基础类型,为什么还要有封装类型呢?两者之间的比较方式?
    java有哪些基础类型boolean/1byte/8char/16short/16int/32float/32long/64double/64java为什么有基础类型,为什么还要有封装类型呢?举个例子吧,Character和char的区别是在于char只是存了个数据,而Character的区别在于他带有了一系列操作该数据的方法好处是什么呢?......
  • Java 初学 day 08
    java081、Abstract关键字java为了表示现实生活中抽象的概念集合,提供了一个关键字给我们使用:abstractabstract抽象的可以修饰类,修饰成员方法1.被abstract修饰的类是抽象类,抽象类不能被实例化2.被abstract修饰的方法是抽象方法,抽象方法不能有大括号实现3.在抽......
  • java 不建议使用stack
    Java不建议使用Stack的原因和替代方案在Java编程中，Stack类通常用于处理数据结构中的堆栈实现。然而，随着Java的发展，越来越多的开发者开始质疑是否应该继续使用Stack类。本文将探讨不建议使用Stack的原因，示例代码，以及推荐的替代方案。Stack类简介在Java中，Stack是一种后进先出（LIFO......
  • Java在for循环中修改集合
    前天看到一篇文章什么？for循环也会出问题？，里面涉及到在for循环中修改集合，想起来自己刚入行的时候就碰到过类似的问题，于是复现了一下文章中的问题，并试验了其它在循环中修改集合的方法。底层原理参考什么？for循环也会出问题？这篇文章的分析1.在fori中修改集合在fori中修改集合，不会......
  • java计算机毕业设计智能点餐推荐系统（开题+程序+论文）
    本系统（程序+源码）带文档lw万字以上 文末可获取一份本项目的java源码和数据库参考。系统程序文件列表开题报告内容研究背景随着科技的飞速发展，人们的生活节奏日益加快，对餐饮服务的需求也愈发多样化和个性化。传统的点餐方式往往依赖于纸质菜单或简单的电子菜单，难以满足现代......
  • Java在for循环中修改集合
    在Java中，ifPresent是一个用于Optional类型的方法，用于检查Optional对象中是否存在值并执行相应的操作。ifPresent方法接受一个Consumer函数式接口作为参数，如果Optional对象中包含值，则将该值传递给Consumer接口的实现方法。以下是ifPresent方法的使用示例：importj......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99