Java语法基础

最新推荐文章于 2021-02-25 08:03:29 发布

Tough_dxx

最新推荐文章于 2021-02-25 08:03:29 发布

阅读量523

点赞数

分类专栏： Java语法 Java编程题 Java编程试题文章标签： for循环结构化程序设计的三种流程图 Java语言基础 for循环执行过程三种循环的区别

本文链接：https://blog.youkuaiyun.com/Tough_dxx/article/details/104222079

版权

Java语法同时被 3 个专栏收录

4 篇文章

订阅专栏

Java编程题

3 篇文章

订阅专栏

Java编程试题

2 篇文章

订阅专栏

Java语言基础

接下来主要带大家了解一下Java程序的语言基础知识，包括Java程序的结构、数据类型、变量、常量、表达式和流程控制语句。

首先从Java的程序结构开始吧！！！！

Java程序的构成

在Java的源程序中，几乎每一个源程序都存在倒包，意思就是在Java源程序中所要用的类都需要倒包之后才能进行编译，即import语句；而在C语言的源程序当中，都有头文件，意思就是该源程序将要用到的文件包含在该头文件当中，即include。这体现出了Java语言的特点，用户只需要编译一次，当用在编写其他的模块（源程序）时，如果用到了已经编译过的模块，只需要告诉编译程序的位置即可，最终就能够将源文件编译通过。

Java源程序是由类定义组成的，每一个程序的中可以有若干个类，但是只有一个类是主类，且在源程序中，主类是包含main（）方法的，即Java程序执行的入口点。
Java源程序中在定义类时使用了Class关键字，类的定义由类头和类体两个部分组成。
Java程序中的语句——对于每一条Java语句都是由分号（；）结束，而且类和方法中的所有语句都用一个大括号括起来。

在编写一个Java源程序时，知道大体的框架是远远不够的，而且还需要表达式、变量、常量和关键字等。其中变量和常量关键字是Java语言语法规定的保留字，当用户进行程序定义时，常量和变量的取名不能与保留字相同。接下来就让小编带大家再看Java语法基础的第二个——数据类型、变量和常量。

数据类型、变量和常量

数据类型

Java的各种数据类型都占用了固定的内存长度，与具体的软硬件平台的环境无关。如下图所列出的Java的基本数据类型：

下面就对8中基本数据类作一简单地介绍：

布尔类型（boolean）：其变量和常量的取值都只有true和false两种。true表示为真，false表示为假。

字节型（byte）：处理未加工的二进制数据，每一个字节型的常量或变量中都包含了8位二进制。

字符型（char）：在内存中占据了2字节，切记字符使用单引号（' '）。

短整型（short）：占用了2个字节。

整型（int）：占用了四个字节。

长整型（long）：占用了8个字节。

浮点型：包括double和float；double在内存中占据了8个字节，float在内存中占了4字节

常量

常量——在程序运行过程中不发生变化的量。Java中常用的常量有布尔型、整型、字符型和浮点型。

布尔类型包括true和false，分别表示真和假；

整型常量：用来给整型变量赋值。整型常量是按照所占用的内存长度可分为整型常量和长整型常量；

浮点型常量表示的是可以含有小数部分的常量。

字符型常量一般用一对单引号括起来表示的，如'a'。

字符串常量一般用一对双引号括起的一串若干个字符（可以为0），其“+”表示的连接符。

变量

变量——与常量是相对应的，在程序运行过程中数值是可以变化的，通常用来记录运算的中间结果或暂存一个数据。且变量必须先声明后使用，声明变量包括指明变量的数据类型h和变量的名称，还可以给变量赋初始值。

表达式

表达式由变量、常量、对象、方法调用和操作符组成的式子。在组成表达式的过程中，操作符有很多种，包括赋值运算、算术运算、关系运算和逻辑运算。

赋值与强制类型转换

赋值运算符：给程序里的变量赋值，就是把一个表达式的值直接赋值给一个变量，具体的格式为：变量=表达式。

i=0;
j=i;
k=i+j*4;

注意事项：在使用赋值运算时，有时会出现等号两边的数据类型不一致，这时候就需要把等号右边的转换为等号左边的数据类型。有时候系统可以自动完成数据类型的转换，有时就必须得强制数据类型的装换。

Java基本数据类型转换的规则——凡是将变量从占用内存较小的数据类型转化成占用内存较大的数据类型，系统则会自动转化，反之，则必须进行强制类型的转化。例：

byte a=10;//byte在内存中占了1个字节
int b=-1;//int在内存中占用了4个字节
/*
如将byte类型的a赋值给int类型，则系统将会自动进行转化，即可写成：
*/
a=b;
/*
如果将int类型赋值给byte类型，这个时候就会可能造成数据的损失，则必须进行强制类型的转化，
即可写为：
*/
b=(byte)a;

