Java__內部類,抽象類,繼承,接口,異常的處理…等 – JAVA編程語言程序開發技術文章

 抽象類的特點:
1,抽象方法一定在抽象類中。
2,抽象方法和抽象類都必須被abstract關鍵字修飾。
3,抽象類不可以用new創建對象。因為調用抽象方法沒意義。
4,抽象類中的抽象方法要被使用,必須由子類復寫起所有的抽象方法後,建立子類對象調用。
     
如果子類隻覆蓋瞭部分抽象方法,那麼該子類還是一個抽象類。
抽象類和一般類沒有太大的不同。
抽象類比一般類多個瞭抽象函數。就是在類中可以定義抽象方法。
抽象類不可以實例化。
 
特殊:抽象類中可以不定義抽象方法,這樣做僅僅是不讓該類建立對象。
 
abstract 關鍵字,和哪些關鍵字不能共存。
final:被final修飾的類不能有子類。而被abstract修飾的類一定是一個父類。
private: 抽象類中的私有的抽象方法,不被子類所知,就無法被復寫。
              而抽象方法出現的就是需要被復寫。
static:如果static可以修飾抽象方法,那麼連對象都省瞭,直接類名調用就可以瞭。
              可是抽象方法運行沒意義。
 
抽象類中有構造函數,因為抽象類是一個父類,要給子類提供實例的初始化。
 
繼承:
1,提高瞭代碼的復用性。
2,讓類與類之間產生瞭關系。有瞭這個關系,才有瞭多態的特性。
 
註:不要為瞭獲取其他類的功能,簡化代碼而繼承。
必須是類與類之間有所屬關系才可以繼承。所屬關系is a。
 
Java語言中:java隻支持單繼承,不支持多繼承。
因為多繼承容易帶來安全隱患:當多個父類中定義瞭相同功能,
當功能內容不同時,子類對象不確定要運行哪一個。
但是java保留這種機制。並用另一種體現形式來完成表示。多實現。
java支持多層繼承。也就是一個繼承體系
 
子父類中的函數。
當子類出現和父類一模一樣的函數時,
當子類對象調用該函數,會運行子類函數的內容。
如同父類的函數被覆蓋一樣。
 
這種情況是函數的另一個特性:重寫(覆蓋)
當子類繼承父類,沿襲瞭父類的功能,到子類中,
但是子類雖具備該功能,但是功能的內容卻和父類不一致,
這時,沒有必要定義新功能,而是使用覆蓋特殊,保留父類的功能定義,並重寫功能內容。
 
覆蓋:
1,子類覆蓋父類,必須保證子類權限大於等於父類權限,才可以覆蓋,否則編譯失敗。
2,靜態隻能覆蓋靜態。
       重載:隻看同名函數的參數列表。
       重寫:子父類方法要一模一樣。
3,子父類中的構造函數。
在對子類對象進行初始化時,父類的構造函數也會運行,
那是因為子類的構造函數默認第一行有一條隱式的語句super();
super():會訪問父類中空參數的構造函數。而且子類中所有的構造函數默認第一行都是super();
 
子類一定要訪問父類中的構造函數。因為父類中的數據子類可以直接獲取。所以子類對象在建立時,需要先查看父類是如何對這些數據進行初始化的。所以子類在對象初始化時,要先訪問一下父類中的構造函數。
如果要訪問父類中指定的構造函數,可以通過手動定義super語句的方式來指定。
 
註:super語句一定定義在子類構造函數的第一行。
 
當父類中沒有空參數的構造函數時,子類必須手動通過super語句形式來指定要訪問父類中的構造函數。
 
子類的構造函數第一行也可以手動指定this語句來訪問本類中的構造函數。
子類中至少會有一個構造函數會訪問父類中的構造函數。
 
final : 最終。作為一個修飾符,
1,可以修飾類,函數,變量。
2,被final修飾的類不可以被繼承。為瞭避免被繼承,被子類復寫功能。
3,被final修飾的方法不可以被復寫。
4,被final修飾的變量是一個常量隻能賦值一次,既可以修飾成員變量,有可以修飾局部變量。
       當在描述事物時,一些數據的出現值是固定的,那麼這時為瞭增強閱讀性,都給這些值起個名字。方便於閱讀。而這個值不需要改變,所以加上final修飾。作為常量:常量的書寫規范所有字母都大寫,如果由多個單詞組成。
5,內部類定義在類中的局部位置上是,隻能訪問該局部被final修飾的局部變量。
 
接口:初期理解,可以認為是一個特殊的抽象類
       當抽象類中的方法都是抽象的,那麼該類可以通過接口的形式來表示。
class用於定義類
interface 用於定義接口。
 
接口定義時,格式特點:
1,接口中常見定義:常量,抽象方法。
2,接口中的成員都有固定修飾符。
       常量:public static final
       方法:public abstract
記住:接口中的成員都是public的。
 
接口:是不可以創建對象的,因為有抽象方法。
需要被子類實現,子類對接口中的抽象方法全都覆蓋後,子類才可以實例化。
否則子類是一個抽象類。
 
