java面向對象，final，super ，抽象類，重寫，代碼塊，static，this，構造方法，堆棧
在jvm內存中主要分布有以下三個區域：
棧：存放基礎數據和自定義對象的引用
堆：主要存儲創建的對象，即new出來的對象
方法區：加載存放class文件（字節碼文件）
什麽是封裝？
封裝是指隱藏對象的屬性和實現細節，僅對外提供公共訪問方式。
封裝的優點：
隱藏代碼的實現細節，提高安全性。
private 私有屬性：（調用屬性先執行提供的get或set方法）
私有屬性：
class Person { //姓名 private String name; //年齡 private int age; //對外提供公共的訪問方式，編寫set和get方法View Codepublic void setAge(int _age){ if(_age>0 && _age < 120){ age = _age; }else{ System.out.println("年齡不符合常理，請重新設置！"); } } public int getAge(){ return age; } public void setName(String _name){ name= _name; } public String getName(){ return name; } }
基本數據類型的參數傳遞，值傳遞：（值不會受到影響）
/* 基本數據類型的參數傳遞，值傳遞 */ public class ParamTest01{ public static void m1(int i){ i = i + 1; System.out.println("m1方法中的i=" + i);//11 }public static void main(String[] args){ int i = 10; m1(i); System.out.println("main方法中的i=" + i);//10 } }
引用數據類型傳遞，傳遞的是引用傳遞（值會改變）
/* 引用數據類型的參數傳遞，傳遞的引用，引用傳遞 */ public class AnimalTest01 { public static void m1(Animal a){ int age = a.getAge(); a.setAge(++age); System.out.println("m1方法中的age=" + a.getAge());//11 } public static void main(String[] args) { Animal a = new Animal(); a.setAge(10); m1(a); System.out.println("main方法中的age=" + a.getAge());//11 } }
構造方法：
對象被創建時會執行
構造方法（constructor），有的地方叫做構造器或者構造函數。
構造方法的作用是給對象數據進行初始化。
構造方法格式特點
1.方法名與類名相同(註意大小寫也要與類名一致)
2.沒有返回值類型
3.沒有void修飾
4.沒有具體的返回值return;
5.如果一個類沒有提供任何構造方法，系統默認提供無參數構造方法
6.如果一個類已經手動的提供了構造方法，那麽系統不會再提供任何構造方法。
定義構造方法
class User{ private String name; private int age; //構造方法，最好手動編寫一個無參的構造方法 public User(){ System.out.println("構造方法"); } public User(String _name, int _age){ name = _name; age = _age; } public String getName(){ return name; } public void setName(String _name){ name = _name; } public int getAge(){ return age; } public void setAge(int _age){ age = _age; } }View Code
調用
public class UserTest01 { public static void main(String[] args) { User u = new User(); //u.User();不能手動調用構造方法 /* User u = new User("趙六",20); System.out.println(u.getName()); System.out.println(u.getAge()); */ } }View Code
通過this 關鍵字（指代當前類） 實例對象調時 值顯示對象傳入的值 （註意：java中就存在近原則）
實例View Code
static（修飾類的變量，和對象沒有關系）
可以修飾變量，被static修飾的變量叫做靜態變量，
程序運行時靜態變量存放在方法區裏面，因此，靜態變量在類加載階段賦值，並且只賦值一次。
class Employee{ private String name; static String company = "阿裏巴巴"; public String getName() { return name; } public void setName(String name) { this.name = name; } } public class StaticTest01 { public static void main(String[] args){ Employee e = new Employee(); System.out.println(e.company);//開發中不建議這樣使用 e = null; System.out.println(e.company);//不報錯，static修飾的變量跟對象沒有關系 System.out.println(Employee.company);//開發中建議這樣寫，使用類名.靜態變量名的方式訪問靜態變量 } }View Code
static可以修飾方法，被static修飾的方法叫做靜態方法，（修飾方法，和對象沒有關系）
不用創建對象就能能直接訪問該方法，即使用類名.靜態方法名的方式。
靜態方法不能訪問非靜態的數據（調用非靜態方法也不可以），靜態方法不能使用this。
public class StaticTest02{ int i; public void m1(){ System.out.println("m1方法"); } public static void m2(){ //m1();//error靜態方法不能引用非靜態方法 //System.out.println(i);//error靜態方法不能引用非靜態變量 System.out.println("靜態方法m2"); } public static void main(String[] args){ StaticTest02 st = new StaticTest02(); st.m1(); m2();//靜態方法可以直接調用靜態方法 StaticTest02.m2();//開發中建議這樣使用 st = null; st.m2();//開發中不建議這樣使用，靜態方法跟對象無關 } }View Code
static可以定義靜態語句塊，靜態語句塊在類加載階段執行，並且只執行一次，並且是自上而下的順序執行，在構造方法之前執行。
public class StaticTest03{ //靜態語句塊中的內容只會執行一次 static{ System.out.println("靜態語句塊1"); } static{ System.out.println("靜態語句塊2"); } static{ System.out.println("靜態語句塊3"); } public StaticTest03(){ System.out.println("構造方法"); } public static void main(String[] args){ System.out.println("main方法1"); System.out.println("main方法2"); new StaticTest03(); new StaticTest03(); } }View Code
代碼塊
局部代碼塊，在方法中出現，限定變量生命周期，及早釋放，提高內存利用率
構造代碼塊，在類中方法外出現；多個構造方法方法中相同的代碼存放到一起，每次調用構造都執行，並且在構造方法前執行
靜態代碼塊， 在類中方法外出現，並加上static修飾；用於給類進行初始化，在加載的時候就執行，並且只執行一次。一般用於加載驅動。
同步代碼塊(後面多線程部分會講解)
public class BlockTest01 { public static void main(String[] args) { //局部代碼塊 { int x = 10; System.out.println(x); } //System.out.println(x); Student s1 = new Student(); System.out.println("------------"); Student s2 = new Student(); } static{ System.out.println("BlockTest01中的靜態代碼塊"); } } class Student { public Student(){ System.out.println("構造方法"); } //構造代碼塊 { System.out.println("構造代碼塊"); } static{ System.out.println("靜態代碼塊"); }View Code
先執行靜態代碼塊 局部代碼塊 構造代碼 構造方法
繼承：extends
子類不能訪問父類中private修飾的方法
public class Test01 { public static void main(String[] args) { SubClass s = new SubClass(); s.m1(); //s.m2();//error子類不能訪問父類中private修飾的方法 s.m3(); s.m0();//子類可以訪問到其祖先類的方法 } }
重寫，也叫做覆蓋，當父類中的方法無法滿足子類需求時，子類可以將父類的方法進行重寫編寫來滿足需求。比如孩子繼承了父親的房子，可以將房子重新裝修。
方法重寫的條件：
- 兩個類必須是繼承關系
- 必須具有相同的方法名，相同的返回值類型，相同的參數列表.
- 重寫的方法不能比被重寫的方法擁有更低的訪問權限。
- 重寫的方法不能比被重寫的方法拋出更寬泛的異常。
- 私有的方法不能被重寫。
- 構造方法無法被重寫，因為構造方法無法被繼承。
- 靜態的方法不存在重寫。
- 重寫指的是成員方法，和成員變量無關。
super 關鍵字 調用父類方法 或 變量
public class Dog extends Animal { public String name = "旺財"; public void eat(){ System.out.println("吃狗糧"); } public Dog(){ //super("土豪金","藏獒");super() System.out.println("Dog中的無參構造方法"); } public void m1(){ System.out.println(super.name); System.out.println(this.name);//可以不加this super.eat(); this.eat();//可以不加this } }
多態： 不同實例調用相同方法時返回值卻不相同
public class AnimalTest01 { public static void main(String[] args) { Cat c1 = new Cat(); c1.eat(); Animal a1 = new Cat();//父類引用指向子類對象，自動類型轉換，也叫做向上轉型 a1.eat();//動態綁定和靜態綁定 //System.out.println(a1.num);//結果10，說明成員變量不存在重寫 //a1.move(); Cat c2 = (Cat)a1;//強制類型轉換，也叫做向下轉型 c2.move(); Animal a2 = new Dog(); if(a2 instanceof Cat){ Cat c4 = (Cat)a2; }else{ System.out.println("a2不是Cat類型"); } //Cat c3 = (Cat)a2;//error ClassCastException類轉型錯誤 } }View Code
成員變量不存在重寫
final：
final修飾的類無法被繼承。
final修飾的方法無法被重寫。
final修飾的局部變量，一旦賦值，不可再改變。
final修飾的成員變量必須初始化值。
public class FinalTest01{ public final int k = 10; //常量，標識符大寫 public static final double PI = 3.14; public static void main(String[] args){ /* final int i = 10; i = 20; */ } }
final修飾的基本數據類型，值不能改變
final修飾的引用數據類型，指向地址是不能改變的，但是對象裏面的值是可以改變的
抽象類：abstract
public abstract class A{ public A(){ System.out.println("class A"); } //抽象方法 public abstract void m1(); public static void main(String[] args){ //A a = new A();//抽象類不能被實例化 A a = new B(); a.m1(); } } class B extends A{ public void m1(){ System.out.println("class B中的m1方法"); } public B(){ super(); System.out.println("class B"); } }
java面向對象，final，super ，抽象類，重寫，代碼塊，static，this，構造方法，堆棧