java的三大特性

ava三大特性： 
封裝:

抽象:處理各類問題的第一步，把具體的問題與解決問題的方法結合起來，這就是抽象的過程.

Java常見的訪問控制修飾符:

Public ：處處均可以訪問，不受包和父子類關係的限制 

默認: 只在同包內能夠訪問，不受父子類關係限制

Protected: 不一樣包的子類和同包的類中訪問，這是一種繼承訪問。

Private：只有本身類內部能訪問，其餘部分不管包內外，父子類都不能訪問

Final:修飾屬性：常量，值不能被修改

              要麼在聲明時候賦值，要麼在構造方法中賦值，兩次機會只能選取一次。

修飾方法 ：final方法子類不能將其重寫



     修飾類：該類不能有子類

Static：修飾屬性:靜態屬性是類全部實例共有，能夠用」類名.屬性」的方式訪問,對於數值型變量，系統會給定初始值，不強制要求賦初始值.

      方法：能夠用」類名.屬性」的方式訪問,方法也爲類的全部實例所共有

      代碼塊 : 加載的優先級最高，甚至比主方法的加載還要早.

對於由final static共同修飾的變量，賦值的機會有兩個，一是在聲明的時候，二是在靜態代碼塊中，兩次機會有且只能有一次被選擇.



繼承: 

容許存在父子類的關係，一個子類有且只有一個直接的父類(Java中的繼承是類之間的單繼承.)

     當在內存造成類的信息綁定的時候不會出現多個交叉點，結構的清晰程度較高.Java自己的運行效率較低，只能達到C語言的五分之一.Java語言捨棄效率的完美要求，換來學習和使用的簡單.

     屬性的遮蓋: Father f = new Son(); 屬性訪問到的是父類的，方法訪問到的是子類的.

     方法的重載 :在類的內部一種方法出現多種表達方式，如參數表的不一樣,構造方法的重載

     方法的重寫:發生在父子類之間，子類方法對父類的方法有新的實現方法，但兩個方法定義部分徹底一致.



     繼承的目的: 實現代碼的複用.理順類型對象之間的結構關係.

     構建一個父類的時候，要求他的子類與父類必須有理論上的確實的繼承關係

     代碼複用的方法： 

繼承複用,徹底的將父類非私有部分做爲子類的內容，若需變化，子類只要重寫父類的同名方法便可。

     組合複用：選取某個類型中的一個對象的方法實現做爲該類的方法實現過程，這兩個類也稱爲理論父類和理論子類. 程序中是不出現extends關鍵字對兩個類關係的描述的.



經過具體實例抽象出父類的過程稱爲泛化

經過父類來確認子類的過程稱爲特化.

在代碼的類之間關係的設計階段，理論上要求父子類之間沒有相同的同名方法.但語法容許子類重寫父類的方法.要求子類當中只有本身特有的方法和屬性，其餘部分與父類和其餘同級子類相同的部分都從父類繼承得來.

有關抽象類:

抽象類是用於描述天然界中層級較高的對象類，人們沒法對一個抽象類實例化，如動物。只能用一個動物類的子類對抽象類的對象進行實例化。

抽象修飾符abstract 能夠修飾類，修飾方法。

抽象類中能夠定義非抽象的方法，但若是一個類中有抽象方法，則這個類必須被定義成抽象類。抽象類中有構造方法，可是沒有抽象的構造方法。構造方法的存在徹底是爲了繼承關係而存在。

與之造成對比的就是接口，接口中的全部方法要求定義成公開抽象方法，由於這些方法所表示的就是標準，標準的信息必須作到公開化，透明化，例如體育競賽中的規則。

抽象類與接口之間的對比：接口與抽象類本質上是兩個概念，但能夠將接口看做是一個抽象層級比抽象類更高的特殊類。因爲接口的信息中只有已知不可變
值以及抽象方法，因此信息的綁定方式單一，從實現上能夠知足繼承但也不會出現網狀的信息綁定效果，不會增長訪問時的節點數。所以接口容許多繼承。

對於類的內容，不容許多繼承，一個子類只能有一個直接的父類，信息綁定的複雜性加上Java自己運行原理的限制，使它不能像C語言同樣高效的運行，若綁定的信息複雜度較高，數據的訪問過程更加複雜，影響運行效率。

