JAVA核心技术 卷1 第三章Java的基础程序设计结构

1. 一个简单的Java应用程序

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("We will not use 'hHello,World1'");
    }
}

运行结果

1）java区分大小写：例main写成Main将会无法运行
2）public访问修饰符：其他部分对这段代码的访问级别（第五章介绍）
3）关键字class：加载程序逻辑的容器。程序逻辑定义了应用程序的行为（第四章介绍）
class后紧跟类名，类名必须字母开头，后面可以和字母数子组合，不可使用保留字
4）类是构建java程序的块。
5）源代码的文件名必须与公共类的名字相同
6）编译后的class文件,java虚拟机将会从main方法开始执行
7）每个句子必须用分号结束

这里使用了System.out对象并调用了他的println方法【 . 用于调用方法】
例子中println方法传递了字符转参数，并将它显示到了控制台，对于没有参数的方法 【()】也需要写出来

2.注释

注释不会出现在可执行程序中
java中的三种注释

public class HelloWorld {
    /**
    * @Author akk
    * @Description //TODO @Date 22:57 2020/4/6
    * @Param [args]
    * @return void
    */
    public static void main(String[] args) {
        // 打印字符串
        /*这是
         多行的住
         注释*/
        System.out.println("We will not use 'hHello,World1'");
    }
}

1）// 最常用，从//开始到本行结束
2）/* 开始 / 结束 将比较长的一段注释括起来
3）/* 开始 */结束 用于自动生成文档

3.数据类型

java是强类型 语言，每一个变量都需要申明类型。

8种基础类型
4种整型
2种浮点类型
1种表示Unicode编码
1种表示真值的布尔类型

1. 四种整型

类型	存储需求	取值范围（负数范围 +1 +负号 例如byte：-128）
int	4字节	2 147 483 647
short	2字节	32 767
long	8字节	9 223 372 036 854 775 807
byte	1字节	127

1）int最常用
2）例如表示星球上的人数就要用long
3）byte和short用于特定场合
长整型后缀L 400000L
十六进制数值前缀0X

2. 两种浮点类型

类型	存储需求	取值范围
float	4字节	有效位6-7
double	8字节	有效位15位

更多的情况下float类型的精度难以满足需求，少数情况需要float如 单精度数据的库，需要存储大量的数据的时候
1）float后缀F 3.14F 没有写F默认为double
2）三个特殊浮点数值
*正无穷大 Double.POSITIVE_INFINITY
*负无穷大 Double.NEGATIVE_INFINITY
*NaN(不是一个数字)

3. char类型
   char类型原本用来表示单个字符，如今一些Unicode字符可以用一个char描述另外一些两个char来描述。
   char的字面值只用单引号括起来。
   ‘A’表示的是Unicode 65
   ”A“表示的是字符A
   char类型的值可以表示为16进制值。因此可以存放转义字符，ASCLL
   链接: char类型-转义字符.

4. boolean类型
   boolean有两个值
   1）true
   2）false
   用于判定逻辑条件

4.变量

每一个变量都有类型,以分号结束
double salary;
int vacationDays;
1）不能使用java保留字
2）变量名必须以一个字母开头，字母数字构成序列
3）如果想知道Unicode字符是否属于Java中的字母，可以在Character类种isJavaIdentifierStart和isJavaIdentifierPart方法来检查
4）变量大小写敏感

变量的初始化
申明一个变量后，必须进行初始化，使用为赋值变量将会报错。

    public static void main(String[] args) {
        int vacationDays;
        // 飘红报错
        System.out.println(vacationDays);
    }

将变量名放在 = 号左边，值放在右边。

    public static void main(String[] args) {
        int vacationDays = 12;
        System.out.println(vacationDays);
    }

显示如下

E:\JDK8_64\bin\
12

Process finished with exit code 0

常量
在java中使用final来指示常量。
1）final表示这个变量只能被赋值一次，一旦赋值不能更改，常量命全大写表示。
2）不变的，在类中多出使用的，通常将这些常量设置为类常量。
3）类常量使用static final设置
4）const是Java保留关键字，目前还没有使用，java中必须使用final来定义常量

5.运算符

Java中算数运算符

算数运算符	意义
+	加运算
-	减运算
*	乘运算
/	除运算（整数为整数除法，否则浮点除法，当除0将会产生异常， ）
%	取模（取余数）

数学函数与常量
1）在Math类中，包含了许多数学函数。开方，三角函数等等

2）数值类型之间的转换

3）强制类型转换
int可以无信息损失的转换为double
但是有时候需要double转换为int，这种情况需要强制类型转换，语法格式如下

        double money = 11.111;
        int nxmonry = (int) money;

