Java 基本程序设计结构

1. 基本程序框架

package *;  // 表示这个文件属于哪个包

import *;  // 引入一些库，不必重复造轮子

/*
 * name：Java 基本程序框架
 * describe: NULL
 */
// public 称为访问修饰符，这部分会在后面详细说明，现在只需要知道它可以控制访问权限即可
// class，类，表明这是一个类，而不是方法或其它什么
// Basiframework 类名称，自定义，一般首字母大写，建议使用驼峰命名法
// 源代码文件的命名必须与公共类一致，即一个代码文件中只能有一个 public class
public class BasicFramework {
    // Java 虚拟机总是从指定类中的 main 方法开始执行
    // Java 项目中每个类都可以有一个 main 方法，但只有一个会被执行，其它的可用作单元测试
    public static void main(String[] args) {
        // 以下是程序的代码主体，在此编写程序的主要功能
        // program statements
        System.out.print("I wana see you at this time .");
    }
    // 可以在这里编写一些其它方法
}

• Java 区分大小写，出现拼写错误时，程序将无法运行

• 每个语句以分号结束

2. 注释

注释有常规注释和文档注释两种，常规注释的内容在且只在源代码中，而文档注释在编写之后会自动由源文件生成一个HTML文档，类似于联机API文档（可以在控制台使用命令将文档注释抽取出来成为一个文档）

1. 常规注释
// 单行注释，直到本行结尾
/*
* 常规多行注释。注意，不要嵌套
*/

2. 文档注释
/**
 * 文档注释
 * @author guyan
 * @param  元素注释
 * @return
 * @throws
 * 
 * @version  
 * @since 引入版本特性的描述
 * @deprecated 对类 方法或变量添加一个不再使用的注释,
 *             给出取代或修改的意见
 * @see 用到的时候再说
 * @link
 */

// 注释抽取
javadoc -d 存放地址 fileName.java

3. 数据类型

Java 是一种强类型语言，这要求每个变量在声明的时候必须声明变量的类型。此外，Java 中的基本数据类型的取值范围不受系统的字长影响。

Java 有 8 种基本数据类型，以及多到不知道有多少种的引用数据类型。

8 种基本数据类型中，有 4 种整型，2 种浮点型，1 种字符型，和一种用于表示真值的 boolean 类型

• 整型：byte(1字节)，short(2字节)，int(4字节)，long(8字节)

• 浮点型：float(4字节)，double(8字节)

• 字符型：char(2字节)

• Boolean值：Boolean(1 bit)

// 声明变量
byte a;
short b;
int c;
long d;

// 变量赋值
// 通常在书写代码的时候并不会十进制之外的进制，但要能看懂当前数字所使用的进制
// 长整形,后缀为 L ;十六进制前缀为 0X ;八进制前缀为 数字0 ;二进制前缀是0B
// 前缀都是数字 0
int n = 0B10011; // n=19
// 连续赋值
int a,b,c;
a = b = c = 4;  //从右往左赋值
// 这种形式的赋值是可行的，但是不建议这样做

// 浮点数的其它进制的写法和整型是一样的
// 声明变量
float e;
double f;
// 浮点数除正常的浮点数之外还有 3 个表示溢出和出错的浮点数值
- 正无穷大
- 负无穷大
- NAN（不是一个数字）

// 字符类型除了表示一个字符的用法之外，还可以用于表示 Unicode 的编码
// 其中最有代表性的是转义字符，一个字符长度的 Unicode 编码可以将值赋给 char 变量
// 声明
char g = 'A';

// 布尔值，Boolean,只有两种取值：false true
// 声明
Boolean flag01 = false;
Boolean flag02 = true;

上面是八种基础数据类型的声明示例，尽量让变量的声明靠近第一次使用的地方

4. 变量与常量

与所有程序设计语言一样，Java 也使用变量来存储值，常量就是值不变的变量

1. 变量
int a ;
char c ;
...
// 如果可以从变量的初始值推断出它的类型，就不需要再声明其类型，而只需要用 var 关键字代替
var a = 10;
var s = "String";

