Java學習第六天_ZenDei技術網路在線

1.構造函數的作用：實現屬性的初始化使用構造函數實現成員變數的初始化非靜態成員變數隨著對象的常見才開闢空間，所以只能使用對象來訪問靜態成員變數，隨著類的載入而開闢空間，可以通過類直接訪問 2.static關鍵字： static修飾成員變數的特點： 1：static修飾的成員變數是隨著類的加 ...

1.構造函數的作用：
　　實現屬性的初始化
　　使用構造函數實現成員變數的初始化
　　非靜態成員變數隨著對象的常見才開闢空間，所以只能使用對象來訪問
　　靜態成員變數，隨著類的載入而開闢空間，可以通過類直接訪問

2.static關鍵字：

static修飾成員變數的特點：

1：static修飾的成員變數是隨著類的載入而在方法區中的靜態區開闢記憶體的
2：static修飾的成員變數是其所屬類的所有對象共用的
3：static修飾的成員變數可以通過類直接訪問，也可以通過對象訪問

缺點:占用記憶體時間太長(static修飾的變數存儲在方法區的靜態區中，直到程式結束才會釋放記憶體)

3.非靜態的方法：靜態的和非靜態的都能用
　靜態的先出現，非靜態的後出現，靜態的只能用靜態的
　靜態的優先於非靜態的開闢記憶體

4.靜態成員變數和非靜態成員變數對比：

1：訪問方式

靜態成員變數可以通過類名訪問，也可以通過對象訪問
非靜態成員變數只能通過對象來訪問

2：存儲位置

靜態成員變數是隨著類的載入在方法區的靜態區中開闢記憶體
非靜態成員變數是隨著對象的創建在堆中開闢記憶體

3：存儲數據

靜態成員變數存儲的是其所屬類的所有對象共用的數據
非靜態成員變數存儲的是其所屬類的每個對象特有的數據

4：生命周期

　　靜態成員變數是隨著類的載入在方法區的靜態區中開闢記憶體,程式退出時才釋放記憶體
　　非靜態成員變數是隨著對象的創建在堆中開闢記憶體，當對象被垃圾回收時才釋放記憶體

 1 class Student
 2 {
 3 　　String name; //非靜態成員變數 隨著對象的創建才開闢記憶體，所以只能使用對象來訪問
 4 　　static String country="CN"; //靜態成員變數,隨著類的載入而開闢記憶體，可以通過類直接訪問
 5 　　//非靜態方法:靜態和非靜態的都能使用
 6 　　public void study(){
 7 　　　　System.out.println("好好學習，天天向上"+name+","+country);
 8 　　}
 9 
10 　　public static void show()//靜態方法 Student.show(); 靜態的先出現，非靜態的後出現，靜態的只能使用靜態的
11 　　{
12 　　　　System.out.println("萬元戶"+name);//無法從靜態上下文中引用非靜態變數
13 　　}
14 }

1 public static void main(String[] args) 
2 public ：公共的
3 static：靜態成員變數是隨著類的載入在方法區的靜態區中開闢記憶體，程式退出時才釋放記憶體
4 void：說明該方法無返回值
5 String[] args：main方法的參數是一個字元串數組

main函數可以重載，只有public static void main(String[] args) 這樣的JVM才會識別為程式的入口，從而進入程式
由靜態可以通過類名調用，通過類名訪問可知，程式入口main()函數定義為static的原因為JVM直接調用類名.main自動運行程式

5.static 只能修飾成員變數、成員方法、內部類
　　1.什麼情況下使用static?

　　　什麼情況下需要把成員變數修飾為static?
　　　　　　當該成員變數的值需要被所有對象共用時，該變數的值在記憶體中只有一份
　　　什麼情況下需要把成員方法修飾為static？
　　　　　　當該方法沒有用到所在類的任何非靜態成員，因為靜態的只能用靜態的，只要方法用到了非靜態的就不能被修飾為static

6.記憶體：靜態成員變數是隨著位元組碼文件的載入載入到在方法區的靜態區中開闢記憶體，程式退出時才釋放記憶體
　　所以可以直接通過類名訪問

 1 class Person
 2 {
 3 　　int age;
 4 　　static String country="CN";
 5 
 6 　　Person(){}
 7 
 8 　　Person(int age){
 9 　　this.age=age;
10 　　}
11 
12 　　public static void show(Person person)//沒有用到本類中的非靜態成員變數,用到的是新的對象中的age屬性，和當前的show方法不是一個類中，所以可以是static的
13 　　{
14 　　　　System.out.println(person.age);
15 　　}
16 
17 　　public static int add(int a,int b)
18 　　{
19 　　　　return a+b;
20 　　}
21 }

