面向对象程序设计——Java语言基础

目录

【学习目标】

单元重点

引例描述

知识储备

2.1 Java程序结构

2.1.1 包

1.Java 中常用的标准类包

（1) java.lang 包

（2） java.awt 包

（3） javax.swing 包

（4）java.util包

（5）java.io 包

（6） javasql 包

2. 包的创建及包中类的引用

（1）创建包

（2）引用类包中的类

2.1.2 主函数及其参数

1.主函数

2. main方法中字符串参数数组的作用

2.1.3 代码块

1. 普通代码块

2.构造块

3.静态代码块

2.2 基本数据类型

2.2.1 整数类型

1. 整型常量的表示方法

2. 整型变量的定义

2.2.2 浮点类型

1. 常量的表示方法

2. 实型变量的定义

2.2.3 字符类型与布尔类型

2.3 变量与常量

2.3.1 标识符和关键字

1.标识符

2.关键字

2.3.2 变量和常量

1.变量

2.常量

第三节 浮点数计算

2.4 数据类型间的相互转换

2.4.1 自动（隐式）类型转换

2.4.2 强制类型转换

1.数据类型之间的转换

2.数据类型强制转换规则

2.5 控制台输入与输出

2.5.1 控制台输入数据

1.从控制台输入整数

2.从控制台输入字符串

3. 其他类型数据的输入

2.5.2 格式化输出

2.6 运算符

2.6.1 算数运算符

2.6.2 关系运算符

2.6.3 逻辑运算符和位运算符

1.逻辑运算符

2.位运算符

2.6.4 赋值运算符和条件运算符

2.6.5 运算符优先级

---

【学习目标】

【知识目标】

• 掌握 Java 中包的使用。

• 掌握 Java 中基本数据类型的使用。

• 掌握变量与常量的使用。

• 掌握控制台输入和输出。

【技能目标】

• 能够使用 package 创建包。

• 能够创建和使用8种基本数据类型。

• 能够正常声明和使用常量与变量。

• 能够利用 Scanner 输入数据。

• 能够利用 printf()方法格式化输出变量。

【素养目标】

• 培养与客户的沟通能力，加强服务意识。

• 提升理论联系实际的软件开发能力。

• 培养主次分明、先搭框架再完成开发细节的习惯。

单元重点

构成程序的最基本元素包括变量、常量和语句等。变量是指程序运行过程中其值可以被改变的量，比如表示不同班级学生平均成绩的变量；常量则是指程序运过程中，值不会发生变化的量，比如最常见的圆周率。

无论是变量还是常量，在使用之前都要先为它们指定一个名字。而语句则是组成一段程序的最基本单元。

本单元主要介绍 Java 的基本语法，包括标识符、保留字、变量、常量、数据类型、运算符和表达式等。本单元技能图谱如所示。

引例描述

王老师来电要求Java课程分组进行学习，每个小组3人，小组长负责把3个组的姓名、成绩输入计算机，且格式化输出每个组员的姓名和成绩以及小组的平均绩(成绩要保留 2位小数)，如图所示。

为了帮助组长更好地完成任务，王老师还对案例实现的思路提出了一些建议，体包括以下 3 个步骤：

第一步，利用变量存储每个组员的姓名和成绩。

第二步，利用System.out.printf()的格式化方法输出数据。

第三步，格式化输出时，不同的数据类型采用不同的格式化占位符

(%d表示输出的是整数；%s 表示输出字符串；%f表示输出浮点数据)。

知识储备

那么，完成上面王老师交给组长的任务，需要掌握哪些知识呢?主要离不开Java语言的数据输入语句，包括存储输入的数据，这里需要定义相应的变量来进行保存；求平均值需要用到合适的算术运算符，比如+、一、*、/等。

当然，输出的数据是直接呈现给用户的，因此输出结果从结构上要符合用户的需求，还要考虑输出结果呈现的美观性，这需要用到System.out.printf()方法的相关参数，来格式化输出数据的呈现方式。

2.1 Java程序结构

2.1.1 包

在Java中，包(package)是一种松散的类的集合，它可以将各种类文件组织在一起，就像磁盘的目录（文件夹）一样。无论是 Java 中提供的标准类，还是我们自己编写的类文件都应包含在某个包内。

包的管理机制提供了类的多层次命名空间，避免了命名冲突问题，解决了类文件的组织问题，方便了用户的使用。

1.Java 中常用的标准类包

Sun公司在JDK中提供了各种实用类，通常称之为标准的API (ApplicationProgramming Interface），这些类按功能分别被放入了不同的包中，供开发程序使用。随着JDK版本的不断升级，标准类包的功能也越来越强大，使用也更为方便。

Java提供的标准类都放在标准的包中，常用的一些包说明如下。

（1) java.lang 包

