面向?qū)ο蟮木幊陶Z言有封裝、繼承 、抽象、多態(tài)等4個主要的特征。

1封裝：

封裝是保證軟件部件具有優(yōu)良的模塊性的基礎(chǔ)，封裝的目標(biāo)就是要實現(xiàn)軟件部件的“高內(nèi)聚、低耦合”，防止程序相互依賴性而帶來的變動影響。在面向?qū)ο蟮木幊陶Z言中，對象是封裝的最基本單位，面向?qū)ο蟮姆庋b比傳統(tǒng)語言的封裝更為清晰、更為有力。面向?qū)ο蟮姆庋b就是把描述一個對象的屬性和行為的代碼封裝在一個“模塊”中，也就是一個類中，屬性用變量定義，行為用方法進(jìn)行定義，方法可以直接訪問同一個對象中的屬性。通常情況下，只要記住讓變量和訪問這個變量的方法放在一起，將一個類中的成員變量全部定義成私有的，只有這個類自己的方法才可以訪問到這些成員變量，這就基本上實現(xiàn)對象的封裝。把握一個原則：把對同一事物進(jìn)行操作的方法和相關(guān)的方法放在同一個類中，把方法和它操作的數(shù)據(jù)放在同一個類中。

2.抽象：

抽象就是找出一些事物的相似和共性之處，然后將這些事物歸為一個類，這個類只考慮這些事物的相似和共性之處，并且會忽略與當(dāng)前主題和目標(biāo)無關(guān)的那些方面，將注意力集中在與當(dāng)前目標(biāo)有關(guān)的方面。例如，看到一只螞蟻和大象，你能夠想象出它們的相同之處，那就是抽象。抽象包括行為抽象和狀態(tài)抽象兩個方面。例如，定義一個Person類，如下：

class Person{ 
String name; 
int age; 
} 

人本來是很復(fù)雜的事物，有很多方面，但因為當(dāng)前系統(tǒng)只需要了解人的姓名和年齡，所以上面定義的類中只包含姓名和年齡這兩個屬性，這就是一種抽像，使用抽象可以避免考慮一些與目標(biāo)無關(guān)的細(xì)節(jié)。

3.繼承：

在定義和實現(xiàn)一個類的時候，可以在一個已經(jīng)存在的類的基礎(chǔ)之上來進(jìn)行，把這個已經(jīng)存在的類所定義的內(nèi)容作為自己的內(nèi)容，并可以加入若干新的內(nèi)容，或修改原來的方法使之更適合特殊的需要，這就是繼承。繼承是子類自動共享父類數(shù)據(jù)和方法的機(jī)制，這是類之間的一種關(guān)系，提高了軟件的可重用性和可擴(kuò)展性。

4多態(tài)：

多態(tài)是指程序中定義的引用變量所指向的具體類型和通過該引用變量發(fā)出的方法調(diào)用在編程時并不確定，而是在程序運行期間才確定，即一個引用變量倒底會指向哪個類的實例對象，該引用變量發(fā)出的方法調(diào)用到底是哪個類中實現(xiàn)的方法，必須在由程序運行期間才能決定。因為在程序運行時才確定具體的類，這樣，不用修改源程序代碼，就可以讓引用變量綁定到各種不同的類實現(xiàn)上，從而導(dǎo)致該引用調(diào)用的具體方法隨之改變，即不修改程序代碼就可以改變程序運行時所綁定的具體代碼，讓程序可以選擇多個運行狀態(tài)，這就是多態(tài)性。多態(tài)性增強(qiáng)了軟件的靈活性和擴(kuò)展性。例如，下面代碼中的UserDao是一個接口，它定義引用變量userDao指向的實例對象由daofactory.getDao()在執(zhí)行的時候返回，有時候指向的是UserJdbcDao這個實現(xiàn)，有時候指向的是UserHibernateDao這個實現(xiàn)，這樣，不用修改源代碼，就可以改變userDao指向的具體類實現(xiàn)，從而導(dǎo)致userDao.insertUser()方法調(diào)用的具體代碼也隨之改變，即有時候調(diào)用的是UserJdbcDao的insertUser方法，有時候調(diào)用的是UserHibernateDao的insertUser方法：

UserDao userDao = daofactory.getDao(); userDao.insertUser(user);

java中實現(xiàn)多態(tài)的機(jī)制是什么？

