Java基础

编程 JAVA

• 课本链接：https://pan.baidu.com/s/184nwV1VfvKRJMiCjYZaqJQ
  提取码：wyzl

第一、二章 基本程序设计

java.包.类.对象.方法 java.util.Scanner.out.ptintln

1. 变量在使用之前必须初始化
2. System.out.println(x = 1)是正确的
   相当于
int x = 1;
System.out.println(x);

3. final用来声明常量 常量名称大写final double PI = 3.14159
4. 变量、方法全小写，多个单词则首字母大写——驼峰命名法
5. 类首字母大写
6. 常量所有字母大写 两个单词用下划线连接如 MAX_VALUE
7. JAVA整数：byte、short、int、long。
   浮点数：float和double。后者是前者的两倍大小。
   通常情况下使用double，因为它比float精确。
8. Scanner的方法 如nextByte（） 读取一个byte类型的整数
   Scanner input = new Scanner（system.in）
9. %用于除余数 如20%3=2 可以求负数 如-7%3=-1 7%-3=1
   偶数%2为0而奇数总为1可以用来判断奇偶
10. -5的-号是一元操作符，4-5这里的-号是二元操作符
11. Math.pow(a,b)可以计算a^b并返回结果，Math类隐藏在java.lang包中，此包为隐式导入的，因此，不需要在开始声明。
    如System.out.println(Math.pow(2,3))
12. 只要两者有一个浮点数结果就是浮点数5.0/2=2.5 5/2.0=2.5 5/2=2

整形字面值

1. int 最大2147483648
2. 若超过的整形字面值要在后面加l or L来示意这个数值是long类型 如2147483648L 同理1010.2d代表double 1002F代表float 这里不区分大小写
3. 二进制0B 0B1111=15
4. 八进制0 07777=4095
5. 16进制0x 0XFFFF=65535
6. 数字之间加_是被允许的 如124_123=124123

浮点型字面值

1. double精确到小数点后16位 而float只到8位 因此double更加精确

科学计数法

1. E即为*10 不区分大小写
2. 123.456 = 1.23456E2 = 1.23456E+02

返回UNIX时间戳

1. System.currentTimeMillis()可以返回从1970年1月1号到现在的毫秒数
2. 通过毫秒数/1000可以得出秒数 秒数/60可以得出分钟数 分钟数/60为小时数 小时数/24为天数
3. 通过秒数%60可以得出当前秒数 分钟数%60可以得出当前分钟数 小时数%24可以得出当前小时数

增强复制操作符

1. += -= *= %= /=
2. 中间没有空格！
3. Java支持i++ i-- ++i --i
4. int a = ++i； 先加了 返回新值
   int a = i++； 加了但返回旧值

double x = 1.0;
double y = 5.0;
double z = x-- + (++y);
x=0.0 y=6.0 但z=7.0

5.从左到右对操作数求值 此规则高于一切

int i = 1;
int k = ++i + i*3
i = 2, k =8
int i = 1;
int k = i++ + i*3
i = 2, k = 7

6.应该避免在同一个表达式中多次使用该规则防止混乱

增强类型转换

1. 将数值赋给范围更大的类型——扩展类型
2. 将数值赋给范围更小的类型——缩小类型——必须显式
3. （类型）数值 如(double)8为8.0
4. 类型转换不改变被转换的变量 上面的8仍然是8 不会变成8.0

int sum = 0;
sum += 4.5;
//sum += 4.5 等价于 sum = （int）（sum += 4.5）
//该式子是正确的

int i = 1;
byte b = 1;//错误 必须使用显性的类型转换
int i = 1;
byte b = (byte)i;//正确

(int)(tax * 100) / 100   //默认——将tax向下四舍五入保留小数点后两位
(int)(x + 0.5) //将任意的tax向上四舍五入
==>
(int)(x * 100 + 0.5)/100

软件开发过程

• 需求规范：旨在理解软件所要处理的问题，以及将软件系统的功能详细记录到文档中。
• 系统分析：旨在分析数据流，并能确定系统的输入和输出。
• 系统设计：设计一个从输入获得输出的过程。
• 实现：将系统设计翻译成程序。
• 测试：确保代码符合需求规范，并且排除错误。
• 部署：使得软件可以被使用。
• 维护：对软件产品进行更新和改进。

常见错误 P58

• 未声明、未初始化的变量和未使用的变量
• 整数溢出
• 舍入错误
• 冗余的输入对象
• 将一个对象重复定义是不行的

int a = 1;
double a = 1.0;
//会报错重复变量

求一个整数各位数的和 P61 2.6题解答 哦也！

package demo;
import java.util.Scanner;
public class Plus {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.print("Enter a number between 0 and 1000:");
        int number = input.nextInt();  //输入一个三位数
        int units = number % 10; //932 % 10 = 2 并赋给个位
        number = number / 10; //932 / 10 = 93 修改number的值
        int tens = number % 10; //93 % 10 = 3
        number = number / 10; //93 / 10 = 9
        int huns = number; 
        int plus = huns + tens + units;
        System.out.println(plus); //9+3+2=14
    }
}

第三章 选择

• boolean和int相互不能转换
• if(boolean){}
• bool表达式必须用括号包围

if()  //if后面没有分号 有分号则等于后面有一个空的块 如if{}; 这是一个逻辑错误 很难被发现
{}
else if()
{}
else if()
{}
else
{}

• else总是与最近的if匹配 所以要尽量添加花括号

两个浮点数不能比较直接相等 可以用Math.abs()返回绝对值后定义一个极小的值来比较差距 如：

final double EPSILON = 1E-14;
double x = 1.0 - 0.1 - 0.1 - 0.1 - 0.1 - 0.1;
if (Math.abs(x - 0.5) < EPSILON) //与0.5无限接近
    System.out.println(x + "is approximately 0.5");

-