该包中存放了Java最基础的核心类，如System、 Math、 String、 Integer、 Floe类等。在程序中，这些类不需要使用import语句导入即可直接使用。

（2） java.awt 包

该包中存放了构建图形化用户界面(GUI)的类，如Frame、 Button、 TextField等。使用它们可以构建出用户所希望的图形操作界面。

（3） javax.swing 包

该包中提供了更加丰富的、精美的、功能强大的GUI组件，是java.awt功能的扩展，对应提供了如JFrame、JButton,JTextField等类，在后续章节中会对这些内容进行讲解。它比java.awt相关的组件更灵活、更容易使用。

（4）java.util包

该包中提供了一些实用工具类，如定义系统特性、使用与日期日历相关的方法以及分析字符串等。

（5）java.io 包

该包中提供了数据流输入/输出操作的类，如建立磁盘文件、读写磁盘文件等。

（6） javasql 包

该包中提供了支持使用标准SQL方式访问数据库功能的类和接口。

2. 包的创建及包中类的引用

如上所述，每一个Java类文件都属于一个包。那么，创建程序的时候一定要创建程序所属的包吗？

事实上，如果在程序中没有指定包名，系统默认为无名包。无名包中的类可以相互引用，但不能被其他包中的Java程序所引用。对于简单的程序，没有特意指定包名也许没有影响，但对于一个复杂的应用程序，如果不使用包来管理类，将会使程序的开发产生很大的混乱。

下面简要介绍包的创建及使用。

（1）创建包

将自己编写的类按功能放入相应的包中，以便在其他的应用程序中引用它，这是对面向对象程序设计者最基本的要求。

可以使用package语句将编写的类放入一个指定的包中。 package语句的一般格式如下：

package 包名;

需要说明的是，此语句必须放在整个源程序第一条语句的位置（注解行和空行除外）；包名应符合标识符的命名规则，习惯上，包名使用小写字母书写。可以使用多级结构的包名，如Java提供的类包java.util, java.sql等。

事实上，创建包就是在当前文件夹下创建一个以包名命名的子文件夹并存放类的字节码文件。如果使用多级结构的包名，就相当于以包名中的“.”为文件夹分隔符。

（2）引用类包中的类

一般来说，可以用如下两种方式引用包中的类。

一种是使用import语句导入类，其应用的一般格式如下:

import 包名.*;    //可以使用包中所有的类

或

import 包名.类名;   //只加载包中类名指定的类

在程序中，import 语句应放在 package 语句之后，如果没有 package 语句，则import语句应放在程序的开始。一个程序中可以含有多个 import语句，即在一个类中，可以根据需要引用多个类包中的类。

另外一种就是在程序中直接引用类包中所需要的类。其引用的一般格式是：

包名.类名

例如，可以使用如下语句在程序中直接创建一个日期对象：

java.util.Date datel = new java.util.Date( )

这里使用系统提供的 java.util 工具包中的 Date 类创建了日期对象。

2.1.2 主函数及其参数

1.主函数

在Java程序中，main方法是Java应用程序的入口方法。也就是说，程序在运行的时候，第一个执行的方法就是main()方法，这个方法和其他的方法有很大的不同，比如方法的名字必须是main，方法必须是public static void类型的，方法必须接收一个字符串数组的参数，等等。

在讲解Java中的main())方法之前，先看一个最简单的Java应用程序HelloWorld，并将通过这个例子说明 Java 类中 main()方法的奥秘。

程序的代码如下：

/*
 * Java中的main()方法详解
 */
public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
}

程序运行结果如图所示。

HelloWorld 类中有 main()方法，说明这是个 Java 应用程序，通过JVM 直接启动来运行程序。这里的 main()方法的声明为"public static void main(String args[])"。

注意，此处必须这么定义，这是Java的规范，和JVM的运行机制有关系。如果一个类中有main()方法，执行命令"java类名”则会启动虚拟机执行该类中的main（）方法。由于JVM在运行这个Java应用程序的时候，首先会调用main()方法，调用时不实例化这个类的对象，而是通过类名直接调用，因此需要限制为public static。

对于Java中的 main()方法，JVM有限制，不能有返回值，因此返回值类型为void。

main()方法中还有一个输入参数，类型为String[]，这也是Java的规范，即main()方法中必须有一个输入参数，参数类型必须是String[]，至于字符串数组的名字是可以自己设定的。

根据习惯，这个字符串数组的名字一般和Sun Java规范范例中main参数名保持一致，取名为args。因此， main()方法的定义必须为"public statiivoid main(String字符串数组参数名[])"。

2. main方法中字符串参数数组的作用

main()方法中字符串参数数组args[]的作用是接收命令行的输入参数，命令行的参数之间用空格隔开。main()方法作为一个特殊的规范，与普通的方法有很大区别，限制很多，理解其原理需要学习JVM相关知识。在后面还会介绍该方法。