接口可以被類多實現,也是對多繼承不支持的轉換形式。java支持多實現。
 
內部類的訪問規則:
1,內部類可以直接訪問外部類中的成員,包括私有。
       之所以可以直接訪問外部類中的成員,是因為內部類中持有瞭一個外部類的引用,格式 外部類名.this
2,外部類要訪問內部類,必須建立內部類對象。
 
訪問格式:
1,當內部類定義在外部類的成員位置上,而且非私有,可以在外部其他類中。
可以直接建立內部類對象。
格式
       外部類名.內部類名  變量名= 外部類對象.內部類對象;
       Outer.Innerin = new Outer().new Inner();
 
2,當內部類在成員位置上,就可以被成員修飾符所修飾。
       比如,private:將內部類在外部類中進行封裝。
              static:內部類就具備static的特性。
              當內部類被static修飾後,隻能直接訪問外部類中的static成員。出現瞭訪問局限。
 
              在外部其他類中,直接訪問static內部類的非靜態成員
              newOuter.Inner().function();
 
              在外部其他類中,直接訪問static內部類的靜態成員
              uter.Inner.function();
 
       註:當內部類中定義瞭靜態成員,該內部類必須是static的。
                當外部類中的靜態方法訪問內部類時,內部類也必須是static的。
 
class Body
{
       privateclass XinZang
       {
 
       }
 
       publicvoid show()
       {
              newXinZang().
       }
}
 
 
 
內部類定義在局部時,
1,不可以被成員修飾符修飾
2,可以直接訪問外部類中的成員,因為還持有外部類中的引用。
       但是不可以訪問它所在的局部中的變量。隻能訪問被final修飾的局部變量。
 
 
匿名內部類:
1,匿名內部類其實就是內部類的簡寫格式。
2,定義匿名內部類的前提:
       內部類必須是繼承一個類或者實現接口。
3,匿名內部類的格式:  new 父類或者接口(){定義子類的內容}
4,其實匿名內部類就是一個匿名子類對象。而且這個對象有點胖。  可以理解為帶內容的對象。
5,匿名內部類中定義的方法最好不要超過3個。
 
class Outer
{
       intx = 3;
       voidmethod(final int a)
       {
              finalint y = 4;
              classInner
              {
                     voidfunction()
                     {
                            System.out.println(y);
                     }
              }
              newInner().function();
       }
}
 
class InnerClassDemo3
{
       publicstatic void main(String[] args)
       {
              Outerout = new Outer();
              out.method(9);
              out.method(7);
       }
 
}
 
繼承:
       特點:
              1,提高瞭代碼的復用性。
              2,讓類與類之間產生關系,是多態性的前提。
 
       Java中的繼承。
              1,java隻支持單繼承,不支持多繼承。因為繼承瞭多個父類如果有相同方法時,子                類對象不確定運行哪一個。
              2,Java還支持多層繼承。A–>B—>C  原來可以形成繼承體系。
                     想要使用體系功能,"查閱父類功能,建立子類對象調用功能。"
                     註:父類的由來其實是由事物中的共性內容不斷向上抽取而來的。
                            所以父類中定義的是該體系中的最基本,最共性功能。
     
       繼承出現後,代碼上特點:
       1,變量。
              當子父類中定義瞭相同的名稱的成員變量,
              子類要使用父類中的同名變量時,需要使用關鍵字super來區分。
              一般不會出現這種情況,因為父類中有瞭,子類不需要定義。
              而且父類定義時,一般變量都私有化。
 
       2,函數。
              子類可以直接訪問父類中非私有的成員函數。
              特殊情況:當子類中定義瞭與父類一模一樣的方法時,會發生覆蓋操作。大多指的是非靜態方法。
                              最終會運行子類的方法,父類相當於被覆蓋瞭。
                              函數的另一個特性:覆蓋(重寫,復寫)。
                              什麼時候用
                              當父類的功能要被修改時,不建議修改源碼。隻要通過一個類繼承原有類,定義一個新的升級後的功能即可。但是功能是相同的,隻是實現方法改變。這是子類可以沿襲父類中的功能定義,
                              並重寫功能內容。這就是覆蓋。
 
                     註意事項:
                              1,子類覆蓋父類時,必須權限要大於等於父類權限。
                              2,靜態不能覆蓋非靜態。
                   
       3,構造函數。
              構造函數可以本類進行對象初始化,也可以給子類對象進行初始化。
              子類對象初始化過程:
              子類中的所有構造方法都會訪問父類中空參數的構造函數,
              因為每一個構造函數的第一行,都有一句隱式的super語句。
              為什麼要有這條語句?
              因為子類會獲取到父類中的數據,必須要先明確父類對數據的初始化過程。
 
              當父類中沒有空參數構造函數時,子類構造函數必須通過super句來明確要訪問的父類中指定的構造函數。
 
              當時子類構造函數也可以通過this語句訪問本類中的構造函數。
              但是子類中肯定,至少有一個構造函數會訪問父類。
 
     
