(一) Java的基本程序设计结构

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

• 下面看一个最简单的 Java 应用程序，它只发送一条消息到控制台窗口中：

public class HelloWorld {
    public static void main(String[] args)
    {
        System.out.println("Hello World !!!");
    }
}

• 虽然程序很简单,但是所有的Java应用程序都具有这种结构

注意:Java区分大小写,如果出现拼写错误程序将无法运行

运行已编译的程序时，Java 虚拟机将从指定类中的 main 方法开始执行

因此为了代码能够执行，在类的源文件中必须包含一个 main 方法。

2.注释

• Java中有三中注释的方式,可以根据不同的场合,使用不同的注释

//	第一种

/*
	第二种
*/

/**
 *	第三种
 */

3.数据类型

• Java是一种强类型语言
• 一共有8种基本 数据类型
• 4 种整型、2 种浮点类型、 1 种用于表示 Unicode 编码的字符 单元的字符类型 char (请参见论述 char 类型的章节） 和 1 种用于表示真值的 boolean 类型

//[]里面的数是类型所占的字节数
Java中数据类型分为两大类：
	1.基本数据类型：
    	1.数值型：
    		1.整数类型(byte[1],short[2],int[4],long[8])
    		2.浮点(小数)类型(float[4],double[8])
    	2.字符型(char[2]),存放单个字符 'a'
    	3.布尔型(boolean[1]).存放 true , false
	2.引用数据类型：
    	1.类(class) String 类
    	2.接口(interface)
    	3.数组([])

1.整型

类型	存储需求	取值范围
int	4字节	-2147483648 ~ 2147483647 (正好超过 20 亿)
short	2字节	-32768 ~ 32767
long	8字节	-9223372036854775808 ~ 9223372036854775807
byte	1字节	-128 ~ 127

注意: 长整型数值有一个后缀 L ( 如 4000000000L)

2.浮点类型

类型	存储需求	取值范围
float	4字节	大约 ± 3.40282347E + 38F(有效位数为6~7位)
double	8字节	大约 ± 1.79769313486231570E+308 (有效位数为 15 位)

注意: float 类型的数值有一个后缀 F

没有后缀 F 的浮点数值（如 3.14 ) 默 认为 double 类型

当然，也可以在浮点数值后面添加后缀 D

3.char 类型

• char 类型原本用于表示单个字符
• 有些 Unicode 字符可以用一个 char 值描述，另外一些 Unicode 字符则需要两个 char 值

4.boolean 类型