Math.random() //可以获得一个0.0到1.0之间的随机double值，不包括1.0
(int)(Math.random() * 10） //因此可以获得一个0~9的整数

逻辑操作符

!  //非
&& //与
|| //或
^  //异或

• 异或：两者不同值为真 因此p1 ^ p2 == p1 != p2

switch

switch(year % 12){  //输入一个值 不可以是判断
case 1:
break;
case 2:
break;
default:  ; //默认语句
}

• 输入boolean值的情况

条件操作符

max = (num1 > num2) ? num1 : num2;
若是括号里的为true，则执行结果为第一个代码块，若为false，则执行结果为第二个代码块。
右边的执行完毕后，再赋值给左边的max，起到取大的效果。

操作符优先级和结合规则

• 所有二元操作符都是左结合的
  所有的赋值运算符是右结合的 因此
  a = b += c = 5 等价于 a = (b += (c = 5))

• 先与后或再赋值

第四章 数学函数、字符和字符串

函数列表：P103 包括：

• 三角函数方法
  sin(radians),asin(a),toRadians(degree),toDegrees(radians);
• 指数函数方法
  exp(x),log(x),log10(x),pow(a,b),sqrt(x)//x >= 0;
• 取整方法
  ceil(x),floor(x),rint(x),round(x)
• min、max、abs方法
• random方法

a + Math.random() * b; //返回a ~ a+b之间的一个随机数，不包括a+b
15 + Math.random() * 30; //返回15~44的一个随机数

字符数据类型和操作

char用于表示单个字符，用单引号扩住。
而字符串字面值必须扩在双引号中。
因此，"A"是一个字符串，'A'是一个字符。

Unicode和ASCII码

char letter = 'A';
char letter = '\u0041';
//这两行语句等价

• 自增和自减操作符可以用在char类型变量上

char ch = 'a';
System.out. println(++ch);
//将输出字符b

转义 P108

\t相当于Tab 输出四个空格
\n换行符
\"双引号

字符测试

*数值转换 P109

char型数据可以转换成任意一种数值类型，反之亦然，将整数转换成char类型只用到该数据的低16位。

char ch = (char)0XAB0041;
System.out.println(ch);
//char为A
char ch = (char)65;  //0041（16）== 65（10）
System.out.println(ch);
//char为A
//第一个char是16进制，将其转换的原理为先截取后四位，再转换为十进制值对应十进制编码值输出。
//0041（16）== 65（10），因此上面两式子是等价的。
char ch = (char)0041;
System.out.println(ch);
//char为!
//如果直接截取后四位将其作为十进制数处理，结果将不同，是错误的。

int i = (int)'A';
//i is 65.

String 字符串

• 函数列表
  

  

• 从控制台输入字符串

String s = input.next() //以空格区分 字符串中不能有空格
String s = input.nextLine(); //可以有空格 输入单个字符也用它

• 字符串转换为整数和浮点数

int int1 = Integer.parseInt(intString);
double double1 = Double.praseDouble(doubleString);

• 整数和浮点数转换为字符串

String s = Integer.valueOf(23).toString();
String s = Double.valueOf(23).toString();

• 这些方法只能通过一个特定的字符串来调用 称为实例方法 如：
  s.length();
  注意，这里要加括号。
  如果是数组长度，则不需要加括号，如array.length
  
  • 非实例方法称为静态方法 他们没有绑定到一个特定的对象 如Math方法：
    Math.pow(2,2.5)
  • Java允许通过字符串字面值直接引用字符串 如：
    "jfisogh".lenth(); 是正确的
  • 可以用 + 号连接两个字符串
  • 不能用 == 判断两个字符串是否相同 应该用equal方法 如：

month == "Feb"; 
//是错误的 它永远为false
month.equal（"Feb"）;
//是正确的

• 单个字符Char与字符串String是不同的 可以用双引号扩单个字符 但不能将单引号括起来的char字符赋给一个string对象 会报错为：
  //类型不匹配：不能从 char 转换为 String
• String类包含的获取子串的方法 和 获取子串地址的方法

格式化控制台输出printf

• 简单的格式标识符是以百分号%开头的转化码。
• %10.2f输出的浮点数的宽度至少为10，包括小数点和小数点后的数字，即前面至少7位整数，小于则加空格，大于则自动增加宽度，后面保留两位小数。
• %后加-可以向左对齐 加0可以在不足的地方补上0
• %10.2e输出123.0为001.23e+02

第五章 循环

三种循环

while(){
}
---
do{
}while(); //只有dowhile有分号
---
for( ; ; ){
}

无限循环错误

int i = 1;
while (i < 10)
    if(i % 2 ==0 )
        System.out.println(i);
//无限循环错误 没有出现自增模块
int i = 1;
while (i < 10)
    if(i % 2 == 0)
        System.out.println(i++);
//无限循环错误 自增模块在if里没机会得到执行
int i = 1;
while (i < 10)
    if((i++) % 2 == 0) //先以i=1判断 然后在下一句语句中得到自增
        System.out.println(i); //在i = 2,4,6,8 得到满足 
//输出i = 3,5,7,9

可以通过System.currentTimeMillis()计算测试所花的时间

long startTime = System.currentTimeMillis();
    long endTime = System.currentTimeMillis();
    long testTime = endTime - startTime;
    System.out.println(testTime/1000);

不要比较浮点数是否相等来进行循环控制 因为浮点数是近似值

double item = 1; double sum = 0;
while(item != 0){
    sum += item;
    item -= 0.1;
    }//item永远不可能减到完全等于0，它会跳过0向负数进发，这将是一个无限循环。

输入重定向 可以将数据存在文件中来一次性输入大量的数据值

java ClassName < input.txt
//输入重定向，前面的是类名，将后面文件里面的数据导入类。
java ClassName > output.txt
//输出重定向，将类中产出的数据导入文件。
java CLassName < input.txt > output.txt
//输入输出重定向 先输入后输出 看起来就像把input文件括在里面

while和do-while循环的区别

do-while至少执行一次，某些情况下这两种会有一种更方便。
do-while改成while的话，某些语句需要在循环前和循环内重复出现以达到至少执行一次的效果。如：

while和for循环的区别

基本上都可以转换 但是for循环定义的变量是在内部，不会影响到后面的代码。
while循环定义的变量是会影响到之后的代码的。

嵌套循环

for(int i = 0; i < 10; i++)
    for(int j = 0; j < i; j++)
        System.out.println(i * j);
//该程序执行了多少次？
//45次 = 1*1 + 2*2 + …9*9

最小化数值错误

在循环条件中使用浮点数将导致数值错误。
浮点数不够精确 可能会导致无限循环

double item = 1; double sum = 0;
while(item != 0){
    sum += item;
    item -= 0.1;
    }//item永远不可能减到完全等于0，它会跳过0向负数进发，这将是一个无限循环。
for(double i = 0.01; i ,<= 1.0; i = i + 0.01)
    sum += i;
    // i可能最后会比1稍微大一点，而这将导致最后一次求和失败！数据偏差将会很大。

十进制转换16进制并且在最后通过用户标记控制循环！

package demo;
import java.util.Scanner;
public class Dec2Hex {
    public static void main(String[] args) {
        char a = ' ';
        do {
            Scanner input = new Scanner(System.in);
            System.out.print("Please input a Dec:");
            int dec = input.nextInt(); //将十进制数存入dec变量
            String hex = " "; //定义一个空字符串
            do{
                int hexValue = dec % 16; //个位等于十进制数对16取余
                char hexDigit = (0 <= hexValue && hexValue <= 9) ?
                (char)(hexValue + '0') : (char)(hexValue - 10 + 'A');
                //定义一个字符，如果个位在0~9之间，则将其与'0'相加，
                //此时的答案是一个ASCII码，如45。
                //再通过char将其转化为字符，如'2'。
                //如果在10到16之间，则通过 - 10 + 'A'来计算。
                //如11 => 66 => B
                hex = hexDigit + hex;//将其插入空字符串的前面
                //注意：此处后面两个变量位置不能互换。
                dec = dec / 16;//新的十进制数由十进制数除以16得出
            }while(dec != 0);//直到dec/16为0为止，也就是dec<16为止
            //此时的dec就是16进制的最大位数上的数
            System.out.println("The hex number is:" + hex);
            System.out.print("Put Y to continue and N to exit:");
            a = input.next().charAt(0);
            //取一个字符串，并返回它的第一个字符给a。
        }while(a == 'Y');//如果a为'Y',则重新开始第一个循环。
    }
}

break和continue 和if配合使用

break跳出整个循环
continue跳出一次循环 直接下一次

第六章 方法

方法定义

• 在其他语言中，方法也成为过程或者是函数。
• 在方法头中，需要对每一个参数进行单独的数据类型说明。即每个参数前都要说明它是哪种类型，int还是别的什么。
• 其他类可以通过类名.方法名来调用你在这个类里定义的方法，如TextMax.max。
• 每当调用一个方法时，系统会创建一个活动记录（也称为活动框架)，用于保存方法中 的参数和变量。活动记录置于一个内存区域中，称为调用堆栈（call stack)。
• 函数参数的使用和栈“后进先出”的特性有关，m1引用了m2，m2引用了m3，则先处理m3，再处理m2，再处理m1。
• 无论形参在方法中作何改变，该变量都不受影响。
• 霍纳算法
  