2.1.3 代码块

代码块本身并不是很难理解的概念，实际上我们也一直在使用。代码块是指使用“()”括起来的一段代码，根据位置及声明关键字的不同，代码块可以分为普通代码块、构造块、静态代码块、同步代码块4种。其中，同步代码块将在后面的多线程中进行讲解。下面进行前面 3 种代码块的讲解。

1. 普通代码块

普通代码块是指直接在方法或语句中定义的代码块，例如：

public class CodeDemo01 {
    public static void main(String[] args) {
        {
        int x = 30;
        System.out.println("普通代码块-->x=" + x);
        }
        int x = 100;
        System.out.println("代码块之外-->x=" + x);
    }
}

2.构造块

构造块是直接写在类中的代码，例如。

class daimakuai_1{
    {
        System.out.println("1.构造块");
    }
        public daimakuai_1() {
            System.out.println("2.构造方法");
        }
    }
public class CodeDemo02 {
    public static void main(String[] args) {
        new daimakuai_1();
        new daimakuai_1();
    }
}

运行结果：

本程序在主方法中产生了2个实例化对象，从输出的结果可以发现，构造块优先于构造方法执行，而且每次实例化对象时都会执行构造块中的代码。

3.静态代码块

静态代码块是使用 static 关键字声明的代码块。例如：

package test;
​
class Demo{
    {
        System.out.println("1,构造块");
    }
    static {
        System.out.println("0,静态代码块");
    }
    public Demo() {
        System.out.println("2,构造方法");
    }
    
}
public class CodeDemo03 {
    static {
        System.out.println("在主方法所在类中定义的代码块。");
    }
​
    public static void main(String[] args) {
        new Demo();
        new Demo();
        new Demo();
    }
}

运行结果：

从程序运行结果中可以发现，静态代码块优先于主方法执行，而在类中定义的静态代码块会优先于构造块执行，而且不管有多少个对象产生，静态代码块只执行一次。

2.2 基本数据类型

Java 语言的数据类型可划分为基本数据类型和引用数据类型，如图所示。

本节主要介绍基本数据类型，引用数据类型将在后面的章节中介绍。数组和字符串本身属于类，由于它们比较特殊且常用，因此也在图中列出。

2.2.1 整数类型

Java 提供了 4 种整型数据，如表所示。

1. 整型常量的表示方法

整型常量可以用十进制、八进制和十六进制表示。一般情况下使用十进制表示如123、-456、0、23456、在特定情况下，根据需要可以使用八进制或十六进制形式表示整型常量。

以八进制表示时，以0开头，如0123表示十进制数83，-011表示十进制数-9;以十六进制表示整型常量时，以0x或0X开头，如0x123表示十进制数291，-0X12表示十进制数-18。此外，长整型常量的表示方法是在数值的尾部加一个拖尾的字符L或l，如 456l、0123L，0x251。

2. 整型变量的定义

例如：

int x = 123;    //指定变量x为int型，且赋初值为123
byte b = 8;     //指定变量b为byte型，且赋初值为8
short s = 10;   //指定变量s为short型，且赋初值为10
long y = 123L,z = 123l; //指定变量y、z为long型，且分别赋初值为123

2.2.2 浮点类型

Java提供了两种浮点型数据，即单精度float和双精度double，如上表所示。

1. 常量的表示方法

一般情况下，实型常量以如下形式表示：

0.123、1.23、123.0等表示双精度数；

123.4f、 145.67F、 0.65431f等表示单精度数。

当表示的数字比较大或比较小时，采用科学计数法表示。例如:

1.23e13或123E11均表示123×10¹¹；0.1e-8或1E-9均表示10﹣⁹。我们把e或E之前的常数称为尾数部分，e或E后面的常数称为指数部分。

注意：使用科学计数法表示常数时，指数和尾数部分均不能省略，且指数部分必须为整数。

2. 实型变量的定义

在定义变量时，都可以赋予它一个初值。例如：

float x=123.5f,y-1.23e8f;//定义单精度变量x、y并分别赋予 123.5、1.23×10⁸的值
 
double d1=456.78,d2-1.8e50;//定义双精度变量d1、d2并分别赋予456.78、1.8×10⁵⁰的值

2.2.3 字符类型与布尔类型

字符型(char)数据占据2字节，即16个二进制位，字符常量是用单引号括起来的一个字符，如'a'、'A'等。字符型变量的定义：

char c='a';	//指定变量c为 char型，且赋初值为'a'

布尔型(boolean)数据的值只有两个: true和false。因此，布尔型常量也只能取这两个值。

布尔型变量的定义：

boolean bl-true, b2-false;	//定义布尔型变量 b1、b2 并分别赋予真值和假值

2.3 变量与常量

2.3.1 标识符和关键字

1.标识符