• boolean (布尔）类型有两个值：false 和 true, 用来判定逻辑条件
• 整型值和布尔值之间 不能进行相互转换

4.变量

• 在 Java 中，每个变量都有一个类型(type)
• 在声明变量时，变量的类型位于变量名之前

double salary;
int age;
long fei;
boolean flag;

• 变量初始化

double salary = 29635.26;
int age = 18;
long tel = 213021569874;
boolean flag = true;

• 常量

//在 Java 中， 利用关键字 final 指示常量
final double PI = 3.1415926D;

关键字 final 表示这个变量只能被赋值一次。
一旦被赋值之后，就不能够再更改了。
习惯上,常量名使用全大写。

• 在 Java 中，经常希望某个常量可以在一个类中的多个方法中使用，通常将这些常量称为 类常量。可以使用关键字 static final 设置一个类常量。

public class Demo{
	public static final double CM_PER_INCH = 2.54;

	public static void main(String[] args){

		double paperWidth = 8.5;
		
		double paperHeight = 11;
		
		System.out.println("Paper size in centimeters: "+ 
		paperWidth * CM_PER_INCH + " by " + paperHeight * CM_PER_INCH) ;
	}
}

5.运算符

//算术运算符(+,-, *,/,%, ++,-–)

//赋值运算符(= ，+=，-=，*=，/=，%=，++, --)
    
//比较运算符(>,>=,<,<=,==,!=)
    
//逻辑运算符(&, &&, |, ||, !)
    或,与,非 单个可通行
    
//三元运算符(判断语句?表达式1:表达式2)
	如果判断语句为 true 执行表达式1,反之执行表达式2  

6.字符串

String 类常见方法：
字符串的比较不适合用"=="比较。
== 是比较的对象地址，只有严格指向同一个地址的两个对象才会返回真。
- 1.s1.equals(s2);            比较s1 与 s2 是否相等    如果相等 为 true 否则为 false
- 2.s1.equalsIgnoreCase(s2);  比较s1 与 s2 是否相等忽略大小写  如果相等 为 true 否则为 false 
- 3.s.length();               获取字符串长度
- 4.s.charAt(i);              获取i索引位置的字符
- 5.s.toCharArray();          把字符串转换成字符数组
- 6.s.substring(0,9);         截取字符串0到8的字符(包前不包后)
- 7.s.replace("XXX","YYY");   替换 把字符串中的XXX 替换为YYY
- 8.s.contains("xxx");        判断xxx是否在字符串s内
- 9.s.startWith("xxx");       是否已xxx 开始
- 10.s.split(",");            按照某个内容把字符串分割成字符串数组返回
String info = String.format("我的名字是%s 年龄是%d ...",name,age);
格式化处理
1. %s , %d , %.2f %c称为占位符
2. 这些占位符由后面变量来替换
3. %s 表示后面由字符串来替换
4. %d 是整敦来替换
5. %.2f表示使用小数来替换，替换后，只会保留小数点两位，并且进行四舍五入的处理
6. %c 使用 char 类型来替换

//s.split(","); 案例
String name = "狗哥,乔老六,陈盼盼";
String[] names = name.split(",");
name 字符串被分割为
    names[0] = "狗哥";
	names[1] = "乔老六";
	names[2] = "陈盼盼";
的数组;

String 类是保存字符串常量的。每次更新都需要重新开辟空间，效率降低，
因此 Java 设计者还提供了 StringBuilder 和 StringBuffer 来增强 String 的功能
并提高效率。

7.输入输出

//构造一个Scanner对象
Scanner in = new Scanner(System.in);

//常用的
in.nextLine(); 方法将输入一行
in.next(); 输入一行以空格结尾
in.nextInt(); 读取一个整数
in.nextDouble(); 读取一个浮点数

System.out.print(); //不带换行
System.out.println(); //带换行
    
//还有一些格式化输出,因为用的比较少,所以需要时再查询

8.控制流程

1.if 语句
语法：
if(条件表达式A){
	语句块A;
}else if(条件表达式B){
	语句块B;
}...
else if(条件表达式N){
	语句块N;
}else{
	语句块N+1
}
if 可以单分支,也可以双分支和多分支
    
2.switch 语句
语法:
switch(表达式){
	case 值1:
		语句块1;
		break;
	.....
	case 值N:
		语句块N;
		break;
	default: 
		语句块default;
} 

3.while 循环(先判断再进入循环)
语法：
初始化部分
while(循环条件部分)｛
	循环体部分; 
	迭代部分; 
}

4.do…while 循环(先进入循环再判断)
语法：
初始化部分;
do{
	循环体部分
	迭代部分
}while(循环条件部分);
  
5. for 循环
for循环
语法:
for(初始化循环条件;循环条件表达式 ;迭代部分 ){
	循环操作(循环体);
}

//continue、break、return三者对比：
continue：
    跳过本次循环，继续下一次循环。
break：
    结束所在的循环。
return：
    结束整个方法。

9.大数值

• 如果基本的整数和浮点数精度不能够满足需求,那么可以使用java.math 包中的两个很有用的类：Biglnteger 和 BigDecimal
• 这两个类可以处理包含任意长度数字序列的数值
• Biglnteger 类实现了任意精度的整数运算
• BigDecimal 实现了任意精度的浮点数运算

//使用静态的 valueOf 方法可以将普通的数值转换为大数值：
	BigInteger a = BigInteger.valueOf(999999999999999999999999999999999999999999999);
/*
遗憾的是，不能使用人们熟悉的算术运算符（如：+ 和 *) 处理大数值。 而需要使用大数
值类中的 add 和 multiply 方法。
*/

BigInteger c = a.add(b); // c = a + b
BigInteger d = c.multiply(b.add(BigInteger.valueOf(2))); // d = c * (b + 2)