7.靜態（static）的應用:工具類

　　讓類不能new對象，為了實現禁止創建對象
　　實現:private Array(){};//自定義構造方法，並且用private修飾

8.javadoc -d doc Array.java
　　//生成api（說明書）-d（路徑）doc(文件目錄) Array.java（要生成api的java源程式）
　　//類必須用public修飾

9.自定義的class類中定義的屬性，即成員變數，在堆中開闢記憶體空間，有預設值
　局部變數，在棧中開闢記憶體空間，沒有預設值，一般需要手動初始化

　靜態代碼塊:隨著類的載入而執行，只執行一次，因為.class文件只載入一次，優先於main的執行

1 class A
2 {
3 　　static int num=10;
4 　　static
5 　　{
6 　　System.out.println(num);
7 　　//靜態代碼塊
8 　　}
9 }

作用：可以把程式的初始化功能寫在靜態代碼塊中，隨著類的載入就同時執行了
應用場景1：對資料庫的連接操作可以寫進靜態代碼塊中

10.構造代碼塊：對象一創建就執行，優先於構造函數

　　作用:構造代碼塊用於定義所有對象共同的行為

 1 class Person
 2 {    
 3     String name;
 4     int age;
 5     {
 6         System.out.println("哈哈");
 7     }
 8     Person(String name,int age)
 9     {
10         this.name=name;
11         this.age=age;
12     }
13 }

11.對象初始化過程：
　　1.因為創建對象需要位元組碼，所以先載入Person.class到方法區
　　2.如果有靜態代碼塊執行靜態代碼塊
　　3.到堆中開闢記憶體
　　4.給成員變數賦預設值
　　5.如果有初始值，給成員變數賦初始值
　　6.執行構造代碼塊
　　7.執行構造函數
　　8.把對象在堆中的記憶體地址賦給棧中變數

12.單例設計模式：解決的是讓一個類在記憶體中只能有一個對象
　　1.要想讓一個類只有一個對象，首先這個類肯定不能new
　　2. 構造方法修飾為private,那麼一個對象都沒有了，只能在本類中創建對象
　　3.需要把這個對象提供給外界使用
　　（外部不能new，不能創建對象，但是在內部能new，能創建自己類型的成員的變數）

 1 單例模式-------餓漢式（實際中使用）    
 2 class Earth
 3 {
 4     private static Earth earth=new Earth();/*Earth類型的成員變數,這裡不能修飾為public，因為如果是public,則可以Earth.diqiu調用，但是如果    Earth.diqiu=null，則沒有對象了，不安全*/
 5     private Earth(){};
 6     //讓外界得到內部創建的對象
 7     public static Earth getIntet()
 8     {
 9     return earth;
10     }
11 }

 1 單例模式-------懶漢式（多線程中容易出現線程安全問題）
 2 class Earth
 3 {
 4     private static Earth earth=null;
 5     private Earth(){};
 6     //讓外界得到內部創建的對象
 7     public static Earth getIntet()//只有在初始化的時候才new對象
 8     {
 9         if (earth==null)
10     {
11         earth=new Earth();
12     }
13         return earth;
14     }
15 }

13.繼承：實現了代碼的重覆使用，使類和類之間產生了關係，被繼承的是父類，繼承的是子類
　單繼承：java中的繼承是單繼承的，一個類只能繼承另外一個類
　多繼承：一個類能繼承多個類(多繼承會出現調用的不確定性)
　　　方法：提取共同的屬性和行為，封裝到一個類中

 1 class A
 2 {
 3 　　public void show(){
 4 　　　　System.out.println("A");
 5 　　}
 6 }
 7 class B
 8 {
 9 　　public void show(){
10 　　　　System.out.println("B");
11 　　}
12 }
13 class C extends A,B{
14 
15 }
16 public static void main(String[] args)
17 {
18 　　C c = new C();
19 　　c.show(); //多繼承會出現調用的不確定性
20 }

　　

14.java支持多層繼承
　　class D(){}
　　class E extends D(){}
　　class F extends E(){}

15.繼承中成員變數的特點：

this:是一個引用，總是指向當前被使用的對象
super:不是引用，代表的是父類的數據空間，當子父類中出現同名現象時用來進行區分的

//具備相同的行為，只是行為的表現方式不同
//重寫，覆蓋

16重寫：子類和父類中出現了相同的方法，這種現象叫重寫，也叫覆蓋
　　　　當創建子類對象並調用重寫的方法時，執行的肯定是重寫以後的方法

1.子類在重寫時，方法的許可權必須大於等於父類中方法的許可權
2.private修飾的方法不能被重寫
3.父類中的方法是靜態的，子類重寫時也必須是靜態的