算术运算

算术运算是针对数值类型操作数进行的运算，可分为双目运算符和单目运算符。

双目运算符如下图所示：

单目运算符如下图所示：

自增中在运算的过程有不同之处：对于a++来说，是先参与运算之后再加加；对于++a来说，是先加加之后再参与运算。

例：

int a=1;
int b=a++;
System.out.println(b);
System.out.println(a);
/*
输出来的结果：b=1；a=2；
因为是a++；因此是先参与运算再自加
*/
int c=++a；
System.out.println(c);
/*
输出来的结果：c=3；
因为上面在进行b的过程中a进行了自加，因此a的值为2；
c又等于++a，而是先自加再赋值，因此c=3
*/

关系运算

关系运算是比较两个数据之间的大小关系的运算。

常用的关系运算如下图所示：

逻辑运算

逻辑运算是针对布尔类型数据进行的运算，运算的结果仍然是一个布尔类型。

常用的逻辑运算符如下图所示：

三目运算

例：

/*
三目运算的条件符号位：（？：）
三目运算符的运算形式：x？y : z
运算的规则为——先计算表达式x的值，若计算的结果为真，则执行y，反之，即执行z
*/
int x=5,y=8,z=2;
int k=x<3 ? y : z;
System.outprintln(k);
/*
所执行的结果为：如果x<3为真，则k=8,反之，k=2
该运行结果：k=2
*/

特别提醒：Java运算符的优先级，如下图所示：

结构化程序设计的三中流程图

结构化程序设计的原则——任何程序的设计仅仅只能有这三种基本流程结构构成。

1、顺序结构：按照顺序依次执行；

2、分支结构：根据计算的结果来判断选择执行那一条语句，即选择结构；

3、循环结构：在一定的条件下反复所执行的语句。

分支语句——选择语句

Java中的有两个分支语句，分别为if-else语句、switch语句。

先看if-else语句，例：

/*
if语句的一般形式：
if(条件表达式){
    语句块1；
}else{
    语句块2；
}
*/
 int a=9;
 int b=8;
 if(a>8){
    System.out.println("haha");
 }else{
    System.out.println("hehe");
 }
/*
上面语句所执行的过程：
先进行if中的表达式，判断该表达式是否为真，如果为真，则打印haha，
如果为假hehe
*/

再看switch语句，例：

/*
switch语句的一般形式：
switch(表达式){
    case 判断值1：语句块1
    case 判断值2：语句块2
    case 判断值3：语句块3
    case 判断值4：语句块4
    ....

    case 判断值n：语句块n
    default: 语句块n+1
}
*/
Scanner input=new Scanner(System.in);
System.out.print("请输入0到4任意一个数:");
int num=input.nextInt();
switch(num){
    case 判断值1：语句块1
    case 判断值2：语句块2
    case 判断值3：语句块3
    case 判断值4：语句块4
}
/*
如果输入的num=1，则执行case1，打印语句块1
如果输入的num=2，则执行case2，打印语句块2
如果输入的num=3，则执行case3，打印语句块3
如果输入的num=4，则执行case4，打印语句块4
*/

循环结构

循环结构——在一定条件下，反复执行某一个源程序中的某一段，而被反复执行地称之为循环体。循环结构的语句共有三种：while语句、do-while语句、for循环。

1、while语句

/*
while语句的一般格式为：
while(条件表达式){
    循环体
}
 */

while语句的执行过程——先判断条件表达式的值，若为真，则执行循环体，再继续判断条件表达式，若为真，再继续，直到判断条件为假跳出循环；反之，跳过循环。

import java.util.Scanner;
/*
当输入若干个数字时，在内存中的调用机制————例：
    输入的数字为：1 2 3 4 5 6 0
                nextDouble();———下一个为1
    1           
                nextDouble();———下一个为2
    2
                nextDouble();———下一个为3
    3
                nextDouble();———下一个为4
    4
                nextDouble();———下一个为5
    5
                nextDouble();———下一个为6
    6
                nextDouble();———下一个为0
    0————表示的是循环结束的条件

    对于当输入的数字存放在所定义的num中时————int num=nextInt();
        nextInt();表示的是存放下一个数字
        当用户输入入若干个数字时，这些数字先存放在一个临时存储区，等待被调用
        因此对于While循环来说——形如：
        System.out.print("Enter an integer,the input ends if it is 0:");
        while(true){
            double num=input.nextDouble();
            if(num==0){
                break;
            }
        }
    运行过程如下：
        先是num=1;  与0做判断，如果等于0，跳出循环，否则num=2；再判断，以此类推。
 */