靠的是父類或接口定義的引用變量可以指向子類或具體實現(xiàn)類的實例對象，而程序調(diào)用的方法在運行期才動態(tài)綁定，就是引用變量所指向的具體實例對象的方法，也就是內(nèi)存里正在運行的那個對象的方法，而不是引用變量的類型中定義的方法。

abstract class和interface有什么區(qū)別?

含有abstract修飾符的class即為抽象類，abstract 類不能創(chuàng)建的實例對象。含有abstract方法的類必須定義為abstract class，abstract class類中的方法不必是抽象的。abstract class類中定義抽象方法必須在具體(Concrete)子類中實現(xiàn)，所以，不能有抽象構(gòu)造方法或抽象靜態(tài)方法。如果子類沒有實現(xiàn)抽象父類中的所有抽象方法，那么子類也必須定義為abstract類型。
接口（interface）可以說成是抽象類的一種特例，接口中的所有方法都必須是抽象的。接口中的方法定義默認(rèn)為public abstract類型，接口中的成員變量類型默認(rèn)為public static final。

兩者的語法區(qū)別：

1.抽象類可以有構(gòu)造方法，接口中不能有構(gòu)造方法。
2.抽象類中可以有普通成員變量，接口中沒有普通成員變量
3.抽象類中可以包含非抽象的普通方法，接口中的所有方法必須都是抽象的，不能有非抽象的普通方法。
4. 抽象類中的抽象方法的訪問類型可以是public，protected和（默認(rèn)類型,雖然eclipse下不報錯，但應(yīng)該也不行），但接口中的抽象方法只能是public類型的，并且默認(rèn)即為public abstract類型。
5. 抽象類中可以包含靜態(tài)方法，接口中不能包含靜態(tài)方法
6. 抽象類和接口中都可以包含靜態(tài)成員變量，抽象類中的靜態(tài)成員變量的訪問類型可以任意，但接口中定義的變量只能是public static final類型，并且默認(rèn)即為public static final類型。
7. 一個類可以實現(xiàn)多個接口，但只能繼承一個抽象類。

兩者在應(yīng)用上的區(qū)別：

接口更多的是在系統(tǒng)架構(gòu)設(shè)計方法發(fā)揮作用，主要用于定義模塊之間的通信契約。而抽象類在代碼實現(xiàn)方面發(fā)揮作用，可以實現(xiàn)代碼的重用，例如，模板方法設(shè)計模式是抽象類的一個典型應(yīng)用，假設(shè)某個項目的所有Servlet類都要用相同的方式進(jìn)行權(quán)限判斷、記錄訪問日志和處理異常，那么就可以定義一個抽象的基類，讓所有的Servlet都繼承這個抽象基類，在抽象基類的service方法中完成權(quán)限判斷、記錄訪問日志和處理異常的代碼，在各個子類中只是完成各自的業(yè)務(wù)邏輯代碼，偽代碼如下：

public abstract class BaseServlet extends HttpServlet{
    public final void service(HttpServletRequest request, HttpServletResponse response) throws  
    IOExcetion,ServletException {
   記錄訪問日志
     進(jìn)行權(quán)限判斷
      if(具有權(quán)限){
  try{
    doService(request,response);
}
  catch(Excetpion e) {
      記錄異常信息
  }
}
    } 
    protected abstract void doService(HttpServletRequest request, HttpServletResponse response) throws 
   IOExcetion,ServletException; //注意訪問權(quán)限定義成protected，顯得既專業(yè)，又嚴(yán)謹(jǐn)，因為它是}
                 專門給子類用的
public class MyServlet1 extends BaseServlet
{
protected void doService(HttpServletRequest request, HttpServletResponse response) throws IOExcetion,ServletException
    {
      本Servlet只處理的具體業(yè)務(wù)邏輯代碼
    } 

}

父類方法中間的某段代碼不確定，留給子類干，就用模板方法設(shè)計模式。

abstract的method是否可同時是static,是否可同時是native，是否可同時是synchronized?

abstract的method 不可以是static的，因為抽象的方法是要被子類實現(xiàn)的，而static與子類扯不上關(guān)系！

native方法表示該方法要用另外一種依賴平臺的編程語言實現(xiàn)的，不存在著被子類實現(xiàn)的問題，所以，它也不能是抽象的，不能與abstract混用。例如，F(xiàn)ileOutputSteam類要硬件打交道，底層的實現(xiàn)用的是操作系統(tǒng)相關(guān)的api實現(xiàn)，例如，在windows用C語言實現(xiàn)的，所以，查看jdk 的源代碼，可以發(fā)現(xiàn)FileOutputStream的open方法的定義如下：private native void open(String name) throws FileNotFoundException;

如果我們要用java調(diào)用別人寫的c語言函數(shù)，我們是無法直接調(diào)用的，我們需要按照java的要求寫一個c語言的函數(shù)，又我們的這個c語言函數(shù)去調(diào)用別人的c語言函數(shù)。由于我們的c語言函數(shù)是按java的要求來寫的，我們這個c語言函數(shù)就可以與java對接上，java那邊的對接方式就是定義出與我們這個c函數(shù)相對應(yīng)的方法，java中對應(yīng)的方法不需要寫具體的代碼，但需要在前面聲明native。

對于synchronized，方法上的synchronized同步所使用的同步鎖對象是this，而抽象方法上無法確定this是什么。

什么是內(nèi)部類？Static Nested Class 和 Inner Class的不同。

內(nèi)部類就是在一個類的內(nèi)部定義的類，內(nèi)部類中不能定義靜態(tài)成員，靜態(tài)成員不是對象的特性，只是為了找一個容身之處，所以需要放到一個類中而已，，內(nèi)部類可以直接訪問外部類中的成員變量，內(nèi)部類可以定義在外部類的方法外面，也可以定義在外部類的方法體中，如下所示：

public class Outer
{
    int out_x = 0;
    public void method()
    {
      Inner1 inner1 = new Inner1();
      public class Inner2  //在方法體內(nèi)部定義的內(nèi)部類
      {
        public method()
        {
          out_x = 3;
        }
      }
      Inner2 inner2 = new Inner2();
    }

