第三章JAVA总结

---

3.1 java主类结构

例题3.1：

package NUmber;
public class Frist{
    static String s1="你好";
    public static void main(String[]args){
        String s2="java";
        System.out.println(s1);
        System.out.println(s2);
    }
}

1. 包声明：一个JAVA应用程序是由若干个类组成的.在例题3.1中就是一个类名为Frist的类，语句package Number为声明该类所在的包，package为包的关键字。

2. 声明成员变量和局部变量：通常将类的属性称为类的全局变量（成员变量），将方法中的属性称为局部变量。全局变量声明在类体中，局部变量声明在方法体中。全局变量和局部变量都有各自的应用范围。在例题3.1中，s1是成员变量，s2是局部变量。

1. 编写主方法：main（）方法是类体中的主方法。该方法从“{”开始，至“}”结束。public、static和void分别是main（）方法的权限修饰符、静态修饰符和返回值修饰符，Java程序中的main（）方法必须声明为public static void。String[]args是一个字符串类型的·数组，它是main（）方法的参数。main（）方法是程序开始执行的位置。

2. 导入API类库：在java语言中可以通过import关键字导入相关的类。在·JDK的API中（应用程序接口）提供了130多个包，如java.awt、java.io等。可以通过JDK的API文档来查看这些包中的类，把握类的继承结构、类的应用、成员变量表。构造方法表等，并对每个变量的使用目的进行了解，API文档是程序开发人员不可或缺的工具。

---

3.2、基本数据类型

1. 整数类型：整数类型简称整型，用来存储整数数值，即没有小数部分的数值。可以是正数，也可以是负数。整型数据根据它所占内存大小的不同，可分为byte、short、int、和long4种类型。它们具有不同的取值范围，如下图所示。

数据类型	内存空间（8位等于1字节）	取值范围
byte	8位（1字节）	-128~127 /-2的7次方~2的7次方减1
hort	16位（2字节）	-32768~32767/-2的15次方~2的15次方减1
int	32位（4字节）	-2147483648~2147483647/-2的31次方~2的31次方减1
long	64位（8字节）	-9223372036854775808~9223372036854775807-2的63次方~2的63次方减1

2. 浮点类型：浮点类型简称浮点型，用来存储含有小数部分的数值。JAVA语言中浮点类型分为单精度浮点类型（float）和双精度浮点类型（double），它们具有不同的取值范围，如下图所示。

数据类型	内存空间（8位等于1字节）	取值范围
float	32位	1.4E-45~3.4028235E38
double	64位	4.9E-324~1.7976931348623157E308

例题3.2：根据身高体重计算BMI指数

代码为：

public class BMIexponent {
    public static void main(String[]args) {
        double height =1.72;        //身高变量，单位：米
        int weight =70 ;            //体重变量，单位：千克
        double exponent =weight/(height*height);  //BMI计算公式
        System.out.println("您的身高为："+height);
        System.out.println("您的体重为："+weight);
        System.out.println("您的BMI指数为："+exponent);
        System.out.println("您的体重属于：");
        if(exponent<18.5) {         //判断BMI指数是否小于18.5
            System.out.println("体重过轻");
        }
        if (exponent>=18.5 && exponent<24.9) {      //判断BMI指数是否在18.5到24.9之间
            System.out.println("正常范围");
        }
        if (exponent>=24.9 && exponent<29.9) {      //判断BMI指数是否在24.9到29.9之间
            System.out.println("体重过重");
        }
        if(exponent>=29.9) {                        //判断BMI指数是否大于29.9
            System.out.println("肥胖");
        }
    }
}

结果为：

---

3.3字符类型

（1）char型：字符类型（char）用于存储单个字符，占用16（两个字节）的内存空间。在定义字符型变量时，要以单引号表示，如's'表示一个字符。但是“s”则表示一个字符串，虽然只有一个字符，但由于使用双引号，它仍然表示字符串，而不是字符。

例题3.3查看字符与Unicode互转结果

代码为：

public class Gess {            //定义类
    public static void main(String[]args) {           //主方法
        char word ='d', word2 = '@';                  //定义char型变量
        int p = 23045,p2= 45213;                      //定义int型变量
        System.out.println("d在Ubicode表中的顺序位置是："+(int)word);
        System.out.println("@在Ubicode表中的顺序位置是："+(int)word2);
        System.out.println("Ubicode表中的第23045位是:"+(char)p);
        System.out.println("Ubicode表中的第45213位是:"+(char)p2);
    }
}

结果为：

---

（2）转义字符：转义字符是一种特殊的字行变量，它以反斜杠“\”开头，后跟一个或多个字符。转义字符具有特定的含义，不同于字符原有的意义，故称“转义”。例如，printf的数的格式串中用到的“\n”就是一个转义字符，意恩是“回车换行”。Java 中的转义字符如下表所示：