package demo;
import java.util.Scanner;
public class Hex2Dec {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.print("Enter a hex number: ");
        String hex = input.nextLine();
        System.out.println("The decimal value for hex number "
        + hex + " is " + hexToDecimal(hex.toUpperCase()));
    }
    public static int hexToDecimal(String hex){
        int decimalValue = 0;
        for (int i = 0; i < hex.length(); i++){
        char hexChar = hex.charAt(i);
        decimalValue = decimalValue * 16 + hexCharToDecimal(hexChar);
        }
        return decimalValue;
    }
    public static int hexCharToDecimal(char ch){
        if (ch >= 'A' && ch <= 'F')
        return 10 + ch - 'A';
        else
        return ch - '0';
    }
}

• 方法可以重载（同名），一个类中有两个方法，它们具有相同的名字但有不同的参数列表，是可以的。Java编译器通过方法签名决定使用哪个方法。
  注意：必须是具有不同的参数列表才行，不同修饰符或者返回值类型不行。
• 生成任意两个字符ch1和ch2之间的随机字符 P194

输出一个数的反序数（ReverseNumber）

package demo;
import java.util.Scanner;
public class ReverseNumber {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.print("Please inter a int number: ");
        int number = input.nextInt();
        reverse(number);
    }
    public static void reverse(int number)
    {   
        StringBuilder str = new StringBuilder(number + "");
        //利用StringBuilder方法来新建一个string字符串以方便修改
        int length = str.length();
        for(int j = 0,k = 1; j < length - 1; j++,k++) {
            //一共循环长度-1次，并定义k变量来每次排序后将排序位数减一
            for (int i = 0; i < length - k ; i++)
                {   char a = str.charAt(i);
                    char b = str.charAt(i + 1);
                    str.setCharAt(i , b);//利用setCharAt方法
                    str.setCharAt(i + 1 , a);//将提取出来的两个位置上的字符互换
                }
        }
        System.out.println("The inversion number is: "+ str);
    }
}

第七章 一维数组

• 可以用double[] myList;或者double myList[];来声明数组变量。
• 注意：数组变量不是数组。
• 接下来可以使用new操作符创建数组，并且将它的引用赋给一个变量。
  如myList = new double[10];
  这样，myList指向一个大小为10的数组，才是一个合格的数组变量。
• 以上的语句可以合并为一句完成：

double myList[] = new double[10];

• 该语句声明了数组变量myList，创建了一个由10个double型元素构成的数组，
  并将该数组的引用赋值给myList。
  myList是一个含有double型元素数组的引用变量。
• 可以使用赋值法给数组赋值。
  myList[0] = 5.6;
• 数组创建了就不能修改它的大小，可以使用arrayRefVar.length获取大小
  如myList.length为10。