2. 常量
// Java 中的常量需要使用关键字 final 明确指示
final int a = 10;
// 以上常量 a 在程序员想要再次修改它的值的时候会拒绝修改
// 常量名 通常使用全大写，请忽视这个示例的大小写问题

5. 运算符

算术运算符

加   减    乘   除
+    -    *    /

赋值运算符

// 赋值运算符除了‘=’，其它赋值运算符都偷偷加了私料
=
// 将运算符 左边的数值 [+,-,*,/,%] 右边的结果
+=    -=    *=    /=    %=

自增与自减运算符

// 自增与自减，通常用作在某次循环中对起到标志作用的变量进行操作
int a = 10;
--a; // 9
a--; // 8
++a; // 9
a++; // 10
// --a 与 a-- 的差异，如 int n = --a; 会先进行自减操作然后再赋值
// 而 int n = a--; 则是先进行赋值然后再自减

关系运算符

==    !=    >=    <=     ? :
// 关系运算符通常与 Boolean 联系起来，因为关系运算的结果就是 布尔值
int a = 3;
int b = 4;
int c = 0;
Boolean flag ;
a == b; // 判定 a 与 b 是否相等，返回布尔值。此处返回 false
a != b; // 判定 a 与 b 是否不等，返回布尔值。此处返回 true
a >= b; // ...
a <= b; // ...
c = a>b ? a : b; // 判断 a 是否大于 b,如果为真，返回 a,如果为假，返回 b
//
flag = (a == b); // flag = false 
// 虽然这里的括号有和没有对于计算机来说没什么区别，但对于人来说，明确的划分方便查看

逻辑运算符

且    与
&&    ||
// 数学自行对号入座

位运算符

and  or   xor  not
&    |    ^    ~

关于运算符的优先级：

• 尽量加括号

• 自增自减 的优先度最高（忽略括号）

• 赋值运算符 优先度最低

数学运算

// 当想要对某个数进行数学操作的时候，不需要自己再次重新编写
// Java 有一个 Math 函数库，大部分的数学运算的函数代码都在这个库中
// 如果想要在代码中调用这些库函数，则需要导入相应的库
import static java.lang.Math.*;
// Math 类中的静态常量
E  // 自然数 e
PI  // 圆周率 π
// 常用数学运算函数
abs(int a)    // 返回 a 的绝对值，a 可以是所有数值类型
max(int x,int y)      // 返回 x 和 y 中的最大值，x 和 y 可以是所有数值类型
min(int x,int y)   // 返回 x 和 y 中的最小值，同上
ceil(double a)      // 返回大于或等于 a 的最小整数   
floor(double a)      // 返回小于或等于 a 的最大整数
rint(double a)      // 返回最接近 a 的整数值，如果有两个同样接近的整数，则结果取偶数
round(float a)      // 将参数加上 1/2 后返回与参数最近的整数
exp(double a)      // 返回 e 的 a 次幂
pow(double a,double b)      // 返回以 a 为底数，以 b 为指数的幂值
sqrt(double a)      // 返回 a 的平方根
cbrt(double a)      // 返回 a 的立方根
log(double a)      // 返回 a 的自然对数，即 lna 的值
log10(double a)      // 返回以 10 为底 a 的对数

6. 数值类型转换

1. 自动转换数据类型
    从低精度的数据类型转向高精度的数据类型是自动的，无需特别标明
    但我们必须清楚，这里发生了数据类型转换
    int a = 10;
    float b = a; 
    // a 的值并不会发生实际的变化，只是在赋值过程中，先取出 a 的只
    // 将其转化为 浮点数，然后将浮点数赋给变量 b

2. 强制转换数据类型
    高精度的变量向低精度的变量进行转换时会丢失数据数据精度
    Java 会对此发出警告，要想屏蔽这种警告需要进行强制类型转换
    double x = 9.997;
    int nx = (int)x;  // nx = 9