    public class Inner1  //在方法體外面定義的內(nèi)部類
    {
    }

}

在方法體外面定義的內(nèi)部類的訪問類型可以是public,protecte,默認(rèn)的private等4種類型，這就好像類中定義的成員變量有4種訪問類型一樣，它們決定這個內(nèi)部類的定義對其他類是否可見；對于這種情況，我們也可以在外面創(chuàng)建內(nèi)部類的實例對象，創(chuàng)建內(nèi)部類的實例對象時，一定要先創(chuàng)建外部類的實例對象，然后用這個外部類的實例對象去創(chuàng)建內(nèi)部類的實例對象，代碼如下：

Outer outer = new Outer();
Outer.Inner1 inner1 = outer.new Innner1();

在方法內(nèi)部定義的內(nèi)部類前面不能有訪問類型修飾符，就好像方法中定義的局部變量一樣，但這種內(nèi)部類的前面可以使用final或abstract修飾符。這種內(nèi)部類對其他類是不可見的其他類無法引用這種內(nèi)部類，但是這種內(nèi)部類創(chuàng)建的實例對象可以傳遞給其他類訪問。這種內(nèi)部類必須是先定義，后使用，即內(nèi)部類的定義代碼必須出現(xiàn)在使用該類之前，這與方法中的局部變量必須先定義后使用的道理也是一樣的。這種內(nèi)部類可以訪問方法體中的局部變量，但是，該局部變量前必須加final修飾符。

在方法體內(nèi)部還可以采用如下語法來創(chuàng)建一種匿名內(nèi)部類，即定義某一接口或類的子類的同時，還創(chuàng)建了該子類的實例對象，無需為該子類定義名稱：

public class Outer
{
    public void start()
    {
      new Thread(
      new Runable(){
          public void run(){};
    }).start();
  }
}

最后，在方法外部定義的內(nèi)部類前面可以加上static關(guān)鍵字，從而成為Static Nested Class，它不再具有內(nèi)部類的特性，所有，從狹義上講，它不是內(nèi)部類。Static Nested Class與普通類在運行時的行為和功能上沒有什么區(qū)別，只是在編程引用時的語法上有一些差別，它可以定義成public、protected、默認(rèn)的、private等多種類型，而普通類只能定義成public和默認(rèn)的這兩種類型。在外面引用Static Nested Class類的名稱為“外部類名.內(nèi)部類名”。在外面不需要創(chuàng)建外部類的實例對象，就可以直接創(chuàng)建Static Nested Class，例如，假設(shè)Inner是定義在Outer類中的Static Nested Class，那么可以使用如下語句創(chuàng)建Inner類：

Outer.Inner inner = new Outer.Inner();

由于static Nested Class不依賴于外部類的實例對象，所以，static Nested Class能訪問外部類的非static成員變量。當(dāng)在外部類中訪問Static Nested Class時，可以直接使用Static Nested Class的名字，而不需要加上外部類的名字了，在Static Nested Class中也可以直接引用外部類的static的成員變量，不需要加上外部類的名字。
在靜態(tài)方法中定義的內(nèi)部類也是Static Nested Class，這時候不能在類前面加static關(guān)鍵字，靜態(tài)方法中的Static Nested Class與普通方法中的內(nèi)部類的應(yīng)用方式很相似，它除了可以直接訪問外部類中的static的成員變量，還可以訪問靜態(tài)方法中的局部變量，但是，該局部變量前必須加final修飾符。

內(nèi)部類可以引用它的包含類的成員嗎？有沒有什么限制？

完全可以。如果不是靜態(tài)內(nèi)部類，就沒有什么限制！

如果你把靜態(tài)嵌套類當(dāng)作內(nèi)部類的一種特例，那在這種情況下不可以訪問外部類的普通成員變量，而只能訪問外部類中的靜態(tài)成員，例如，下面的代碼：

class Outer
{
  static int x;
  static class Inner
  {
    void test()
    {
      syso(x);
    }
 }
}
}