• 数值型默认为0，char型默认为'\u0000'，boolean型的默认值为false，也有字符串数组。
• 数组初始化简写方式：

 double[] myList = {1.9, 2.9, 3.4, 3.5};
 //这条语句声明、创建并且初始化包含4个元素的数组myList。
 //大括号！！！
 //该语句相当于
 double[] myList = new double[4];
 myList[0] = 1.9;
 myList[1] = 2.9;
 myList[2] = 3.4;
 myList[3] = 3.5;

• 打印数组需要使用for循环：

for(int i = 0; i < myList.length; i++)
    System.out.print(myList[i] + " ");
    //数值类型的数组需要for循环。
char[] city = {'a','a'};
    System.out.print(city);
    //char类型的数组可以直接打印。

数组数值处理 P216

• 随机初始化数组
• 显示数组
• 对所有元素求和
• 找出最大元素
• 找出最大元素的最小下标值
• 随机打乱
• 移动元素
• 简化编码

foreach循环

for (double e : myList)
System.out.print(e);
//对myList中每个元素e进行以下操作，即遍历整个数组。
//注意：变量e的数据类型必须与数组类型相同。

复制数组

1. 利用for循环逐个复制
2. 利用静态方法arraycopy（注意此方法copy的c没有大写）

arraycopy(原数组，原数组起始位置，目标数组，目标数组起始位置，元素个数）
System.arraycopy(sourceArray, 0, targetArray, 0, sourceArray.length);
System.arraycopy(source, 0, t, 0, source.length);
//用此方法前要先声明目标数组并分配内存空间。

数组传递给方法后值会改变

• 对于基本数据类型参数，传递的是实参的值。
• 而对于数组，传递的是引用。最好的描述为传递共享信息。
• 比如：要使用方法来改变数组，最好把数组传进去，不要使用数组下标的类型如int来定义方法参数。
• 如

swap(a[0], a[1])
public static void swap(int a1, int a2){}
//这样改变的只是实参，而不会涉及数组。  ×
swap(a)
public static void swap(int[] array){}
//这样传递的是整个数组。               √

可变长参数列表

• 在指定类型后紧跟省略号如(double…numbers)
• 只能给方法中指定一个可变长参数。同时该参数必须是最后一个参数。

public static viod printMax(double…numbers) {
 if (numbers.length == 0)
 System.out.println("No argument passed");
 return;
}

二分查找法 需要先从小到大排好序

package demo;
public class BinarySearch {
//二分查找法（不含main函数）
    public static int binarySearch(int[] list, int key) {
        int low = 0;
        int high = list.length - 1;
        while (high >= low) { //此处不能用 > ，不然对只有一个元素的数组无法处理。
            int mid = (low + high) / 2;
            if (key < list[mid])
                high = mid - 1;
            else if (key == list[mid])
                return mid;
            else {
                low = mid + 1;
            }
        }
        return -low-1;
    }
}

选择排序算法

package demo;
import java.util.Scanner;
public class SelectSort {
//选择排序算法:从所有数中选择最小的与第一个交换。
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int[] list = { 5, 2, 3, 7, 9, 8, 1 };
        for (int j = 0; j < list.length - 1; j++) {//用j < list.length 也可运行，但是要多运算一步。
            int min = list[j];//将第一个值赋给min，后面的值与其比较。
            int tag = j;
            for (int i = j + 1; i < list.length; i++) {//用i = j也可运行，但是要多运算一步。
                if (list[i] < min) {
                    min = list[i];//记录最小值。
                    tag = i;//标记最小下标。
                }
            }
            list[tag] = list[j];
            list[j] = min;//将当前最前面的值于min所处位置的值交换。
        }
        for (int e : list)
            System.out.println(e);//for each循环输出。
    }
}

Arrays类

• 使用import.util.Arrays导入

Arrays.sort(list, indexStart, indexEnd);//从小到大对start和end里面进行排序，不包括end。
Arrays.parallelSort();//同上，但是多处理器这个会快些。
Arrays.binarySearch();//二分查找法，必须提前按升序排好。
Arrays.equals(list1, list2);//严格比较相等，一对一。
Arrays.fill(list1, 5);//使用5填充整个数组。
Arrays.fill(list1, 1, 5, 8);//使用8填充1至5地址，不包括5。
Arrays.toString(list);//将数组返回成一个字符串。

向main方法传递参数

main就像一个普通的函数，它可以接收字符串args。
不仅可以直接在其他类调用它，还可以从命令行向他传递参数。

第八章 多维数组

多维数组的定义

int[][] matrix;
matrix = new int[5][11];
//两句可以合并成一句：
int[][] matrix = new int[5][12];

• 注意：第一个下标表示行数，第二个下标表示列数。
  

• 注意：每个下标必须放在一对方括号中。

matrix[2][14] = 7; //是正确的
matrix[2,7] = 7; //是错误的

• 二维数组实际上就是很多一维数组的集合。
  它的每一行都是一个一维数组，所以它的长度为一维数组的个数。
  每个一维数组又有自己的长度，都可以用array.length表示

array.length//行数
array[0].length//第一行的长度

二维数组初始化

int[][] array ={
{1,2,3},
{1,2,3},
}
int[][] array2 ={
{1,2,3},
{1,2},
}//不规则数组是被允许的
如果不想一开始就给不规则数组赋值 可以使用空括号
int[][] array = new int[5][];
//第一个括号必须有值。

处理二维数组 P251

• 嵌套的for循环常用来处理二维数组。
• P251
  1.使用输入值初始化数组。
  2.使用随机值初始化数组。
  3.打印数组
  4.对所有元素求和
  5.按列求和
  6.哪一行的和最大？
  7.随机打乱

将二维数组传递给方法

• 将一个二维数组传递给方法时，数组的引用传递给了方法。