7. 字符串

概念上，Java 的字符串就是 Unicode 字符序列。

实际上，Java 并没有内置的字符串类型，而是在标准的 Java 类库中提供了一个预定义类，很自然地叫做 “String”

String s = "";  // 一个空字符串
String greeting = "Hello";

在 Java 中字符串是不可变的，即一个字符串里不可以改变其中的字符，但是可以通过字符串拼接或其它操作，将新的字符串赋给字符串变量，实现字符串的变化。

关于效率问题，所有字符串都都存放在公共的存储池中，字符串变量指向存储池中相应的位置。

下面的例子将展示一个项目中源码文件书写格式 并在其中展示有关字符串的一些操作。

package chapter03;

import java.lang.String;
import java.util.Locale;

/*
 * NO:02
 * Name：字符串测试
 * Describe：
 *      Java 共享池的基本性质
 *      一些字符串处理函数
 */
public class StringTest {
    public static void main(String[] args) {
        // Java 字符串共享池 测试
        // "==" 可用于检测两个字符串是否存放在同一个位置上，即检查引用是否相同
        System.out.println("字符串共享池测试：");
        String s1 = "share pool";
        String s2 = s1;//"share pool";
        String s3 = new String("share pool");
        System.out.println("字符串 s1 为："+s1);
        System.out.println("字符串 s2 为："+s2);
        System.out.println("字符串 s3 用 new 方法创建为："+s3);
        System.out.println("(s1 == s2) = " + (s1 == s2));  // true
        System.out.println("(s1 == s3) = " + (s1 == s3));  // false

        // 提取字符串字串
        // 相同的字符串字面量共享地址，提取或拼接后的字符串不共享
        System.out.println();
        System.out.println("字符串提取字串测试：");
        System.out.println("字符串 s3 为："+s3);
        String s4 = s3.substring(0,5);
        System.out.println("从字符串 s2 中提取字符串，" +
                "字符串 s4 为："+s4); // s3="share"
        System.out.println("(s3 == s4) = " + (s3 == s4));

        // 字符串拼接
        System.out.println();
        System.out.println("字符串拼接测试：");
        String s5 = " pool";
        String s6;
        s6 = s4 + s5;
        System.out.println("字符串 s4 为："+s4);
        System.out.println("字符串 s5 为："+s5);
        System.out.println("拼接字符串 s4 与 s5,生成字符串 s6" +
                "\n"+
                "字符串 s6 为："+ s6);

        // 字符串相等测试 equals
        // “equals” 用于对比两个字符串中的字符，“==”用于检测引用是否相等
        System.out.println();
        System.out.println("字符串 equals() 测试：");
        System.out.println("字符串 s2 为：" + s2 +
                "\n" +
                "字符串 s3 为：" + s3 +
                "\n" +
                "字符串 s4 为：" + s4 );
        System.out.println("s2 equals s3 ?  " + (s2.equals(s3)));
        System.out.println("s3 equals s4 ?  " + (s3.equals(s4)));

        // 空字符串测试
        System.out.println();
        System.out.println("空字符串检测方式：");
        String s7 = "";
        System.out.println("空串 s7 长度为：" + s7.length());
        Boolean flag = (s7.length() == 0); // flag = true
        flag = (s7 == null); // flag = true

        // 码点单元，码点是字符的 Unicode 编码
        // 获取字符串中的字符数量，即字符串的长度
        String greeting = "hello";
        int n = greeting.length(); // is 5
        // 获取字符串实际长度，即码点数量
        int cpCount = greeting.codePointCount(0, greeting.length()); // 5
        // charAt() 返回某个位置的码点单元
        char first = greeting.charAt(0); // is 'h'
        char last  = greeting.charAt(4); // is 'o'
        // 获取码点
        int index = greeting.offsetByCodePoints(0,2);
        // 返回从给定位置开始的码点
        int cp    = greeting.codePointAt(index);
        System.out.println(index +" "+ cp);

        // 字符串大小写转换
        String name = "guyan";
        name = name.toUpperCase(); // GUYAN
        name = name.toLowerCase(); // guyan

        // 删除字符串头或尾的空格
        String space = "  space  ";
        System.out.println(space.length());  // 9
        space = space.strip();
        System.out.println(space.length());  // 5

        // 多字符串连接
        // 返回一个字符串，用给定的定界符连接所有元素
        String sencent = "q";
        sencent.join(" ","a");
        System.out.println(sencent);

        // StringBuilder 字符串构建
        // Stringbuilder 构建一个容器，在容器里的内容被转化为字符串前
        // 可以任意对其中的内容进行修改
        // 创建一个新的容器
        StringBuilder builder = new StringBuilder();
        // 追加一个字符串，并返回 this
        builder.append("stabt");  // "stabt"
        // 追加一个字符并返回 this
        builder.append(" "); // "stabt "
        // 追加一个码点
        builder.append(118);  // "stabt 118"
        // 修改某个代码党员的值
        builder.setCharAt(2, 'r'); // "start 118"
        // 将字符串构建器中的内容转化为字符串
        String s = builder.toString();
        System.out.println(s);
    }
}