标识符就是用来标识类名、变量名、方法名、类型名、数组名、文件名的有效序列。简单地说，标识符就是一个名字。Java语言规定标识符由字母、下画线、美元符号$和数字组成，并且第一个字符不能是数字字符。

（1）标识符的命名规则

1. 标识符必须以字母（a-z或A-Z）或下划线（_）开头。

2. 标识符中的其余部分可以是字母、数字（0-9）或下划线。

3. 标识符是区分大小写的，因此Java中的"MyVariable"和"myvariable"是两个不同的标识符。

4. 避免使用Java的关键字作为标识符，以避免命名冲突。

5. 标识符应该具有描述性，以便于理解和阅读。

6. 避免使用Java语言规范中定义的保留字或标准库中的已有标识符作为自己的标识符。

7. 对于类名，通常使用驼峰式命名法，即每个单词的首字母小写，后续单词的首字母大写。对于接口名和枚举名，也可以使用驼峰式命名法。

8. 对于变量和方法名，可以使用下划线命名法，即单词之间用下划线连接，每个单词的首字母大写。

9. 在命名复杂或关键的类和方法时，建议使用有意义的描述性名称，而不是简单的标识符名称。

此外，在Java中还有一些约定俗成的命名规范，例如：

• 常量名通常使用大写字母和下划线命名法，并使用全大写字母表示常量值是恒定的。

• 在方法名中使用"get"、“set”、"is"等前缀来表示获取器（getter）和设置器（setter）方法。

• 对于类的私有成员变量和方法，通常使用小写字母和下划线命名法。

• 对于类中的公共成员变量和方法，通常使用驼峰式命名法，并遵循常规的命名规范。

遵循这些命名规则和约定，可以提高代码的可读性和可维护性。

（2）标识符的约定

包名的约定： Java包的名字都是由小写单词组成的。但是由于Java面向对象线程的特性，每一名Java程序员都可以编写属于自己的Java包，为了保障每个Jav包命名的唯一性，在最新的Java编程规范中，要求程序员在自己定义的包的名称之前加上唯一的前缀。由于互联网上的域名称是不会重复的，所以程序员一般采用自己在互联网上的域名称作为自己程序包的唯一前缀。

类的命名：类的名称必须由大写字母开头而单词中的其他字母均为小写：如果类名称由多个单词组成，则每个单词的首字母均应为大写，如TestPage；如果类名称中包含单词缩写，则这个缩写词的每个字母均应大写，如XMLExample。

还有个命名技巧，就是由于类是设计用来代表对象的，所以在命名类时应尽量选择名词，如 Circle。

方法的命名：方法的名称的第一个单词应以小写字母开头，后面的单词则用大写字母开头，如sendMessage())。

常量的命名：常量的名称应该都使用大写字母，并且指出该常量的完整含义。如果一个常量的名称由多个单词组成，则应该用下画线来分割这些单词，如MAX_VALUE。

参数的命名：参数的命名规范和方法的命名规范相同，而且为了避免阅读程序时引起歧义，应在尽量保证参数名称为一个单词的情况下使参数的命名尽可能明确。

2.关键字

关键字就是 Java 语言中已经被赋予特定意义的单词，这些关键字只能由 Java系统使用，而用户自定义的类名、方法名和变量名不可以使用关键字。

Java常用关键字如表所示。

2.3.2 变量和常量

1.变量

（1）变量的定义

变量就是程序中值可以改变的量。

变量需要一个名字，变量的名字是一种“标识符”，意思是它是用来识别这个和那个的不同的名字。

标识符有标识符的构造规则。基本的原则是:

• 标识符只能由字母、数字和下划线组成。

• 数字不可以出现在第一个位置上。

• Java的关键字(有的地方叫它们保留字)不可以用做标识符。

详细说明：

1）Java 要求在使用一个变量之前对变量的类型加以声明。

2）Java中一个变量的声明就是一条完整的Java语句，所以应该在结尾使用分号。

3）变量的命名规则：

① 变量名必须以字母开头。变量名是一系列字母或数位的任意组合。

②在Java中字母表示Unicode中相当于一个字母的任何字符。数位也包含0~9以外的其他地位与一个数位相当的任何Unicode字符。

③ +、版权信息符号©和空格不能在变量名中使用。变量名区分大小写。

④ 变量名的长度基本上没有限制。

⑤ 如想知道 Java到目前为止认为哪些Unicode 字符是字母，可以使用Character类中的isJavaldentifierStart以及isJavaldentifierPart方法进行检查。

⑥ 变量名不能使用 Java的保留字。

4）可在一条语句中进行多个变量的声明，不同变量之间用逗号分隔。

（2）变量的赋值和初始化

变量的值可以通过两种方法获得：一种是赋值，给一个变量赋值需要使用赋值语句。另外一种方法就是初始化，说是初始化，其实还是一个赋值语句，只不过这个赋值语句是在声明变量时就一起完成的。

