版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/u012417380/article/details/79871425
3.1 简单Java程序
public class FirstSample {
public static void main(String[] args) {
System.out.println("We will not use Hello,World!");
}
}
类名命名规则：
1.大小写敏感
2.以大写字母开头，后面跟数字和字母任意组合，无长度限制，保留关键字
3.驼峰命名法
4.源文件名与公共类库名必须相同
每个java程序必须有一个main方法，退出返回0，其它返回值用’System.exit()`方法
3.2 注释
注释3种：
1.//
2./* */ 不能嵌套
3. /**
*/ 能够生成文档3.3 基本数值类型
Java基本数据类型8种：整型 4 种、浮点型 2 种、1种 Unicode char 、另一种 boolean
3.3.1 整型
都是有符号数,没有无符号数
| 类型 | 存储字节 | 范围 |
|---|---|---|
| int | 4 | |
| short | 2 | |
| long | 8 | |
| byte | 1 | -128~127 |
1. 长整形 20000L
2. 16 进制 前缀 0x ,8 进制前缀 0 ，2进制 java7 可以加 前缀0b，数字之间可以加_分隔，编译时去掉
3. Java整形与目标平台无关
3.3.2 浮点型
| 类型 | 存储字节 | 范围 |
|---|---|---|
| float | 4 | |
| double | 8 |
1. float 类型加后缀 L;
浮点值遵循IEEE754 规范。
3类特殊浮点值：
1)正无穷（Double.POSITIVE_INFINITY） 2)负无穷（Double.NEGATIVE_INFINITY）
3) NaN(非数字，如负数平方根 Double.NaN)
if(x==Double.NaN)//never true 不能这样判断
Double.isNaN(x)//正确判断4.浮点数不能用于四舍五入，使用BigDecimal类
2.0-1.1=0.89999999999999993.3.3 char类型
char 用来表示单个字符，16位的Unicode码表示\u0052
3.3.4 boolean类型
boolean类型值有两个 true 和false,Java中boolean和整形两者之间不能相互转换
3.4 变量
变量命名规则：
1.大小写敏感
2.以大写字母开头，后面跟数字和字母任意组合，无长度限制，保留关键字。字母可以包括“_”等Unicode字符
3.驼峰命名法
4.不能使用保留关键字
3.4.1初始化
1.声明变量后，使用前必须进行初始化。
2.变量声明尽可能放在第一次使用的地方
3.5 常量
Java中用final 关键字声明常量。常量名通常大写。常量只能被赋值一次。
final double CM_PRE_INCH = 2.54如果常量能够在多个地方使用，用static final 声明类常量
3.5 运算符
3.5.1 自增、自减
++i，i++
3.5.2 关系运算符与布尔运算符
1.> < == >= <= !=
2.&& 、||短路运算符
3. condition? a:nb 三目运算符3.5.3 位运算符
&（与）、|（或）、^（异或）、~ （非）
int forthBitFromRight =(n&0b1000)/0b1000;
int forthBitFormRight =(n&(1<<3))>>3;>>>运算符将用0填充高位，>>运算符用符号位填充高位，没有<<<运算符移位运算符右侧操作数应当取模32。
3.5.6 数学函数与常量
Math.sqrt(a); //a的开方
Math.pow(x, a);// x的a次幂
Math.log(a);
Math.log10(a);
Math.PI;
3.5.7 数值类型转换
graph TD
A[byte]-->B[short]
B[short]-->C[int]
D[char]-->C[int]
C[int]-->E[long]
C[int]-->F[float]
C[int]-->G[doule]
E[long]-->F[float]
E[long]-->G[doule]整形转浮点型会发生数据丢失
int n =123456789
float f =n ;// f is 1.23456792e83.5.8 强制类型转换
String类是常量，是不以被改变的。
double x = 9.97;
int nx =(int)x; //高精度向低精度需要强制类型转换
double x = 9.97f;
int nx =(int)Math.round(x);3.6 子符串
3.6.1 子串
String greeting ="Hello";
String s = greeting.substring(0, 3);
//输出 Hel
容易计算长度 length= 3 - 0;
public String substring(int beginIndex, int endIndex) {
if (beginIndex < 0) {
throw new StringIndexOutOfBoundsException(beginIndex);
}
if (endIndex > value.length) {
throw new StringIndexOutOfBoundsException(endIndex);
}
int subLen = endIndex - beginIndex;
if (subLen < 0) {
throw new StringIndexOutOfBoundsException(subLen);
}
return ((beginIndex == 0) && (endIndex == value.length)) ? this
: new String(value, beginIndex, subLen);
}
3.6.2 拼接
String expletive ="Expletive";
String PG13 = "delete";
String message = expletive + PG13;非字符串与字符串拼接时，会被转成字符串
int age = 13;
String rating ="PC"+age;3.6.3 不可变字符串
String类是常量，是不以被改变的。每次字符串操作都是返回的一个新的String对象。
public final class String
implements java.io.Serializable, Comparable<String>, CharSequence {
/** The value is used for character storage. */
private final char value[]; //final 声明
.....
}
不可变字符串优点：编译器可以让不可变字符串共享
3.6.4 检测字符串是否相等
String greeting ="Hello";
if(!"hello".equals(greeting)){
System.out.println("true");
}//输出true
if("hello".equalsIgnoreCase(greeting)){
System.out.println("true");
}//输出flase比较字符串时，使用equals而不使用==,
Object.equals默认比较的是地址，String复写了equals方法，比较的是字符相等。
String{
...
public boolean equals(Object anObject) {
if (this == anObject) {
return true;
}
if (anObject instanceof String) {
String anotherString = (String)anObject;
int n = value.length;
if (n == anotherString.value.length) {
char v1[] = value;
char v2[] = anotherString.value;
int i = 0;
while (n-- != 0) {
if (v1[i] != v2[i])
return false;
i++;
}
return true;
}
}
return false;
}
...
}
而== 比较是值或者是地址值是否相等，由于只有字符串常量被虚拟机共享，所以不能用==比较字符串的相等性。
3.6.5 空串与null
空串”“是长度为0的字符串
if(str.length() == 0)
或者
if(str.equals(""))空串是一个Java 对象，可以为null：
检查一个字符串既不是null也不是空串。
if(str !=null && str.length() !=0)3.6.6 代码点与代码单元
char类型为UTF-16编码表示Unicode代码点的代码单元。
length 表示采用UTF-16编码表示的字符串所需要的代码单元数量。
String greeting ="Hello";
greeting.codePointCount(0, greeting.length())// is 5
3.6.7 字符串 API
3.6.8 阅读联机API文档
3.6.9 构建字符串
拼接字符串时，每次都会创建一个新的String对象。既耗时，又浪费空间。可采用 StringBuilder 类解决，它对字符串进行修改之后，返回的仍是当前对象。
StringBuilder sb = new StringBuilder()；//默认容量为16个字符常用操作
append
insert
delete
indexOf
调用 toString() 方法返回String 类对象
3.7 输入输出
3.7.1 读取输入
package inputtest;
import java.util.Scanner;
public class InputTest {
public static void main(String[] args) {
Scanner in= new Scanner(System.in);
System.out.print("What is your name?");
String name = in.nextLine();
System.out.print("How old are you?");
int age = in.nextInt();
System.out.println("Hello,"+name+".Next year,you'll be"+(age+1));
}
}3.7.2 格式化输出
double x = 10000.0 /3.0;
System.out.println(x);
System.out.printf("%8.2f",x);
System.out.printf("Hello,%s. Next year,you'll be %d","suxiang",13);
String message = String.format("Hello,%s . Next year, you'll be %d ","suxiang",13);
System.out.printf("%tc",new Date());
//格式化参数索引，下标从1开始
System.out.printf("%1$s %2$tB %2$te, %2$tY","Due date:",new Date());
3.7.3 文件输入输出
//格式化参数索引，下标从1开始
System.out.printf("%1$s %2$tB %2$te, %2$tY","Due date:",new Date());
System.out.println(System.getProperty("user.dir")+"\\myfile.txt");
Scanner in = new Scanner(Paths.get(System.getProperty("user.dir")+"//myfile.txt"));
PrintWriter out = new PrintWriter(System.getProperty("user.dir")+"//myfile2.txt");
out.println("hahaha");
out.flush();3.8 控制流程
3.8.1 块作用域
Java中不能在嵌套的两个块中声明同名的变量。C++ 允许，会进行同名覆盖。
{int n;
{
int k;
int n;
}
} //不允许3.8.2 条件语句
3.8.3
3.9 大数值
package bigintegertest;
import java.math.BigInteger;
import java.util.Scanner;
public class BigIntegerTest {
public static void main(String[] args) {
Scanner in = new Scanner (System.in);
System.out.print("How many numbers do you need to draw?");
int k = in.nextInt();
System.out.print("What is the highest number you can draw?");
int n = in.nextInt();
BigInteger lotteryOdds = BigInteger.valueOf(1);
for(int i = 1;i<=k;i++)
lotteryOdds = lotteryOdds.multiply(BigInteger.valueOf(n-i+1)).divide(BigInteger.valueOf(i));
System.out.println("your olds are 1 "+lotteryOdds+".Good luck");
}
}
3.10 数组
一维数组初始化之前不能使用它。
int[] a = new int[100];3.10.1 for each循环
数组或者是实现了Iterable接口的类对象可以用
for(int element : a)
System.out.println(element);或者用Arrays.toString(int [])对象。
3.10.2 数组化及匿名数组
int [] smallPrimes ={2,3,5,7,11,13};//声明并初始化
new int[]{17,19,23,29,31,37};
//初始化匿名数组
smallPrimes = new int[]{17,19,23,29,31,37};
int[] anonymous ={17,19,23,29,31,37};
smallPrimes = anonymous;3.10.3 数组拷贝
Java中允许将一个数组变量。这时，两个变量将引用同一个数组。
int[] luckyNumbers = smallPrimes;
luckyNumbers[5]=12;//now smallPrimes[5] is also 12Arrays.copyOf将一个数组的所有值都拷贝到一个新的数组中。第2个参数是数组的长度。
int[] copiedLuckyNumbers = Arrays.copyOf(luckyNumbers, luckyNumbers.length*2);3.10.4 命令行参数
3.10.5 数组排序
Arrays.sort返回的仍是原数组
public class LotteryDrawing {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
System.out.print("How many numbers do you need to draw?");
int k = in.nextInt();
System.out.print("What is the highest number you can draw?");
int n = in.nextInt();
int[] numbers = new int[n];
for(int i =0;i<numbers.length;i++)
{
numbers[i]=i+1;
}
int [] result = new int[k];
for(int i=0;i< result.length;i++){
int r =(int)(Math.random()*n);
result[i]= numbers[r];
numbers[r]=numbers[n-1];
n--;
}
Arrays.sort(result);
System.out.println("Bet the following combination.It'll make you rich!");
for(int r:result)
System.out.println(r);
}
}
3.10.6 多维数组
多维数组初始化之前不能使用它
double [][] balances = new double [NYEARS][NRATES];int [][] magicSquare={{16,2,2,13},{5,10,11,8},{9,6,7,12},{4,15,14,1}};package CompoundInterest;
public class CompoundInterest {
public static void main(String[] args){
final double STARTRATE = 10;
final int NRATES = 6;
final int NYEARS = 10;
double [] interestRate = new double[NRATES];
for(int j =0;j<interestRate.length;j++){
interestRate[j]=(STARTRATE+j)/100.0;
}
double[][] balances = new double[NYEARS][NRATES];
for(int j = 0;j<balances[0].length;j++)
balances[0][j]=10000;
for(int i =1;i<balances.length;i++)
{
for(int j =0 ;j<balances[i].length;j++)
{
double oldBalance = balances[i-1][j];
double interest = oldBalance * interestRate[j];
balances[i][j]= oldBalance + interest;
}
}
for(int j=0;j<interestRate.length;j++)
System.out.printf("%9.0f%%",100*interestRate[j]);
System.out.println();
for(double[] row:balances){
for(double b : row)
System.out.printf("%10.2f", b);
System.out.println();
}
}
}
3.10.6 不规则数组
Java实际上没有多维数组，只有一维数组
package lotteryarray;
public class LotteryArray {
public static void main(String[] args) {
final int NMAX = 10;
int[][] odds = new int[NMAX+1][];
for(int n =0;n<=NMAX;n++)
odds[n]= new int [n+1];
for(int n =0;n<odds.length;n++){
for(int k = 0;k <odds[n].length;k++){
int lotteryOdds = 1;
for(int i =1;i <=k;i++)
lotteryOdds = lotteryOdds * (n -i+1)/i;
odds[n][k]=lotteryOdds;
}
}
for(int [] row:odds)
{
for(int odd : row)
System.out.printf("%4d",odd);
System.out.println();
}
}
}