转义字符	含义	转义字符	含义
\ddd	1~3位八进制数据所表示字符，如\123	\r	回车
\uxxxx	4位十六进制数据所表示的字符，如\u0052	\n	换行
\'	单引号字符	\b	退格
\\	反斜杠字符	\f	换页
\t	垂直制表符，将光标移到下一个制表符的位置

例题3.4输出'\'字符和'★'字符，★字符的Unicode码为2605

代码：

public class Demo {
    public static void main(String[]args) { 
        char c1 ='\\';                        //将转义字符'\\'赋值给变量c1
        char char1 ='\u2605';                 //将转义字符'\u2605'赋值给变量c哈人
        System.out.println(c1);               //输出结果\
        System.out.println(char1);            //输出结果★
    }
}

结果为：

3.4布尔类型：布尔类型又称逻辑类型，简称布尔型，通过关键字boolean来定义布尔类型变量。布尔类型只有true和false两个值，分别代表布尔逻辑中的“真”和“假”。布尔值不能与整数类型进行转换。布尔类型通常被用在流程控制中，作为判断条件。

3.3变量与常量

1. 标识符：标识符可以简单地理解为一个名字，是用来标识类名、变量名、方法名、数组名、文件名的有效字符序列。Java语言规定标识符由任意顺序的字母、下划线(___)、美元符号（$）和数字组成，并且第一个字符不能是数字。标识符不能是Java中的关键字（保留字）。

2. 关键字：关键字又称保留字，是Java语言中已经被赋予特定意义的一些单词，不可以把这些单词作为标识符来使用。

3. 声明变量：变量的使用是程序设计中一个十分重要的环节。声明变量就是告诉编译器这个变量的数据类型，这样编译器才知道需要配置多少空间给它，以及它能存放什么样的数据。在程序运行过程中，空间内的值是变化的，这个内存空间就称为变量。为了便于操作，给这个空间取个名字，称为变量名。变量的命名必须是合法的标识符。内存空间内的值就是变量值。在声明变量时可以是没有赋值，也可以直接赋给初值。

4. 声明常量：在程序运行过程中一直不会改变的量称为常量（constant），通常也被称为“final变量”。常量在整个程序中只能被赋值一次。在为所有的对象共享值时，常量是非常有用的。

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

代码为：

public class part {          //新建类Part     
    static int age=23;     //声明常量PI，此时如不对PI进行赋值，则会出现错误提示
    static final double PI=3.14;
     //声明int型变量age并进行赋值
    public static void main(String[]args) {    //主方法
        final int number;    //声明int型常量number
        number=1235;         //对常量进行赋值
        age=22;              //再对变量进行赋值
        number=1236;         //错误代码，number为常量，只能赋值一次
        System.out.println("常量PI的值为："+PI);  //将PI的值输出
        System.out.println("赋值后number的值为:"+number);//将number的值输出
        System.out.println("int型变量age的值为:"+age);    //将age的值输出
    }
}

结果为：

从这个结果可以看到，Part类运行后发生了错误，异常日志中记载Part类出现编译问题，此编译问题正是常量number被二次赋值。

5. 变量的有效范围：由于变量被定义出来后只是暂存在内存中，等到程序执行到某一个点，该变量会被释放掉，也就是说变量有它的生命周期。因此，变量的有效范围是指程序代码能够访问该变量的区域，若超出该区域，则在编译器会出现错误。在程序中，一般会根据变量的“有效范围”将变量分为“成员变量”和“局部变量”。

5.1成员变量：在类体中所声明的变量被称为成员变量，成员变量在整个类中都有效。类的成员变量又可分为两种，即静态变量和实例变量。

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

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

代码为：

public class val {       //新建类
    static int times = 3;   //定义成员变量times
    
        // TODO Auto-generated method stub
        public static void main(String[]args) {  //主方法
            int times = 4;                     //定义局部变量times
            System.out.println("times的值为："+times);  //将times的值输出
    }
}

结果为：

---

3.4运算符

运算符是一些特殊的符号，主要用于数学函数、一些类型的赋值语句和逻辑比较方面。Java中提供了丰富的运算符，如赋值运算符、算术运算符、比较运算符等。

1. 赋值运算符：赋值运算符以符号“=”表示，它是一个二元运算符（对两个操作数作处理），其功能是将右方操作所含的值赋给左方的操作数。（从右往左运行）

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

代码为：

public class Eval {     //创造类
    public static void main(String[] args) {  //主方法
        int a, b, c;     //声明int型变量a、b、c
        a=15;            //将15赋值给变量a
        b=a+4;            //将a与4的和赋值给变量b
        c=b;              //变量b赋值给变量c
        System.out.println("c值为:"+c);//将变量c的值输出
        System.out.println("b值为:"+b);//将变量b的值输出
    }
}