变量定义的一般形式：

<类型名称> <变量名称>

例如:

int a = 10； //这就是一个变量初始化的过程

下面两条语句的功能和上面一条的功能相同，只是这里将变量的声明和赋值分开来进行。

int a;
а = 10;	//在赋值语句的结尾应该使用分号

说明：

1）在Java中绝对不能出现未初始化的变量，在使用一个变量前必须给变量赋值

2）声明可以在代码中的任何一个位置出现，但在方法的任何代码块内只可对一个同名变量声明一次。

（3）变量的有效范围

变量的有效范围也叫作变量的作用域，是指从变量自定义的地方起可以使用的有效范围。在程序中不同地方定义的变量具有不同的作用域。一般情况下，在本程序块（即以大括号“｛｝”括起的程序段）内定义的变量在本程序块内有效。以下实例将为大家展示不同变量的作用范围。

package test;
​
public class Var_Area_Example {
    static int n_1 = 10;    //类变量n_1，对整个类都有效
    public void display() {
        int n_2 = 200;  //方法变量n_var2,只在该方法内有效
        n_1 = n_1 + n_2;
        System.out.println("n_1 = " + n_1);
        System.out.println("n_2 = " + n_2);
    }
    public static void main(String[] args) {
        // TODO 自动生成的方法存根
        int n_3;
        n_3 = n_1 * 2;
        System.out.println("n_1 = " + n_1);
        System.out.println("n_3 = " + n_3);
    }
}

程序运行结果如图所示：

2.常量

常量是在程序运行过程中保持不变的量，即不能被程序改变的量，也把它称为最终量。标识常量使用一个标识符来替代一个常数值，其定义的一般格式为：

final 数据类型 常量名 = value[,常量名 = value...];

其中，final 是保留字，说明后面定义的是常量，即最终量；数据类型指常量的数据类型，它可以是基本数据类型之一；常量名是标识符，表示常数值value，在程序中凡是用到 value 值的地方均可用常量名标识符替代。

例如：

final double PI = 3.1415926;

这里定义了标识常量PI，类型是double，其值为3.1415926。

注意：在程序中，为了区分常量标识符和变量标识符，常量标识符一般全部使用大写字母书写。

第三节 浮点数计算

在计算机以外的世界，我们提到数的时候，不会特意去考虑整数还是带有小数点的数，也不会觉得5和5.0有什么区别。但是在计算机里，处理不带小数点的整数和带小数点的数，是差别非常大的事情，需要的计算时间和资源是不同的。

案例引入：

【英尺与米的转换】

英尺和米的转化公式：

$1英尺=12英寸=0.3048米$

美国人固执地使用英制计量单位，他们习惯用几尺几寸(英尺英寸)来报自己的身高。如果遇到一个美国人告诉你他是5英尺7英寸（五尺七寸），他的身高应该是一米几呢？

(5 + 7 ÷ 12) x 0.3048 = 1.7018米

package test03;
 
import java.util.Scanner;
 
public class Test01 {
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		int foot;
		int inch;
		
		foot = input.nextInt();
		inch = input.nextInt();	
		System.out.println((foot + inch / 12) * 0.3048);
	}
}

程序运行结果：

总结：

10 / 3 = ？

两个整数的运算结果只能是整数。

修改：

(foot + inch / 12) * 0.3048)

(foot + inch / 12.0) * 0.3048)

当浮点数和整数放到一起运算时，Java会将整数转换成浮点数，然后进行浮点数的运算。

double inch;

整数类型不能表达有小数部分的数，整数和整数的运算结果还是整数。计算机里会有纯粹的整数这种奇怪的东西，是因为整数的运算比较快，而且占地方也小。其实人们日常生活中大量做的还是纯粹整数的计算，所以整数的用处还是很大的。

2.4 数据类型间的相互转换

2.4.1 自动（隐式）类型转换

整型、浮点型、字符型数据可以混合运算。运算中，不同类型的数据先转换为同一类型，然后进行运算。一般情况下，系统自动将两个运算数中低级的运算数转换为和另一个较高级运算数的类型相一致的数，然后再进行运算。

例如：

int i = 100;
float f1 = 12.3f;
System.out.println (f1 + i);

这时输出的结果是 112.3，因为在“System.out.println(fl+i);”语句中，将i自动转换为float类型后，再进行相加运算。

应该注意的是，如果将高级类型数据转换成低级类型数据，则需要进行强制类型转换，这样做有可能导致数据溢出或精度下降。

例如:

long numl = 8;
int num2= (int) num1;
long num3 = 547892L;
short num4=(short)num3; //将导致数据溢出

2.4.2 强制类型转换

1.数据类型之间的转换

分为以下几种情况：

