Java——基本程序设计结构

最新推荐文章于 2024-06-21 11:06:09 发布

「已注销」

最新推荐文章于 2024-06-21 11:06:09 发布

阅读量182

点赞数

本文链接：https://blog.csdn.net/zjuwxx/article/details/88785640

版权

一、最简单的Java应用程序

/**
 * This is a very easy program
 * @version 22:15 2019-03-21
 * @auther 云烟成雨yycy
 */

public class First{
	public static void main(String[] args){
		System.out.println("I won't use \"Hello World!\"");
	}
}

测试结果：

I won't use "Hello World!"

程序解析

Java区分大小写
关键字 public 称为访问修饰符，用于控制程序其他部分对这段代码的访问级别
关键字 class 表明Java程序中的全部内容都包含在类中
First 是类名，类是构建所有Java应用程序和applet的构建块，类名必须以字母开头，后面可以跟字母和数字的任意组合
main 方法必须声明为 public
源代码的文件名必须与公共类的名字相同，并用 .java 作为扩展名

该程序 main 方法中只包含一条语句，其功能是：将一个文本行输出到控制台上，通过使用 System.out 对象并调用其 println 方法实现（注意，点号（.）用于调用方法）

System.out 还有一个 print 方法，它在输出之后不换行

如果已经正确地命名了该文件，且源代码中没有录入错误，编译该源代码后得到一个包含这个类的字节码的文件，Java编译器将其命名为 First.class，并与源文件存储在同一目录下

二、注释

在Java中有三种标记注释的方式：

最常用的是 // ，其注释内容从 // 开始到本行结束
使用 /*...*/ ，将一段比较长的注释括起来；这种注释不能嵌套，因为代码中可能也包含一个 */
以 /** 开头，以 */ 结尾，可以用来自动地生成文档，

/**
 * this is the first example in Java
 * @version 10:52 2019-03-22
 * @author 云烟成雨yycy
 * 第三种注释
 */

public class First{
    public static void main(String[] args){ //main 方法必须声明为 public 第一种注释
        System.out.println("I won't use \"Hello World!\"");
        /* System.out 还有一个 print 方法，它在输出之后不换行 第二种注释 */
    }
}

测试结果：

I won't use "Hello World!"

三、数据类型

3.1整型

（后期配图 P32）

在Java中，整型的范围与运行Java代码的机器无关，这就解决了软件从一个平台移植到另一个平台，或者在同一个平台的不同操作系统之间进行移植给程序员带来的诸多问题

最常用类型是 int 类型
长整型数值有一个后缀 L 或 l，如 4000000000L
十六进制数值有一个前缀 0x 或 0X，如 0xCAFE。八进制数值有一个前缀 0，如 017
从Java7开始，加上前缀 0b 或 0B可以表示二进制，如 0b1001；还可以为数字字面量加下划线，如 1_000_000，表示一百万

3.2浮点类型

（后期配图 P33）

double 类型的数值精度是 float 的两倍，因此很少情况使用 float 类型，如需要单精度数据的库，需要存储大量数据等

浮点数值不适用于无法接受舍入误差的金融计算，若在数值计算中不允许有任何舍入误差应该使用 BigDecimal 类
可以使用十六进制表示浮点数据，如 0.125=2^(-3) 可以表示成 0x1.0p-3。在十六进制表示法中，用 p 表示指数，而不用 e；尾数采用十六进制，指数采用十进制；指数的基数是2，不是10
所有的浮点数值计算遵循 IEEE 754 规范，用于表示溢出和出错情况的三个特殊的浮点数值是：正无穷大，负无穷大，NaN（非数值），分别用常量Double.POSITIVE_INFINITY、Double.NEGATIVE_INFINITY和Double.NaN（Float.NaN）表示，例如一个正整数除以0结果为正无穷大，0/0或复数的平方根结果为NaN

特别说明：

不能这样检测一个特定值是否等于Double.NaN：if(x == Double.NaN) // is never true
所有"非数值"的值都认为是不相同的，但可以使用Double.isNaN方法：if(Double.isNaN(x)) // check whether x is "not a number"

3.3char类型

