Java PTA(2)——数据类型与运算符

770-0

已于 2024-06-11 20:28:54 修改

阅读量903

点赞数 17

文章标签： java 开发语言

于 2023-12-15 19:46:39 首次发布

本文链接：https://blog.csdn.net/m0_61442114/article/details/135018910

版权

二.数据类型与运算符

1.java语言基本元素

（1）标识符

程序员对程序中的各个元素加以命名时使用的命名记号称为标识符（identifier）包括：类名、变量名、常量名、方法名、…
Java语言中，标识符是以字母，下划线(_),美元符($)开始的一个字符序列，后面可以跟字母，下划线，美元符，数字。
合法的标识符 identifier userName User_Name _sys_value $change
非法的标识符 2mail room# class

（2）保留字

具有专门的意义和用途，不能当作一般的标识符使用，这些标识符称为关键字。

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

（3）关键字

基本分类：

数据和返回值类型：int, void, return……
包/类/成员/接口：package, class, interface
访问控制：public, private, protected
循环及循环控制：if, switch, break
例外处理：throw, try, finally
保留字：goto, const，true，false，null

注意事项：

在Java中，所有关键字都是小写。例如，true、false和null，区别于C++中大写的TRUE、FALSE和NULL。
所有的数据类型所占用的字节数都是固定的，和平台无关，因此在Java中没有sizeof操作符。
不必死记这些关键词，当理解每个关键词的含义后，自然就记住了所有的关键词。

2.java数据类型

（1）常量——final

常量：

        Java中的常数是用文字串表示的，它区分为不同的类型，如整型常量123，实型常量1.23，字符常量'a'，布尔常量true、false以及字符串常量"This is a constant string."。

标识符常量：

        与C、 C++不同，Java中不能通过#define命令把一个标识符定义为常量，而是用关键字final来定义，其定义格式为：

        final Type varName = value [, varName [ =value] …];

        final int GLOBAL_ACCOUNT=100;

        final double PI=3.14159

（2）变量

程序中的基本存储单元，其定义包括变量名、变量类型和作用域三个部分。

定义格式为： Type varName [= value ][{, varName [=value]}];

int n = 3, n1 = 4;

Java中变量的缺省初值(成员变量)都是确定的：

布尔变量的初值为：false
整数变量的初值为：0
浮点数变量的初值为：0.0
字符型变量的初值为：'\u0000'
引用（复合）变量的初值为：null

在方法实现中定义的变量必须显式的初始化。

（3）数据类型

基本数据类型

所有基本类型所占的位数都是确定的，并不因平台的不同而不同。
所有基本类型的关键词都是小写的。

1.布尔类型 boolean

布尔型数据只有两个值true和false，且它们不对应于任何整数值
布尔型数据只能参与逻辑关系运算： && || = = != !

2.字符类型 char

字符型数据代表16位的Unicode字符
字符常量是用单引号括起来的一个字符
字符型数据的取值范围为 0~65535 或者说 \u0000~\uFFFF ，\u0000为缺省值

示例

char c1;       \\ 缺省值为0

char c2 = '0';   \\ 赋初值为字符'0'

char c3 = 32;   \\ 用整数赋初值为空格

特殊字符的常量表示法：

反斜线（Backslash）    '\\'

退格（Backspace）         '\b'

回车（Carriage return） '\r'

进纸符（Form feed）       '\f'

制表符（Form feed）       '\t'

换行（New line） '\n'

单引号（Single quote）   '\''

Unicode字符 '\uHHHH'

3.整数类型 byte、short、int、long

十进制整数    如123，－456，0
八进制整数    以0开头，如0123表示十进制数83，－011表示十进制数－9
十六进制整数    以0x或0X开头，如0x123表示十进制数291，－0X12表示十进制数－18

整型变量(每一个整型常数默认为int类型，占有32位 )

类型为byte、short、int或long

byte在机器中占8位，short占16位，int占32位，long占64位。

整型变量的定义如：

int x=123; //指定变量x为int型，且赋初值为123

byte b = 8;

short s = 10;

long y = 123L; 或 long z = 123l; 64位长整数以l或L结尾

4.浮点数类型 float、double

实型常量

1. 十进制数形式

由数字和小数点组成，且必须有小数点，如0.123, .123, 123.,123.0

2. 科学计数法形式

如：123e3或123E3，其中e或E之前必须有数字，且e或E后面的指数必须为整数。