1）低级到高级的自动类型转换。

2）高级到低级的强制类型转换(会导致数据溢出或精度下降)。

3）基本类型向类类型转换。

4）基本类型向字符串转换。

2.数据类型强制转换规则

在双操作数以及位运算等算术运算中，会根据操作数的类型将低级的数据类型自动转换为高级的数据类型，如果结果要获取低级数据类型的数据，可以使用下述强制类型转换。

double b = 10.3; 
int a = (int)b;

只是从那个变量计算出了一个新的类型的值，它并不改变那个变量，无论是值还是类型都不改变。

强制类型转换

double a = 1.0;
double b = 2.0;
int i = (int)a / b;
int i = (int)(a/b);

强制类型转换的优先级高于四则运算+ - * /

int a = 5; 
int b = 6; 
double d = (double)(a / b);

例如：

short i = 101 ;
char c = (char)i;
System.out.println ("output:" + c);

以上代码输出的结果是output:e。

这里直接把int类型转换为对应的ASCI码字符了，十进制的 101 对应的字符是小写字母 e。强制类型转换还有以下规则：

ASCII码表 2^8 2^7其中有一位用来表示+ -

1）不能在布尔值和任何数字类型间进行强制类型转换。

2）不同级别数据类型间的强制转换，可能导致数据溢出或精度下降。

3）当字节类型变量参与运算时，Java将自动提升数据运算类型，将其转换为int 类型。

关于第3条的解释：

在Java中，当一个byte、short或char类型的变量参与运算时，会自动地提升为int类型进行运算。这是因为在Java中进行算术运算时，整型运算是32位的，而byte和short则分别只有8位和16位，char有16位但是存在Unicode字符集，其值可能会超过32767。因此，为了保证运算的准确性，Java在运算时会自动将这些值提升为int类型。

这种自动类型提升是Java语言的规范之一，它确保了运算的准确性和一致性。

例如：

byte b;
b = 3;
b = (byte) (b+3);//必须声明 byte

2.5 控制台输入与输出

2.5.1 控制台输入数据

在很多情况下，需要Java程序能够对指定的值进行计算，这样就需要Java程序能够读取所输入的值。可以使用 Java 自带的 Scanner 类来从控制台获取输入。

Scanner类在包java.util中。一般在程序代码的最开始引入所有需要用到的包和类。

下面尝试引入Scanner类，在代码的最前面插入一行，然后写下这条语句:

import java.util.Scanner;

Java本身并不直接支持控制台输入，因此要使用Scanner类创建它的对象，用以读取来自System.in即标准输入设备的数据，这里一般指键盘。

Scanner input = new Scanner(System.in);

任何需要读用户输入的程序都需要这行。

【小技巧】输入Scan之后，按下键盘上的Alt键和“/"键，让Eclipse自动为你补全必要的代码。

其中, new Scanner(System.in)表明创建了一个Scanner 类型的对象，而Scanner input声明input是一个Scanner类型的对象，这样的对象可以接收来自System.in设备的数据。

整行代码表明创建了一个Scanner对象，并且将它的引用赋值给了变量input.Scanner对象可以调用它自己的方法，接收来自输入设备的数据。

输入也在终端窗口中
红色的方块表示程序正在运行
输入是以行为单位进行的,行的结束标志就是你按下了回车键。在你按下回车之前，你的程序不会读到任何东西

System.out.println(input.nextLine())

实例：

System.out.println("2+3=" + 5);     //输出两数相加的和 2+3=5
System.out.println("2+3=" + 2+3);   //输出2+3=23
System.out.println("2+3="+(2+3));   //输出2+3=5
System.out.println(2+3+"=2+3");     //输出5=2+3
System.out.println("100-23="+(100-23)); //输出100-23=77
System.out.println("100-23="+(100-in.nextTnt()));   //输出100-23=
System.out.println("100-"+in.nextInt()+"="+(100-in.nextTnt()));
int price;  //引入变量
price = in.nextInt();
System.out.println("100-"+price+"="+(100-price));

1.从控制台输入整数

如果声明一个 int类型的变量 i，然后使用Scanner 类的 nextInt()方法来接收据，且将接收的数据赋值给变量i，则变量i中就存放了从输入设备输入的整数。具体代码如下：

int i = input.nextInt ();

下面的实例是接收用户输入的数据且输出平均值。代码如下：

package test04;
 
import java.util.Scanner;
 
public class Demo04 {
 
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		System.out.println("请输入第一个整数：");
		int i1 = input.nextInt();
		System.out.println("请输入第二个整数：");
		int i2 = input.nextInt();
		System.out.println("请输入第三个整数：");
		int i3 = input.nextInt();
		System.out.println("输入的三个数平均值为：" + (i1 + i2 + i3) / 3);
	}
}

输出结果如图所示：