package demo;
import java.util.Scanner;
public class Test {
    public static void main(String[] args) {
        int[][] m = getArray();
        System.out.println("\nSum of all elements is " + sum(m));
    }
    // 返回一个二维数组
    public static int[][] getArray() {
        Scanner input = new Scanner(System.in);
        int[][] m = new int[3][15];
        System.out.println("Enter " + m.length + " rows and " + m[0].length + " columns: ");
        for (int i = 0; i < m.length; i++)
            for (int j = 0; j < m[i].length; j++)
                m[i][j] = input.nextInt();
        return m;
    }
    // 对一个二维数组求和
    public static int sum(int[][] m) {
        int total = 0;
        for (int i = 0; i < m.length; i++) {
            for (int j = 0; j < m[i].length; j++)
                total += m[i][j];
        }
        return total;
    }
}
//for(int e :list)
//System.out.print(e);

矩阵乘法！哦也！

package demo2;
import java.util.Scanner;
public class MultiplyMatrix {
//矩阵乘法
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.print("请输入第一个矩阵的行数和列数，如（2 3）：");
        int arow = input.nextInt();
        int acol = input.nextInt();
        int[][] a = new int[arow][acol];
        System.out.print("请输入第二个矩阵的行数和列数，如（2 3）：");
        int brow = input.nextInt();
        int bcol = input.nextInt();
        int[][] b = new int[brow][bcol];
        if (arow != bcol) {
            System.out.print("Input invalid.");
            System.exit(0);
        }
        System.out.println("请输入第一个矩阵的数值：");
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[0].length; j++) {
                a[i][j] = input.nextInt();
            }
        }
        System.out.println("请输入第二个矩阵的数值：");
        for (int i = 0; i < b.length; i++) {
            for (int j = 0; j < b[0].length; j++) {
                b[i][j] = input.nextInt();
            }
        }
        int[][] c = multiplyMatrix(a, b);
        for (int i = 0; i < c.length; i++) {
            for (int j = 0; j < c[0].length; j++) {
                System.out.print(c[i][j] + " ");
            }
            System.out.println();
        }
    }
    public static int[][] multiplyMatrix(int[][] a, int[][] b) {
        if (a.length != b[0].length) {
            System.out.print("The input is invalid.");
            return null;
        }
        int[][] c = new int[a.length][b[0].length];
        int length = a.length;
        for (int i = 0; i < length; i++) {
            for (int j = 0; j < length; j++) {
                for (int j2 = 0; j2 < a[0].length; j2++) {
                    c[i][j] += a[i][j2] * b[j2][j];
                }
            }
        }
        return c;
    }
}

第九章 对象和类

UML类图详解:https://www.cnblogs.com/pangjianxin/p/7877868.html

Date类和Random类、Print2D类

静态方法和静态数据 static

• 静态方法用static修饰如

static int getNumberOfObjects() {
    return numberOfObjects;
}
可以直接通过类名调用而不用声明对象
Circle.getnumberOfObjects;

• 注意：实例方法可以调用静态方法，而静态方法不能调用实例方法。
• 如：在main函数中不声明新对象调用实例方法和实例变量是错误的，因为对象都没有被创建，并且main函数是static方法。

可见性修饰符

• public修饰的方法和变量可以被包外访问。
• 不加前缀的只能在包内访问。
• private修饰的包内都不能访问。

对象数组

• 数组可以装载对象，但是一定要记得对里面的每一个成员初始化。

Circle[] cir = new Circle[5];
for (i = 0; i < Circle.length; i++) //创建一个新数组。
    cir[i] = new Circle(); //为每一个成员初始化。

不可变对象

• 如果一个类是不可变的，那么它的所有数据域必须都是私有的，而且没有对任何一个数据域提供公共的set方法。
• 但是！一个类的所有数据都是私有的且没有修改器并不意味着它一定是不可变类。
  如果有一个函数传出了对类内对象的一个引用，那么就可以通过修改这个引用来修改类内的对象。如：

public class Student{
    private java.util.date dateCreated;
public java.util.Date getDateCreated{
    return dateCreated;
    }
}
public class Test { 
    public static void main(String[] args){
    Student student = new Student(m223333, "John");
    java.util.Date dateCreated2 = student.getDateCreated(); 
    // 传出了dateCreated对象的引用
    // dateCreated2和dateCreated其实指向的是同一个对象
    dateCreated2.setTime(200000); 
    // 达到修改对象的目的

因此要创建一个不可变对象，要满足三点：

1. 所有数据都是私有的。
2. 没有set方法。
3. 没有一个返回指向可变数据域的引用的访问器方法。

变量的作用域

• 一个类的实例变量和静态变量称为类变量（class’svariables)或数据域（data field)。在方法内部定义的变量称为局部变量。
• 如果一个局部变量和一个类变量具有相同的名字，那么局部变量优先。而同名的类变量将被隐藏（hidden)

this引用

https://blog.csdn.net/Return_head/article/details/80744056

1.假如在一个构造方法中使用了this语句，那么它必须作为构造方法的第一条语句(不考虑注释语句)。
2.只能在一个构造方法中使用this语句来调用类的其他构造方法，而不能在实例方法中用this语句来调用类的其他构造方法。
3.只能用this语句来调用其他构造方法，而不能通过方法名来直接调用构造方法。

第十章 面向对象思考

• Java对象——依赖、关联、聚合和组合之间的区别与理解
  https://www.cnblogs.com/wanghuaijun/p/5421419.html

将基本数据类型值作为对象处理——包装类 P349

BigInteger and BigDecimal

• BigInteger用于处理大数据，它继承自java.math.BigInteger。

初始化：BigInteger sum=new BigInteger("0");
加法：sum=sum.add(n1);   //这里sum和n都为BigInteger类型
减法：sum=sum.subtract(n1);
乘法：sum=sum.multiply(n1);
除法：sum=sum.divide(n1);
幂运算：sum=sum.pow(10);
取相反数：sum=sum.negate();

• 同理，BigDecimal是处理浮点数的大数据运算，继承自java.math.BigDecimal.