• Biglnteger add(Biglnteger other)
• Biglnteger subtract(Biglnteger other)
• Biglnteger multipiy(Biginteger other)
• Biglnteger divide(Biglnteger other)
• Biglnteger mod(Biglnteger other)
返冋这个大整数和另一个大整数 other 的和、 差、 积、 商以及余数。
• int compareTo(Biglnteger other)
如果这个大整数与另一个大整数 other 相等， 返回 0; 
如果这个大整数小于另一个大整数 other, 返回负数； 否则， 返回正数。
• static Biglnteger valueOf(Long x)
返回值等于 x 的大整数。

• BigDecimal add(BigDecimal other)
• BigDecimal subtract(BigDecimal other)
• BigDecimal multipiy(BigDecimal other)
• BigDecimal divide(BigDecimal other RoundingMode mode)
返回这个大实数与另一个大实数 other 的和、 差、 积、 商。要想计算商， 必须给出舍
入方式 (rounding mode) RoundingMode.HALF_UP 是在学校中学习的四舍五入方式
(即, 数值 0 到 4 舍去， 数值 5 到 9 进位）。它适用于常规的计算。有关其他的舍入方
式请参看 Apr文档。
• int compareTo(BigDecimal other)
如果这个大实数与另一个大实数相等， 返回 0 ; 如果这个大实数小于另一个大实数，
返回负数；否则，返回正数。
• static BigDecimal valueOf(Long x)
• static BigDecimal valueOf(Long x ,int scale)
返回值为 X 或 x / 10^scale 的一个大实数。

10.数组

1.数组的基本介绍

//数组基本介绍
数组可以存放多个同一类型的数据.数组也是一种数据类型,是引用类型.
//数组的定义：
	1.动态初始化1
		数据类型[] 数组名 = new 数据类型[]; 前后数据类型要一致
		例如： int[] arr = new int[10];
	2.动态初始化2
		定义数组：
		数据类型[] 数组名; 例如： int[] arr;
		创建数组：
         数组名 = new 数据类型[大小]; 例如 arr = new int[10];
		(就是把第一种的拆开来写了)
	3.静态初始化
		数据类型[] 数组名 = {元素值,元素值,元素值,元素值...};
		把数组的创建和数据的插入一次性完成
//数组的使用：
	数组名[下标/索引]
	例如：你要使用arr数组的第三个数 arr[2] //数组下标是从0开始
	for(int i = 0;i<arr.length;i++){
        对数组的arr[i]进行操作;
    }

//二维数组
	数据类型[][] arr = new 数据类型[行数][列数];
	int[][] arr = new int[3][4];
	基本与一维数组一致.

2.数组的注意事项和细节

//数组使用注意事项和细节
1．数组是多个相同类型数据的组合,实现对这些数据的统一管理
2.数组中的元素可以是任何数据类型，包括基本类型和引用类型，但是不能混用。
3.数组创建后，如果没有赋值，有默认值 int 0, short 0, byte 0, long 0, float 0.0,double 0.0, 
char \u0000,boolean false, String null
4．使用数组的步骤：
	1.声明数组并开辟空间
	2给数组各个元素赋值
	3使用数组
5.数组的下标是从 0 开始的。
6.数组下标必须在指定范围内使用,否则报:下标越界异常，比如
	int [] arr=new int[5]; 则有效下标为 0-4
7.数组属引用类型,数组型数据是对象(object)

1.一维数组的声明方式有:
int[] x或者int x[]
2.二维数组的声明方式有:
int[][] y 或者int[] y[]或者int y[][]
3.二维数组实际上是由多个一维数组组成的，它的各个一维数组的长度可以相同,
也可以不相同。比如:map[][]是一个二维数组
map[][] = {{1,2}{3,4,5}};
由map[0]是一个含有两个元素的一维数组，map[1]是一个含有三个元素的一维数组构成，我们也称为列数不等的二维数组。

3.数组赋值机制

1.基本数据类型赋值,这个值就是具体的数据,而且相互不影响(值拷贝 b不会影响a) 
	int a = 2; int b = a; b = 20;
	输出：a = 2，b = 20
2.数组在默认情况下是引用传递,赋的值是地址(引用赋值)
	int[] arr1 = {1,2,3};
	int[] arr2 = arr1;
	arr2[0] = 100;
	输出：arr1 为 100 2 3
赋值方式为引用赋值是一个地址，arr2的变化会影响arr1

4.值传递/值拷贝 和 引用传递/地址拷贝的 区别 （JVM内存图）

5.二维数组内存布局