抽象類:在分析事物時,事物中的功能有些是不明確的內容的。這些不明確內容就是抽象的。
              可以通過抽象函數來描述。
 
              抽象函數一定要定義在抽象類中,因為,抽象函數所在類,也必須被抽象標識。
 
              寫法特點:
              1,抽象函數隻對函數進行聲明,沒有函數主體。
              2,抽象類和抽象函數都需要用abstract修飾。
              3,抽象類不可以進行實例化。
              4,想要使用抽象功能,必須通過子類覆蓋瞭父類中所有的抽象方法後,才可以對子類實例化。
                     如果隻覆蓋瞭部分抽象方法,那麼子類還是一個抽象類。
 
              也可以理解為:抽象類是一個父類,是不斷向上抽取而來的,
              在抽取過程中,隻抽取瞭方法聲明,但沒有抽取方法實現。
 
              抽象類和一半類差不多。
              區別:
              抽象類可以定義抽象方法。
              抽象類不可以建立對象。
 
              抽象類一樣用於描述事物,既可以定義抽象方法,也可以定義非抽象方法。
 
 
接口
        初期理解:接口看上去是一個特殊的抽象類。裡面存的都是抽象方法。
 
        特點:
        格式:
              1,通過interface來定義。
              2,接口中常見成員:常量,抽象方法。
                     而且這些成員都有固定的修飾符。
                     常量:public static final
                     方法:public abstract
              3,接口中的成員都是共有的。
              4,一個類可以對接口進行多實現,用多實現方法來體現多繼承的特性。
              5,一個類可以繼承一個類的同時,實現多個接口。
              6,接口與接口之間是繼承關系,而且可以多繼承。
 
       應用特點:
              1,接口是對外暴露的規則。
              2,接口是功能的擴展。
              3,接口的出現降低瞭耦合性。
 
抽象類和接口異同:
相同:
1,都可以在內部定義抽象方法。
2,通常都在頂層。
3,都不可以實例化,都需要子類來實現。
 
不同點:
1,抽象類中可以定義抽象方法和非抽象方法,
       而接口中隻能定義抽象方法。
2,接口的出現可以多實現。
       抽象類隻能單繼承。
       也就是說:接口的出現避免瞭單繼承的局限性。
3,繼承和實現的關系不一致。繼承:is a,實現:like a
 
異常:就是程序在運行時出現不正常情況。
異常由來:就是java對不正常情況進行描述後的對象體現。
 
對於問題的劃分:兩種:一種是嚴重的問題,一種非嚴重的問題。
 
對於嚴重的,java通過Error類進行描述。
       對於Error一般不編寫針對性的代碼對其進行處理。
 
對與非嚴重的,java通過Exception類進行描述。
       對於Exception可以使用針對性的處理方式進行處理。
 
無論Error或者Exception都具有一些共性內容。
比如:不正常情況的信息,引發原因等。
 
Throwable
       |–Error
       |–Exception
 
2,異常的處理
 
java 提供瞭特有的語句進行處理。
try
{
       需要被檢測的代碼;
}
catch(異常類變量)
{
       處理異常的代碼;(處理方式)
}
finally
{
       一定會執行的語句;
}
 
 
3,對捕獲到的異常對象進行常見方法操作。
       StringgetMessage():獲取異常信息。
 
class Demo
{
       intp(int a,int b)throws Exception//在功能上通過throws的關鍵字聲明瞭該功能有可能會出現問題。
       {
              returna/b;
       }
}
 
 
class ExceptionDemo
{
       publicstatic void main(String[] args)
       {
              Demod = new Demo();
              try
              {
                     intx = d.p(4,1);
                     System.out.println("x="+x);
              }
              catch(Exception e)//Exception e = new ArithmeticException();
              {
                     System.out.println("除零啦");
                     System.out.println(e.getMessage());//  / by zero;
                     System.out.println(e.toString());//異常名稱 :異常信息。
 
                     e.printStackTrace();//異常名稱,異常信息,異常出現的位置。
                                                 //其實jvm默認的異常處理機制,就是在調用printStackTrace方法。
                                                 //打印異常的堆棧的跟蹤信息。
              }          
              System.out.println("over");
       }
}
 
 
自定義異常:
必須是自定義類繼承Exception。
 
繼承Exception原因:
異常體系有一個特點:因為異常類和異常對象都被拋出。
他們都具備可拋性。這個可拋性是Throwable這個體系中獨有特點。
隻有這個體系中的類和對象才可以被throws和throw操作。
 
throws和throw的區別
throws使用在函數上。
throw使用在函數內。
 
throws後面跟的異常類。可以跟多個。用逗號隔開。
throw後跟的是異常對象。
 
自定義異常時:如果該異常的發生,無法在繼續進行運算,
就讓自定義異常繼承RuntimeException。
 
對於異常分兩種:
1,編譯時被檢測的異常。
2,編譯時不被檢測的異常(運行時異常。RuntimeException以及其子類)

發佈留言