char类型的字面量值要用单引号括起来；其值可以表示为十六进制值，范围从 \u0000 到 \Uffff

（后续配图 P34）

警告！

Unicode转义序列会在解析代码之前得到处理，如 "\u0022+\u0022" 是由引号包围加号构成的字符串，实际上， \u0022 会在解析之前转换为 " ，这会得到 " "+" "，即一个空串
当心注释中的 \u：

注释 // \u00A0 is a newline 会产生一个语法错误，因为读程序时 \u00A0 会替换成换行符
注释 // Look inside c:\users 会产生一个语法错误，因为 \u 后并未跟着4个十六进制数

强烈建议：

不要在程序中使用char类型（因为它已经不能满足描述所有Unicode字符的需要），除非确实需要处理UTF-16代码单元
最好将字符串作为抽象数据类型处理

3.4boolean类型

boolean类型有两个值：false 和 true

整型值和布尔值之间不能相互转换

四、变量与常量

4.1变量

逐一声明每个变量可以提高程序可读性

变量的声明尽可能地靠近变量第一次使用的地方

4.2常量

习惯上，常量名使用全大写

利用关键字 final 指示常量，表示该变量只能赋值一次

某个常量可以在一个类中的多个方法中使用，成为类常量，使用关键字 static final 设置；类常量的定义位于 main 方法的外部

/**
 * This is a program about constant
 * @version 22:25 2019-03-25
 * @auther 云烟成雨yycy
 */

public class Constant{
    public static final double CM_PER_INCH=2.54; //类常量

    public static void main(String[] args){
        final double paperWidth=8.5; //常量
        double paperHeight=11;
        System.out.println("Paper size in centimeters："+paperWidth*CM_PER_INCH+" by "+paperHeight*CM_PER_INCH);
    }
}

测试结果：

Paper size in centimeters：21.59 by 27.94

五、运算符

5.1数据类型之间的转换

5.1.1隐式类型转换

当两个不同数据类型的数值进行二元操作时，先转换为同一数据类型再进行运算

若两个操作数有一个是 double 类型，另一个就会转换成 double 类型
否则，若其中一个操作数是 float 类型，另一个就会转换成 float 类型
否则，若其中一个操作数是 long 类型，另一个就会转换成 long 类型
否则，两个操作数都将转换为 int 类型

（后续配图 P41）

5.1.2强制类型转换

浮点类型转换为整型通过截断小数部分实现

如果试图讲一个数值从一种类型强制转换为另一种类型，又超出了目标类型的表示范围，结果会大不相同，如 (byte)300 的实际值是44

5.2赋值运算符

若运算符得到一个值，其类型与左侧操作数的类型不同，会发生强制类型转换，若 x 是一个 int，则以下语句合法：x+=3.5，将把 x 设置为 (int)(x+3.5)

5.3自增自减运算符

自增（++），自减（--）

运算符可以放在操作数前面（++n / --n），也可以放在后面（n++ / n--）

区别：前缀形式先加 1，再执行当前语句；后缀形式先执行当前语句，再加 1

int m=7;
int n=7;

int a=2* ++m; //now a is 16，m is 8
int b=2* n++; //now b is 14，n is 8

5.4位运算符

处理整型类型时，可以直接对组成整型数值的各个位进行操作；可以使用掩码技术得到整数中的各个位

位运算符包括：

&运算符：对应位都为1，结果值对应位才为1，如：0110 & 1011=0010
| 运算符：对应位都为0，结果值对应位才为0，如：0110 | 1011=1111

应用在布尔值上时，& 和 | 运算符也会得到一个布尔值

它们与 && 与 || 运算符类似，但前者不采用 "短路" 方式求值，即运算符两侧的操作数都需要计算

^ 运算符：对应位相同结果值对应位为0，对应位不同结果值对应位为1，如：0110 ^ 1011=1101
~ 运算符：结果值与初始值正好相反，如：~ 1011=0100
<< 运算符：左移，N << S 的值是将 N 左移 S 位，右边空出来的位填充0，相当于乘以2的 S 次方，如：11111000 << 1=11110000
>> 运算符：右移，N >> S 的值是将 N 右移 S 位，左边空出来的位如果是正数则填充0，如果是负数则填充1，相当于除以2的 S 次方，如：00010111 >> 2=00000101，11110110 >> 3=1111110
>>> 运算符：无符号右移，无论正数还是负数，无符号右移后左边空出来的位都填充0，如：11111000 >>> 2=00111110