32位浮点数形式： 0.23f, 1.23E-4f , . 18F

实型变量(实数的默认类型是double型,占64位)

类型为float或double，float在机器中占32位，double占64位。

实型变量的定义如：

double d1 = 127.0;   \\ 赋初值为127

double d2 = 127;   \\ 赋初值为127

float f1 = 127.0f;   \\ 必须在数字后加f或F

float f2 = 4.0e38f;   \\ 错误！32位浮点数不能超过3.4028234663852886e38

float f3 = (float)d1; \\必须强制类型转换

5.数据类型转换

自动类型转换

整型、实型、字符型数据可以混合运算。

运算中，不同类型的数据先转化为同一类型，然后进行运算，转换从低级到高级：

低----------------------------------------------------------->高

byte,short,char—> int —> long—> float —> double

当单目运算的操作数类型是byte、short或char时，自动转换为int类型;

否则保持原有类型，不进行转换。

数据类型转换必须满足如下规则：

不能对boolean类型进行类型转换。
不能把对象类型转换成不相关类的对象。
在把容量大的类型转换为容量小的类型时必须使用强制类型转换。宽整型强制转换为窄整型(n位)时，只保留最低的n位。

转换过程中可能导致溢出或损失精度

int i = 8;

byte b=(byte)i;

(byte)255 == -1   (byte)0x5634 == 0x34

浮点数到整数的转换是通过舍弃小数得到，非四舍五入

(int)23.7 == 23   (int)-45.89f == -45

复合(引用)数据类型

在Java中，引用（reference）指向一个对象在内存中的位置，本质上它是一种带有很强的完整性和安全性限制的指针。

当你声明某个类、接口或数组类型的变量时，那个变量的值总是某个对象的引用或者是null。

指针就是内存地址，引用除了表示地址而外，还象被引用的数据对象的缩影，还提供其他信息。
指针可以有++、--运算，引用不可以运算。

引用型变量只支持有限的逻辑判断：

相等判断（是否同一个对象的引用）：== !=

        theObject == null

        otherObject != theObject

类型判断（是否是某个类的实例）： instanceof

        theObject instanceof ClassName

        "" instanceof String

        例：Car car=new Car();

                if (car instanceof Car) result=1;

                else result=0;

3.java语言的结构

（1）运算符

算术运算符： +，-，*，/，%，++，--

关系运算符： >，<，>=，<=，==，!=

布尔逻辑运算符： !，&&，|| ，&，|

位运算符： >>，<<，>>>，&，|，^，~

赋值运算符： =，及其扩展赋值运算符如+=，-=，*=，/=等。

条件运算符： ? ：

其它

        分量运算符 ·

        下标运算符 []

        实例运算符 instanceof

        内存分配运算符 new

        强制类型转换运算符 (类型)

        方法调用运算符 ()

         …

由于数据类型的长度是确定的，所以没有长度运算符sizeof。

instanceof 是 Java 的保留关键字。

它的作用是测试它左边的对象是否是它右边的类的实例，返回 boolean 的数据类型。

instanceof是Java中的二元运算符，左边是对象，右边是类；

当对象是右边类或子类所创建对象时，返回true；否则，返回false。

类的实例包含本身的实例，以及所有直接或间接子类的实例

instanceof左边显式声明的类型与右边操作元必须是同种类或存在继承关系，也就是说需要位于同一个继承树，否则会编译错误

运算符的优先次序

1）   . , [] , ()
2）   ++ , -- , ! , ~ , instanceof
3）   new (type)
4）   * , / , %
5）   + , -
6）   >> , >>> , <<
7）   > , < , >= , <=
8）   == , !=
9）   &
10）^
11）|
12）&&
13）||
14）?:
15）= , += , -= , *= , /= , %= , ^=
16）&= , |= , <<= , >>= , >>>=

位运算符

位运算符功能

~ 取反 &按位与 |按位或 ^按位异或

移位运算符

左移

         "a<<b; "将二进制形式的a逐位左移b位，最低位空出的b位补0；

带符号右移

        "a>>b; "将二进制形式的a逐位右移b位，最高位空出的b位补原来的符号位；

无符号右移

        "a>>>b;"将二进制形式的a逐位右移b位，最高位空出的b位补0。

移位运算符性质

适用数据类型:byte、short、char、int、long，对低于int型的操作数将先自动转换为int型再移位
对于int型整数移位a>>b，系统先将b对32取模，得到的结果才是真正移位的位数
对于long型整数移位时a>>b，则是先将移位位数b对64取模

