Java學習筆記
視頻課堂：https://edu.csdn.net/course/play/8222
JAVA學習之筆記(面向對象篇)
面向對象(上)
1、對于構造函數，如果聲明為public void structor()，則如果聲明該對象時不會調用該構造函數，如果聲明為public structor()，則對象會自動調用該構造函數
2、this的使用情況：在還沒聲明該對象卻要調用該對象時，其傳遞參數可用this；另外在構造函數中其傳遞的參數跟該類的成員變量相同時，為增加可讀性和區別成員變量可用this；
如果一個class有多個構造函數，其中在某個構造函數中需要調用另一個或幾個構造函數時可用諸如this()的形式來調用該類的構造函數，其中()中的內容可根據具體的參數調用相應的構造函數
3、垃圾回收，java中也有C++中析構函數的機制，其函數為public void finalize()，當對象被使用完畢需要通過System.gc()，讓編譯器啟動垃圾回收器
4、靜態成員變量的訪問方式有3種，通過類名訪問；通過對象名訪問；同一類中的成員函數也可以直接對該靜態變量進行訪問
5、靜態方法的訪問跟靜態變量的訪問類似：通過類名訪問；通過對象名訪問；對象中的成員函數訪問。
6、內部類：在類中直接定義的類，內部類可訪問其外部類中的成員變量，反之外部類不能訪問內部類中的成員。聲明為內部類的好處：代碼緊湊，程序更具模塊行
面向對象(下)
1、類的繼承
2、子類對象的實例化過程
3、finally關鍵字
4、抽象類
5、接口
面向對象(上)
1、對于構造函數，如果聲明為public void structor()，則如果聲明該對象時不會調用該構造函數，如果聲明為public structor()，則對象會自動調用該構造函數
2、this的使用情況：在還沒聲明該對象卻要調用該對象時，其傳遞參數可用this；另外在構造函數中其傳遞的參數跟該類的成員變量相同時，為增加可讀性和區別成員變量可用this；
如果一個class有多個構造函數，其中在某個構造函數中需要調用另一個或幾個構造函數時可用諸如this()的形式來調用該類的構造函數，其中()中的內容可根據具體的參數調用相應的構造函數
3、垃圾回收，java中也有C++中析構函數的機制，其函數為public void finalize()，當對象被使用完畢需要通過System.gc()，讓編譯器啟動垃圾回收器
4、靜態成員變量的訪問方式有3種，通過類名訪問；通過對象名訪問；同一類中的成員函數也可以直接對該靜態變量進行訪問
5、靜態方法的訪問跟靜態變量的訪問類似：通過類名訪問；通過對象名訪問；對象中的成員函數訪問。
//靜態成員變量實例
//靜態方法
//1、在靜態方法里只能直接調用同類中其它的靜態成員(包括變量和方法),而不能直接訪問類中的非靜態成員。這是因為，對于非靜態的方法和變量，需要先創建類的實例對象后才可使用，而靜態方法在使用前不用創建任何對象。
//2、靜態方法不能以任何方式引用this和super關鍵字。與1的道理一樣，因為靜態方法在使用前不用創建任何實例對象，當靜態方法被調用時，thsi所引用的對象根本就沒產生。
//3、main()方法是靜態的，因此JVM在執行main方法時不創建main方法所在的類的實例對象，而已在main()方法中，我們不能直接訪問該類中的非靜態成員，必須創建該類的一個實例對象后，才能通過這個對象去訪問類中的非靜態成員。
class Chinese
{
//static Chinese objRsf = new Chinese(); //看看與下面一句二者的區別
Chinese objRsf = new Chinese();?? //在該類的內部創建一個對象，以防止其它類創建該類的對象，前提是該類的構造函數為private，如果外面要訪問該對象，則需要定義一個供外部訪問的方法，且該方法又必須為靜態的，因為外部訪問它時還沒有被創建
//private int count=0;
private static int count=0; //統計一共創建了多少個實例對象，實驗：如果將static去掉，則結果始終是1
static String country="中國"; //若定義為 private static Stringcountry="中國"; 則在其它類不能進行訪問
static //靜態代碼塊：在裝載時只被執行一次
{
count=2;
System.out.println("Static Code!");
}
String name;
intage;
public static Chinses getInstance() //聲明一個可供外部訪問的靜態方法，好處是無論外部怎樣訪問都只生成一個對象實例，該方法產生了另一個問題，因為是靜態的，不能訪問其非靜態的方法，即不能訪問Chinese()，所以需要聲明為：static Chinese objRsf = new Chinese();
{
return objRsf; //返回一個對象
}
public Chinese()
{
//count++;
System.out.println(++count);
}
static void sing() //聲明一個靜態方法
{
System.out.println("啊");
}
voidSingOurCountry()
{
System.out.println(country);
sing();
}
}
class Test Chinese
{
public static void main(String [] args)
{
System.out.println(Chinese.country);
Chinese ch1 = new Chinese();
ch1.SingOurCountry(); //靜態成員變量可以通過類名或對象名來訪問，同一類中的成員函數也可以直接對該靜態變量進行訪問
System.out.println(ch1.Country);
Chinese.sing(); //類名訪問靜態方法
System.out.println("begin");//靜態代碼塊在用到的時候進行加載
newChinese().sing(); //對象訪問靜態方法
System.out.println("end);
newChinese().SingOurCountry();//成員函數訪問靜態方法
newChinese(); //1
newChinese(); //2
newChinese(); //3
Chinese obj1 = Chinese.getInstance(); //在其它類中訪問該對象
Chinese obj2 = Chinese.getInstance();
System.out.println(obj1==obj2); //比較obj1和obj2是不是屬于同一個對象，結果是同一對象，但有一個潛在的問題是，
//如果在classChinese中聲明為ChineseobjRsf = new Chinese();則在多次創建時將被重復創建該對象產生一個循環，直到內存被耗盡
}
}
//單態設計模式：即在程序中只允許產生一個對象，那樣的話，需要把構造函數設為private
6、內部類：在類中直接定義的類，內部類可訪問其外部類中的成員變量，反之外部類不能訪問內部類中的成員。聲明為內部類的好處：代碼緊湊，程序更具模塊行
//內部類實例：內部類中成功調用外部內中的變量，而外部類不能訪問內部類變量
//內部類好處：代碼緊湊，程序更具模塊性；最大的好處是如果聲明為兩個類，其中一個類要訪問另一個類的成員變量卻無能為力
//解決方法是需要在訪問類中設置一個訪問被訪問類的方法Inner
class Outer
{
intouter_i=100;
voidtest()
{
Inner in=new Inner();
in.display();
}
/*static*/ class Inner //加上static關鍵字后相當于是一外部類，則不能在訪問其內部類
{
void display()
{
System.out.println("outer_i-" + outer_i); //內部類中可以訪問外部類中的成員變量
}
}
public static void main(String [] args)
{
Outer outer = new Outer();
outer.test();
}
}
//不使用內部類的情況，則需要在訪問類中設置一個訪問被訪問類的方法Inner
/*class Outer
{
intouter_i=100;
voidtest()
{
Inner in=new Inner(this);
in.display();
}
public static void main(String [] args)
{
Outer outer = new Outer();
outer.test();
}
}
class Inner
{
Outer outer;
public Inner(Outer outer)
{
this.outer=outer;
}
voiddisplay()
{
System.out.println("outer_i-" + outer.outer_i); //內部類中可以訪問外部類中的成員變量
}
}
*/
//如果函數的局部變量(函數的形參也是局部變量)，內部類的成員變量，外部類的成員變量重名，我們應該按下面的程序代碼所使用的方式來明確指定我們真正要訪問的變量
public class Outer
{
private int size;
public class Inner
{
private int size;
public void doStuff(int size)
{
size++ ; //引用的是doStuff函數的形參
this.size++; //引用的是Inner類中的成員變量
Outer.this.size ; //引用的是Outer類中的成員變量
}
}
}
//內部類如何被外部類引用
class Outer
{
private int size=10;
public class Inner
{
public void doStuff()
{
System.out.println(++size);
}
}
}
public class TestInner
{
public static void main(String [] args)
{
Outer outer=new Outer();
Outer.Inner inner=outer.new Inner();
inner.doStuff();
}
}
//方法中定義的內部類嵌套類并非只能在類里定義，也可以在幾個程序塊的范圍之內定義內部類。比如，在方法中，或甚至在for循環體內部，都可以定義嵌套類，例如：
//該變量盡管是在一個方法中被定義，但是卻不能被訪問，因此在方法中定義的內部變量類中能訪問方法中的final類型的局部變量，因為用final定義的局部變量相當于是一個常量，
//它的生命周期超出了方法運行的生命周期
class Outer
{
intouter_i=100;
voidtest()
{
/*final*/ int x ; //需要在此加上final后才能在該方法的內部類中訪問局部變量x，另外在方法中的該局部變量需要被初始化
class Inner
{
void display()
{
System.out.println("outer_i = " + outer_i);
System.out.println(x); //去掉final后運行結果會報錯
}
}
Inner in = new Inner();
in.display();
}
public static void main(String [] args)
{
Outer outer=new Outer();
outer.test();
}
}
7、java的文檔注釋
//java的文檔注釋，java中支持3種形式的注釋，其中一種被稱為文檔注釋，它以"/**"開始，"*/"結尾，文檔注釋提供將程序使用的幫助信息嵌入到程序中的功能，
//開發者可以使用javadoc工具將這些信息取出，然后轉換成html說明文檔，由此可見文檔注釋提供了編寫程序文檔的便利方式。
//
在html中邊換行，@標注會自動換行
import java.io.*;
/**
*Title: engineer類
*Description: 通過engineer類來說明java中的文檔注釋
*Copyright:(c)2003 www325.com
*Company: XXX公司
*@Author: XXX //標記參數，是固定格式
*@Version 1.00
*/
public class engineer //注：新建的類為public，其源文件名字也必須是engineer
{
public String Enginerr_name;
/**
*這是engineer的構造函數
*@param name engineer的名字
*/
public engineer(String name)
{
}
/**
*這是repairing方法的說明
*@param sum需要修理的機器總數
*@param alltime需要修理的總時間
*@return Repairing的數量
*/
public int repairing(int sum, int alltime)
{
}
}
//命令格式：-d directory 默認情況下不生成author和version,所以需要把這兩個加進去
//javadoc -d engineer -author -version engineer.java
面向對象(下)
1、類的繼承
*通過繼承可簡化類的定義
*java只支持單繼承不允許多重繼承
*可以有多層繼承，即一個類可以繼承某一個類的子類，如B繼承了類A，類C又可以繼承類B，那么類C也間接繼承了類A
*子類繼承父類所有的成員變量和成員方法，但不繼承父類的構造方法。在子類的構造方法中可使用語句super(參數列表)調用父類的構造方法
*如果子類的構造方法中沒有顯示地調用父類構造方法，也沒有使用this關鍵字調用重載的其它構造方法，則在產生子類的實例對象時，系統默認調用父類無參數的構造方法.
2、子類對象的實例化過程
*分配成員變量的存儲空間并進行默認的初始化，就是用new關鍵字產生對象后，對類中的成員變量按第三章的表3.1中的對應關系對對象中的成員變量進行初始化
*綁定構造方法參數，就是new Person(實際參數列表)中所傳遞進的參數賦值給構造方法中的形式參數變量
*如有this調用，則調用相應的重載構造方法(被調用重載構造方法又從步驟2開始執行這些流程)，按調用的重載構造方法的執行流程結束后，回到當前構造方法，當前構造方法直接跳到步驟6執行
*顯式或隱式追溯調用父類的構造方法(一直到Object類為止，Object是所有java類的最頂層父類)，父類的構造方法又從步驟2開始對父類執行這些流程，父類的構造方法的執行流程結束后，回到當前構造方法，當前構造方法繼續往下執行
*進行實例變量的顯式初始化操作，也就是執行在定義成員變量時就對其進行賦值的語句，如：這個圖需要畫出來在教材中
*執行構造方法中的程序代碼
3、finally關鍵字
*如果在類前加上了finally則不能被繼承，成員變量定義成finally子類中不能在對其進行賦值，方法中被定義成finally則在子類中不能對其覆蓋，不能再進行改寫，final定義的常量不能在其它方法中進行賦值
4、抽象類
java中可以定義一些不含方法體的方法，它的方法體實現交給該類的子類根據自己的情況去實現，這樣的方法就是抽象方法，包含抽象方法的類就是抽象類
*抽象類和抽象方法都必須用abstract關鍵字來修飾
*抽象類不能被實例化，也就是說不能用new關鍵字去產生對象
*抽象方法只需聲明，而不需實現
*含有抽象方法的類必須被聲明為抽象類，抽象類的子類必須覆蓋所有的抽象方法后才能被案例化，否則這個子類還是個抽象類
5、接口
如果一個抽象類中的所有方法都是抽象的，我們就可以將這個類用另外一種方法來定義，也就是接口的定義。接口是抽象方法和常量值的集合，從本質上講
接口是一種特殊的抽象類，這種抽象類中只包含常量和方法的定義，而沒有變量和方法的實現
*接口中的成員都是public訪問類型的。接口里的變量默認是用public static finall標識的
*我們可以定義一個新的接口用extends關鍵字去繼承一個已有的接口
*我們也可以定義個類用implements關鍵字去實現一個借口中的所有方法，還可以去定義一個抽象類用implements關鍵字去實現一個接口中定義的部分方法
*一個類可以繼承一個父類的同時，實現一個或多哥接口，extends關鍵字必須位于implemnets關鍵字之前
代碼解釋要點：
//類與繼承實例
//繼承的特點：可以簡化類的定義，java中只支持單繼承不允許多重繼承
class Person
{
public final String x; //定義為final的常量除了在此處和構造函數中賦初值外，不能在其它地方被賦值，否則編譯會報錯
/*public static final String x="abc"; */ //另外對于該常量的引用，如果要調用它時，需要首先創建一個對象，如果不創建對象也希望調用它則在final前需要聲明為static，這樣就可以直接在用classname.varible格式對其訪問
//如果這樣，則不能在構造函數中對其賦值了，而只能在開始聲明的時候進行賦初值，因為在構造函數中賦值的話，調用構造函數的時候，首先會生成一個對象，而此時該static final常量還沒賦值所以會報錯
public String name="unknown";
public int age=-1;
public Person()
{
x="abc"; //因不知道調用者調用哪個構造函數，所以2個構造函數都被賦初值
}
public Person(String name, int age) //子類不會繼承父類的構造方法，如果不定義則編譯器會自動增加一個不帶參數的構造方法，如果自己增加了則編譯器不會再增加
{
x="abc";
this.name = name;
this.age = age;
}
public void getInfo()
{
System.out.println("name=" +name+",age=" +age);
}
}
class Student extends Person
{
public String school="unknown";
public Student() //默認情況下在它調用父類之前會調用此默認構造函數，調用該構造函數之前又會去調用父類的默認構造函數，而此時開發人員已編寫了一個帶參數的父類構造函數，所以編譯器會報錯
{
super(); //編譯器默認調用的為super()，即無參的構造函數
/*super("zhangsan", 15);*/ //super表示明確要調用父類的構造函數，此時編譯器不會再報錯
}
/*public Student(String name, int age)
{
super(name, age);
}*/
public Student(String name, int age, Stringschool)
{
/*this(name, age);*/ //如果有this()調用則要先執行該類中的Student(Stringname, int age)函數
/*this.name=name; //表明繼承了父類的age和name，如果這個2個成員變量為私有的話，就不能這樣賦值
this.age=age;*/
super(name, age); //繼承用父類的name, age
this.school = school;
}
public void getInfo()
{
System.out.println("school = " + school+ ", name ="+name+ ", age= " +age);
super.getInfo(); //明確調用父類的getInfo
}
/*public String name;
public int age;
public void getInfo()
{
}*/
public void study()
{
}
}
class TestStudent
{
public static void main(String [] args)
{
Student st = new Student("zhangsan", 20, "清華大學"); //調用的是子類中的getInfo而非父類中的
/*st.name = "zhangshan";
st.age = 20;*/
st.getInfo();
System.out.println(float.MAX_VALUE); //在float類中MAX_VALUE就被聲明為 public static finall floatMAX_VALUE
}
}
//抽象類和抽象方法
abstract class A //不是抽象類中所有的方法都是抽象方法，但只要有一個是抽象方法則該類必須為抽象類
{
abstract int aa(int x, int y); //注：定義抽象方法直接用";"結束
/*public static void main(String [] args)
{
A a= new A(); //抽象類中不能被實例化
}*/
}
class B extends A
{
intaa(int x, int y) {return 1; }
}
Java
版權聲明：本文內容由網絡用戶投稿，版權歸原作者所有，本站不擁有其著作權，亦不承擔相應法律責任。如果您發現本站中有涉嫌抄襲或描述失實的內容，請聯系我們jiasou666@gmail.com 處理，核實后本網站將在24小時內刪除侵權內容。
相關文章