移位运算符的右操作数要完成模32的运算（除非左操作数是 long 类型，此时需要对右操作数模64），如1 << 32的值等于1 << 3或8

5.5括号与运算符优先级

（后续配图 P44）

5.6枚举类型

有时候，变量的取值只在有限集合中。如果分别对其编码存在一定隐患，变量中很可能保存的是一个错误的值，因此设置枚举类型

例如，披萨的尺寸有小，中，大，超大4种，可自定义枚举类型：

enum Size { SMALL, MEDIUM, LARGE, EXTRA_LARGE };

声明这种类型的变量：

Size s = Size.MEDIUM;

Size类型的变量只能存放这个类型中给定的某个枚举值，或者 null 值（null 表示该变量没有设置任何值）

六、字符串

Java没有内置的字符串类型，而是在标准Java库中提供了一个预定义类String

6.1拼接

与绝大多数程序设计语言一样，Java语言允许使用 + 号连接两个字符串

当一个字符串与一个非字符串的值拼接时，后者被转换成字符串（任何一个Java对象都可以转换成字符串）

6.2空串与null串

空串是一个Java对象，有自己的串长度（0）和内容（空）

String变量可以存放一个特殊值，名为NULL，表示目前没有任何变量与该变量关联

若要检查一个字符串既不是null也不是空串，需要使用语句 if(str != 0 && str.length() != 0)，首先要检查 str 不为 null

七、大数值

如果基本的整数和浮点数精度不能满足需求，可以使用 Java.math 包中的 BigInteger 类和 BigDecimal 类，处理包含任意长度数字序列的数值

特别注意，大数值的计算中不再使用简单运算符，而是使用方法

import java.util.*;
import java.math.*;

/**
 * This program discribes big number that is about luck draw
 * @version 12:27 2019-03-27
 * @auther 云烟成雨yycy
 */

public class BigNumberTest{
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        System.out.println("总共几个数？");
        int total=in.nextInt();
        System.out.println("要抽几个数？");
        int number=in.nextInt();

        BigInteger lotteryOdds=BigInteger.valueOf(1);
        for(int i=1; i<=number; ++i)
            lotteryOdds=lotteryOdds.multiply(BigInteger.valueOf(total-i+1)).divide(BigInteger.valueOf(i));
        /**
         * 中奖概率 n*(n-1)*(n-2)*...*（n-k+1)/(1*2*3*...*k)
         */
        System.out.println("你的中奖率为1/"+lotteryOdds);
    }
}

测试结果：

总共几个数？
490
要抽几个数？
60
你的中奖率为1/716395843461995557415116222540092933411717612789263493493351013459481104668848

八、数组

声明数组有两种方式，int[] a; 或 int a[]; ，多数人喜欢使用第一种，它将类型 int[] （整型数组）与变量名分开

Java中，数组长度可以是变量：new int[n] 表示创建一个长度为 n 的数组；还可以是0，但与null不同

创建数字数组时，所有元素默认初始化为0
创建 boolean 数组时，所有元素默认初始化为 false
创建对象数组时，所有元素默认初始化为 null，表示这些元素未存放任何对象

8.1for each 循环

1. 一维数组

for(value: collection)
    do something with value

collection 集合表达式必须是一个数组或者是一个实现 Iterable 接口的类对象

2. 二维数组

for(double[] row : a)
    for(double value : row)
        do something with value

for each 语句不能自动处理二维数组的每一个元素，它是按照行，也就是一维数组处理的

8.2一维数组部分操作

8.2.1数组初始化

（1）静态初始化：初始化时显式指定每个数组元素的初始值，系统决定数组长度：arrayName = new type[]{ element1, element2, element3... }

int[] intArr;
intArr = new int[]{1,2,3,4,5,9};