（2）表达式

例子：

(1)用int变量a,b,c表示三个线段的长，它们能构成一个三角形的条件是：任意两边之和大于第三边。

该条件的Java布尔表达式为：

(a + b) > c && (b + c) > a && (a + c) > b

或 !((a + b) <= c || (b + c) <= a || (a + c) <= b)

(2)用int变量y，表示年号y是闰年：

y%400==0 || y%4==0 && y%100!=0

(3)用int变量age存放年龄，boolean变量sex存放性别（true为男），表示20岁与25岁之间的女性：

age>=20 && age <= 25 && !sex

表达式的计算次序

从左到右，并尊重运算符优先级和结合性的原则进行。
结合性:确定同级运算符的运算顺序。运算符有左结合性和右结合性两种。左结合性指的是从左向右使用运算符。例如二元算术运算符具有左结合性，计算a + b - c时；而右结合性是从右向左使用运算符。例如，赋值运算符具有右结合性，计算a = b = c时。

（3）注释

// 单行注释，简单的解释语句含义.

/* 多行注释，用来说明更多的内容，包括算法等. …… */

/** Java文档注释，可以通过javadoc生

* 成类和接口的HTML格式的帮助文档.

* 这种注释有其特殊的格式（参见相关文档）

*/

（4）语句和代码段

一个由分号（;）结尾的单一命令是一条语句（Statement），一条语句一般是一行代码，但也可以占多行代码。
用大括号（{…… }）围起来的多条语句构成一个代码段（Code block）

（5）作用域

作用域决定了变量可使用的范围

成员变量（Global variables）：变量可以在整个类中被访问；

局部变量（ Local variables ）：变量只能在定义其的代码段中被访问。

作用域规则：在一个代码段中定义的变量只能在该代码段或者该代码段的子代码段中可见。

使用局部变量比使用成员变量更安全。

4.包装类

Java语言中专门提供了所谓的包装类（wrapper class）。这些类将基本类型包装成类。

使用包装类的方法与普通类一样，定义对象的引用、用new运算符创建对象，用方法来对对象进行操作。

（1）包装类的类型转换

1）Integer的parseInt方法将字符串转换为整型数值，同样，其它包装类可将字符串转为相应基本类型数值。

public static int parseInt(String s)

public static float parseFloat(String s)

public static double parseDouble(String s)

public static long parseLong(String s)

public static byte parseByte(String s)
String s="12.34";
float     y1=Float.parseFloat(s);
double y2=Double.parseDouble(s);
int        y3=Integer.parseInt(“1234”);
long     y4=Long.parseLong(“12345678”);
byte     y5=Byte.parseByte(“123”);

2）toString方法将基本类型数值转换为字符串

float  x1=12.34f;
double x2=123.4;
int  x3=1234;
long x4=12345678;
byte x5=123;
String ss1=Float.toString(x1);
String ss2=Double.toString(x2);
String ss3=Integer.toString(x3);
String ss4=Long.toString(x4);
String ss5=Byte.toString(x1);

3）valueOf方法将字符串转换为包装类型

int i=Integer.valueOf(str).intValue()

第一步：valueOf(str)：返回一个整型(Integer)对象，该对象含有字符串str表示的整数值。

第二步，intValue() ：返回整型对象的整数值。

同理，有： String s1=“3.1415926”;

float y1=Float.valueOf(s1).floatValue();

4）String类的valueOf方法将基本类型数值转换为字符串

float  x1=12.34f;
double x2=123.4;
int    x3=1234;
long   x4=12345678;
String s1=String.valueOf(x1);
String s2=String.valueOf(x2);
String s3=String.valueOf(x3);
String s4=String.valueOf(x4);

5.装箱和拆箱

装箱：把基本类型的值转换为相应的包装类对象。

拆箱：把包装类对象转换为基本类型的值。

Integer iobj=new Integer(100); //装箱

Float fobj=new Float(3.14f); //装箱

int i=iobj.intValue(); //拆箱

float f=fobj.floatValue(); //拆箱

6.输入输出初步

System.out.println:在程序中可以将常量、变量或表达式的值输出到屏幕。

参数可以是任何类型的，各种类型的数据转换成相应的字符串类型输出。

print和println方法的区别——println自动换行

用“+”运算符连接多个输出项为一项进行输出。

System.in.read(): 可用于从键盘输入整数值在0-255之间的byte值（单个字符）。