当系统运行到类似 sc.nextInt()的语句时，会停下来等待用户输入数据，系统只有接收到了需要的数据才会继续运行！

2.从控制台输入字符串

利用Scanner类接收字符串的方法是next()。

下面用一个例子来说明该方法的使用。

package test04;
 
import java.util.Scanner;
 
/*
 * 从控制台输入字符串
 */
public class Demo05 {
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		System.out.println("请输入姓名：");
		String name = input.next();	//将控制台输入的字符串赋值给变量name
		
		System.out.println("请输入语文成绩：");
		int Chinese = input.nextInt();
		System.out.println("请输入数学成绩：");
		int math = input.nextInt();
		System.out.println("请输入英语成绩：");
		int English = input.nextInt();
		System.out.println(name + "的平均成绩为：" + (Chinese + math + English) / 3);
	}
}

程序运行结果如图所示：

以上程序通过Scanner实例sc调用next()方法接收键盘输入的数据并用赋值给变量name，然后在System.out.printin()中把接收的学生名字作为输出结果的一部分。

3. 其他类型数据的输入

除了以上所提到的对于整数和字符串数据的输入方法，Scanner类还提供了输入其他类型数据的方法，如nextByte()、nextShort()、nextLong()、nextFloat()、nextDouble()。

从这些方法的名称可以知道每个方法的功能和使用方法，可以自己尝试使用。

2.5.2 格式化输出

通过前面一系列的讲解可知，常用的一个输出方法就是System.out.println()， 该方法将指定内容直接输出，之后按Enter键换行；与之对应的一个方法就是System.out.print()，该方法与System.out.println()的不同之处在于输出指 定内容后进行回车。

如果想要按照指定的格式输出内容，而不是直接输出，以上两个方法无法完成了。

下面介绍一个可以格式化输出内容的方法。

该方法的基本格式如下：

System.out.printf（“格式化字符串”，输出对象);

下面以一个具体的实例来说明该方法的使用过程。

package test;
​
public class TestPrintf{
    public static void main(String[] args){
        //定义一些变量，用来格式化输出
        double d = 345.678;
        String s = "你好!";
        int i = 1234;   
        //”%”表示进行格式化输出，“%”之后的内容为格式的定义
        System.out.printf("%f",d);  //"f"表示格式化输出浮点数
        System.out.println();
        System.out.printf("%9.2f",d);   //"9.2"中的9为整数部分长度，2为小数点后的位数
        System.out.println();
        System.out.printf("%+9.2f",d);  //“+"表示输出的数带正负号
        System.out.println();
        System.out.printf("%-9.4f",d);  //"-"表示左对齐（默认为右对齐)
        System.out.println();
        System.out.printf("+-9.3f",d);  //”+-”表示输出的数带正负号且左对齐
        System.out.println();
        System.out.printf("%d",i);  //"d"表示输出十进制整数
        System.out.println();
        System.out.printf("%o",i);  //"o"表示输出八进制整数
        System.out.println();
        System.out.printf("%x",i);  //"x"表示输出十六进制整数
        System.out.println();
        System.out.printf("%#x",i); //"#x"表示输出带有十六进制标志的整数
        System.out.println();
        System.out.printf("%s",s);  //"s"表示输出字符串
        System.out.println();
        System.out.printf("输出一个浮点数：%f，一个整数：%d，一个字符串：%s",d,i,s); //可以输出多个变量，注意顺序
    }
}

程序运行结果如图 2-8 所示。

以上实例中，利用printf())方法的参数对不同类型的数据进行了格式化输出。

2.6 运算符

2.6.1 算数运算符

算术运算符用在数学表达式中，它们的作用和在数学中的作用一样。表中列出了所有的算术运算符。表中的实例假设整数变量 A 的值为 10， 变量 B值为 20。

B++ : B = B + 1

B--：B = B - 1

按照 Java 语法，把由算术运算符连接数值型操作数的运算式称为算术表达式。例如x+y*z/2、i++、(a+b)%10等。

有两个算术运算符与我们平时见到的数学符号不同，即++和--，这两个符号就是自增、自减运算符，例如 i++相当于 i = i+1

下面举一个例子来进一步说明算术运算符的使用。

package test03;
 
public class Arithmetic {
 
	public static void main(String[] args) {
		int a = 0;
		int b = 1;
		float x = 5f,y = 10f;
		float s0,s1;
		System.out.println();
		s0 = x * a++;	//输出结果？
		s1 = ++b*y; 
		System.out.println(s0);
		System.out.println(s1);
		
	}
}

输出结果：

在这个Java程序中，s0的值由以下步骤计算：

1. 定义变量a，并初始化为0。

2. 定义变量x，并初始化为5.0。

3. 定义变量s0，但未初始化。

4. 计算表达式x * a++。

在这个表达式中，涉及到两个操作数：x 和 a++。