初始化：BigDecimal num1=new BigDecimal("1234.56453324");
加法：sum=sum.add(n1);   //这里sum和n都为BigDecimal类型
减法：sum=sum.subtract(n1);
乘法：sum=sum.multiply(n1);
除法：sum=sum.divide(n1);
将BigDecimal类型转换为double类型：num1.doubleValue();
比较大小：num1.compareTo(num2); 
//小于时，返回-1; 等于时，返回0; 大于时，返回1。
四舍五入处理：
num1.divide(num2,scale,BigDecimal.ROUND_HALF_UP).doubleValue();
//scale表示保留几位小数

String类

String类源码：
https://blog.csdn.net/ylyg050518/article/details/52352993

构造字符串

String message = new String("hello");
// 一般用法
String message = "hello";
// Java将字符串直接看做String对象，这样也合法。

不可变字符串与限定字符串

• String对象是不可变的，当你把一个String对象的“字面”改变，实际上只是改变了它的引用，将其引用给一个新的对象，而原来的对象被抛弃。

String s = "Java";
s = "HTML": ;
// "Java"对象被抛弃，s引用为新的string对象"HTML"。

• Java 虚拟机为了提高效率并节约内存，对具有相同字符序列的字符串直接量使用同一个实例。

String s1 = "Welcome to ]ava";
String s2 =  new String("Welcome to ]ava");
String s3 = "Welcome to ]ava";
//s1 == s3, s1 != s2;

字符串的替换和分隔

• 注意：replace用来替换字符，而replaceAll用来替换字符串。

str.replace('a','b');
str.replaceAll("ab","abc");

• 一旦创建了字符串，它的内容就不能改变。但是，方法 repalce、replaceFirst和replaceAll会返回一个源自原始字符串的新字符串（并未改变原始字符串！）。
• split 方法可以从一个指定分隔符的字符串中提取标识。

String[] tokens = "Java#HTML#Perl".split("#"); 
for (int i = 0; i < tokens.length; i++)
System.out.print(tokens[i] + " ");
// split将字符串分割成了三个小字符串并存入数组。
//显示Java HTML Perl

正则表达式

• JAVA 正则表达式 （超详细）：
  https://www.cnblogs.com/xyou/p/7427779.html
• Java正则表达式的语法与示例：
  https://www.cnblogs.com/lzq198754/p/5780340.html
• String类自带的matches方法就可以使用正则表达式

"Java".matches("Java");
"Java is fun".matches("Java.*");
"Java is cool".matches("Java.*");
//字符串.*与零个或多个字符相匹配。
// . 任意字符 *任意长度
String s = "a$b%c^".replaceAll("[$%^]","NNN");
System.out.println(s);
//aNNNbNNNcNNN
String[] tokens - "Java.C?C#,C++".split("[.,:;?]");
for (int i = 0; i < tokens.length; i++) System.out.println(tokens[i]+" ");
//Java C C# C++

字符串与字符数组的相互转换

• 字符串转换为字符数组。

char[] a = "Java".toCharArray();
char[] dst = {'J','A','V','A','1','3','0','1'};
"CS3720".getChars(2,6,dst,4);
//dst{'J','A','V','A','3','7','2','0'};

• 字符数组转换为字符串

String str = new String(new char[]{'a','a'});
// 可以直接使用构造方法。
String str = String.valueOf(new char[]{'a','a'});
// 也可以使用valueOf方法。

字符串和数值的相互转换

• 可以使用包装类中的方法将字符串转换为数值，如：

Double.parseDouble(str);
Integer.parseInt(str);

• 可以使用valueOf方法转换回字符串

String a = String.valueOf(5.44);
//a:{'5','.','4','4'}

格式化字符串

String s = String.format("%7.2f%6d%-4s", 45.556, -4s, "AB");
System.out.println(s)
//□□45.56□□□□14AB□□
注意
System.out.printf();
等价为
System.out.print(String.format());

StringBuilder And StringBuffer Class

• 效率：stringBuilder > stringBuffer > String；但是StringBuilder线程不安全，StringBuffer线程安全；
• Java中的String，StringBuilder，StringBuffer三者的区别：
  https://www.cnblogs.com/su-feng/p/6659064.html

append重载方法

StringBuilder StringBuilder = new StringBuilder(); 
stringBuilder.append("Welcome"); 
stringBui1der.append(' '); 
stringBuilder.append("to"); 
stringBui1der.append(' '); 
stringBui1der.append("Java");
//"Welcome to Java"

insert、delete、deleteCharAt、reverse、replace、setCharAt重载方法

//"Welcome to Java"
StringBuilder.insert(11, "HTML and ");
//"Welcome to Html and Java"

stringBui1der.delete(8,11) // Welcome Java。
stringBuilder.deleteCharAt(8) // Welcome o Java。
stringBuilder.reverse() // avaJ ot emocleW。
stringBuilder.replace(11,15,"HTML") // Welcome to HTML。
stringBuilder.setCharAt(0,'w') // welcome to Java

toString、capacity、length、setLength和charAt构建器和返回方法

去除字符串中除了数值和字母的字符并判断是否为回文

package demo2;
import java.util.Scanner;
public class PalindromelgnoreNonAlphanumeric {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.print("input a string: ");
        String s = input.nextLine();
        System.out.print(s + " " + isPalindrome(s));
    }
    public static boolean isPalindrome(String s) {
        StringBuilder s1 = new StringBuilder();
        //将字符串转换为stringbuilder对象
        for(int i = 0; i<s.length();i++) {
            if(Character.isLetterOrDigit(s.charAt(i))) {
            //使用character类中的方法来判断是否为数字和字母
            //也可以使用编码。
                s1.append(s.charAt(i));
            }
        }
        StringBuilder s2 = s1;
        s2 = s2.reverse();
        return s1.equals(s2);
    }
}

String类的实现 oh yeah!