不论从键盘输入何种类型的数据，Java从键盘接收数据都是以字符的形式进行，再根据实际数据的需要进行类型转换。

7.题目

（1）判断题

1.1 java语言中不用区分字母的大写小写。（F）

1.2 Java的字符类型采用的是Unicode编码，每个Unicode码占16个比特。（T）

1.3 数组也是对象。（T）

1.4 使用方法length( )可以获得字符串或数组的长度。（F）

使用 length 获得数组的长度

使用 length() 获得字符串的长度
int [] a = new int[3];
System.out.println(a.length);

String b = "ancd";
System.out.println(b.length());

1.5 一个Java源文件中可以有多个类，但只能有一个类是public的。(T)

1.6 boolean型数据的值只有true和false。(T)

1.7 Java中的常量用final关键字修饰，标识符一般大写，赋值机会只有一次，必须在定义的时候赋初值。(F)

1.8 Java中，通过强制类型转换实现高精度的数据类型向低精度的数据类型赋值时，其数值不变。(F)

1.9 Java基本数据类型的变量所占存储空间大小是固定的，与平台（操作系统）无关。这样方便程序的移植。(T)

1.10 Java中，某个四则运算表达式中的数值有一个是double类型，则计算之后的数值一定是double类型。(T)

1.11 -5%3的运算结果是2。(F)

1.12 在为double类型的变量赋值时，后面可以加字母D或d，也可以不添加。(T)

1.13 在Java中，小数会被默认是double类型的值。(T)

1.14 JAVA中常量名所有字母都大写，单词之间用下划线连接。(T)

1.15 "float height=1.0f;"是正确的float变量声明。(T)

1.16 “byte amout=128;”是正确的byte型变量声明。(F)

byte—— 8位 —— -2^7 ~ 2^7-1（-128 ~ 127）

（2）单选题

2.1 下面（）表达式可以得到x和y中的最大值。

A.x>y?y:x

B.x<y?y:x

C.x>y?(x+y):(x-y)

D.x==y?y:x

2.2 假设有如下程序：

public class Demo {
          public static void main(String args[]) {
                   int num = 50 ;
                   num = num ++ * 2 ;
                   System.out.println(num) ;
         }
}

最终的执行结果是什么？

A.50.0

B.102.0

C.100.0

D.101.0

2.3 假设有如下程序：

public class Demo {
        public static void main(String args[]) {
                int num = 68 ;
                char c = (char) num ;
                System.out.println(c) ;
        }
}

最终的执行结果是什么？

A.B

B.C

C.D

D.a

2.4 以下语句输出的结果是?

 String str="123";
 int x=4,y=5;
 str = str + (x + y);
 System.out.println(str);

A.1239

B.12345

C.会产生编译错误

D.123+4+5

2.5 一个表达式中有int、byte、long、double型的数据相加，其结果是（）类型的值

A.int

B.long

C.byte

D.double

2.6

阅读下列Java程序，如果在命令窗口输入java cmdtest Welcome to Earth!来运行此程序，请写出程序运行时输出结果：

class cmdtest {
   public static void main(String[] args){
      for(int i=0;i＜args.length;i++){
         System.out.println("args["+i+"]="+args[i]);
      }
   }
}

args[0]=java
args[1]=cmdtest
args[2]=Welcome
args[3]=to
args[4]=Earth!

args[0]=java
args[1]=cmdtest
args[2]=Welcome to Earth!

args[1]=Welcome
args[2]=to
args[3]=Earth!

args[0]=Welcome
args[1]=to
args[2]=Earth!

2.7 下列关于变量作用域的说法中，正确的是（）

A.在main()方法中任何位置定义的变量，其作用域为整个main()方法。

B.代码块中定义的变量，在代码块外也是可以使用的。

C.变量的作用域为：从定义处开始，到变量所在代码块结束的位置。

D.变量的作用域不受代码块的限制。

2.8 以下标识符中，不合法的是（）

A.user

B.$inner

C.class

D.login_1

2.9 下列选项中，不属于赋值运算符的是（）

A.-=

B.=

C.==

D.*=

2.10 下列选项中，不属于比较运算符的是（）

A.=

B.==

C.<

D.<=

2.11 执行下列程序后，输出的正确结果是（）。

public class Test {
    public static void main(String[] args) {
        System.out.print(100%3);
        System.out.print(",");
        System.out.println(100%3.0);
    }
}

A.1,1

B.1,1.0