（2）简化的静态初始化：type[] arrayName = {element1, element2, element3... };

String[] strArr = {"张三","李四","王二麻"};

（3）动态初始化：初始化时指定数组的长度，由系统初始化每个数组元素的默认值：arrayName = new type[length];

int[] price = new int[4];

注意：不要同时使用静态初始化和动态初始化，即不要在进行数组初始化时，既指定数组的长度，又为每个数组元素分配初始值

8.2.2数组拷贝

Java中允许将一个数组变量拷贝给另一个数组变量，这时两个变量引用同一个数组

int[] luckNumber=intArr; //接上面的数组
luckNumber[5]=12; //now kakaka[5] is also 12

若想把一个数组的所有值拷贝到新的数组，可使用 Arrays 类的 copyOf 方法，该方法通常用来增加数组大小

int[] copyLuckNumber= Arrays.copyOf(luckNumber, luckNumber.length);

8.3多维数组

import java.util.*;

/**
 * This program demonstrates a YanghuiTriangle arrey
 * @version 21:29 2019-03-27
 * @auther 云烟成雨yycy
 */

public class YanghuiTriangle{
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        System.out.print("请输入杨辉三角的行数：");
        int n = in.nextInt();

        int[][] triangle = new int[n][];
        for (int i=0; i<triangle.length; i++) {
            triangle[i] = new int[i+1];

            for (int j = 0; j < triangle[i].length; j++) {
            if (i == 0 || j == 0 || i == j) {
                    triangle[i][j] = 1;
                } else {
                    triangle[i][j] = triangle[i - 1][j] + triangle[i - 1][j - 1];
                }
                System.out.print(triangle[i][j] + " ");
            }
            System.out.println();
        }
    }
}

测试结果：

请输入杨辉三角的行数：8
1 
1 1 
1 2 1 
1 3 3 1 
1 4 6 4 1 
1 5 10 10 5 1 
1 6 15 20 15 6 1 
1 7 21 35 35 21 7 1

另：中断控制流程语句

break：跳出当前所在循环，执行循环后面的语句
continue：中断正常的控制流程，将控制转移到最内层循环的首部；若用于 for 语句，跳到循环变量的更新部分
带标签的 break 语句：类似 goto 语句，用于跳出多重循环；标签必须放在希望跳出的最外层循环之前，并且紧跟一个冒号
带标签的 continue 语句：跳到与标签匹配的循环首部

import java.util.*;
import java.math.*;

/**
 * This program discribes special "break" statements
 * @version 11:15 2019-03-27
 * @auther 云烟成雨yycy
 */

public class SpecialBreak{
    public static void main(String[] args) {
        int[] score = new int[10];
        int total=0;
        for (int i = 0; i < 10; ++i){
            score[i] = (int) (1 + Math.random() * 100); //随机产生学生分数
            total+=score[i]; //计算总分
        }
        double average=1.0*total/10; //计算平均分
        int counter=0;
        /**
         count 用来记录第一个低于平均分的学生的序号，且必须要初始化
         */

        read_data:
        while(average<total){
            for(int i=0; i<10; ++i){
                if(score[i]>average)
                    System.out.println("Congratulations! You are ok!"); //对超过平均分的学生鼓励
                else{
                    System.out.println("\nThe first student who doesn't get an average score appears.");
                    counter=i;
                    break read_data;
                }
                System.out.println(score[i]);
            }
        }
        System.out.println("\nThe average is "+average+"\nThis student's score is "+score[counter]);
    }
}

测试结果：

Congratulations! You are ok!
92
Congratulations! You are ok!
85

The first student who doesn't get an average score appears.

The average is 61.6
This student's score is 39

~~by 云烟成雨yycy~~

「已注销」

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java——基本程序设计结构

目录一、最简单的Java应用程序程序解析二、注释三、数据类型3.1整型3.2浮点类型3.3char类型3.4boolean类型四、变量与常量4.1变量4.2常量五、运算符5.1数据类型之间的转换5.1.1隐式类型转换5.1.2强制类型转换5.2赋值运算符5.3自增自减运算符5.4位运算符5.5括号与运算符优先级5.6枚...
复制链接

扫一扫