8. 输入与输出

package chapter03;

import java.io.IOException;  // 输入输出异常包，检测输入输出
import java.io.PrintWriter;  // 用于创建一个文件并向文本写入数据
import java.nio.charset.StandardCharsets;  // 标准Charsets的常量定义
import java.nio.file.Path;  // 指向文件的路径
import java.util.Scanner;  // 标准输入相关的包

/*
 * NO：03
 * Name：输入输出测试
 * Describe：
 *  输入输出
 *  格式化输入输出
 */
public class IO {
    public static void main(String[] args) throws IOException {
        // 构造一个与标准输入流 System.in 相关联的Scanner 对象
        // 其中，System.in 可以换成 字符串变量，读取的时候和i自动从字符串读取
        Scanner input = new Scanner(System.in);
        // 获取下一行输入
        String line = input.nextLine();
        // 获取下一个字符串（以空格作为分隔符）
        String word = input.next();
        // 获取下一个整数
        int n = input.nextInt();
        // 获取下一个浮点数,依次类推，double 类型的浮点数类似
        float f = input.nextFloat();
        // 检查键盘是否还有未使用的 单词、整数、浮点数
        input.hasNext(); //返回 Boolean 值
        input.hasNextInt(); // 可以将 Int 换成其它数据类型
        input.hasNextFloat();
        // 关闭输入流
        input.close();

        // 格式化输出
        // Java 继承了 C 语言的 printf(),格式化输出数据
        int a = 10;
        f = (float) 12345.54;
        // '%'是格式化输出的标志，后面的字母 'd' 表示整数
        // 连起来的意思是将 a 替换到 %d 里
        System.out.printf("%d \n",a);
        // 常用的还有 %f %s %c %b
        // 上面的字母通常只是用来表示数据类型
        // 还可以在 '%' 与 'd' 之间添加其它参数来确认数据的打印格式
        // emmmm, 不想写了，过

        // 文件输入与输出
        // 如果想要读取一个文件的内容，打开一个文件输入流
        Scanner in =new Scanner(Path.of("myfile.txt"), StandardCharsets.UTF_8);
        // 如果想要将内容写入文件，需要构造一个 PrintWriter 对象
        PrintWriter out = new PrintWriter("myfile.txt", StandardCharsets.UTF_8);
    }
}

9. 控制流程

// 块作用域
{}

// 条件语句
if(condition) {}

if(condition) {}
else {}

if(condition1) {} 
else if(condition2){}
else{}

// 循环
while(){}
do{}while();

// 确定循环
// 在一个 for 循环中，“int i=10”只执行一次
// 在一个 for 循环中，“i>0” 每次循环前进行一次判断，如果为真，执行循环体
// 在一个 for 循环中，在执行完循环体之后，执行 “i--” 
for( int i=10; i>0; i--) {} 