输入结果：11
强制类型转换截断小数部分，转换为整型。
如果想让他进行四舍五入进行如下操作
使用数学类进行四舍五入
使用了round依然需要强制转换是因为round的返回类型是long，long转int 也是精度丢失

        double money = 11.66;
        int nxmonry = (int) Math.round(money);

4）结合赋值和运算符
赋值中可以使用二元运算符 是一种方便的简写
x += 4；
等价于
x = x + 4;

5)自增和自减运算符
后缀
自增运算符 n++ 将当前n的值加1
自减运算符 n-- 将当前n的值减1

前缀
自增运算符 ++n 将当前n的值加1
自减运算符 --n 将当前n的值减1

1. 自增自减运算符只能对应变量，不能是数值如 4++ 这就是不对的
2. 前缀后缀都是变量+1或-1，差异在表达式中体现
   例子

    public static void main(String[] args) {
        int m = 7;
        int n = 7;
        int a = 2 * --m;
        int b = 2 * n--;
        System.out.println(a);
        System.out.println(b);
    }

输出结果：a 的值 12，b 的值 14
由此可见在表达式中 自增自减运算符的前缀后缀，表达先自增/自减 还是运算后自增/自减
前缀前自增/自减

6)关系和boolean运算符
检测相等性
使用 == 来检测相等
3 == 7 的值就是false 是不相等的
使用 ！=来检测不相等
3 ！= 7 的值就是true是不相等的
<, >, <=, >= 等等运算符

&& 表示逻辑与
|| 表示逻辑或
！表示逻辑非

三元运算符 ？：
value = a < b ? x : y;
若a < b 成立 则value = x
若a < b 不成立 则value = y

1.&& 和 || 是按照短路方式来求值的 即如果第一个已经能够确定表达式的值，后面一个就不必计算了。

7. 位运算符

8. 括号与运算符级别

9. 枚举类型
   当变量的取值只在一个有限的集合内
   自定义枚举类型，枚举类型包括有限个命名的值。
   详细介绍第五章

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

6.字符串

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

1. 子串
   String类的 subString方法可以从一个较大的字符串中提取出字串

    String greeting = "Hello";
    String s = greeting.substring(0,3);

上述方式创建出一个有Hello字符串创建出来子串Hel
substring(0,3) 从第零个开始 第三个结束（不包括第三个）

2. 拼接
   Java支持 + 号进行拼接两个字符串。

3）不可变字符串
对于String类没有提供修改字符串的方法
只能通过拼接的方式

    String greeting = "Hello";
    String s = greeting.substring(0,3) + "p!";

拼接成修改成字符串help!
因为不能修改Java字符串，所以java文档中将String类对象称为不可变字符串
不可变字符串的优点：编译器可以让字符串共享。
字符串变量指向存储池中相应的位置。如果复制一个字符串变量，他们将共享相同的字符

4）检查字符串是否相同
使用equals来检查字符串是否相同。

s.equals(t)

以上若相等 返回true 否则返回false。s和t可以是字符串变量，可以是字面值。
1.一定不能使用 == 来比较字符串，== 只能用来确定两个字符串是否放在同一个位置上。
事实上只有字符串常量是共享的，而 + 或者 substring等操作产生的结果并不是共享的。
简而言之，“ ==”测试引用是否相等，而equals（）测试值是否相等。
除非要检查两个字符串是否是同一对象，否则应始终使用equals（）

5）空串与Null串
空串：长度为0的字符串。
检测方式

if(str.length() == 0)
// 或者
if(str.equals(""))

空串也是一个Java对象，串长0，内容空

Null串：当内容为null表示没有任何对象与本变量有关。
检测方式

if(str == null)

当检查字符串既不是null也不是空串，需要先检查null，因为如果null.length() null上调用方法将会报错。

6）构建字符串
使用字符串连接在拼接次数很多的情况下效率低，每次连接字符串，就会构建一个新的String对象
StringBuilder类可以解决避免

StringBuilder builder = new StringBuilder();
// 当添加一部分内容，就调用append方法
builder.append("xxx");
builder.append("uuu");
// 最后构建一个String对象
String completedString = builder.toString();

7.输入输出

1. 读取输入
   System.out标准输出流
   System.in标准输入流
   想要通过控制台进行输入，需要构造一个Scanner对象，并与System.in进行关联

 Scanner in = new Scanner(System.in);

这样就可以通过Scanner类的各种方法实现输入操作。

System.out.print("What is your name?");
String name = in.nextLine();

nextLine：读入输入的一行
next:读取有效字符
nextInt：读取一个整数

2. 格式化输出
   对于Print的格式化，暂不赘述。
   可以使用format方法来创建一个格式化的字符串