package demo2;
public class MyString1 {
    private final char value[];
    public static void main(String[] args) {
//      char[] a = "Hello World".toCharArray();
//      MyString1 s = new MyString1(a);
//      char[] b = "Hello World".toCharArray();
//      MyString1 s2 = new MyString1(b);
        System.out.print(MyString1.valueOf(123455).value);
    }
    public MyString1(char[] chars) {
        value = chars;
        //源码中用copy实现
    }
    public MyString1() {
        this.value = new char[0];
    }
    public char charAt(int index) {
        return value[index];
    }
    public int length() {
        return value.length;
    }
    public MyString1 substring(int begin, int end) {
        char[] newValue = new char[end - begin];
        for (int i = begin, j = 0; i < end; i++, j++) {
            newValue[j] = value[i];
        }
        MyString1 s1 = new MyString1(newValue);
        return s1;
    }
    public MyString1 toLowerCase() {
        MyString1 s1 = new MyString1(value);
        for (int i = 0; i < s1.value.length; i++) {
            if (s1.value[i] >= 'A' && s1.value[i] <= 'Z') {
                s1.value[i] = (char) (s1.value[i] - 'A' + 'a');
            }
        }
        return s1;
    }
    public boolean equals(MyString1 s) {
        boolean isequal = true;
        if (s.length() != value.length) {
            return false;
        }
        for (int i = 0; i < s.length(); i++) {
            if (s.value[i] != value[i])
                isequal = false;
        }
        return isequal;
    }
    public static MyString1 valueOf(int i) {
        int digit = 1;
        int k = i;
        while (k / 10 > 0) {
            digit++;
            k = k / 10;
        }
        char[] ch = new char[digit];
        for (int j = digit - 1; j >= 0; j--, i = i / 10) {
            if (j == 0) {
                ch[j] = (char)(i + 48);
            } else {
                ch[j] = (char)((i % 10) + 48);
            }
        }
        return new MyString1(ch);
    }
}

第11章 继承和多态

继承

public class Circle extends CeometricObject
//          Subclass 继承于 Superclass

• 父类的普通方法由子类继承。但是私有数据域和构造方法不继承。子类虽然也有这些数据域，但是得用set和get访问它。构造方法可以使用super关键字访问。
• 因为子类拥有父类的数据域，因此不能随意定义子类。如：正方形是一种矩形。但不能用正方形类去继承矩形类，因为矩形的长宽数据域在正方形中并没有意义。
• Java中，如果使用extends来继承，子类只允许有一个父类。即不允许多重继承。

使用super关键字

• 关键字super用来指代上一个父类，可以用来调用父类的普通方法和构造方法。
• 注意：不能用来调用静态方法！
  静态方法直接使用父类名调用即可。
• 子类调用父类的构造方法只能使用super，而不能使用构造方法名。

普通函数
super.toString();
Superclass.toString();
// 等价
构造函数
super();
// 正确
Superclass();
// 错误！在子类中不能直接用函数名调用父类的构造函数，只能使用super。

• 语句super()和super(arguments)必须出现在子类构造方法的第一行。
• 如果子类构造方法没有使用super，那就会默认在第一行加入隐形的super函数（无参），来调用父类的无参构造方法。

public ClassName(double a){
    //some statements
}
等价于
public ClassName(double a){
    super();
    //some statements
}

因此，如果父类没有无参构造方法，会出现一个错误。

• 当构造一个子类的对象时，子类构造方法会在完成自己的任务之前，首先调用它的父类的构造方法。如果父类继承自其他类，那么父类构造方法又会在完成自己的任务之前，调用它自己的父类的构造方法。
• 这就是构造方法链。

问题：子类继承了父类的普通方法，那为什么还要用super调用父类的普通方法？

• 因为存在方法重写，子类可能会改变从父类那继承的方法，要调用原汁原味的父类方法，只能使用super。

方法重写

POINT：
要重写一个方法，需要在子类中使用和父类一样的签名以及一样的返回值类型来对该方法进行定义。

• 方法重写就是把父类的普通方法重新定义，除了{ }里头不同看起来全都一样。
• 方法重载可以在同一个类也可以是子类和父类，除了{ }里头不同括号( )里的参数也不同。
• 注意：两个方法都没有用更改返回值类型和方法名。

重写标注：@Override

• 该标注重写一个方法，在该标注后的方法必须被重写，否则会报错。
• 好处：系统会帮你检测重写是否成功，不然如果出错，系统可能只会以为这是你新定义的一个方法。

Object类与toString( )方法和equals()方法

Java中的所有类都继承自java.lang.Object类。

• == 和 equals的区别：https://mp.weixin.qq.com/s/hJRx42sQs5i0NHMQj3_m4A
• 因此Object类是所有类的父类，他其中有toString()方法。
• 一般情况下，toString( )返回 [类名@地址]

• 这没有什么用，因此一般需要重写toString( )方法。

• Object类中的euqals()方法用来测试两个对象是否相等

object1.equals(object2);

默认的equals只能判断两个是否指向同一对象。

• 这也没什么用，因此也需要重写equals方法。如将圆类的equals方法定义为比较半径大小，如果相等则返回true。

注意，在object类中，equals的参数是object类，因此重写的时候要遵循这个规则。

public boolean equals(Circle o){
} //是错误的
public boolean equals(Object o){
} //是正确的

例子：