// 多重选择
switch(choice) // 传入一个参数，匹配下面的case
{   
    // choice 可以为 char byte short int enum String，这例子里的是 int
    // 当 choice = 1 时，执行 case 1 后面的块，其它 case 以此类推
    case 1:{} // 最好每个 {} 里都有一个 break，否则就会在switch 里不断匹配
    case 2:{}
    case 3:
    case 4:{}
        //此时 3 和 4 将会执行同一块
    default: {};
}

// 中断控制循环 break
// 当一个循环体执行到一条 break 语句的时候，会直接终止“当前“循环
break;

// 当在循环体中，执行到 continue 语句的时候
// 会跳过当前循环剩余未执行的语句，提前进入下一次循环
continue;

// for each
// for each 会遍历数组中的所有元素而不是固定的次数
for(int element : a)
    System.out.print(element+" "); 

10. 大数

当 long 或 double 的精度不足以满足使用的需求，可以使用大数，即 BigInteger 或 BigDecimal，这两个类可以处理任意长度的数字序列数值

package chapter03;

import java.math.BigInteger;
import java.util.Scanner;

/*
 * NO：04
 * Name：大数
 * Describe：
 *  大数声明
 *  对大数操作
 */
public class BigIntegerTest {
    public static void main(String[] args) {
        BigInteger x = new BigInteger("1234567890123456789012345678901234567890");
        BigInteger y = new BigInteger("1231231231231231231231231231212312312312");
        BigInteger z = new BigInteger("0");

        // +
        System.out.println(x.add(y));
        // -
        System.out.println(x.subtract(y));
        // *
        System.out.println(x.multiply(y));
        // /（除）
        System.out.println(x.divide(y));
        // 取余
        System.out.println(x.mod(y));
        // 平方根
        System.out.println(x.sqrt());
        // 比较
        System.out.println(x.compareTo(y));
        // 基本数据类型转大数
        long n = 100;
        z = BigInteger.valueOf(n);
        System.out.println(z);
        System.out.println(y);
    }
}

11. 数组

package chapter03;

import java.util.Arrays;
import java.util.Scanner;

/*
 * NO:05
 * name：Java 数组
 * describe: 测试数组基本操作
 *      声明数组
 *      访问数组元素
 *      for each 遍历数组
 *      数组拷贝
 *      数组排序
 *      二维数组
 */
public class ArrayTest {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);

        // 声明数组
        int[] a = new int[10];
        int[] aExtra = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};
        a = new int[]{1, 11, 111};  // 匿名数组
        // 可以使用上面这种声明匿名数组的语法
        // 声明数组的时候，声明的是一个数组的引用，这个数组引用可以指向任意该类型的数组

        // 访问数组元素
        // 常规获取数组元素的方式是通过数组下标
        System.out.println(a[1]);

        //  for each 遍历数组
        // for功能更为强大，但 foreach 对遍历数组来说，更加方便
        for(int element : a)
            System.out.println(element);

        // 数组拷贝 copyOf()
        // 如果直接用 '=' 复制数组，那新数组的地址依旧为旧数组的地址
        // 第一个参数是将要被复制的数组名
        // 第二个参数是新数组的长度，只可以比原数组的长
        int[] b = Arrays.copyOf(a, a.length+2);
        for(int element : b)
            System.out.print(element + " ");
        System.out.println();

        // 数组排序
        // Java 库中有排序方法，当然，平时练还是要练的
        a = new int[] {2, 6, 5, 9};
        Arrays.sort(a); // sort() 是快速排序方法
        for(int element : a)
            System.out.print(element + " ");
        System.out.println();

        // 二维数组（平时使用的最多是二维，三维或者三维以上是很少的,也不建议使用）
        int[][] square = new int[10][10];
        // 声明使用方式和一维数组基本相同，过
    }
}

参考

• Java 核心技术 11版 Cay S.Horstmann 著 林琪 等译

原文地址：http://www.cnblogs.com/GuYan-Dragon/p/16899462.html