• x的值是5.0。

• a++是一个后缀自增运算符，它首先返回a的当前值（0），然后再将a的值增加1。

所以在计算x * a++之前，a的值为0。然后，a的值增加到1。

现在，表达式变成了5.0 * 0（因为++a返回了0）。结果是0。

最后，将计算得到的结果0赋给变量s0。

因此，程序打印出来的结果将是0.0。

2.6.2 关系运算符

下面的简单示例程序演示了关系运算符的用法。

package test03;
​
public class Text {
    public static void main(String[] args) {
        int a = 10,b = 20;
        System.out.println(a == b);
        System.out.println(a != b);
        System.out.println(a > b);
        System.out.println(a < b);
        System.out.println(b >= a);
        System.out.println(b <= a);     
    }
}

关系运算符都是二目运算符。

下表为Java支持的关系运算符，表中的实例假设整数变量A的值为10，变量B的值为20。

2.6.3 逻辑运算符和位运算符

1.逻辑运算符

逻辑运算符就是表示逻辑关系的运算符。

表中列出了逻辑运算符的基本运算，假设布尔变量 A为真，变量 B为假。

下面的示例程序演示了逻辑运算符。

package test03;
/*
 * 逻辑运算符操作演示
 */
public class Test_luoji {
    public static void main(String[] args) {
        boolean a = true;
        boolean b = false;
        System.out.println(a && b);
        System.out.println(a || b);
        System.out.println(!(a && b));
    }
}

程序编译运行结果如图所示。

2.位运算符

位运算符主要用于整数的二进制位运算，可以分为移位运算和按位运算。

（1）移位运算

1)位右移运算(>>)。

>>用于整数的二进制位右移运算，在移位操作的过程中符号位不变，其他位右移。

2)位左移运算（<<)。

<<用于整数的二进制位左移运算，在移位操作的过程中，左边的位移出（舍弃)，右边位补 0。

例如，将整数 a 进行左移 3 位的操作为a<<3。

3)不带符号右移运算(>>>)。

>>>用于整数的二进制位右移运算，在移位操作的过程中，右边位移出，左边位补 0。

（2）按位运算

1）按位与（&）。

&运算符用于两个整数的二进制按位与运算，在按位与操作过程中，如果对应两位的值均为1，则该位的运算结果为1，否则为0。例如，将整数a和b进行按位与操作为a&b。

2）按位或（1)。

运算符用于两个整数的二进制按位或运算，在按位或操作过程中，对应两位的值只要有一个为 1，该运算结果就为 1，否则为 0。

3） 按位异或（^）。

^运算符用于两个整数的二进制按位异或运算，在按位异或操作过程中，如果对应两位的值相异(即一个为1，另一个为0)，则该位的运算结果为 1，否则为 0。

2.6.4 赋值运算符和条件运算符

1.赋值运算符

赋值运算是编程语言中非常重要的功能。下表是Java语言支持的赋值运算符。

2.条件运算符

条件运算符是三元运算符。由条件运算符组成的条件表达式的一般使用格式是：

逻辑(关系)表达式 ? 表达式1  : 表达式2

其功能是：若逻辑(关系)表达式的值为true，则取表达式1的值：否则，取表达式 2的值。条件运算符及条件表达式常用于简单分支的取值处理。

例如，若已定义 a和b为整型变量且已赋值，求a 和b 两个数中的较大者，并赋给另一个量 max可以用如下表达式处理：

max = (a > b)  ? a : b

2.6.5 运算符优先级

表达式中运算的先后顺序由运算符的优先级确定。掌握运算符的优先级是非常重要的，它确定了表达式的表达是否符合题意，表达式的值是否正确。

表 列出了Java中所有运算符的优先级。

该表中优先级按照从高到低的顺序列出，也就是数字 1 对应的优先级最高，数字14对应的优先级最低。

结合性是指运算符结合的顺序，通常都是从左向右。从右向左的运算符最典型的就是负号。例如，3+-4，其意义为3 加-4，符号首先和运算符右侧的数字结合。

【同步训练】

训练步骤

1. 按实验要求创建工程并配置环境。

2. 获取用户输入的身高，体重，年龄等信息：

(1) 要求用户输入身高，提示语句：”请输入您的身高（单位：米）：”；

(2) 要求用户输入体重，提示语句：“请输入您的体重（单位：千克）：”；

(3) 要求用户输入年龄，提示语句：“请输入您的年龄：”；

(4) 获取用户输入的年龄；打印用户年龄

        1. 计算体脂率

(1) 体脂率的计算公式如下：

(2) BMI = 体重（公斤）÷（身高×身高）（米）；

(3) 体脂率 = 1.2×BMI+0.23×年龄-5.4；

        2. 输出结果：

控制台输出：“您的体脂率为：”+体脂率+“%”