抽象類就是類，接口就是接口，都處於較抽象的層級而使它們具備相近的特性。(接口能夠當作是一個特殊的抽象類)

多態: 一個接口多種實現,能夠理解爲一種語法上的容許，表現形式多樣。如下的代碼表達均可以認爲是Java多態性的具體表現:

IA ia = new TestIA(); 其中IA爲定義的接口，TestIA爲接口的實現類

Father f = new Son()  其中Father爲父類，Son爲子類

Animal a = new Dog() 其中Animal爲抽象類,Dog爲Animal類的子類.

父子類中的方法重寫

一個類中的方法重載



Java中的多態基本上是由接口實現的，抽象類與子類之間的多態只佔一少部分，接口是在Java中抽象層級最高的一類,其內部的定義是純抽象的，屬性的定義是公開靜態常量,純抽象的方法和常量屬性構成一個標準，其全部的實現類，包括抽象類都要遵照接口中定義的規則。

Java類中的通訊方式最好是以接口的形式進行值或對象的傳遞，如燈泡與檯燈的關係。不管將何種類型的對象做爲參數，只要是接口對象的一個實現類，就能夠成爲一個合理的參數。

將兩個模塊的內容以接口的方式進行通訊，可使兩個模塊的開發方式相對獨立，不依賴於任何一個模塊的已實現的信息。造成在代碼設計中要求的鬆藕合狀態。

對於多態沒必要要下明確的定義，只須要理解它的表現形式以及意義，代碼中徹底實現鬆藕合的接口方式通訊的可能性基本爲零，但要求儘可能實現。

接口的存在表面上是實現一種多態語法，其實是實現了Java中的多繼承方式，一個類能夠同時繼承一個類，並實現另外一個或多個接口，以同時得到多個類型的信息（包括屬性和方法）。

   其餘的邊緣知識點:

有關Java的垃圾回收機制:

虛擬機給程序員提供一個統一的編程接口（API），程序員只需按API中的規定進行編程。與C和C++最大的不一樣是，Java中不須要考慮內存的回收，虛擬機會以延時的方式對垃圾進行回收，以達到對內存空間的最大利用。

Java中有多種垃圾回收的方法，但每一中方法都只是對要回收的內容進行提醒式的說明，並不是操做虛擬機進行回收.如System.gc()方法，
是系統提供的回收垃圾的常見方式，但當對象的取值爲null的時候，gc（）方法並非當即將內存空間釋放，只是null的取值提醒虛擬機，該對象的內容
能夠被回收。

程序員沒法控制Java虛擬機的垃圾回收時間點，只能盡到提示的責任，但多數狀況下，虛擬機的垃圾回收區的自動運行可以知足系統運行的須要。

在程序運行的過程當中，能夠會報出與虛擬機堆棧溢出的相關信息，此類錯誤都是與虛擬機運行過程當中的數據結構有關，是人力不能保證不發生的錯誤,多數
狀況下，程序中拋出虛擬機異常後，只需從新啓動虛擬機或從新編譯相對應的Java代碼便可，只有少數狀況須要重啓PC以及其它相關部件。
----------------------------

Java語言的三大特性便是：封裝、繼承、多態

封裝：
首先，屬性可用來描述同一類事物的特徵，方法可描述一類事物可作的操做。封裝就是把屬於同一類事物的共性（包括屬性與方法）歸到一個類中，以方便使用。
1. 概念：封裝也稱爲信息隱藏，是指利用抽象數據類型將數據和基於數據的操做封裝在一塊兒，使其構成一個不可分割的獨立實體，數據被保護在抽象數據類型的內部， 儘量地隱藏內部的細節，只保留一些對外接口使之與外部發生聯繫。系統的其餘部分只有經過包裹在數據外面的被受權的操做來與這個抽象數據類型交流與交互。 也就是說，用戶無需知道對象內部方法的實現細節，但能夠根據對象提供的外部接口(對象名和參數)訪問該對象。
2.好處：(1)實現了專業的分工。 將能實現某一特定功能的代碼封裝成一個獨立的實體後，各程序員能夠在須要的時候調用，從而實現了專業的分工。(2)隱藏信息，實現細節。經過控制訪問權限 能夠將能夠將不想讓客戶端程序員看到的信息隱藏起來，如某客戶的銀行的密碼須要保密，只能對該客戶開發權限。