8.控制流程

条件语句，循环结构控制流程

1. 块作用域
   控制结构之前，需要了解块的概念
   块：一对大括号括起来若干条简单Java语句。块决定了变量的作用域，同时一个块可以嵌套在顶一个块中
   注意点：在嵌套块中不能申明相同的名字的变量。

2. 条件语句

if(yourSales >= target) {
    performance = "akk";
    bonus = 100;
}

2. 循环语句
   while循环
   当循环条件为false，循环体就一次都不循环。在循环中要设置退出条件，不然会变成死循环

3. 确定循环
   for循环是一种支持迭代的通用结构。使用计数器来控制循环次数。
   例：

for(int i = 1; i <= 10; i++) {
    System.out.frintln(i);
}

4. 多重选择：switch语句

switch(choice) {
    case 1:
    System.out.frintln("1");
    break;
    case 2:
    System.out.frintln("2");
    break;
    default:
    System.out.frintln("default");
    break;
}

5. 中断控制流程语句
   break:退出循环
   continue:跳过当前循环体，进入下一次循环中

9.大数值

当整数和浮点精度不能满足需求，那么可以使用java.math包中的
很有用的两个类：BigInteger 和 BigDecimal
BigInteger:实现了任意精度的整数运算
BigDecimal:实现了任意精度的浮点数运算

使用valueOf方法 可以将普通的数值转换为大数值

BigInteger a = BigInteger.valueOf(100);

注意：大数值不能使用+ 和 * ，取而代之的是大数值类中的add 和 multiply方法

BigInteger c = a.add(b);
BigInteger d = c.multiply(b.add(BigInteger.valueof(2)));

以上等同于 d = c * (b+2)

10.数组

1.数据简介
数组是一种数据集合，保存同一类型值的集合。
通过下标访问数组中的每一个值
申明一个数组
int[] a
初始化数组
int[] a = new int[100];
以上初始化了数组可以存放100个整数。
[100]中的内xx可以不是一个常量也可以是一个变量

注意点:
下标是从0开始
数字数组初始化都是0
boolean的数组初始化都是false
对象数组初始化都是null
数组一旦创建不能变更大小，需要变更大小需要使用另一种数据结构，数组列表。

2.for each循环
用来依次处理数组中的每个元素。而不必指定下标

for(int element : a){
    System.out.println(element);
}

3.数组初始化以及匿名数组
数组还可以通过以下方式赋予初始值。这种方式将不需要调用new
int[] smallPrimes = {2，3，4，5，6}；
用如上方式创建一个匿名的数组
new int[] {1,2,3,4,5};
以上方式就是在打括号中提供值进行初始化，数组的大小就是初始化的个数。
这种方式就可以在不创建新的变量的时候重新初始化一个数组
smallPrimes = new int[] {1,2,3,4,5,6}

4.数组的拷贝
一个数组拷贝给另一个数组，两个变量将引用同一个数组。

    public static void main(String[] args) {
        int[] smallPrimes = {1,2,3,4,5};
        int[] luckyNumbers = smallPrimes;
        luckyNumbers[0] = 10;
        System.out.println(smallPrimes[0]);
    }

输出结果：10

如果是希望所有值的拷贝可以使用Arrays类的copyOf方法

    public static void main(String[] args) {
        int[] smallPrimes = {1,2,3,4,5};
        int[] luckyNumbers = Arrays.copyOf(smallPrimes, smallPrimes.length);
        for (int x: luckyNumbers) {
            System.out.print(x);
        }
    }

输出结果：12345
copyOf的第二个参数是指带新数组的长度，可以通过第二个参数扩容数组。

5.命令行参数

    public static void main(String[] args) {

    }

一个main方法中有String[] args表示main方法接收一个字符串数组，也就是命令行参数
添加参数

执行以下代码

    public static void main(String[] args) {
        if (args.length == 0 || args[0].equals("-h")) {
            System.out.print("Hello,");
        } else if (args[0].equals("-g")) {
            System.out.print("Goodbye,");
        }
        for (int i = 1; i < args.length; i++) {
            System.out.print(" " + args[i]);
        }
        System.out.println("!");
    }

执行结果:Goodbye, cruel world!

6.数组排序
对数形数组进行排序 同样使用Arrays类中的sort方法
sort是优化的快排算法。

    public static void main(String[] args) {
        int[] excursiveArray = {2, 5, 1, 2, 5, 6};
        Arrays.sort(excursiveArray);
        for (int x: excursiveArray) {
            System.out.print(x);
        }
    }

输出结果122556

7.多维数组
暂且不赘述

8.不规则数组
暂且不赘述