class Demo11{
    public static void main(String[] args){
        Scanner input=new Scanner(System.in);
        int pos=0;//存放的是大于0的数
        int neg=0;//存放的是小于0得数
        double sum=0;//求和
        System.out.print("Enter an integer,the input ends if it is 0:");
        while(true){
            double num=input.nextDouble();
            if(num!=0){
                sum+=num;
                if(num>0){
                    pos++;
                }else{
                    neg++;
                }
            }else{
                break;
            }
        }
        System.out.println("The number of positives is "+pos);
        System.out.println("The number of negatives is "+neg);
        System.out.println("The total is "+sum);
        System.out.println("The average is "+sum/(pos+neg));
    }
}

2、do-while语句

/*
do-while语句的一般格式为：
do{
    循环体；
}while(条件表达式)
*/

do-while语句的执行过程与while语句几乎相同，不同的是，do-while语句不管是真是假都得执行一次，再判断条件表达式。

3、for循环

for语句应该是三个语句中功能最较强的语句，for语句的一般语法格式为：

for（表达式1；表达式2；表达式3）{

循环体；
}

其中表达式2时布尔值得条件表达式，用来作为循环继续的条件；表达式1是完成初始化循环变量，表达式3改变循环变量的值。

for语句的执行过程——先计算表达式1，在判断表达式2，若为真，则执行循环体，执行完之后，再计算表达式3，再进行表达式2的判断，若为真，执行循环体，再执行表达式3，直到再次判断表达式2时，为假，循环停止。

例：

/*
题目要求：总共打印8行，用五行分析一下解题思路吧；打印如下图形：
空格数：1   2   3   4   
                        1                       1
                    1   2   1                   2
                1   2   4   2   1               3
            1   2   4   8   4   2   1           4
        1   2   4   8  16   8   4   2   1       5
........
经上面的分析可得：该图形总共有5行： ————每一行由空格和具体的数字组成。
                空格数是随着行数的增加而减一，因此该代码可写成：
                for(int i=1;i<=5;i++){//i表示的是所打印的行数
                    for(int k=1;k<=5-i;k++){//k表示所打印的空格数
                        System.out.print("  ");
                    }
                }


                由上面可知，每一行的空格已打印，但是每一行的数字存在什么规律，以及每一行数字所要打印的个数：
        1   2   3   4   
1                        1                       1
2                    1   2   1                   2
3                1   2   4   2   1               3
4            1   2   4   8   4   2   1           4
5        1   2   4   8  16   8   4   2   1       5

        2^0 2^1 2^2 2^3 2^4 2^3 2^2 2^1 2^0
        -4  -3  -2  -1  0   1   2   3   4           x-(0)       1
                                                    x-(-1~1)    3
                                                    x-(-2~2)    5
                                                    x-(-3~3)    7
                                                    x-(-4~4)    9
                                                    
........

因此由上面分析得每一行所打印数字的个数为1-i ~ i-1
        并且每一行随打印的数值都是2的次幂，次幂的规律而是从0~4~0
    第五行———— 所对应的坐标的绝对值与行数差了一个1
    第四行———— 所对应的坐标的绝对值与行数差了一个1
    第三行———— 所对应的坐标的绝对值与行数差了一个1
    .......以此类推
    因此在坐标的绝对值的基础上再加一个1与行数相等，正它们的差刚好是所对应每一行所要打印的第一个数值的次幂数，即2^（坐标的绝对值的基础上再加一个1与行数的差）
    
    ------因此代码可写为：
        for(int m=1-i;m<=i-1;m++){
            System.out.print(Math.abs(m)+1);
        }
[注：再下来就是格式的要求——由于每一行所打印的最高位数值所占的大小为三个空格大小，因此就有输出的格式要求——————代码就可改为：
        System.out.printf("%3.0f",Math.pow(2,i-1-Math.abs(k)));

特别提醒：为什么格式输出是%3.0f,因为Math.pow()——所执行的结果直接为double型，所以为%f，至于4，就是所输出的值所占的空格大小。
]


最后如果改成输入多少行就打印多少行，则只需改代码中的数字五变成一个变量。
*/
class Demo16{
    public static void main(String[] args){
        for(int i=1;i<=5;i++){//i表示的是行数
            for(int j=1;j<=5-i;j++){
                System.out.print("    ");
            }
            for(int k=1-i;k<=i-1;k++){
                System.out.printf("%4.0f",Math.pow(2,i-1-Math.abs(k)));
            }
            System.out.println();
        }
    }
}

未完待续··················