结果为：

2. 算术运算符：Java中的算术运算符主要有+（加）、-（减）、*（乘）、/（除）、%（求余），它们都是二元运算符。

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

代码为：

//sc 键盘扫描口，out输出
import java.util.Scanner;
public class ArithmeticOperator {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);   //创建扫描器，获取控制台输入的值
        System.out.println("请输入两个数字，用空格隔开（num1 num2): ");//输入提示
        double num1=sc.nextDouble();  //记录输入的第一个数字
        double num2=sc.nextDouble();  //记录输入的第二个数字
        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();              //关闭扫描器
    }
}

结果为：

3. 自增和自减运算符：自增、自减运算符是单目运算符，可以放在操作元之前，也可以放在操作元之后。操作元必须是一个整形或浮点型变量。自增、自减运算符的作用是使变量的值增1或减1。放在操作元前面的自增、自减运算符，会先将变量的值加1（减1），然后再使该变量参与表达式的运算。放在操作元后面的自增、自减运算符，会先使变量参与表达式的运算，然后再将该变量加1（减1）。（符号在前先运算再使用，符号再后先试用再运算。）

4. 比较运算符：比较运算符属于二元运算符，用于程序中的变量之间、变量和自变量之间以及其他类型的信息之间比较。比较运算符的运算结果是boolean型。当运算符对应的关系成立时，运算结果为true，否则为false。所有比较运算符通常作为判断的依据用在条件语句。比较运算符共有6个，如下图所示。

运算符	作用	举例	操作数据	结果
>	比较左方是否大于右方	'a'>'b'	整形、浮点型、字符型	false
<	比较左方是否小于右方	156<456	整形、浮点型、字符型	true
==	比较左方是否等于右方	'c'=='c'	基本数据类型、引用型	true
>=	比较左方是否大于等于右方	479>=426	整形、浮点型、字符型	true
<=	比较左方是否小于等于右方	12.45<=45.5	整形、浮点型、字符型	true
!=	比较左方是否不等于右方	'y'!='t'	基本数据类型、引用型	true

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

代码为：

public class Compare {     //创造类
    public static void main(String[]args) {
        int number1=4;      //声明int型变量number1
        int number2=5;      //声明int型变量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));
        System.out.println("number1<=number2的返回值为："+(number1<=number2));
    }
}

结果为：

3.5逻辑运算符：返回类型为布尔型的表达式，如比较运算符，可以被组合在一起构成一个更复杂的表达式。这是通过逻辑运算符来实现的。逻辑运算符包括&（&&）（逻辑与）、||（逻辑或）、！（逻辑非）。逻辑运算符的操作元必须是boolean型数据。在逻辑运算符中，除了“！”是一元运算符，其他都是二元运算符。下表给出了逻辑运算符的用法和含义。

运算符	含义	用法	结合方向
&&、&	逻辑与	op1&&op2	从左到右
||	逻辑或	op1||op2	从左到右
！	逻辑非	!op	从右到左

（||只要有一者为真结果就是真、&&两者都为真结果才是真、！非真即假，非假即真）

结果为boolean型的变量或表达式可以通过逻辑运算符组合为逻辑表达式。用逻辑运算符进行逻辑运算是如下图所示：

表达式1	表达式2	表达式1&&表达式2	表达式1||表达式2	！表达式1
true	true	true	true	false
true	false	false	true	false
false	false	false	false	true
false	true	false	true	true

例题3.10使用不同的比较运算符判断两个整数的关系

代码为：

public class Calculation {
    public static void main(String[]args) {
        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);
    }
}

结果为：

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

（1）“按位与”运算（两者都为1，结果才是1）如下图所示。

（2）“按位或”运算（只要有一者为1，结果就是1）如下图所示。

（3）“按位取反”运算（0变1,1变0）如下图所示

（4）“按位异或”运算（两者相同即为0，不同为1）如下图所示

（5）移位操作：除了上述运算符，还可以对数据按二进制位进行移位操作。Java中的移位运算符有一下3种:<<:左移（整体左移，空位补零，溢出去掉），>>:右移（整体右移，正数补零，负数补一，溢出去掉），>>>：无符号右移。（整体右移，空位补零，溢出去掉）。如下图所示。

3.5数据类型转换

类型转换是将一个值从一种类型更改到另一种类型的过程。数据转换有两种方式，即隐藏转换和显式转换。

1.隐式类型转换（自动类型转换，一定不会丢失数据）：从低级类型向高级类型的转换，系统将自动执行，程序员无须进行任何操作。这些类型按精度从低到高的顺序为byte<short<int<long<float<double。

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

代码为：

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

结果为：

2.显示类型转换（强制类型转换，有可能会丢失数据）