JAVA4ANDROID筆記
靜態成員變數，可以直接用類名呼叫（也可以用成員的名稱呼叫，如p1.name）... 26
一、物件的向上轉型：將子類的物件賦值給父類的引用... 29
二、物件的向下轉型:將父類的物件賦值給子類的引用... 29
三、try…catch…finally結構的使用方法... 38
接上節課的例項（以及使用finally關閉I/O）... 44
BufferedReader（字元輸入處理流）介紹... 46
強制終止錯誤或無限迴圈的程式：Ctrl+C
第二課
什麼是程式設計？
學會程式設計可以讓你和計算機隨意的溝通
程式設計是一種創造性的工作
學會程式設計會讓上帝與你同在
編譯原始碼
什麼是編譯？
1、原始碼是人類可以理解的程式碼
2、計算機無法理解原始碼
3、編譯就是將原始碼轉換為計算機可以理解的程式碼
執行程式
原始檔編譯(javac)之後，會生成一個類檔案；
使用java命令執行類檔案；
觀察執行結果；
程式設計習慣的養成
1凡是成對出現的符號最好一次性寫一對，比如小括號、中括號和引號等；
2注意字元的大小寫；
3養成良好的縮排 習慣；
第三課
什麼是環境變數？
環境變數通常是指在作業系統當中，用來制定作業系統執行時需要的一些引數；
環境變數通常為一系列的鍵值對；
Path環境變數的作用
Path環境變數是作業系統外部命令搜尋路徑
Classpath環境變數的作用
Classpath環境變數是類檔案搜尋路徑
什麼是JRE
JRE是Java Runtime Environment，即Java執行環境，包括以下幾個部分：
2、Java虛擬機器；
3、Java平臺核心類檔案；
4、其他支援檔案；
5、什麼是JVM
6、JVM是Java Virtual Machine(Java虛擬機器)的縮寫，他是一個由軟體虛擬出來的計算機：
第四課
什麼是變數？
計算機是一種極度精確的機器；
要將資訊儲存在計算當中，就必須指明資訊儲存的位置和所需要的記憶體空間；
在Java程式語言當中，使用宣告語句完成上述的任務；
變數的宣告方法
|
int age ; |
|
變數型別 |
|
變數名 |
|
表示語句結束結束技 |
|
這條語句是計算機分配足夠的空間，用於儲存一個整數，而這個整數的名字就叫做age。 Int是Java定義的一種資料型別，專門用於儲存一定大小的整數；
|
變數有哪些型別？
|
資料型別 |
|
基本資料型別 |
|
引用資料型別 |
|
數值型 |
|
字元型（char） |
|
布林型（boolean） |
|
整數型別（byte，short，int，long） 浮點型別（float，double） |
|
類（class）
介面（interface）
陣列
|
變數的命名規範
變數命名語法規範
應該以字母、下劃線或者美元符號開頭；
後面跟字母、下劃線、美元符或者是數字；
Java變數名沒有長度限制；
Java變數名對大小寫敏感
駝峰命名法：
變數名應該用有意義的英文單詞；
變數名如果只是一個單詞，則所有的字元小寫；
變數名如果由多個英文單片語成，則從第二個單詞開始首字母大寫；
變數命名示範
合法的變數命名：
Password
Last-name
$abc
–ref
正確的變數命名：
password
lastName
第五課
布林型變數
boolean型別適用於邏輯運算，一般用於程式流程控制；
在java當中的boolean型別只有兩種取值可能——true和false
eg：
注意的是不能用0和非0，或者空和非空來表示；
字元型變數
Char型別資料用來表示通常意義上的字元；
字元是由單引號包括起來的單個字元；(字串用雙引號)
Java字元使用Unicode字符集；
什麼是Unicode字符集呢？
ASCII字符集
全稱為American Standard Code for Information intetchange
對字符集的理解可以從以下幾個方面入手：
在計算機當中，所有資料都需要使用二進位制的數字表示
類似於a、b、c之類的字母無法直接用二進位制表示
所以就將所有常見的字元經行編號。標準ASCII碼使用7位2進位制數來表示字元。
7位2進位制數可以表示所有的數字，大小寫字母以及一些常見符號（例如！@#和$等等）
Unicode字符集
Unicode為每種語言的每個字元設定了通同意並且唯一的二進位制編碼
Unicode滿足了跨語言文字轉換和處理的需求
Unicode在網際網路當中扮演著非常重要的角色
Unicode使用數字0-0x10FFFF來表示字元
最多允許有1114112個字元
Java與Unicode字符集
由於Java在設計的初期就考慮該語言使用在網際網路當中，所以設計者們就選用了Unicode字符集，這也使得Java程式能夠在網際網路當中更好的流通，也正在由於這樣的原因，一下的程式碼是合法的；
Char c=‘中’；
數值型變數
數值型變數分為兩大類
整數型別：
Byte(佔用1位元組)
short(佔用2位元組)
int (佔用4位元組)
long(佔用8位元組)
浮點型：
float(佔用4位元組)
double(佔用8位元組)
整數型別
Java語言整數常量的三種表示形式：
—十進位制整數，如12，-314,0
—八進位制整數，要求以0開頭，如012
—十六進位制數，要求0x或0X開頭如0x12
Java語言的整型常量預設為int型，如：int i=3；
宣告long型常量可以後加‘l’或‘L’，如long l=3L
第六課
字面量：
整數字面量為整型（int）
小數字面量為雙精度浮點型（double）
第七課
Java當中的運算子
1、算數運算子：+，—，*，%，++，——
2、關係運算子：>,<,>=,<=,==,!=
運算形式：左運算元關係運算子 右運算元；
在關係運算子中，最終得到的一定是布林型別中的真（true）或者假（flase），不會有第三種值；
關係運算子包括： == 等於：如果兩個值相等，則返回真值
（注：關係運算一定要用==【等於】不要用=【賦值號】）
3、布林邏輯運算子：!(邏輯非),&（邏輯與）,丨（邏輯或），
^（邏輯異或）,&&（短路與）,丨丨（短路或）
4、位運算子：&，丨，^，~,>>,<<,>>>
5、賦值運算子：=擴充套件賦值運算子：+=， —=，*=，/=
6、字串連線運算子：+
算數運算子
要點一：
Int I = 3/2 請問i的值是幾？（答案：i=1）
原因;一個運算的結果取決於所有運算元中運算元那個最大的型別。
要點二：
I++和++ide 區別是什麼？
i++是使用了i的值之後再將i的值加1
++i是在使用i的值之前就將i的值加1
表示式的型別和值
表示式是符合一定語法規範的運算子和操作符的序列：
如I; 10.5+I; (i+j)-2
表示式的值；
對於表示式中運算元進行運算得到的結果稱為表示式的值
表示式的型別;
表示式的值得資料型別即為表示式的型別
第八課
程式執行流程的分類
1． 順序結構
2． 分支結構
3． 迴圈結構
順序結構
l 語句一
l 語句二
l 語句三
分支結構
|
語句一 |
|
判斷 語句 |
|
語句三 |
|
語句四 |
|
真 |
|
假 |
If…else…結構（一）
語法結構：
If（布林型別表示式）{
語句一；
語句二；
……
}
If…else…結構（二）
語法結構：
If（布林型別表示式）{
語句一；
語句二；
……
}
else{
語句一；
語句二；
……
}
If…else…結構（三）
語法結構：
If（布林型別表示式）{
語句一；
語句二；
……
}
else if（布林型別表示式）{
語句三；
語句四；
……
}
else if（布林型別表示式）{
語句五；
語句六；
……
}
else{
語句七；
……
}
Swith結構：
Swith（表示式）{
Case常量1:
語句1；
Break；
Case常量2:
語句2；
Break；
……
Case常量N:
語句n；
Break；
[default:
預設語句
Break;]
}
第十課
for迴圈執行過程
for（int i = 0; i <10; i++）{
System.out.println(i);
}
十一課
練習課
目標：熟悉java當中的for迴圈使用方法
練習一：列印出100——200之間的所有素數
步驟：
1、定義一個類，名為TestPrimNumber
2、在類當中定義函式；
3、用for迴圈列印出所有在100——200之間的數字；
用for迴圈當中，每當迴圈執行一次，就判斷迴圈變數的值是否為素數，如果是，就將迴圈變數的當前值列印出來；
a）判斷n是否為素數，首先用2除n，如果除不盡，再用3除n，一次類推，如果從2到n-1,都無法整除n，那麼n就為素數。
編譯過程：
class TestPrimeNumber{
public static voidmain(String args []){
for(int i = 100 ; i< 201 ; i++ ){
boolean b =false;
for(int j = 2; j < i-1;j++ ){
int k= i % j;
if(k==0){
b= true;
}
}
if(!b){
System.out.println(i);
}
}
}
}
練習二：在命令列中列印出如下的圖形：
*
* *
* **
* * * *
步驟：
1、定義一個類，名為TestTriangle；
2、在類當中定義一個主函式；
3、使用for迴圈列印四行，每行一個“*”
列印四行，每一行當中都包含四個“* ”
列印四行，第一行當中有一個“* ”第二行當中有“* ”，一次類推；
在列印“*”之前，首先要列印“”第一行當中首先列印三個“”，第二行兩個，一次類推；
編譯過程：
class TestTriangle{
public static voidmain(String args[]){
for(int i = 1; i< 5 ; i++){
for(int j = 0; j < 4 - i ; j++ ){
System.out.print("");
}
for(int k =0; k < i ; k++){
System.out.print("*");
}
System.out.println("");（括號內空字串代表換行）
}
}
}
（注：print如果不加—ln代表不用換行，加—ln代表需要換行，System.out.println("")這語句代表換行）
第十二課
什麼是物件導向？
1、物件導向是一種程式設計方法；
2、物件導向是一種思維方式；
3、物件導向不是一種程式語言；
應該如何學習物件導向？
1、掌握一門物件導向語言的語法
2、掌握物件導向的思維方式
3、熟悉物件導向設計原則
4、掌握物件導向設計模式
什麼是物件導向思維方法？
1、首先確定誰來做，其次確定怎麼做；
2、首先考慮整體，其次考慮區域性；
3、首先考慮抽象，其次考慮具體
小結:
1、不要認為掌握了一門物件導向語言就是掌握了物件導向；
2、習慣於將物件導向與現實世界作比較；
3、物件導向設計的終極目標就是減少重複程式碼。
十三課
定義類的方法
class 類名
{
屬性；
方法；
}
屬性也叫成員變數，主要用於描述類的狀態
方法也叫成員方法，主要用於描述類的行為
|
類名 |
|
Dog |
|
|
color
age name |
|
|
bark() jump()
|
例子： 類名 成員變數 成員函式
class Person
{
Int age;
void shout(){
Syetem.out.println(“oh,mygod! I am”+age);
}
}
age是類的屬性，也叫類成員變數
shout是方法也叫類的成員函式
shout方法可以直接訪問通一個類中的age變數，
如果一個方法中有與成員變數同名的區域性變數，
該方法中對這個變數的訪問是區域性變數， 而不再是成員變數。
生成物件的方法
格式：類名 物件名=new類名（）；
例如：Dog dog =new Dog（）；（這是引用資料型別）
|
|
|
Dog 物件 |
|
棧記憶體 |
|
堆記憶體 |
棧記憶體存放的是物件的名字（名字專用術語就是引用）
堆記憶體存放的是物件的本體
|
a
|
格式：類名物件名=new類名()；
例如：Dog d = new Dog()；
Dog d = new Dog()；
建立一個Dog的引用
Dog d = new Dog();
建立一個Dog的物件
(放在堆記憶體裡)
Dog d = new Dog();
將建立的Dog物件賦給這個引用
類和物件的關係
類是抽象的概念，而物件是具體的個體，物件的共同屬性可以組成一個類
十五課
函式的過載
1、這些函式在同一個類當中
2、這些函式的函式名相同
3、這些函式的引數列表不同
建構函式的作用
建構函式語法注意點
1、建構函式的函式名必須和類名相同（大小寫也必須一樣）
2、建構函式沒有返回值型別的定義
3、使用new來呼叫建構函式
4、如果你的類裡面沒有建構函式，編譯器會幫你加一個引數為空、方法體也為空的建構函式
5、如果你的類裡面已經有了建構函式，編譯器將不會加無參的建構函式
十六課
1、this呼叫成員變數和成員函式
this代表的就是呼叫這個函式的當前物件
2、this呼叫建構函式
1.this(引數)來呼叫建構函式，呼叫哪一個建構函式取決於你傳入引數的個數和型別
2.this呼叫建構函式必須是建構函式中的第一條語句。
十七課
普通的成員變數
Person p1 = new Person();
p1.i = 10;
Person p2 = new Person();
p2.i = 20;
|
p1
p2
|
|
i=10 |
|
i=20
|
靜態的成員變數
Person p1 = newPerson();
Person p2 = newPerson();
Person.i = 10;
|
p1
p2
|
|
i=10 |
8集
//布林表示式用if…else…,具體“值”的選擇分支用switch。
if…else…結構
if (布林型別表示式){
語句一；
語句二；
……
}
例：publicclass test{
public static void main(String args[]){
int i = 6;
if (i> 5 && i<10) {
System.out.println("5<i<10");
}
}
}
if (布林型別表示式){//if條件一旦成立，就不會判斷後面的其他邏輯表示式
語句一；
語句二；
……
}
elseif (布林型別表示式){
語句一；
語句二；
……
}
elseif (布林型別表示式){
語句一；
語句二；
……
}
……
else (布林型別表示式){ //最後這一條可有可無
語句一；
語句二；
……
}
二、switch結構
switch （表示式//byte、short、long、char型別）{
case 常量1（值）：
語句1；
break；
case 常量2：
語句2；
break；
case 常量3：
語句3；
break；//如果沒有break，就不會比較下一條是否符合，直接執行下一條語句。
……
default //最後這一條可有可無
預設語句；
break；
}
10集
For迴圈與while迴圈的區別：
for迴圈三部分：定義變數；邏輯判斷；新的運算表示式；
while迴圈只有一部分：邏輯判斷。
for迴圈、
for （ 定義語句 ； 判斷條件 ； 新運算語句 ；）{
}
例子：for (int i = 0 ;i < 10 ;i = i + 2 ) {
System.out.println(i);
}
判斷條件：值為真則執行，值為假則退出。
while (布林表示式) {
}
例子：while (i < 10) {
System.out.println(i);
}
布林表示式：值為真則執行，值為假則退出。
13集
建立類的方法
class {
屬性；（也叫成員變數，說明類的狀態）
方法；（也叫成員函式，說明類的行為）
}
物件的建立方法
類名 物件名 = new 類名（）；
Dog dog = new Dog();
類和物件的關係
14集
物件的使用方法
物件.變數
物件.函式（）
class dog{
Stringname;
Stringcolor;
int age;
voidjump(){
System.out.println("跳");
}
void sit(){
System.out.println("坐");
}
}
class test{
public staticvoid main (String args []){
dog d =new dog();
d.name ="布布";
d.color ="黃色";
d.age =4;
d.jump();
d.sit();
System.out.println(d.name);
System.out.println(d.color);
System.out.println(d.age);
}
}
二、多物件的建立方法
三、匿名物件的建立和使用方法
new 類名().成員函式()；
new dog().jump();
直接建立一個無名物件，並呼叫這個無名物件的成員函式；
15集
一、函式的過載
二、建構函式
函式的過載：
同一個類中的函式（就是方法），同樣的函式名，不同的引數列表，如下
void jump(){/無參的函式
}/
void jump(String name,intage){ //有兩個引數的函式
}
以上就是過載
呼叫：在test檔案中編譯
Dog d1=new Dog（）；
d1.jump()； //呼叫無參的jump
d1.jump(“旺財”,8)； //呼叫了兩個引數的jump
建構函式：
class A{
A（）{
}
}
·不是成員函式
·如果作者編寫了一個有參的建構函式，系統不會再預設新增一個無參的建構函式了。
·建構函式沒有返回值型別
·建構函式的名字，必須和類名一樣。
Dog（）{
}
·格式：類名(){
}
·建構函式在變數和方法中間寫，可以過載不同個數、不同內容的引數
class person
{
//下面兩行是變數
Stringname;
intage;
//下面是建構函式
Person(){//第一個預設的建構函式，可以不寫
}
person(Stringname,int age){ //過載了第二個有兩個引數的建構函式
this.name=name;
this.age=age;
}
//下面是方法
voidintro(){
System.out.println(name+age);
}
}
16集
一、用this呼叫成員變數和函式；
二、用this呼叫建構函式；
1、this的來由
class person
{
String name;
void talk(){
System.out.println(name);//前面省略了“this.”
}
}
this.=呼叫該變數或者函式的物件的人稱代詞
2、下面的this.不能被省略；
（成員變數也有name，成員函式也有name；要呼叫成員變數的name，就必須寫上name）
class person{
String name;
void talk(String name){
this.name= name; //把引數的值賦值給成員變數
System.out.println(name);
}
}
3、this.呼叫建構函式
//呼叫建構函式格式：
this（引數列表），不用寫類名稱
class person{
String name;
int age;
String add;//這三個定義變數型別的一定要有
person(){//無參建構函式；
}
person(String name,intage){ //兩個引數的建構函式
this.name=name;
this.age=age;
person(String name,int age,String.add){ //三個引數的建構函式，
this(name,age) //呼叫兩個引數的建構函式
this.add =a dd;
}
void talk(String name){
this.name = name;
System.out.println(name);
}
}
4、this.呼叫建構函式時，一定要是建構函式大括號中的第一個語句
呼叫無參的建構函式：this();
呼叫方法的時候則不必放在第一行。
17集 static
一、靜態成員變數的語法特點
靜態：表示在這個類中，該值是統一的、不變的。
靜態成員變數，可以直接用類名呼叫（也可以用成員的名稱呼叫，如p1.name）
class person{
static int i;
}
class test{
public static voidmain(String args[]){
person p1 = newperson();
person p2 = newperson();
person.i=10;
System.out.println("p1的i值是"+p1.i);
System.out.println("p2的i值是"+p2.i);//這兩行列印的都是“10”
p1.i=20;//可以用一個變數，改變整個類的變數值
System.out.println("p1的i值是"+p1.i);
System.out.println("p2的i值是"+p2.i); //這兩行列印的都是“20”
}
}
2、靜態函式
class person{
int i;
staticvoid fun(){
System.out.println("我是靜態函式");
}
}
class test{
public static void main(String args[]){
person.fun();
}
}
靜態函式，只能！！！呼叫靜態的變數。如下
class person{
static String name;
static void talk(){
System.out.println("我們這一類的名字是"+name);
}
}
class test{
public static void main(String args[]){
person.name="張三";
person.talk();
}
}
3、靜態程式碼塊
格式：static{
System.out.println(“這就是靜態程式碼塊”);
}
在裝載類到記憶體的時候，就會被呼叫，
不管有沒有主函式，它都會執行
靜態程式碼塊自己就執行
作用：用於給一些變數賦初始值。
也可以給一些軟體開頭的文字用。
18集 繼承
一、什麼是繼承
二、為什麼要用
三、繼承的基本如法
繼承：一個類得到了另一個類的變數和方法，沒有得到建構函式
class person{}
class student extends person{}
什麼是繼承?
1. 在現實世界當中，繼承就是兒子得到了老子的東西。
2. 在物件導向的世界當中，繼承就是一個類得到了另一個類當中的成員變數和成員方法。
Java當中只支援單繼承，不允許多繼承。
|
父類 |
|
子類A |
|
子類B |
|
子類C |
19集 子類例項化過程
一、生成子類的過程
在子類的建構函式中必須呼叫父類的建構函式；
二、super呼叫父類建構函式
呼叫父類建構函式，預設加入了super();
super（建構函式的引數）；
super(name,age,add);
用super呼叫建構函式，一定是本條建構函式語句的第一行語句。
20集 函式的複寫
一、函式的複寫override(過載是在一個類中，複寫實在父子兩個類中)
二、super呼叫父類的成員函式函式（上節課呼叫的是構造函式）
複寫：
1、複寫（override）也稱為覆蓋或者重寫。
2、在具有父子關係的兩個類中；
3、在父類和子類中，各有一個函式，它們的返回值型別、函式名、引數列表完全相同
class person{
String name;
int age;
voidintroduce(){
System.out.println("我的姓名是" + name + ",我的年齡是" + age);
}//這是原始函式
}
class student extends person{
String address;
void introduce(){
System.out.println("我的姓名是" + name + ",我的年齡是" + age);
System.out.println("我的家在" + address);
} //這是複寫後的函式
}
或者：class student extendsperson{
String address;
void introduce(){
super.introduce();//super呼叫父類的成員函式函式
System.out.println("我的家在" + address);
}
}
21集 物件的轉型
一、物件的向上轉型：將子類的物件賦值給父類的引用
二、物件的向下轉型:將父類的物件賦值給子類的引用
Student s = new Student();
Person p = s;
例如：我現在用的膝上型電腦（子類）是一臺電腦（父類）
茶杯（子類）是杯子（父類）
class test{
public static void main (String args[]){
Student s = new Student();
Person p = s; //向上轉型（把一個學生向上轉型到一個人）
或者 Person p = new Student();
父類 父類的變數 = new 子類（）
p.name="zhangsan";
p.age=23;
p.introduce();
p.add="beijing";
p.study();
//如果在person類中，沒有定義String add和voidstudy()，而student類中有定義String add和voidstudy()；那麼編譯的時候會報錯，
因為
* 一個引用，能夠呼叫那些成員變數，必須是這個引用（p）所在父類中已經定義好的成員變數，不能在執行檔案中重新定義，否則報錯。
p.introduce();//這條很重要
** 一個引用（p）呼叫的是哪一個類中的方法(introduce)，取決於這個引用(p)指向的物件(s)的類中(student)的方法(student類中void introduce)} }
//也就是說:轉型後的物件（P）能呼叫的方法，只能是在父類（Person）中有的，或者是在子類（student）中複寫的方法。不能是在父類中沒有而在子類中新出現的。
即：引用 呼叫 成員變數時，成員變數要在父類中定義過；
呼叫 成員函式時，呼叫的是子類中的函式。
向下轉型：
Student s1 = new Student();
Person p = s1;//先把s1向上轉型
Student s2 = (Student)p;//再把這個物件強制向下轉型
或者： Person p = new Student();
Student s = (Student)p;
問：為什麼向上轉型在向下轉型：
答：比如先定義一臺筆記本，先向上轉型成電腦，再向下轉型成另一臺筆記本，是可以的；如果沒有向上轉型，那就
相當於隨便一臺電腦（包括桌上型電腦）向下轉型成筆記本，是不現實的。
所以，要先在子類建立一個物件，比如在Student類中建立一個孩子，再向上轉成Person，再轉回來。不能直接建立一個大人（Person），再變成小孩（Student）。
22集 物件導向的應用（一）
一、被客戶不斷變化的需求所折磨（各種印表機）
1、設計一個印表機程式，能開機、關機、列印
class printer{
void open(){
System.out.println("open");
}
void close(){
System.out.println("close");
}
void print(String s){
System.out.println("print---->"+s);}}
class test{
public static void main(String args[]){
printer p = new printer();
p.open();
p.print("abc");
p.close(); }}
2、加了一臺電腦，並不是同一牌子的，開發程式具備以上功能
class printer{
void open(){System.out.println("open"); }
void close(){System.out.println("close");}
void print(String paizi){
System.out.println("這臺電腦的牌子是"+paizi);}}
class hp extends printer{}
class canon extends printer{
void print(String paizi){super.print(paizi);this.clean();}
void clean(){System.out.println("關機前清理噴頭");}}
class test{
public static void main(String args[]){
int flag =1;
if (flag==0)
{hp hp1 = new hp();hp1.open();hp1.print("惠普");hp1.close();}
else
{canon cn1 = new canon();cn1.open();cn1.print("佳能");cn1.close();}}}
23集 抽象類和抽象函式
一、抽象函式的語法特徵
二、抽象類的語法特徵
抽象函式：只有函式定義，沒有函式體的函式
abstract void fun（）；//沒有大括號
class person{
String name;
int age;
void intro(){ System.out.println(name+age); }
abstract void eat();//抽象函式}
什麼是抽象類：
使用abstract定義的類，被稱為是抽象類。
1、抽象類不能聲稱物件；
2、如果一個類中，有抽象函式，那麼這個類也必須是抽象類；
3、如果一個類中，沒有抽象函式，那麼這個類也可以被定義為抽象函式。
abstract class person{
String name;
int age;
void intro(){ System.out.println(name+age); }
abstract void eat();//抽象函式}
class china extends person{
void eat()
{System.out.println("中國人用筷子吃飯");}//複寫person中的eat函式}
class test{
public static void main(String args[]) {
person p= new china();//向上轉型
p.name="zhang san"; p.age=33;
p.intro();
p.eat(); //以上兩行呼叫的是china中的方法（參見21課筆記“**”）}}
抽象類可以有建構函式麼?
可以。在生成子類的建構函式的時候通過子類生成super（）來被呼叫。
24集 為什麼用抽象類
一、抽象類的作用
1、如果在父類中定義了抽象函式（父類也必然是抽象類），在子類（非抽象類）中沒有或忘記對抽象函式進行復寫，那麼程式就會報錯，通知作者對抽象函式進行復寫（使方法具體化）。
25集 包和訪問許可權（一）
一、什麼是java中的軟體包
二、為什麼用軟體包
三、如何打包
packagecheng;//打包命令，別忘了分號
class test{
public static void main (String args[]){
System.out.println("hello package"); }}
javac -d . test.java
//-d的意思是：根據包名，生成一個資料夾名。Directory目錄
//.點的意思是，把生成的資料夾放在當前目錄下。
javac -d c:\windows test.java
打包後一個類的全名，應該是：
“包名”+“.”+“類名”：cheng.test
進入包的資料夾裡g:\java\cheng>javatest,也不行。
包名的命名規範：
1、要求所有字母都要小寫。
2、一般是域名倒寫 package com.chengbin;
//生成com資料夾，在裡面有chengbin資料夾
26集 包和訪問許可權（二）
一、包的訪問許可權
二、軟體包的匯入
public：公共
private：私人
default：預設
protected：保護
public：可以修飾類、變數、函式
如果一個類是public的，那麼類的名字，必須和.java前的檔名必須一致。
package bin.cheng;
public class person{
//如果person類不是公共的，那就無法在下面，不同包的其他類中進行引用。
public String name;
public int age;
//如果name或age不是公共的，那就無法在下面，不同包的其他類中進行引用。
public void intro(){
System.out.println(name+age); }}
package com.mars;
class test{
public static void main(String args[]){
bin.cheng.person p= null;}}
類是public，裡面的變數不是跟著自動public的，需要用public說明。
private：能修飾變數也能修飾函式
表示變數和函式，只能在當前類中使用，在外部無法使用
default：（不寫許可權修飾符，就是default許可權）
在同一個包中，default許可權不受限制；
在不同的包中，就需要public許可權了；
如果兩個類在同一個包中，那麼可以相互呼叫彼此的函式
如果兩個類不在同一個包中，那麼不可以相互呼叫彼此的函式
包的匯入
呼叫不同包的變數或者函式，需要寫上全名，
全名很長，為了簡單起見，就用報的匯入。
匯入的包裡要是public才能被繼承和引用。
package com.mars;
import bin.cheng.person ;
class test{
public static void main(String args[]){
bin.cheng.person p= new bin.cheng.person();
//因為匯入了包，所以“bin.cheng.”就省略了
p.name="zhangsan";
p.age=12; }}
import bin.cheng.* ; //匯入包下所有的類。
27集 包和訪問許可權（三）
一、訪問許可權與繼承
二、protected許可權
protected：
和default一樣，但是隻能修飾成員變數和成員函式，不能修飾類；
protected允許跨包的繼承。
protected和public的區別：
protected說明在不同包的類中，只有這個類（person）的子類（student），才能呼叫父類的變數和成員函式。
public說明包外任何類都可以呼叫變數和成員函式，沒有父子關係也可以使用。
public > protected > default > private
公共 > 跨包繼承的 > 同一個包的 > 本類中的
28集 介面的基本語法
一、什麼是介面
二、介面的基本語法
1、用interface定義的
2、介面中的方法全是抽象方法
3、介面中的方法全是public
4、介面不能生成物件，在繼承的子類中，複寫抽象方法。
5、一個類可以實現多個介面，與類繼承不同，如手機可以通過usb和wifi等連結電腦
6、一個介面可以繼承多個介面。
interface usb{
public void read();//寫不寫public都行，都是public的
void write();}//都是抽象的；雖然沒寫許可權但都是public的，不是default的
interface WiFi{
public void open();
void close();}
class phone implements usb，WiFi//介面被兩個子類實現，用逗號隔開
{ publicvoid read(){System.out.println("usbphone 讀"); }
publicvoid write(){System.out.println("usb phone 寫"); }
public void open(){ System.out.println("WiFi 開啟"); }
publicvoid close(){System.out.println("WiFi 關閉"); } }
//實現介面，複寫介面的抽象函式時，這4個public必須要寫
class test{
public static void main(String args[]){
phone phone1 = new phone();
usb usb1 = phone1；//向上轉型
usb1.read(); usb1.write();
WiFi w1 = phone1；//向上轉型
w1.open(); w1.close();}
}
一個介面可以繼承多個介面,說明如下
interface a{
public void funA(){ } }
interface b{
public void funB(){ }}
interface c extendsa,b{
public void funC(){ }}
//c介面裡有funA、funB和funC三個抽象方法，如果要實現c介面，則需要複寫全部三個方法，而不是隻有funC一個方法
29集 介面的應用
一、為什麼要用介面
二、工廠方法模式
class Test{
public static void main(String args []){
//根據使用者的選擇，生成相應的印表機物件
//並且向上轉型為Printer型別
//PrintergetPrinter(int flag)
int flag = 2 ;
Printer printer = PrintFactory.getPrinter(flag);
printer.open();
printer.print("test");
printer.close();
}
}
工廠模式:
class PrinterFactory{
public static Printer gerPrinter(int flag){
Printer printer = null;
if(flag == 0){
printer = new HPPrinter();
}
else if(flag ==1){
printer = new CanonPrinter();
}
else if(flag == 2){
printer = new XXXPrinter();
}
teturn printer;
}
}
30集 Java當中的異常（一）
一、什麼是異常
異常是指中斷了正常的指令流的事件。
二、異常的分類
三、try…catch…finally結構的使用方法
class Test{
public static void main (String args []) {
System.out.println(1);
try {
System.out.println(2);
int i = 1 / 0;
System.out.println(3); }
catch (Exception e) {//如果try中的語句沒有異常，catch裡的就不執行
e.printStackTrace();
System.out.println(4); }
System.out.println(5);
}}
//finally無論try中有沒有異常，都會執行，是try的出口。
31集 Java當中的異常（二）
一、throw
throw丟擲在方法體內一個異常，丟擲之後如果不用try…catch處理就中止指令。
例：
class User{
private int age;
public void setAge(intage){
if(age < 0){
RuntimeExceptione = new RuntimeException("年齡不能為負數");
throw e;
}
this.age = age;
}
}
class Test{
public static voidmain(String args[]){
User user = newUser();
user.setAge(-20);
}
}
執行結果：
二、throws
throws是在定義方法時候宣告一個異常，原方法（函式）將不負責處理這個異常，而是誰呼叫這個方法，誰就處理這個異常
例：
class User{
private int age;
public void setAge(int age) throws Exception{
if(age < 0){
Exception e = new Exception("年齡不能為負數");
throw e;
}
this.age = age;
}
}
class Test{
public static void main(String args[]){
User user = new User();
try{
user.setAge(-20);
}
catch(Exception e){
System.out.println(e);
}
}
}
執行結果：
32集 JAVA當中的I/O（一）
一、I/O操作的目標
二、I/O的分類方法
三、讀取檔案和寫入檔案的方法
I/O操作的目標
從資料來源當中讀取資料，以及將資料寫入到資料目的地當中。
|
檔案 鍵盤 網路 |
|
Java程式 |
|
檔案 螢幕 網路 |
|
輸入 |
|
輸出 |
I/O的分類
第一種分類
1、輸入流 2、輸出流
第二種分法
1、位元組流 2、字元流
第三種分法
1、節點流 2、處理流
I/O當中的核心類
|
InputStream |
|
FileOutputStream （常用子類） |
|
FileputStream （常用子類） |
|
OutputStream |
|
這兩個類是所有位元組流的父類，而且這兩類為抽象類，不能生成物件。 |
核心類的核心方法 (byte型別)的陣列
int read(byte [] b ,int off ,int len) 最多讀取多少資料
偏移量 （從讀取陣列第幾位之後開始讀取）
此方法返回值為呼叫該read方法總共讀取了多少個位元組的資料
void write(byte [] b, int off , int len)
讀取檔案和寫入檔案的方法
輸入流例項：
import java.io.*;
class Test{
public static voidmain(String args[]){
//宣告輸入流引用
FileInputStream fis= null;
try{
//生成代表輸入流的物件(並傳入所要讀取資料來源的當前檔案目錄)
fis = new FileInputStream("d:/work/src/from.txt");
//生成一個位元組陣列
byte [] buffer =new byte[100];
//呼叫輸入物件的read方法，讀取資料來源中的資料存放於陣列之中
fis.read(buffer,0,buffer.length);
//根據陣列buffer傳入的引數把位元組陣列還原成一個字串
String s = newString(buffer);
//呼叫一個String物件的trim方法，將會去掉這個字串
//的首尾空格和空字元
s = s.trim();
System.out.println(s);
for(int i = 0 ;i < buffer.length; i++){
System.out.println(buffer[i]);
}
}
catch(Exception e){
System.out.println(e);
}
}
}
執行結果1：
執行結果2（還原成字串abcd）：
輸出流例項：
//第一步驟：匯入類
import java.io.*;
class Test{
public static voidmain(String args[]){
//宣告輸入流引用
FileInputStream fis= null;
//宣告輸出流引用
FileOutputStream fos= null;
try{
//生成代表輸入流的物件
fis = new FileInputStream("d:/work/src/from.txt");
//生成代表輸出流的物件
fos = newFileOutputStream("d:/work/src/to.txt");
//生成一個位元組陣列
byte [] buffer =new byte[100];
//呼叫輸入物件的read方法，讀取位元組陣列的資料
int temp =fis.read(buffer,0,buffer.length);
//temp臨時定義用來接收read返回值型別，從而判斷寫入多少資料
fos.write(buffer,0,temp);
}
catch(Exception e){
System.out.println(e);
}
}
}
|
寫入 |
執行結果：
33集 JAVA當中的I/O（二）
1、大檔案的讀寫方法
2、字元流的使用方法
大檔案的讀寫方法
接上節課的例項（以及使用finally關閉I/O）
//第一步驟：匯入類
import java.io.*;
class Test{
public static void main(String args[]){
//宣告輸入流引用
FileInputStream fis = null;
//宣告輸出流引用
FileOutputStream fos = null;
try{
//生成代表輸入流的物件
fis = newFileInputStream("d:/work/src/from.txt");
//生成代表輸出流的物件
fos = new FileOutputStream("d:/work/src/to.txt");
//生成一個位元組陣列
byte [] buffer = newbyte[1024];
while(true){
//呼叫輸入物件的read方法，讀取位元組陣列的資料
int temp =fis.read(buffer,0,buffer.length);
if(temp == -1){
break;
}
//呼叫輸出流的write方法，寫入位元組陣列的資料
fos.write(buffer,0,temp);
}
}
catch(Exception e){
System.out.println(e);
}
finally{
try {
fis.close();
fos.close();
}
catch(Exceptione){
}
}
}
}
字元流的使用方法
基礎知識：
字元流：讀取檔案時，以字元為基礎
根本類包括
1、位元組輸入流都是Reader的子類
常用子類：FileReader
核心方法：int read(char [] c , int off , int len)
2、位元組輸出流都是Writer的子類
常用子類：FileWriter
核心方法：Void write(char [] c , int off , int len)
字元流例項
import java.io.*;
public classTestChar{
public static void main(String argsp[]){
FileReader fr = null;
FileWriter fw = null;
try{
fr = newFileReader("d:/work/src/from.txt");
fw = newFileWriter("d:/work/src/to.txt");
char [] buffer = newchar[100];
int temp =fr.read(buffer,0,buffer.length);
fw.write(buffer,0,temp);
}
catch(Exception e){
System.out.println(e);
}
finally{
try {
fr.close();
fw.close();
}
catch(Exception e){
System.out.println(e);
}
}
}
}
34集 JAVA當中的I/O（三）
1、處理流使用例項
2、“裝飾者（Decorator）”模式
3、節點流與處理流的關係
BufferedReader（字元輸入處理流）介紹
Public String readline()
throws IOException
BufferedReader使用方法
生成BufferedReader物件的方法；
BufferedReader in= new BufferedReader（newFileReader（“foo.in”））；
例項(此例項使用了裝飾者模式)：
|
fileReader這裡是讀取檔案，也是被裝飾者，也可以換做類似物件，比如像讀取鍵盤資料的物件等。 |
import java.io.*;
class Test{
public static void main(String args[]){
FileReader fileReader = null;
BufferedReader bufferedReader =null;
try{
fileReader = newFileReader("d:/work/src/users.txt");
//以上是把fileReader物件傳入bufferedReader引用中
bufferedReader = new BufferedReader(fileReader);
String line = null;//定義一個空值的line引用（物件）
while(true){
line =bufferedReader.readLine();//這是一個while迴圈
if(line == null){
break;
}
|
這裡的bufferedReader是一個裝飾者的角色，並不是真正去讀取檔案，而是裝飾fileReader去讀取檔案，同樣的也可裝飾鍵盤等讀取其他資料。 |
System.out.println(line);
}
}
catch(Exception e){
System.out.println(e);
}
finally{
try{
bufferedReader.close();
fileReader.close();
}
catch(Exception e){
System.out.println(e);
}
}
}
}
35集內部類和匿名內部類
1、 什麼是匿名內部類
2、 內部類的使用方法
3、 匿名內部類的使用方法
內部類例項
執行結果：
匿名內部類的使用例項：
class Test{
public static voidmain(String args[]){
//AImpl al = new AImpl();
//A a = al;
B b = new B();
b.fun(new A(){
public voiddoSomething(){
System.out.println("匿名內部類");
}
});
}
}
執行結果：
說明：1、紅色部分代表的就是匿名的內部類，（相當於實現類A）。
2、紅色部分的 new A 代表的就是實現類A，那麼打括號裡就是為了實現類A對介面A進行復寫。
第36集
1、程式和執行緒
2、多執行緒程式執行模式
3、定義執行緒的方法
多執行緒與多程式
多程式：（程式是在各自獨立的記憶體空間中執行）
作業系統中能（同時）執行多個任務（程式）
多執行緒：（一個程式中的執行緒可以共享系統分派給這個程式的記憶體空間）
在同一應用程式中有多個順序流（同時）執行
執行緒的執行過程
|
就緒狀態 |
|
執行狀態 |
定義執行緒的方法有兩種：
1、第一種是：繼承Thread類，另一種是：實現Runnable介面。
2、兩種方法的本質上是一種方法，即都是通過Thread類建立執行緒，並執行
Run()方法。
建立執行緒的第一種方法
方式1：
定義一個執行緒類，它整合類Thread（由JDK提供）並重寫其中的方法run（），方法run（）稱為執行緒體。
由於Java只支援單繼承，用這種方法定義的類不能在繼承其他類。
執行緒例項：
class FristThread extends Thread{
publicvoid run(){
for(inti =0; i < 100; i++){
System.out.println("FristThread-->"+ i);
}
}
}
class Test{
publicstatic void main(String args[]){
//生成執行緒類的物件
FristThreadft = new FristThread();
//啟動執行緒
//ft.run()千萬不能這樣寫，start()繼承於Thread
ft.start();
for(inti =0; i < 100; i++){
System.out.println("main-->"+ i);
}
}
}
（部分）執行結果：
從以上結果我們可以看出兩個執行緒同時在執行，一個是主方法執行緒，一個是ft.start（）執行緒，誰搶到CPU誰就執行，否則進入就緒，這樣一直交替，直到執行完畢。
第37集
1、實現執行緒的第二種方法
2、控制執行緒的常用函式
實現執行緒的第二種方法（實現Runnable介面）
總述:JDK提供一個實現Runnable介面的類作為執行緒的目標物件，在初始化一個Thread類或者Thread子類的執行緒物件時，把目標物件傳遞給這個執行緒例項（執行緒物件的引用），由該目標物件提供執行緒體。
分述：實現Runnable介面的類必須使用Thread類的例項才能建立執行緒。通過Runnable介面建立執行緒分為兩步。
（1）將實現Runnable介面的類例項化。
（2）建立一個Thread物件，並將第（1）步例項化的物件作為引數傳入Thread類的構造方法。
執行緒例項：
class RunnableImpl implements Runnable{
publicvoid run(){
for(inti = 0; i < 100; i++){
System.out.println("Runnable-->"+ i);
}
}
}
class Test{
publicstatic void main(String args[]){
//生成一個Runnable介面實現類的物件(該物件提供執行緒體
給Thread執行緒)
RunnableImplri = new RunnableImpl();
//生成一個Thread物件，並將Runnable介面實現類的物件
//作為引數傳遞給該Thread物件
Thread t = new Thread(ri);
//通知Thread物件，執行start方法
t.start();
}
}
（部分）執行結果：
執行緒的簡單控制方法
中斷執行緒
1、Thread.sleep（）執行緒進入休眠
2、Thread.Yield（）執行緒讓出CUP，並重新爭奪CPU的使用
設定執行緒的優先順序
1、getPriority（）取得優先順序（最大或者最小優先順序等）
2、setPriority（）設定優先順序
第38集
1、多執行緒資料安全
2、同步執行緒的方法
同步執行緒例項：
class MyThread implements Runnable{
inti = 100;
publicvoid run(){
while(true){
//this指呼叫這個方法（函式）的物件。
synchronized(this){//這是一個同步程式碼塊（它是鎖住一個物件，不是 鎖住一個程式碼塊）
//Thread.curretThread()是Thread的靜態方法
//Thread.curretThread()可以返回當前執行的執行緒以及執行緒的名字
System.out.println(Thread.currentThread().getName()
+i);
i--;
Thread.yield();
if(i< 0){
break;
}
}
}
}
}
說明：1、如果沒有同步程式碼塊將有可能出現執行錯誤
2、有了同步程式碼塊一個執行緒即使搶佔CPU也無法執行程式碼塊的建構函式 的方法體只能等待正在執行的執行緒執行完畢才能重新爭奪CPU執行。
class Test{
publicstatic void main(String args[]){
MyThreadmyThread = new MyThread();
//生成兩個Thread物件，但是這兩個Thread物件共用
//同一個執行緒體
Threadt1 = new Thread(myThread);
Threadt2 = new Thread(myThread);
//每一個執行緒都有名字，可以通過Thread物件的setName()方法
//設定執行緒名字，也可以使用getName方法獲取執行緒的名字；
t1.setName("執行緒a");
t2.setName("執行緒b");
//分別啟動兩個執行緒
t1.start();
t2.start();
}
}
第39集
深入synchronizad關鍵字
1.1同步程式碼塊可以具體指鎖住的是哪一個物件
2.1而同步方法鎖住的就是this（呼叫這個方法【函式】的物件）。
第40集
1、陣列的型別
2、陣列的定義方法
3、陣列的操作方法
一維陣列的定義方法：
例項
class Test{
publicstatic void main(String args[]){
//陣列的靜態宣告法
//intarr [] = {5,2,3,6,0};
//陣列的動態宣告法
intarr [] = new int[10];
System.out.println("arr陣列的長度是"+ arr.length);
arr[3]= 10;
for(inti = 0; i < arr.length; i++){
System.out.println(arr[i]);
}
}
}
二維陣列的定義方法：
例項
class Test01{
publicstatic void main(String args []){
//二維陣列的靜態宣告法
intarr [] [] = {{1,2,3},{4,5,6},{7,8}};
//二維陣列的動態宣告法
//intarr[]][] = new int[3][5];
for(inti = 0; i < arr.length;i++){
for(intj = 0; j < arr[i].length;j++){
System.out.println(arr[i][j]);
}
}
}
}
第41集
1、什麼是類集框架
2、集合的中類
3、類集框架的基礎結構
什麼是類集框架
1、類集框架是一組類和介面；
2、位於java.util包當中（JDK提供）；
3、主要用於儲存和管理物件；
4、主要分為三大類：集合、列表和對映：
什麼是集合（Set）
集合中的物件不按特定的方式排序，並且沒有重複物件；
什麼是列表（List）
集合中物件按照索引位置排序，可以有重複的物件
|
1 |
|
2 |
|
3 |
|
4 |
|
5 |
|
6 |
什麼是對映（Map）
集合中的每一個元素包含一個鍵物件和一個值物件，鍵不可以重複，值可以重複。
|
key1 |
Value1 |
|
Key2 |
Value2 |
|
Key3 |
Value3 |
|
Key4 |
Value4 |
|
Key5 |
Value5 |
類集框架主體結構
例項說明：
//匯入包
import java.util.List;
//匯入List實現類子介面
import java.util.ArrayList;
public class Test{
publicstatic void main(String args[]){
ArrayList<String>arrayList = new ArrayList<String>();
//呼叫add()方法，向列表新增資料（物件）
//<String>是定義ArrayList的泛型
arrayList.add("a");
arrayList.add("b");
arrayList.add("c");
//呼叫get()方法取出列表的資料（物件）
//arrayList.size()是代表列表的長度
for(inti = 0; i < arrayList.size();i++){
Strings = arrayList.get(i);
System.out.println(s);
}
}
}
第42集
1、Collection和Iterator介面
2、Set與HashSet的使用方法
Collection介面（一）
|
boolean add(Object o) |
向集合當中加入一個物件 |
|
void clear() |
刪除集合當中的所有物件 |
|
blooean isEmpty() |
判斷集合是否為空 |
|
remove(Object o) |
從集合中刪除一個物件的引用 |
|
int size() |
返回集合中元素的數目 |
例項1：
public class Test{
publicstatic void main(String args[]){
//HashSet<String>hashSet = new HashSet<String>();
//Set<String>set = hashSet;
Set<String>set = new HashSet<String>();
booleanb1 = set.isEmpty();
System.out.println(b1);
set.add("a");
set.add("b");
set.add("c");
set.add("d");
set.add("c");
booleanb2 = set.isEmpty();
System.out.println(b2);
inti = set.size();
System.out.println("clear之前的set物件的長度是"+ i);
set.clear();//set.remove("a");
intj = set.size();
System.out.println("clear之後的set物件的長度是"+ j);
}
}
例項2：
import java.util.Set;
import java.util.HashSet;
import java.util.Iterator;//Iterator迭代器
public class Test{
publicstatic void main(String args[]){
//HashSet<String>hashSet = new HashSet<String>();
//Set<String>set = hashSet;
//Iterator<--Collection <-- Set <--HashSet
//HashSet中的方法有 1、hasNext()判斷迭代器中還有沒有下一個物件
//2、next()取出當前迭代器中元素，並返回迭代器中的下一個物件
Set<String>set = new HashSet<String>();
set.add("a");
set.add("b");
set.add("c");
set.add("d");
set.add("c");
//呼叫Set物件的Iterator方法，會生成一個迭代器物件，
//該物件用於遍歷整個Set
Iterator<String>it = set.iterator();
while(it.hasNext()){
Strings = it.next();
System.out.println(s);
}
}
}
第43集
1、Map與HashMap的使用方法
2、JDK幫助文件的使用方法
對映例項：
import java.util.Map;
import java.util.HashMap;
public class Test{
publicstatic void main(String args[]){
HashMap<String,String>hashMap = new HashMap<String,String>();
Map<String,String>map = hashMap;
//<String,String>第一個String表示鍵的型別，第二個表示值的型別
map.put("1","a");
map.put("2","b");
map.put("3","c");
map.put("4","d");
map.put("3","e");//e覆蓋了c
inti = map.size();
System.out.println(i);
Strings = map.get("3");
System.out.println(s);
}
}
第44集(理解)
1、equals函式在什麼地方
2、equals函式的作用
3、複寫equals函式的方法
“==”操作符的作用
作用是：判斷兩個引用是否指向堆記憶體的同一個地址
User u1 = newUser();
User u2 = newUser();
User u3 = u1
|
|
|
u3 |
|
u2 |
|
u1 |
例項說明：
class User{
Stringname;
intage;
}
class Test{
publicstatic void main(String[] args) {
User u1 = new User();
User u2 = new User();
User u3 =u1;
booleanb1 = u1 == u2;
booleanb2 = u1 == u3;
System.out.println(b1);
System.out.println(b2);
}
}
執行結果：
什麼是物件的內容相等
通常情況下：物件內容相等需要符合兩個條件
1、物件的型別相同（可以使用instanceof操作符進行比較）：
2、兩個物件的成員變數的值完全相同；
例項說明：
class User{
Stringname;
intage;
//這裡的equals()方法是複寫Object裡面方法
publicboolean equals(Object obj){
if(this== obj){
returntrue;
}
booleanb = obj instanceof User;
if(b){
Useru = (User)obj;
if(this.age== u.age && this.name.equals(u.name)){
returntrue;
}
else{
returnfalse;
}
}
else{
returnfalse;
}
}
}
class Test{
publicstatic void main(String[] args) {
Useru1 = new User();
Useru2 = new User();
Useru3 = u1;
u1.name = "zhangsan";
u1.age = 12;
u2.name = "lisi";
u2.age = 12;
u3.name = "zhangsan";
u3.age = 12;
System.out.println(u1.equals(u2));
System.out.println(u1.equals(u3));
}
}
執行結果：
第45集
1、hashCode()的作用
2、hashCode()的實現方法
3、toString()的作用
4、toString()的實現方法
什麼是Hash演算法(瞭解)
實質：輸入一個任意長度的資料，通過Hsah演算法，得到一個唯一的雜湊值。
HashCode()複寫原則：如果兩個物件用equals相比是相等得，那麼這兩個物件呼叫HashCode()所返回的Hash值也應該是相等的
|
任意長度二進位制資料 |
|
雜湊值 |
|
Hash演算法 |
Hash演算法的特點
|
輸入1 |
|
雜湊值1 |
|
輸入2 |
|
雜湊值2 |
|
輸入3 |
|
雜湊值3 |
|
輸入4 |
|
雜湊值4 |
|
Hash演算法 |
例項說明：
class User{
String name;
int age;
public User(){
this.name= name;
this.age =age;
}
Public User
public boolean equals(Object obj){
if(this == obj){
return true;
}
boolean b = obj instanceof User;
if(b){
User u = (User)obj;
if(this.age == u.age&& this.name.equals(u.name)){
return true;
}
else{
return false;
}
}
else{
return false;
}
}
public int hashCode(){
int result = 17;
result = 31*result + age;
result = 31*result + name.hashCede();
return result;
}
}
Import java.util.*;
class Test{
publicstatic void main(String[] args) {
Useru = new User("zhangsan",12);
HashMap<User,String>map = new HashMap<User,String>;
map.put(u,"abc");
Strings = map.get(new User("zhangsan",12));
System.out.println(s);
}
}
執行結果：
Java當中的toString()函式
一下的程式碼執行的結果是什麼；
System.out.println(“abc”);
那麼下面的這兩行程式碼呢：
User u = new User();
Sysrem.out.println(u);
例項說明：
class User{
String name;
int age;
public User(){
}
public User(Stringname,int age){
this.name = name;
this.age = age;
}
public StringtoString(){
String result ="age:" + age+ "," + "name:" + name;
return result;
}
}
import java.util.*;
class Test{
publicstatic void main(String[] args) {
Useru = new User("zhangsan",12);
System.out.println(u);
}
}
執行結果：
第48集
Eclipse部分使用快捷鍵
1、Alt + / 程式碼助手功能
2、Ctrl + D刪除一行程式碼
3、Ctrl + Z 撤銷操作（Undo）
4、Ctrl + Y 恢復操作（Redo）
5、選單裡Source快捷生成構造方法（函式）、equals方法、hashCode方法、toString方法等。
6、註釋生成：
1）註釋一行程式碼：選中內容 + Ctrl +/ (也可以選中多行程式碼進行分別註釋)
2）註釋多行程式碼：選中內容 + Ctrl +Shift + /
解除註釋多行程式碼：選中內容 + Ctrl+ Shift + \(這是反斜槓)
7、Ctrl + Alt + 複製當前游標所在的一行程式碼（使用英特爾整合顯示卡及驅動的除外）。
第49集
程式碼的重構
1、重構可以改善軟體的設計
2、重構可以讓軟體更加容易理解
3、重構可以協助尋找bugs
4、重構可以提升開發速度
相關文章
- 印象筆記 --- 方法分享筆記筆記
- 筆記筆記
- CUUG筆記 ORACLE索引學習筆記筆記Oracle索引
- 主動筆記與被動筆記筆記
- 淘寶記錄筆記筆記
- 心情筆記筆記
- 命令筆記筆記
- 筆記：Docker筆記Docker
- Meteor筆記筆記
- ES筆記筆記
- AbstractQueuedSynchronizer筆記筆記
- Redis筆記Redis筆記
- new筆記筆記
- vio筆記筆記
- Liunx筆記筆記
- Nacos 筆記筆記
- oracle筆記Oracle筆記
- html 筆記HTML筆記
- Cookie筆記Cookie筆記
- jQuery筆記jQuery筆記
- docker 筆記Docker筆記
- Restful 筆記REST筆記
- kafka 筆記Kafka筆記
- 路由筆記路由筆記
- webSocket筆記Web筆記
- 筆記1筆記
- 筆記-FMDB筆記
- Scrum筆記Scrum筆記
- canvas筆記Canvas筆記
- 小馬筆記筆記
- 隨筆記筆記
- spark筆記Spark筆記
- mysql 筆記MySql筆記
- 筆記：JVM筆記JVM
- Servlet筆記Servlet筆記
- 夢筆記筆記
- GIF筆記筆記
- shell 筆記筆記