C.1.0,1

D.1.0,1.0

2.12 下列赋值语句中错误的是（）。

A.float a=11.2f;

B.double b=5.3E10;

C.char c='\r;

D.byte d=433;

2.13 假设有以下整型变量赋初值语句：int i=1+1/2+1/4；请问该语句执行后变量i的值为：

A.1

B.1.75

C.2.5

D.3

2.14 下面程序段：

boolean a = false;
boolean b = true;
boolean c = (a && b) && (!b);
boolean result = (a & b) & (!b);

执行完后，正确的结果是（）。

A.c=false; result=false;

B.c=true; result=true;

C.c=true; result=false;

D.c=false; result=true;

2.15 下列选项中，（）是正确的char型变量的声明。

A.char ch="R";

B.char ch='\\'

C.char ch='ABCD'

D.char ch="ABCD"

（3）编程题

7-1 jmu-Java-02基本语法-06-枚举

定义一个枚举类型Grade来表示考试的4个等级，值包含A,B,C,D,E

编写一个函数Grade getGrade(int score)将传递进来的score转化为枚举类型
>=90 and <=100返回A，
>=80 and <90 返回B，
>=70 and <80 返回C，
>=60 and <70返回D，
其他的返回E

#main方法
输入分数后，调用getGrade函数返回相应的Grade，使用switch根据Grade，根据分数打印不同的评价：
Excellent Good Average Fair Poor
并且每输出一个评语后，要调用如下函数

public static void printGradeInfo(Grade grade){
       System.out.println("class name="+Grade.class);
       System.out.println("grade value="+grade);
}

输入样例:

输出样例:

Excellent
class name=class Grade
grade value=A
Good
class name=class Grade
grade value=B
Average
class name=class Grade
grade value=C
Fair
class name=class Grade
grade value=D

代码：

import java.util.*;
enum Grade{
    A, B, C, D, E;// 定义一个枚举类型Grade来表示考试的4个等级
}
 
public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            int score = sc.nextInt();
            Grade dengji = getGrade(score); //输入score，并调用函数
            switch(dengji){
                    case A: System.out.println("Excellent"); break;
                    case B: System.out.println("Good"); break;
                    case C: System.out.println("Average"); break;
                    case D: System.out.println("Fair"); break;
                    case E: System.out.println("Poor"); break;
                }
            printGradeInfo(dengji);
            }
    }
    
    public static Grade getGrade(int score){
        if(score > 100 ) return Grade.E;
        else if(score >= 90) return Grade.A;
        else if(score >= 80) return Grade.B;
        else if(score >= 70) return Grade.C;
        else if(score >= 60) return Grade.D;
        else return Grade.E;
    }
    
    public static void printGradeInfo(Grade grade){
       System.out.println("class name="+Grade.class);
       System.out.println("grade value="+grade);
    }
}

7-2 编程题：判断闰年

根据输入的正整数y所代表的年份，计算输出该年份是否为闰年
闰年的判断标准：

能够被4整除且不能被100整除的年份

或者能够被400整除的年份

输入格式:

输入n取值范围是【1..3000】

输出格式:

是闰年，输出 yes

非闰年，输出 no

输入样例:

在这里给出一组输入。例如：

输出样例:

在这里给出相应的输出。例如：

no

代码：

 
import java.util.Scanner;
 
public class Main {  
     public static void main(String[] args) {
       Scanner sc=new Scanner(System.in);
       int leap=sc.nextInt();
       if((leap%4==0&&leap%100!=0)||(leap%400==0)) {
    	 
    	   System.out.println("yes");
       }else {
    	   System.out.println("no");
       }
    	 
    }
}

7-3 计算摄氏温度

求华氏温度100对应的摄氏温度
计算公式：celsius = 5 * (100 - 32) / 9

输入格式:

无

输出格式:

输出100和对应的摄氏温度

输入样例:

在这里给出一组输入。例如：

输出样例:

在这里给出相应的输出。例如：

100 37.78

代码：

public class Main{
    public static void main(String[]args){
        int num = 100;
        double celxius =(double) 5*(num - 32)/9;
        //保留两位小数
        celxius = (double) Math.round(celxius*100)/100;
        System.out.println(num+" "+celxius);
    }
}

或


public class Main {
    public static void main(String[] args){
        int n = 100;
        double celsius =5*((double)n-32)/9;
        String result =String.format("%.2f",celsius);
        System.out.println(n+" "+result);
    }
}