繼承：
就是個性對共性的屬性與方法的接受，並加入個性特有的屬性與方法
1.概念：一個類繼承另外一個類，則稱繼承的類爲子類，被繼承的類爲父類。
2.目的：實現代碼的複用。
3. 理解：子類與父類的關係並非平常生活中的父子關係，子類與父類而是一種特殊化與通常化的關係，是is-a的關係，子類是父類更加詳細的分類。如 class dog extends animal,就能夠理解爲dog is a animal.注意設計繼承的時候，若要讓某個類能繼承，父類需適當開放訪問權限，遵循里氏代換原則，即向修改關閉對擴展開放，也就是開-閉原則。
4.結果：繼承後子類自動擁有了父類的屬性和方法，但特別注意的是，父類的私有屬性和構造方法並不能被繼承。
另外子類能夠寫本身特有的屬性和方法，目的是實現功能的擴展，子類也能夠複寫父類的方法即方法的重寫。

多態：
多態的概念發展出來，是以封裝和繼承爲基礎的。
多態就是在抽象的層面上實施一個統一的行爲，到個體（具體）的層面上時，這個統一的行爲會由於個體（具體）的形態特徵而實施本身的特徵行爲。（針對一個抽象的事，對於內部個體又能找到其自身的行爲去執行。）
1.概念：相同的事物，調用其相同的方法，參數也相同時，但表現的行爲卻不一樣。
2. 理解：子類以父類的身份出現，但作事情時仍是以本身的方法實現。子類以父類的身份出現須要向上轉型(upcast)，其中向上轉型是由JVM自動實現的， 是安全的，但向下轉型(downcast)是不安全的，須要強制轉換。子類以父類的身份出現時本身特有的屬性和方法將不能使用。

用java作一個簡單計算器；

import java.io.*;

class OperationAttridute

{

       private double numberA=0;

       private double numberB=0;

       private double result=0;

       public double setNumberA(double i)

       {

              return numberA=i;

       }

       public double getNumberA()

       {

              return numberA;

       }

       public double setNumberB(double j)

       {

              return numberB=j;

       }

       public double getNumberB()

       {

              return numberB;

       }

       public double setResult(double z)

       {

              return result=z;

       }

       public double getResult(double a,double b)

       {

              return result;

       }

}

//將要運算的2個數字和運算結果進行封裝。

class OperationA extends OperationAttridute

{    

       public double getResult(double a,double b)

       {

              double result=0;

              result=a+b;

              return result;

       }    

}

//加法類：繼承OperationAttridute類而且覆蓋其getResult方法

class OperationS extends OperationAttridute

{

       public double getResult(double a,double b)

       {

              double result=0;

              result=a-b;

              return result;

       }

}

//減法類：繼承OperationAttridute類而且覆蓋其getResult方法

class OperationM extends OperationAttridute

{

       public double getResult(double a,double b)

       {

              double result=0;

              result=a*b;

              return result;

       }

}

//乘法類：繼承OperationAttridute類而且覆蓋其getResult方法

class OperationD extends OperationAttridute

{

       public double getResult(double a,double b)

       {

              double result=0;

              if(b==0)

              {

                     Throw new RuntimeException(「被除數不能爲0」);

              }

              result=a/b;

              return result;

       }

}

//除法類：繼承OperationAttridute類而且覆蓋其getResult方法，除法要對被除數進行判斷並拋出異常

class Operationdo

{

       public static Object expression_r(char r)

       {

              OperationAttridute oa=new OperationAttridute();       

              switch(r)

              {

                     case '+':

                     oa=new OperationA();                

                     break;

                     case '-':

                     oa=new OperationS();                 

                     break;

                     case '*':

                     oa=new OperationM();         

                     break;

                     case '/':

                     oa=new OperationD();         

                     break;                  

              }

              return oa;             

       }

}

//運算類：經過傳進來的參數，來調用運算方法

class Account

{

       public static void main(String []args)throws Exception

       {

              char r='*';                   

              OperationAttridute oa=(OperationAttridute)Operationdo.expression_r(r);

              double a=oa.setNumberA(9);

              double b=oa.setNumberB(2);

              System.out.println(oa.getResult(a,b));  

       }

}

//主程序

這樣，只須要輸入運算符號，經過多態，返回父類的方式實現了計算器的結果。