Java程序设计的基本结构
1.一个简单的Java应用程序（要十分注意java的大小写）
关键字class表明Java的全部程序都在类中（这里有一个对于类的有意思定义：将类看做是加载程序逻辑的容器，程序逻辑定义了应用程序的行为）
********************************************************************
public class FirstSample //这一行是表明了类的类型
{
public static void main(String[] args) //在所有包含主线程的程序中都会出现
{
System.out.println("HelloWorld"); //在屏幕上打印出“HelloWorld”
}
}
在类名以及关键字方面的限制：
类名必须以字母开头，但是在后面的命名就可以随意的采用数字或者是字母，而且没有长度的限制。类名最好采用骆驼命名法（这样显得专业）
注意：
1>
所谓的驼峰命名法就是以单词组成你的函数名（方法名），变量，但是每个单词的首字母都要大写
例如： FirstSample isPrime
2>
System.out.print()这个方法在输出之后不换行，紧紧地跟随在最后一个字符的后面
System.out.println()这个方法在打印进行的时候，会进行换行
2.注释
注释一共有三种类型：
一。行注释以//开始，到一行的末尾结束
第二就是块注释以结尾,同样的在Java中不能再进行嵌套其他的注释符
第三就是用来自动的生成文档用法就是
3.数据类型
a.整型
整型一共有四种类型：
标准整型int(范围是正负二十亿)、
短整型short(范围是正负三万两千多)、
长整形long(反正是8个字节，大的很)、
byte(127)
注意：
1>
长整形的后面有l或L, 16进制有0x的前缀，八进制有前缀0（不过不容易与进制进行区分）
2>
从Java 7 开始就可以在数字的字面量的前面加上0b/0B,并且在数字中加上下划线例如1_000_1111,编译器在后期会把它删除，不用管。
3>
在Java中没有无符号类型
b.浮点类型
浮点类型就只有两类单精度和双精度（float/double）,大部分在工程中的应用都是双精度的。注意如果要使用单精度的时候（在单精度变量的后面加上F/f后缀，双精度是默认的）
浮点数值用十六进制进行表示
注：
在十六进制表示法中，使用p表示指数而不是e
用于表示出错情况和溢出的三个特殊的浮点数值:正无穷大、负无穷小、NaN(不是数字)
能不能检测一个数据是不是非数值的一种方法（NaN的判断的方法）
//例如正整数除以0就是NaN
if(Double.isNaN(x))
//检测一个值是不是NaN
c.字符类型（char）
推荐尽量不要使用
d.变量
1>
变量的定义、变量的初始化
int variable = 100; //所有的变量都要进行赋值
double Dvariable = 100.0;
2>
常量的定义 在Java中利用final来指示常量，该变量只能被赋值一次，用大写
可以使用一个常量类static final 定义的数值可以在一个类中的多个“函数”使用。一般定义于main方法的外部。如果一个常量声明为public，其他的类的“函数”也可以使用这个常量。
4.运算符
a一般的具体运算符
+ - * / %
b.在Math类中包含各式各样的数学函数：
计算数值的平方根sqrt() 例如 double y = Math.sqrt(x);
******************************************
具体的可以使用牛顿迭代法实现：
public static double sqrt(double c)
{
if(c < 0) return Double.NaN;
double err = 1e - 15;
double t = c;
while(Math.abs(t - c / t) > err * t) //abs是绝对值的方法
t = (c / t + t) * 2.0;
return t;
}
************************************************
进行幂运算所要用的pow()
例如 double y = Math.pow(x,a); //传入两个double参数，而且最后的计算结果也是double
进行取余运算的floorMod（position+adjustment,12）得到0到11内的数
一些三角函数方法：Math.sin()、Math.cos()、Math.tan()、Math.atan()、Math.atan2()、
指数函数Math.exp、反函数Math.log、以10为底的对数Math.log10、
圆周率Math.PI，e的常量Math.E
注：
（调用这些数学方法的方法：在源文件的顶部加上这些代码 import static java.lang.Math.*,就可以使用了）
c.数值类型转换（略）、强制转换（略）
注：
进行舍入运算就是找到最为接近的整数，调用Math.round方法
double x = 9.997;
int nx = (int)Math.round(x); //保留为最近的整数，仍然得强制转换为整型
d.结合赋值（强制跟随被赋值对象的类型）、自增/自减运算符（不要用）、关系运算符（略）、位运算符（P43）、括号/运算符级别（会细讲这个问题）
5.字符串
a.子串
使用String类的substring方法从一个大的字符串中提取一个字串
String greeting = “Hello”;
String s = greeting.substring(0,3); //创建Hel
Substring的第二个参数是不想复制的第一个位置，在String类中字符串都是从0开始计算
b.拼接
在Java中可以使用“+”进行连接，在连接的时候单词与单词之间的空格不计
进行字符串与非字符串进行拼接时，将非字符串转换为字符串
int age = 13;
String rating = “PG”+age; //结果为PG13
将多个字符串连接在一起，使用分界符分割，并且使用静态的join方法
String all = String.join(“/”,”S”,”M”,”L”,”XL”);//输出S/M/L/XL
c.不可变字符串
在Java的String类中没有提供可以修改字符串的方法，可以先将目标字符串提取出来，再进行连接
d.检查字符串是否相等
使用equals方法进行字符串，字符的比较
s.equals(t); // 检测两个s,t字符串是否相等
如果比较两个字符串相等与否（不区分大小写）
“Hello”.equalsIgnoreCase(“hello”);
不要使用==运算符进行字符串是否相等的判断
e.空串与Null串
空串就是长度为0的字符串，可以用来检测一个字符串是不是为空
调用方法：
if(str.length()==0) if(str.equals(“”)) //用来判断字符串是不是空
注：
空串是一个java对象，有自己的串长度（0）和内容（空）
不过有一个特殊的值，null，这个变量没有任何对象与之关联
检测方法：
if(srt == null) //检测一个字符串是不是null
if(str != null && str.length() != 0)
//检测一个字符串既不是空字符串，也不是null
f.码点和代码单元
1>
length方法返回采用UTF-16编码方式的代码长度（字符串所需的代码单元的数量）
String greeting = “Hello”;
int n = greeting.length(); //返回5
2>
得到实际的长度就是码点的数量
int cpCount = greeting.codePointCount(0,greeting.length());
3>
调用s.charAt(n)返回位置n的代码单元
char first = greeting.charAt(0); //返回Hello的第一个字符H
使用codePoint的方法来遍历字符串
int cp = sentance.codePointAt(i);
if(Charcter.isSupplementaryCodePoint(cp)) i += 2;
else i++;
g.构建字符串
连接许多小段字符串用StringBuilder类
步骤：
构建一个空的字符串构建器
StringBuilder builder = new StringBuilder();
当每次添加一部分内容的时候
builder.append(ch);
builder.append(str);
在需要构建字符串的时候调用toString类，得到一个String对象
String completedString = builder.toString();
6.输入输出
A.
读取输入(Scanner定义在java.util.*包中，在使用之前必须将它用import加载进来)
进行标准输入流System.in，首先构造一个Scanner对象，并与System.in相关联
Scanner in = new Scanner(System.in);
使用Scanner类的方法进行输入的操作
****************************************************
nextLine方法输入一行（在输入的行中可能存在空格）
System.out.println(“What your name?”);
String name = in.nextLine();
读取一个整数，调用nextInt方法
System.out.println(“How old are you?”);
int age = in.nextInt();
想要读取下一个浮点数，调用nextDouble方法
int num = in.nextDouble();
使用Java中的Console这个类进行密码的输入
Console cons = System.console();
String username = cons.readLine(“User name :”);
char[] passwd = cons.readPassword(“Password :”);
注：
返回的密码是存放在一维数组中，对密码进行处理之后吧应该立刻用填充值来覆盖这个密码的值
B.格式化的输出
利用Java SE 中的C语言库函数中的printf方法
double x = 10000.0/3.0;
System.out.printf(“%8.2f”,x);//可以用8个字符宽度，以及可以小数点后两位
在printf的方法中可以使用多个参数
System.out.printf(“Hello,%s . Next year ,you will be %d ”,name,age);
System.out.printf(“Hello,”+name+”. Next year ,you will be ”+(age+1));
//对比这两句话上面的在名字，年龄的地方进行了替换
注：
每一个以%开头的格式说明符都用相应的参数进行替换，f表示浮点数，d表示整数，s表示字符串
System.out.printf(“%,.2f”,10000.0/3.0);//输出3,333.33
printf方法中时间和日期的表达方法（本来可以直接使用java.time包）
格式包括两个字母，以t开始以转换表中的任意一个转换符为结束System.out.printf(“%tc”,new date());
//打印出当前的日期和时间 Mon Feb 09 18:05:19 PST 2015
System.out.printf(“%tF”,new date()); //打印ISO8601日期
C.文件输入与输出*
想要对文件进行读取，就需要用File对象构造一个Scanner对象
Scanner in = new Scanner(Path.get(“myfile.txt”),”UTF-8”);
//指定了采用UTF-8编码形式的名为myfile的txt文件，就是生成了一个文件叫做myfile
如果文件中包含反斜杠“\”,必须在每个反斜杠之前再加一个额外的反斜杠“\”
“C:\\mydirectory\\myfile.txt”
想要写入文件，就需要构造一个PrintWriter对象，在构造器中，只需要提供文件名
PrintWriter out = new Scanner(“myfile.txt”,”UTF-8”);
//如果该文件不存在，就会创建该文件,然后就可以正常的使用print,println,printf
注：
如果用一个不存在的文件构建一个Scanner,或者用一个不能被创建的文件名，系统就会抛出异常
public static void main(String[] args) throws IOexception
{
Scanner in = new Scanner(Path.get("myfile.txt"),"UTF-8");
}
当发生异常的时候，红色字体的部分的功能就是抛出这个异常的原因与形式
//**********************************************
API
* java.util.Scanner
Scanner(File f) //构造从指定文件中读取数据的Scanner
Scanner(String data) //构造从给定字符串中读取数据
* java.io.PrintWriter
PrintWriter(String fileName) //将数据写入文件中，名字自己起
* java.nio.Paths
static Path get(String pathname) //根据给定的路径名，构造一个Path,就是指路
//*********************************************************************
7.控制流
A.块作用域
一对大括号括起来的多条Java语句（在嵌套的块中不能定义同名的变量---就是括号
套括号的情况下）
B.条件语句（与C++一样略）
C.循环（略与C++一样）
注：
for循环进行浮点数比较的时候，由于舍入否认操作有可能永远无法继续进行下面步骤
for(double x = 0;x != 10;x += 0.1;)
在循环体内部定义的变量不能再定义到外部
switch语句与C++完全一样（略）
在Java中switch的标签case
*可以是char、byte、short、int的常量表达式
*枚举常量
*case标签还可以是字符串字面常量
***********************************
String input;
Switch(input.toLowerCase())
{
case "yes" :
.........
break;
}
D.中断控制流程语句
break语句
正常的不带标签的break语句
while(years <= 100)
{
balance += payment;
double interest = banlance * interestRate / 100;
balance += interest;
if(balance >= goal) break;
years++;
}
使用case的标签跳转语句（就是在你想要跳转的地方放置一个标签，然后使用break语句+你的标签）
注：所有的置在外面的标签的值必须放在最外层循环之前，加上冒号
read_data:
while(......)
{ ........
break read_data;
}//作用就是返回上一个放置标签read_data的地方（最外层）
如果输入有误的话，break就会跳转到带标签语句块的末尾，所以当循环中带有break标签的时候必须检测循环能不能正常进行
continue语句
将语句控制转到最内层的循环
*******************************************
Scanner in = new Scanner(System.in);
while(sum>goal)
{.........
if(n<0) continue;
statement.....
}//直接跳出当前循环的剩余部分，直接跳到循环的首部（在没有for语句的情况下）
//for语句的话，就是直接跳转到for语句的“++部分”
还有带标签的continue语句，就是跳到带有标签的循环块的首部
大数值
使用java.math包中的BigInteger BigDecimal （就是处理超出范围的数的方法）
调用包的格式：
import java .math.*; //使用math这个包
BigInteger实现了对于任意精度的整数进行计算
BigDecimal实现了对于任意精度的浮点数的计算
BigInteger a = BigInteger.valueOf(100);
//将100转为精度不受限制的大数值
不能继续使用通常的“+”“*”进行一般的算术运算
BigInteger c = a.add(b); //将大数值a和b进行相加
BigInteger d = c.multiply(b.add(BigInteger.valueOf(2))); //d=c*(b+2)
BigInteger k = d.divide(b); //k=d/b
在Java中里面用一个包的方法必须先：包名 变量名 =包名.方法名（参数）
//****************************************************************
API
* java.math.BigInteger
BigInteger a .add(BigInteger b) //a+b
BigInteger a.multiply(BigInteger b) //a*b
BigInteger a.divide(BigInteger b) //a/b
BigInteger a.mod(BigInteger b) //a%b
BigInteger a.subtract(BigInteger b) //a-b
int a.compareTo(BigInteger b) //a，b相等返回0，a<b返回负数，a>b返回正数
BigDecimal (和BigInteger一样的用法)
//*************************************************************************
9.数组
A.数组的基本概念
声明数组：
int[] a; //声明一个变量名为a的整型数组
对数组进行初始化操作
int[] a = new a[100]; //创建一个可以储存100个元素的数组，并且将数组初始化为0
对数组进行循环赋值
for(int i= 0;i<100;i++)
a[i] = i; //填充数组从0到99（fills the array with numbers 0 to 99）
*创建一个数字数组时，初始化为0
int[] a = new a[100];
*创建一个boolean数组，初始化为false
*创建一个对象数组，初始化为null(表示在这些元素中啥也没有)
String[] names = new String[10];
for(int i=0;i<10;i++)
names[i] = “ ”; //指定元素为空串
想要获取数组中字符的个数，使用array.length方法
for(int i=0;i<array.length;i++)
B.for each循环
定义一个变量暂时存放集合中的每个元素，并执行相应的语句或是语句块
for(int element: a)
System.out.println(element); //遍历a中的每一个元素，执行相应的语句
可以利用Arrays类中的toString方法直接就进行输出
System.out.println(Arrays.toString(a));
//将a中的所有元素以逗号进行分割，并且放在括号里打印出来
C.数组的初始化以及匿名数组
int[] smallPrimers = {2,3,4,5,6};
//不用调用new
new int[] {34,45}; //直接开辟匿名数组
int[] smallPrimers = new int[] {34,45}
//使用匿名数组给已知数组重刷
int[] annoymous = {23,45};
smallPrimer = annoymous; //直接就可以用数组来初始化数组（重刷，确保类型一致
注：Java中数组可以为0长度
D.数组拷贝
在Java中可以将一个数组变量拷贝给另外的一个数组变量（就是用数组声明数组）
int[] a = smallPrimer;//smallPrimer也是一个数组变量
将整个数组的所有的值进行拷贝，使用Arrays类的copyOf方法
int[] copiedLuckyNumber = Arrays.copyOf(LuckyNumber,LuckyNumber.length);
//方法中的参数就是数组名，数组长度
可以使用这样的拷贝方法增加数组的长度
int[] LuckyNumber = Arrays.copyOf(LuckyNumber,2*LuckyNumber.length);
注：
如果数组时数字型的，多余的数字就会被置为0
如果数组时boolean类型，多余的元素就会被置为false
如果你将要进行拷贝的目标数组的位宽小，拷贝的数组就会截断
E.命令行参数
每一个Java程序都带有String arg[]参数的main方法，表明main方法接受一个字符串数组
**************************************
public class Massage
{
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 = 0;i < args.length;i++)
System.out.print(" "+args[i]);
}
}
如果在命令行界面输入
java Massage -g cruel world
//这个数组包含以下的内容
-g
cruel
world
然后运行这个程序
Goodbye,cruel world
***********************
注：
你在同时必须要注意，所谓的java Massage 并不包含在args数组当中
F.数组排序
1>
对数值型数组进行排序用Arrays类中的sort方法
int[] a = new int[100];
Arrays.sort(a);
2>
产生随机数
调用Math.random方法返回一个0到1之间的随机浮点数
int r = (int)(Math.random() * n);
//用返回的这个浮点数乘以n就可以得到0 到n- 1之间的一个整数了
API
static type copeOf(type[] a,int length) //拷贝数组，后面的是长度
static type sort(type[] a) //对数组进行排序
static void fill(type[] a.type v) //将数组全部置为v，类型随前面
static boolean equals(type[] a,type[] b)
//数组a，b大小相同，下标元素相同返回true ***********************************************************
G.多维数组（和c++完全一致）
二维数组初始化
int[][] a = {
{1,2,3,4},
{2,3,4,5},
{3,4,5,6},
{4,5,6,7}
}
for each循环不能自动的处理多维数组，需要进行嵌套
for（double[] row:a） //遍历二维数组的行变量
for(double[] value:row) //遍历二维数组的列变量，其中把上一个的中间变量作为下一个的遍历数组
快速打印二维数组
System.out.println(Arrays.deepToString(a))
H.不规则数组
创建不规则数组
int[][] odds = new int[MAX+1][];
对行，以及列进行创建
for(int i = 0;i<odds.length;i++)
odds[i] = new int[i+1];
对数组进行赋值
for(int i = 0;i < odds.length;i++)
for(int k = 0;k < odds[i].length;k++)
{.........}//可以打印出一个直角三角形的数字矩阵
![Java小案例——随机数猜测随机数猜测[图]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)