public class Text {
    public static void main(String[] args) {
        Object a = new Circle();
        Object b = new Circle();
        System.out.print(a.equals(b));
    }
1.
public class Circle {
    double radius;
    public boolean equals(Object circle) {
        return this.radius == ((Circle) circle).radius;
    }
}// 输出为true。两者的半径相同。
2.
public class Circle {
    double radius;
    public boolean equals(Circle circle) {
        return this.radius == circle.radius;
    }
}// 输出为false。它根本就没有调用Circle里的这个euqals方法，因为传入的值是object类型，它直接调用了Object类中的equals去了！因为比较的是引用，两者没有指向同一个变量，所以为false。

多态

面向对象程序设计的三大支柱是封装、继承和多态。

• 总可以将子类的实例传给需要父类型的参数。
• 即：方法参数只需要要求了父类型，所有的子类型对象都可以传进方法。

动态绑定

方法可以在沿着继承链的多个类中实现。JVM决定运行时调用哪个方法。

Object o = new  GeometricObject();
//声明类型        实际类型

• 现在实际类型中寻找方法，找不到就在父类中找，直到找到为止。以找到的第一个为准。

对象转换和instanceof运算符

对象转换和强制类型转换很像。可以将子类隐式转换为父类，但父类下来必须用强制转换。就像byte可以直接转换为int，但是int赋值给byte而不用（int）byte就会出错。

Object o = new Student;
// 可以将一个Student对象的引用赋给object变量
Student b = o；
// 错误！原因是Student对象总是Object的实例，但是，Object对象不一定是 Student的实例。
// 即使可以看到o实际上是一个Student的对象，但是编译器还没有聪明到知道这一点。
Student b = (Student)o;

转换记住左大右小。

• 使用instanceof关键字

Object a = new Circle();
if(a instanceof Circle){
// *使用instanceof关键字*来确定这个实例是不是这个类的实例。
System.out.print(((Circle)a).getYou());
}
// 然后再将Object变量的*引用强制转换*为对Circle对象的引用，才能调用Circle中的getYou方法。

即使需要进行如此复杂的对象类型转换，一开始也要定义为父类（Object），这样，它就能接受任意子类型的值。

• 如：我们可以定义一个方法，其参数为object对象，在方法内再进行对象类型判定，这样可以简化参数。
• 注意：圆点运算符的优先级高于类型转换，因此，要将对象用括号括起来。如：((class)a).getYou();
• 虽然它和基本类型强制转换很像，但是基本类型强制转换会返回一个新的值，而对象类型转换只是将引用转移。
• 总是可以将子类的实例转换为父类。比如：苹果总是水果。

ArrayList类

可以创建一个数组存储对象，但是这个数组一旦创建，它的大小就固定了。
因此，Java提供ArrayList类来存储不限定个数的对象。
即可变对象列表（不叫数组）。

• ArrayList类在java.util包中，因此要导入该包

import java.util.ArrayList

• 创建一个ArrayList

ArrayList<Class> a = new ArrayList<Class>();
JDK1.7后也可以简写为
ArrayList<Class> a = new ArrayList<>();

ArrayList虽然和数组很像，但是还是有不同之处。

ArrayList和数组可以相互转换。

将数组转换为列表
String[] a = {"a","b","c"};
ArrayList<String> list = new ArrayList<>(Arrays.asList(a));
// 使用Arrays类中的静态方法asList()。
将列表转换为数组
String[] b = new String[list.size()];
list.toArray(b);
// ArrayList类中的普通方法toArray()将list中的元素复制到数组内。

java.util.Collections类中有一些有用的方法。如：排序，最大值，随机打乱。

import java.util.Collections
Intege [] array = {3, 5, 95, 4, 15, 34, 3, 6, 5};
ArrayList<Integer> list = new ArrayList<>(Arrays.asList(array));
Collections.sort(list); 
// 排序
Collections.max(list); 
Collections.min(list); 
Collections.shuffle(1ist);
// 随机打乱

protected数据和方法

一个类中的受保护成员可以从子类中访问。
在UML类图中，protected的方法前面加#

例子：

可以看出，protected只比默认开放一点点，只是增加了在继承类中可以访问，而在不同包里仍不可以访问。而同一个包里不管继不继承，只要不是private就可以访问

第12章 异常处理和文本I/O

异常是从方法抛出的。方法的调用者可以捕获以及处理该异常。
异常需要消耗系统资源，因此，可以预料的错误尽量使用if。
并且，不要将异常处理当做简单的逻辑测试。

• 可以在方法中抛出一个异常，异常就是异常类的一个对象。
• 如果一个异常没有被当前方法捕获，则该异常被传给调用者。这个过程不断重复直到异常被捕获或者传递给main 方法。
• 在抛出错误后try字块内之后的语句就不会再运行。

public static int quotient(int num1,int num2){
    if (num2 == 0){
        throw new ArithmeticException("Divisor can not be Zero. ")
    }
    return num1 / num2;
}
public static void main(String[] args){
    try{
        int result = quotient(1, 0);
        System.out.print(result);
    } //如果遇到异常，则抛出一个异常对象，并被catch捕获。
    catch(ArithmeticException ex){
      //程序跳转至catch功能块，并在处理完catch块后接着往下运行。
        System.out.print("Invaild input. ")
    }
}

• 异常类型:系统错误、异常、运行时异常。

• RuntimeException、Error和他们的子类都被称为免检异常。所有其他异常都被称为必检异常。
  免检异常通常为逻辑错误，可能在程序的任何一个地方出现，为了避免过多的使用try-catch块，不强制要求编写代码捕获或者声明免检异常。
• 不管是否在方法头中声明，每个方法都能抛出 RuntimeException 异常（免检异常）。

声明异常，抛出异常和捕获异常

• 为了在方法中声明一个异常，需要使用关键字throws

public void method() throws IOException
//多个异常
public void method() 
    throws IOException,Exception2,Exception3...ExceptionN

• 程序可以创建异常类的一个实例并抛出它

IllegalArgumentException ex = new IllegalArgumentException("Wrong Argument");
throw ex;
//可以使用简写
throw new IllegalArgumentException("Wrong Argument");

1. 注意：声明异常的关键字是throws，抛出异常的关键字是throw。
2. 异常类包含一个无参构造方法和带字符串的构造方法。可以用getMessage()获取。

• 使用try-catch块来捕获异常

try{
    statements; 
} 
catch (Exception1 exVarl){ 
    handler for exceptionl;
}
catch (Exception2 exVar2){
    handler for exception2;
}
..
catch (ExceptionN exVarN){ 
    throw exVarN;// Java允许重新抛出异常。
}
//JDK7的新的多捕获特征可以用来简写
catch(Exception1 | Exception2 | ... | ExceptionN){
    //same handling these exceptions
}