Anonymous Inner Class (匿名內(nèi)部類) 是否可以extends(繼承)其它類，是否可以implements(實現(xiàn))interface(接口)?

可以繼承其他類或?qū)崿F(xiàn)其他接口。不僅是可以，而是必須!

例如：

import java.util.Date;
public class Test extends Date{
  public static void main(String[] args) {
    new Test().test();
  }

  public void test(){
    System.out.println(super.getClass().getName());
  }
}

結(jié)果是Test

在test方法中，直接調(diào)用getClass().getName()方法，返回的是Test類名，由于getClass()在Object類中定義成了final，子類不能覆蓋該方法，所以，在test方法中調(diào)用getClass().getName()方法，其實就是在調(diào)用從父類繼承的getClass()方法，等效于調(diào)用super.getClass().getName()方法，所以，super.getClass().getName()方法返回的也應(yīng)該是Test。如果想得到父類的名稱，應(yīng)該用如下代碼：

getClass().getSuperClass().getName();

面向?qū)ο笈c面向過程有什么區(qū)別

1出發(fā)點不同。面向?qū)ο蠓椒ㄊ怯梅铣Ｒ?guī)思維的方式來處理客觀世界的問題。強(qiáng)調(diào)把問題域的要領(lǐng)直接影射到對象與對象之間的接口上。而面向過程方法強(qiáng)調(diào)的則是過程的抽象化與模塊化，它是以過程為中心構(gòu)造或處理客觀世界問題。

2層次邏輯不同，面向?qū)ο蠓椒ㄊ怯糜嬎銠C(jī)邏輯來模擬客觀世界中的物理存在，以對象的集合類作為處理問題的基本單位，盡可能使計算機(jī)世界像客觀世界靠攏，以使問題的處理更加直接清晰直接，面向?qū)ο蠓椒ㄊ怯妙惖膶哟谓Y(jié)構(gòu)來體現(xiàn)類之間的繼承與發(fā)展，而面向?qū)ο筮^程方法處理問題的基本單位使能清晰準(zhǔn)確的表達(dá)過程的模塊，用模塊的層次結(jié)構(gòu)概括模塊或模塊間的關(guān)系與功能，把客觀世界的問題抽象成計算機(jī)可以處理的過程

3數(shù)據(jù)處理方式與控制程序方式不同。面向?qū)ο蠓椒▽?shù)據(jù)與對應(yīng)的代碼封裝成一個整體，原則上其他對象不能直接修改其數(shù)據(jù)，即對象的修改只能由自身的成員函數(shù)完成，控制程序方式上是通過“事件驅(qū)動”來激活和運行程序。而面向?qū)ο筮^程是直接通過程序來處理數(shù)據(jù)，處理完畢后即顯示處理結(jié)果，在控制程序方式上是按照設(shè)計調(diào)用或返回程序，不能由導(dǎo)航，各模塊之間存在控制與被控制，調(diào)用與被調(diào)用的關(guān)系。

4分析設(shè)計與編碼轉(zhuǎn)換方式不同。面向?qū)ο蠓椒ㄘ灤┯谲浖芷诘姆治觥ＴO(shè)計及編碼中，是一個平滑的過程，從分析到設(shè)計再到編碼是采用一致性的模型展示，即實現(xiàn)的是一種無縫連接。而面向?qū)ο筮^程方法強(qiáng)調(diào)分析設(shè)計以及編碼之間按規(guī)則進(jìn)行轉(zhuǎn)換，貫穿 與軟件生命周期的分析，設(shè)計及編碼中，實現(xiàn)的是一種有縫連接。

