第三章：Java语言基础

一、基本数据类型

分为：数据型，字符型，布尔型。数据型又分为整数类型和浮点类型。

1. 整数类

整数类可分为整数类型和浮点类型；整数类型：可分为byte、short、int和long4种类型。

浮点类型：可分为float、double两种类型。它们具有不同的取值范围。

long型需要在整数后面加L或者l(小写L)；float型则需要在小数后面添加F或f

代码及运行结果：

public class Number {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        byte b=3;//定义一个byte类型的变量，名字为b，值为3
        System.out.println(b);//输出b的值
        short s=456;//定义一个short类型的变量，名字为s，值为456
        System.out.println(s);//输出s的值
        int i=234567;//定义一个int的变量，名字为i，值为234567
        System.out.println(i);//输出i的值
        long l=1234567L;//定义一个long的变量，名字为l，值为1234567
        System.out.println(l);//输出l的值
        float f=0.4f;//定义一个float的变量，名字为f，值为0.4
        System.out.println(f);//输出f的值
        double d=3.1415926;//定义一个double的变量，名字为d，值为3.1415926
        System.out.println(d);//输出d的值
    }

    /*1.定义一个byte类型的变量，名字为b，值为3
     * 2.输出b的值
     * 3.定义一个short类型的变量，名字为s，值为456
     * 4.输出s的值
     * 5.定义一个int的变量，名字为i，值为234567
     * 6.输出i的值
     *7.定义一个long的变量，名字为l，值为1234567
     *8.输出l的值
     *9.定义一个float的变量，名字为f，值为0.4
     *10.输出f的值
     *11.定义一个double的变量，名字为d，值为3.1415926
     *12.输出d的值/
}

【例3.2】根据身高体重计算BMI指数

创建BMIexponent 类，声明 double 型变量 height 来记录身高，单位为米;声明 int 型变量weigh记录体重，单位为千克;根据 BMI=体重/(身高x身高)计算 BMI 指数。实例代码如下:

public class BMIexponent {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        double height=1.75;      //定义一个double变量,变量名为height,值为1.75
        int weight=70;//定义一个变量并赋值
        double exponent=weight/(height*height);//定义一个变量，并赋予公式计算结果
        System.out.println("您的身高为:"+height);//输出您的身高
        System.out.println("您的体重为:"+weight);//输出您的体重
        System.out.println("您的BMI指数为:"+exponent);//输出您的BMI指数
        System.out.print("您的体重属于:");//输出您的体重类型
        if(exponent<18.5) {//判断BMI指数类型是否<18.5
            System.out.print("体重过轻");//输出
        }
        if(exponent>=18.5&&exponent<24.9) {//判断BMI指数类型是否>=18.5并且<24.9
            System.out.print("正常范围");//输出
        }
        if(exponent>=24.9&&exponent<29.9) {//判断BMI指数类型是否>=24.9并且<29.9
            System.out.print("体重过重");//输出
        }
        if(exponent>=29.9) {//判断BMI指数类型是否>=29.9
            System.out.print("肥胖");//输出
        }
                
    }

/*1.定义一个double变量,变量名为height,值为1.75
*2.定义一个int变量weight并赋值为70
*3.定义一个double变量exponent，并赋予公式计算结果
*4.输出您的身高
*5.输出您的体重
*6.输出您的BMI指数
*7.输出您的体重类型
*8.判断BMI指数类型是否<18.5
*9.输出，如果输出数字小于18.5，输出结果就会是体重过轻
*10.判断BMI指数类型是否>=18.5并且<24.9
*11.输出，如果输出数字大于等于18.5并且小于24.9，输出结果就会是正常范围
*12.判断BMI指数类型是否>=24.9并且<29.9
*13.输出，如果输出数字大于等于24.9并且小于29.9，输出结果就会是体重过重
*14.判断BMI指数类型是否>=29.9
*15.输出，如果输出数字大于等于29.9，输出结果就会是肥胖/
}

运算结果：

2.字符类型

字符型（char）用于存储单个字符，占用16位（两个字节）的内存空间。在定义字符型变量时，要以单引号表示，如's'表示一个字符。

【例3.3】查看字符与Unicode码互转的结果

在项目中创建类Gess，编写如下代码，将Unicode表中某些位置上的字符以及一些字符在 Unicode表中的位置在控制台上输出。

public class Gess {//定义类

    public static void main(String[] args) {//主方法
        // TODO Auto-generated method stub//
        char word='d',word2='@';//定义两个char型变量word和word2,并给它们赋值d和@
        int p=23045,p2=45213;//定义两个int型变量p和p2，并给它们赋值23045和45213
        System.out.println("d在Unicode表中的顺序位置是："+(int)word);//输出word的运行结果
        System.out.println("@在Unicode表中的顺序位置是："+(int)word2);//输出word2的运行结果
        System.out.println("Unicode表中的第23045位是："+(char)p);//输出p的运行结果
        System.out.println("Unicode表中的第45213位是："+(char)p2);//输出P2的运行结果
    }
/*1.定义两个char型变量word和word2,并给它们赋值d和@
*2.定义两个int型变量p和p2，并给它们赋值23045和45213
*3.输出word的运行结果
*4.输出word2的运行结果
*5.输出p的运行结果
*6.输出P2的运行结果
}

运行结果：

转义字符是一种特殊的字符变量，它以反斜杠“\”开头，后跟一个或多个字符。将转义字符赋值给字符变量时，与字符常量值一样需要使用单引号。

【例3.4】输出‘\'字符和'*'字符

'\'字符的转移字符'\\'，'*'字符的Unicode码为2605，实例代码如下：

public class Demo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        char c1='\\';//定义一个char类型的变量，变量名为c1，值为'\\'
        char char1='\u2605';//定义一个char类型的变量，变量名为char1，值为'\u2605'
        System.out.println(c1);//输出c1
        System.out.println(char1);//输出char1
    }

/*1.定义一个char类型的变量，变量名为c1，值为'\\'
*2.定义一个char类型的变量，变量名为char1，值为'\u2605'
*3.输出c1运行结果
*4.输出char1运行结果/
}

运行结果：

3.布尔类型

布尔类型只有true和false两个值，分别代表布尔逻辑中的“真” 和“假”，用作判断条件，给boolean型变量赋初值赋小写true或false,不会报错，但是如果用大写如TRUE或FALSE就会报错,那么可以在大写的前面加第一个字母为大写的Boolean,则不会报错，大写的Boolean和小写boolean的包装类。

代码及运行结果：

public class TrueOrfalse {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        boolean b1=true;//定义一个boolean类型的变量，将true赋值给b1
        boolean b2=Boolean.FALSE;//定义一个boolean类型的变量，将Boolean.FALSE赋值给b2
        System.out.println(b1);//输出b1
        System.out.print(b2);//输出b2
    }

/*1.定义一个boolean类型的变量b1，将true赋值给b1
*2.定义一个boolean类型的变量b2，将Boolean.FALSE赋值给b2
*3.输出b1运行结果
*4.输出b2运行结果/

}

二、变量与常量

在程序执行过程中，其值不能被改变的量称为变量，其值能被改变的量称为变量。变量与常量的命名都必须使用合法的标识符。

1. 标识符和关键字

• 标识符

标识符可以简单的理解为一个名字，是用来标识类名、变量名、方法名、数组名、文件名的有效字符序列。

标识符由任意顺序的字母、下划线（-）、美元符号（$）、和数字组成。注：不能以数字开头；标识符要避开关键字；变量名中不能有斜杠。

• 关键字

关键字又称保留字，是被赋予特定意义的一些单词，不可以把这些单词作为标识符来使用。int、boolean等都是关键词。显示器所显示的代码颜色为彩色的单词都是关键字。Java语言中的关键字如下表所示。

2. 声明变量

在程序运行过程中一直不会改变的量称为常量，通常也被称为“final变量”。常量在整个程序中只能被赋值一次，如果赋值多次，运行结果就会报错，强制运行会显示一串红色英文。

【例3.5】尝试给常量赋值，观察是否会发生错误

在项目中创建类Part，在类体中创建变量age与常量PI。在主方法中分别将变量与常量赋值，通过输出信息可测试变量于常量的有效范围。

public class Part {
    static int age=20;//定义一个int变量，名为age,赋值为20
    static final double PI=3.14;//定义一个double型变量，名为PI，赋值为3.14

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        final int number;//定义一个int变量，名为number,在前面加一个final就变成了常量
        number=1235;//给它赋值
        age=22;//再次对变量进行赋值
        munbe=1456;//错误代码，number为常量，只能赋值一次
        System.out.println(number);//输出
        System.out.println(age);//输出
        System.out.println(PI);//输出
    }

/*1.定义一个int变量，名为age,赋值为20
*2.定义一个double型变量，名为PI，赋值为3.14
*3.定义一个int变量，名为number,在前面加一个final就变成了常量
*4.给它赋值为1235
*5.再次对变量进行赋值为22
*6.错误代码，number为常量，只能赋值一次
*7.输出number结果
*8.输出age结果
*9.输出PI结果/
}

运行结果：

正确的代码和运行结果：

public class Part {
    static int age=20;//定义一个int变量，名为age,赋值为20
    static final double PI=3.14;//定义一个double型变量，名为PI，赋值为3.14

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        final int number;//定义一个int变量，名为number,在前面加一个final就变成了常量
        number=1235;//给它赋值
        System.out.println(number);//输出
        System.out.println(age);//输出
        System.out.println(PI);//输出
    }

/*1.定义一个int变量，名为age,赋值为20
*2.定义一个double型变量，名为PI，赋值为3.14
*3.定义一个int变量，名为number,在前面加一个final就变成了常量
*4.给它赋值为1235
*5.输出number结果
*6.输出age结果
*7.输出PI结果/
}

运行结果：

3. 变量的有效范围

变量的有效范围是指程序代码能够访问该变量的区域，若超出该区域，则在编译时会出现错误。在程序中，一般会根据变量的”有效范围“将变量分为”成员变量“和”局部变量“。

• 成员变量

在类体中所声明的变量被称为成员变量，成员变量在整个类中都有效。

• 局部变量

在类的方法体中声明的变量（方法内部定义，”{“与”}“之间的代码中声明的变量）称为局部变量。局部变量只在当前代码块中有效，也就是只能在”{“与”}“之内使用。

变量的有效范围如下图所示：

【例3.6】把成员变量”排挤掉“的局部变量

在项目中创建类Val，分别定义名称相同的局部变量与成员变量，当名称相同时成员变量将被隐藏。

public class Val {
    static int times=3;//定义一个成员变量times,赋值为3

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int times=4;//定义一个局部变量times,赋值为4
        System.out.println("time的值为："+times);//将times的值输出
    }

/*1.定义一个int型成员变量times,赋值为3
*2.定义一个int型局部变量times,赋值为4
*3.将times的值输出/
}

运行结果：

结果会以就近原则运行出来。我们可以在定义的局部变量前加“//”,运行的结果就会是成员变量；还可以在输出值的那一行加类名，运行结果也会是成员变量。如“System.out.print("times的值为："+times)；”改成“System.out.print("times的值为："Val.+times)”

三、运算符

1. 赋值运算符

赋值运算符以符号“=”表示，它是一个二元运算符（对两个操作数做处理），其功能是将右方操作数所含的赋值给左方的操作数。左方的操作数必须是一个变量，而右方的操作数 则可以是任何表达式，包括变量、常量、有效的表达式。

表达式中若含有两个以上的“=”运算符 ，会从最右方的“=”开始处理。

【例3.7】使用赋值运算符同时为两个变量赋值

在项目中创建类Eval，在主方法中定义变量，使用赋值运算符为变量赋值

public class Eval {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int a,b,c;//定义三个int型变量a,b,c
        a=15;//定义三个int型变量a,b,c
        c=b=a+4;//把变量a与4的和赋值给变量b，然后再赋值给变量c
        System.out.println("c的值为："+c);//输出变量c的值
        System.out.println("b的值为："+b);//输出变量b的值

    }

/*1.定义三个int型变量a,b,c
*2.定义三个int型变量a,b,c
*3.把变量a与4的和赋值给变量b，然后再赋值给变量c
*4.输出变量c的值
*5.输出变量b的值/
}

运行结果：

2. 算术运算符

Java中的算术运算符主要有+（加）、-（减）、*（乘）、/（除）、%（求余）。其中，“+”和“-”运算符还可以作为数值的正负值的正负符号。

【例3.8】使用算术运算符模拟计算器

创建ArithmeticOperator类，任意输入两个数字，分别用5种运算符对这两个数字进行计算。

代码及运行结果：

import java.util.Scanner;

public class ArithmeticOperator {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner sc=new Scanner(System.in);//创建扫描器，获取控制台输入的值
        System.out.println("请输入两个数字，用空格隔开(num1 num2):");//输入运行提示
        double num1=sc.nextDouble();//记录输入的数字num1
        double num2=sc.nextDouble();//再次记录输入的数字num2
        System.out.println("num1+num2的和为："+(num1 + num2));//输出记录的两数的和
        System.out.println("num1-num2的差为："+(num1 - num2));//输出记录的两数的差
        System.out.println("num1*num2的积为："+(num1 * num2));//输出记录的两数的积
        System.out.println("num1/num2的商为："+(num1 / num2));//输出记录的两数的商
        System.out.println("num1%num2的余数为："+(num1 % num2));//输出记录两数的余数
        sc.close();//关闭扫描器 
    }

/*1.创建扫描器，获取控制台输入的值
*2.输入运行提示
*3.记录输入的数字num1
*4.记录输入的数字num1
*5.输出记录的两数的和
*6.输出记录的两数的差
*7.输出记录的两数的积
*8.输出记录的两数的商
*9.输出记录两数的余数
*10.关闭扫描器/
}

运行结果：

3. 自增和自减运算符

符号在前，先运算后使用；符号在后，先使用，后计算。

“++a”与“a++”的作用都相当于a=a+1。假设a=4，则：

b=++a； //先将a的值加1，然后赋给b，此时a值为5，b值为5

另一个语法，同样假设a=4，则：

b=a++； //先将a的值赋给b，再将a的值变为5，此时a的值为5，b的值为4

4. 比较运算符

比较运算符属于二元运算符，用于程序中的变量之间、变量和自变量之间以及其他类型的信息之间的比较。比较运算符的运算结果是boolean型。当运算符对应的关系成立时，运行结果为true,否则为false.

【例3.9】使用不同的比较运算符判断两个整数的关系

在项目中创建类Compare,在主方法中创建整型变量，使用比较运算符对变量进行比较运算，并输出运算结果。代码如下：

public class Compare {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int number1=4;//定义一个int型变量number1,并赋值为4
        int number2=5;//定义一个int型变量number2,并赋值为5
        //依次将变量number1与变量number2的比较结果输出
        System.out.println("number1>number2的返回值为："+(number1>number2));//
        System.out.println("number1<number2的返回值为："+(number1<number2));//
        System.out.println("number1==number2的返回值为："+(number1==number2));//
        System.out.println("number1!=number2的返回值为："+(number1!=number2));//
        System.out.println("number1>=number2的返回值为："+(number1>=number2));//
        System.out.println("number1<=number2的返回值为："+(number1<=number2));//
    }

/*1.定义一个int型变量number1,并赋值为4
*2.定义一个int型变量number2,并赋值为5
*3.比较number1与number2的大小，当number1大于number2时，它们的返回值为ture或者false
*4.当number1小于number2时，它们的返回值为...
*5.当number1等于number2时，它们的返回值为...
*6.当number1不等于number2时，它们的返回值为...
*7.当number1大于等于number2时，它们的返回值为...
*8.当number1小于等于number2时，它们的返回值为.../
}

运行结果如下：

5. 逻辑运算符

逻辑运算符的操作元必须是boolean型数据。在逻辑运算符中，除了“！”是一元运算符，其他都是二元运算符。

逻辑运算符包括：&(&&)(逻辑与)、||（逻辑或）、！（逻辑非）。

逻辑运算符口诀：两者都为真，结果才是真。 只要有一者为真，结果就是真。非真即假，非假即真。

【例3.10】使用不同的比较符判断两个整数的关系

在项目中创建类Calculation，在主方法中创建3个整数，分别记录男生人数、女生人数和总人数，使用逻辑运算符来判断“男生人数大于女生人数并且总人数大于 30 人”和“男生人数大于女生人数或者总人数大于 30 人”这两种情况是否存在。

public class Calculation {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int boys=15;// 男生人数
        int girls=17;//女生人数
        int totle=boys+girls;//总人数
        boolean result1=((boys>girls)&&(totle>30));//男生人数多于女生，且总人数大于30
        boolean result2=((boys>girls)||(totle>30));//男生人数多于女生，或总人数大于30
        System.out.println("男生人数大于女生人数并且人数大于30人："+result1);//输出结果
        System.out.println("男生人数大于女生人数或者人数大于30人："+result2);
        
    }
/*1.定义一个int型变量boys,并赋值为15
*2.定义一个int型变量girls，并赋值为17
*3.定义一个int型变量totle,并赋值为boys+girls
*4.定义一个boolean型变量result1,并判断”男生人数大于女生人数并且总人数大于30人“时是否存在
*5.定义一个boolean型变量result2,并判断”男生人数大于女生人数或者总人数大于30人“时是否存在
}

运行结果：

6. 位运算符

位运算符除“按位与”和“按位或”运算符外，其他只能用于处理整数的操作数，包括byte、short、char、int和long等数据类型。位运算符是完全针对位方面的操作。

左边最高位是符号位，最高位是0表示正数，若位1则表示负数。负数采用补码表示。

• “按位与”运算

“按位与”运算的运算符为“&” 口诀：两者都为1，结果才是1.

• “按位或”运算

“按位或”运算的运算符为“|” 口诀：只要有一者为1，结果就是1.

• “按位取反”运算

“按位取反”运算的运算符为“~” 口诀：0变1，1变0.

• ”按位异或“运算

”按位异或“运算的运算符为"^" 口诀：两者相同，即为0，不同为1.

• 移位操作

Java中的移位运算符有以下3种：

<< :左移 口诀：整体左移，空位补0，溢出去掉。

>> :右移 口诀：整体右移，整数补0，负数补1，溢出去掉。

>>> :无符号右移 口诀：整体右移，空位补0，溢出去掉。

7. 三元运算符

三元运算符的使用格式为：返回值=判断公式？结果1：结果2

三元运算符的运算规则为：若条件式的值为true，则整个表达式取结果1，否则取结果2.

三元运算符等价于if...else语句，例如：

public class If {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        boolean a;//定义一个boolean型的变量a
        if(20<45);//将20<45作为判断条件
        a=true;//条件成立，将true赋值给a
        else
            a=false;//条件不成立，将false赋值给a
    }

/*1.定义一个boolean型的变量a
*2.将20<45作为判断条件
*3.条件成立，将true赋值给a
*4.条件不成立，将false赋值给a/

}

运行结果：条件不成立，报错

四、数据类型转换

类型转换是将一个值从一种类型更改为另一种类型的过程。数据类型转换有两种，可分为：

1. 隐式类型转换

隐式类型转换也叫自动类型转换，它一定不会丢失数据。

从低级类型向高级类型的转换，系统将自动执行，程序员无须进行任何操作。这些类型按精度从低到高排列的顺序为byte<short<int<long<float<double。

隐式转换也要遵循一定的规则，在什么情况下将那种类型转换成另一种类型的数据。表3.10列出了各种数据类型隐式转换的一般规则。

【例3.11】使用隐式转换提升数值的精度

在项目中创建 类Conver，在主方法中创建不同数值型的变量，实现将各变量隐式转换。

代码及运行结果：

public class Conver {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        byte mybyte=127;//定义一个byte型变量mybyte,并把允许的最大值赋值给mybyte
        int myint=150;//定义一个int型变量myint，并赋值150
        float myfloat=452.12f;//定义一个float型变量myfloat,并赋值452.12
        char mychar=10;//定义一个char型变量mychar，并赋值10
        double mydouble=45.46546;//定义一个double型变量mydouble，并赋值45.46546
        System.out.println("byte型与float型数据进行运算结果为："+(mybyte+mybyte));//输出
        System.out.println("byte型与int型数据进行运算结果为："+(mybyte+myint));//输出
        System.out.println("byte型与char型数据进行运算结果为："+(mybyte+mychar));//输出
        System.out.println("double型与char型数据进行运算结果为："+(mydouble+mychar));//输出
    }

    /*1.定义一个byte型变量mybyte,并把允许的最大值赋值给mybyte
     * 2.定义一个int型变量myint，并赋值150
     * 3.定义一个float型变量myfloat,并赋值452.12
     * 4.定义一个char型变量mychar，并赋值10
     * 5.定义一个double型变量mydouble，并赋值45.46546
     * 6.输出byte型与float型数据进行运算的结果
     *7.输出byte型与int型数据进行运算的结果
     *8.输出byte型与char型数据进行运算的结果
     *9.输出double型与char型数据进行运算的结果/
}

2. 显式类型转换

也叫强制类型转换，有可能会丢失数据。

当把高精度的变量的赋值给低精度的变量时，必须使用显式类型转换运算。

语法如下：

（类型名）要转换的值

例如，将高精度数字转换为低精度数字。代码如下：