面向?qū)ο箝_發(fā)方式有什么優(yōu)點

1較高的開發(fā)效率。采用面向?qū)ο箝_發(fā)，可以對現(xiàn)實的事物進(jìn)行抽象，可以把現(xiàn)實的實務(wù)直接映射為開發(fā)的對象。

2保證軟件的魯棒性，正是由于面向?qū)ο箝_發(fā)方法有很高的重用性，在開發(fā)過程中可以重用已有的而且在相關(guān)領(lǐng)域經(jīng)過長期測試的代碼，因此，自然而然的對軟件的魯棒性起到很好的促進(jìn)作用。

3保證軟件的高維護(hù)性。由于采用面向?qū)ο蟮拈_發(fā)方式，使得代碼的可讀性非常好，同時面向?qū)ο蟮脑O(shè)計模式使得代碼結(jié)構(gòu)更加清晰明了，同時針對面向?qū)ο箝_發(fā)模式，已有許多非常成熟的設(shè)計模式，這些設(shè)計模式可以使程序在面對需求的變更時，只需要修改部分的模塊就可以滿足需求，因為維護(hù)起來更加方便。

This與super有什么區(qū)別

在JAVA語言中，this是指向當(dāng)前實例對象，他的一個非常重要的作用就是用來區(qū)分對象的成員變量與方法的形參（當(dāng)一個方法的形參與成員變量的名字相同時，就會覆蓋成員變量）。
Super可以用來訪問父類的方法或成員變量。當(dāng)子類的方法或成員變量與父類有相同的名字時也會覆蓋父類的方法或成員變量，要想訪問父類的方法或成員變量只能通過super關(guān)鍵字來訪問

如何獲取父類的類名

Java語言中提供了獲取類名的方法：getClass().getName()，開發(fā)人員可以調(diào)用這個方法來獲取類名。但對于繼承，不能通過調(diào)用父類的getClass().getName()方法來獲取父類的類名例如：

Class A{}
Public class Test extends A{
public void test(){
System.out.println(super.getClass().getName());
}
Public static void main(String [])args){
New Test.test();
}
}

程序運行結(jié)果為Test。原因是java語言中任何類都繼承自object類，getClass方法在object類中被定義為final何native，子類不能覆蓋該方法。因此this.getClass()和super.getClass()最終都調(diào)用的object類中的getClass()方法.而object類中的getClass()方法的釋義是：返回此object的運行時類?？梢酝ㄟ^java的反射機(jī)制在子類中獲取父類的名字代碼如下：

Class A{}
Public class Test extends A{
public void test(){
System.out.println(this.getClass().getSuperclass().getName());
}
Publci static void main(string[] args){
New Test().test();
}
}

組合與繼承有什么區(qū)別

組合和繼承是面向?qū)ο笾袃煞N代碼復(fù)用的方式。組合是指在新類里面創(chuàng)建原有類的對象，重復(fù)利用已有類的功能。繼承是面向?qū)ο蟮闹饕匦灾?，它允許設(shè)計人員根據(jù)其他類的實現(xiàn)來定義一個類的實現(xiàn)。組合和繼承都允許在新的類中設(shè)置子對象，只是組合是顯示的，而繼承是隱式的。組合和繼承存在著對應(yīng)關(guān)系：組合中的整體類和繼承中的子類對應(yīng)，組合中的局部類和繼承中的父類對應(yīng)。在使用時遵循以下兩點原則：

1除非兩個類之間是“is-a”的關(guān)系，否則不要輕易使用繼承，因為過多的使用繼承會破壞代碼的可維護(hù)性，當(dāng)父類被修改時，會影響到所有繼承自他的子類。

2,不要僅僅為了實現(xiàn)多態(tài)而使用繼承，如果類之間不是“is-a”的關(guān)系，就可以通過實現(xiàn)接口與組合的方式來達(dá)到相同的目的。
由于java語言只支持單繼承，如果想同時繼承兩個或多個類，在Java中是無法直接實現(xiàn)的，同時，在java語言中，如果繼承太多，也會使一個class里面的內(nèi)容變得臃腫不堪，所以在Java語言中，能使用組合就盡量不使用繼承。

感謝閱讀，希望能幫助到大家，謝謝大家對本站的支持！