java 面向對象：這里整理了面向對象的基礎知識，幫助大家學習理解，希望能幫助到大家，這里是 根據公司面試資料整理的相關知識：
Overload和Override的區別。Overloaded的方法是否可以改變返回值的類型?
Overload是重載的意思，Override是覆蓋的意思，也就是重寫。重載Overload表示同一個類中可以有多個名稱相同的方法，但這些方法的參數列表各不相同（即參數個數或類型不同）。
重寫Override表示子類中的方法可以與父類中的某個方法的名稱和參數完全相同，通過子類創建的實例對象調用這個方法時，將調用子類中的定義方法，這相當于把父類中定義的那個完全相同的方法給覆蓋了，這也是面向對象編程的多態性的一種表現。
override可以翻譯為覆蓋，從字面就可以知道，它是覆蓋了一個方法并且對其重寫，以求達到不同的作用。對我們來說最熟悉的覆蓋就是對接口方法的實現，在接口中一般只是對方法進行了聲明，而我們在實現時，就需要實現接口聲明的所有方法。除了這個典型的用法以外，我們在繼承中也可能會在子類覆蓋父類中的方法。在覆蓋要注意以下的幾點：
1、覆蓋的方法的標志必須要和被覆蓋的方法的標志完全匹配，才能達到覆蓋的效果；
2、覆蓋的方法的返回值必須和被覆蓋的方法的返回一致；
3、覆蓋的方法所拋出的異常必須和被覆蓋方法的所拋出的異常一致，或者是其子類；
4、被覆蓋的方法不能為private，否則在其子類中只是新定義了一個方法，并沒有對其進行覆蓋。
overload可以翻譯為重載，是指定義一些名稱相同的方法，通過定義不同的輸入參數來區分這些方法，然后再調用時，VM就會根據不同的參數樣式，來選擇合適的方法執行。在使用重載要注意以下的幾點：
1、在使用重載時只能通過不同的參數樣式。例如，不同的參數類型，不同的參數個數，不同的參數順序（當然，同一方法內的幾個參數類型必須不一樣，例如可以是fun(int,float)，但是不能為fun(int,int)）；
2、不能通過訪問權限、返回類型、拋出的異常進行重載；
3、方法的異常類型和數目不會對重載造成影響；
4、對于繼承來說，如果某一方法在父類中是訪問權限是priavte，那么就不能在子類對其進行重載，如果定義的話，也只是定義了一個新方法，而不會達到重載的效果。
如果幾個Overloaded的方法的參數列表不一樣，它們的返回者類型可以不一樣。如果兩個方法的參數列表完全一樣，就不可以通過返回值不同來實現重載Overload。我們可以用反證法來說明這個問題，例如，我們調用map.remove(key)方法時，雖然remove方法有返回值，但是我們通常都不會定義接收返回結果的變量，這時候假設該類中有兩個名稱和參數列表完全相同的方法，僅僅是返回類型不同，Java就無法確定編程者倒底是想調用哪個方法了，因為它無法通過返回結果類型來判斷。
構造器Constructor是否可被override?
構造器Constructor不能被繼承，因此不能重寫Override，但可以被重載Overload。
接口是否可繼承接口? 抽象類是否可實現(implements)接口? 抽象類是否可繼承具體類(concrete class)? 抽象類中是否可以有靜態的main方法？
接口可以繼承接口。抽象類可以實現(implements)接口。抽象類中可以有靜態的main方法。
抽象類與普通類的唯一區別就是不能創建實例對象和允許有abstract方法。
寫clone()方法時，通常都有一行代碼，是什么？
Clone()方法就是克隆，就是拷貝對象；即已經有對象A，其中A中包含了一些有效的值，但想要有個對象B，并且對B的任何改動都不會影響到A中的值，但B又不是被new出的新的對象。
拷貝：①拷貝對象返回的是一個新的對象，而不是有一個引用。②拷貝對象與用new操作符返回的對象的區別是拷貝 的已經包含了原來對象的信 息，而不是對象 的初始信息
clone 有缺省行為，super.clone();因為首先要把父類中的成員復制到位，然后才是復制自己的成員。
面向對象的特征有哪些方面
面向對象的編程語言有封裝、繼承 、抽象、多態等4個主要的特征。
1封裝：
封裝是保證軟件部件具有優良的模塊性的基礎，封裝的目標就是要實現軟件部件的“高內聚、低耦合”，防止程序相互依賴性而帶來的變動影響。在面向對象的編程語言中，對象是封裝的最基本單位，面向對象的封裝比傳統語言的封裝更為清晰、更為有力。面向對象的封裝就是把描述一個對象的屬性和行為的代碼封裝在一個“模塊”中，也就是一個類中，屬性用變量定義，行為用方法進行定義，方法可以直接訪問同一個對象中的屬性。通常情況下，只要記住讓變量和訪問這個變量的方法放在一起，將一個類中的成員變量全部定義成私有的，只有這個類自己的方法才可以訪問到這些成員變量，這就基本上實現對象的封裝。把握一個原則：把對同一事物進行操作的方法和相關的方法放在同一個類中，把方法和它操作的數據放在同一個類中。
2.抽象：
抽象就是找出一些事物的相似和共性之處，然后將這些事物歸為一個類，這個類只考慮這些事物的相似和共性之處，并且會忽略與當前主題和目標無關的那些方面，將注意力集中在與當前目標有關的方面。例如，看到一只螞蟻和大象，你能夠想象出它們的相同之處，那就是抽象。抽象包括行為抽象和狀態抽象兩個方面。例如，定義一個Person類，如下：
|
1
2
3
4
|
class Person{ String name; int age; } |
人本來是很復雜的事物，有很多方面，但因為當前系統只需要了解人的姓名和年齡，所以上面定義的類中只包含姓名和年齡這兩個屬性，這就是一種抽像，使用抽象可以避免考慮一些與目標無關的細節。
3.繼承：
在定義和實現一個類的時候，可以在一個已經存在的類的基礎之上來進行，把這個已經存在的類所定義的內容作為自己的內容，并可以加入若干新的內容，或修改原來的方法使之更適合特殊的需要，這就是繼承。繼承是子類自動共享父類數據和方法的機制，這是類之間的一種關系，提高了軟件的可重用性和可擴展性。
4多態：
多態是指程序中定義的引用變量所指向的具體類型和通過該引用變量發出的方法調用在編程時并不確定，而是在程序運行期間才確定，即一個引用變量倒底會指向哪個類的實例對象，該引用變量發出的方法調用到底是哪個類中實現的方法，必須在由程序運行期間才能決定。因為在程序運行時才確定具體的類，這樣，不用修改源程序代碼，就可以讓引用變量綁定到各種不同的類實現上，從而導致該引用調用的具體方法隨之改變，即不修改程序代碼就可以改變程序運行時所綁定的具體代碼，讓程序可以選擇多個運行狀態，這就是多態性。多態性增強了軟件的靈活性和擴展性。例如，下面代碼中的UserDao是一個接口，它定義引用變量userDao指向的實例對象由daofactory.getDao()在執行的時候返回，有時候指向的是UserJdbcDao這個實現，有時候指向的是UserHibernateDao這個實現，這樣，不用修改源代碼，就可以改變userDao指向的具體類實現，從而導致userDao.insertUser()方法調用的具體代碼也隨之改變，即有時候調用的是UserJdbcDao的insertUser方法，有時候調用的是UserHibernateDao的insertUser方法：
UserDao userDao = daofactory.getDao(); userDao.insertUser(user);
java中實現多態的機制是什么？
靠的是父類或接口定義的引用變量可以指向子類或具體實現類的實例對象，而程序調用的方法在運行期才動態綁定，就是引用變量所指向的具體實例對象的方法，也就是內存里正在運行的那個對象的方法，而不是引用變量的類型中定義的方法。
abstract class和interface有什么區別?
含有abstract修飾符的class即為抽象類，abstract 類不能創建的實例對象。含有abstract方法的類必須定義為abstract class，abstract class類中的方法不必是抽象的。abstract class類中定義抽象方法必須在具體(Concrete)子類中實現，所以，不能有抽象構造方法或抽象靜態方法。如果子類沒有實現抽象父類中的所有抽象方法，那么子類也必須定義為abstract類型。
接口（interface）可以說成是抽象類的一種特例，接口中的所有方法都必須是抽象的。接口中的方法定義默認為public abstract類型，接口中的成員變量類型默認為public static final。
兩者的語法區別：
1.抽象類可以有構造方法，接口中不能有構造方法。
2.抽象類中可以有普通成員變量，接口中沒有普通成員變量
3.抽象類中可以包含非抽象的普通方法，接口中的所有方法必須都是抽象的，不能有非抽象的普通方法。
4. 抽象類中的抽象方法的訪問類型可以是public，protected和（默認類型,雖然eclipse下不報錯，但應該也不行），但接口中的抽象方法只能是public類型的，并且默認即為public abstract類型。
5. 抽象類中可以包含靜態方法，接口中不能包含靜態方法
6. 抽象類和接口中都可以包含靜態成員變量，抽象類中的靜態成員變量的訪問類型可以任意，但接口中定義的變量只能是public static final類型，并且默認即為public static final類型。
7. 一個類可以實現多個接口，但只能繼承一個抽象類。
兩者在應用上的區別：
接口更多的是在系統架構設計方法發揮作用，主要用于定義模塊之間的通信契約。而抽象類在代碼實現方面發揮作用，可以實現代碼的重用，例如，模板方法設計模式是抽象類的一個典型應用，假設某個項目的所有Servlet類都要用相同的方式進行權限判斷、記錄訪問日志和處理異常，那么就可以定義一個抽象的基類，讓所有的Servlet都繼承這個抽象基類，在抽象基類的service方法中完成權限判斷、記錄訪問日志和處理異常的代碼，在各個子類中只是完成各自的業務邏輯代碼，偽代碼如下：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
public abstract class BaseServlet extends HttpServlet{ public final void service(HttpServletRequest request, HttpServletResponse response) throws IOExcetion,ServletException { 記錄訪問日志 進行權限判斷 if(具有權限){ try{ doService(request,response);} catch(Excetpion e) { 記錄異常信息 }} } protected abstract void doService(HttpServletRequest request, HttpServletResponse response) throws IOExcetion,ServletException; //注意訪問權限定義成protected，顯得既專業，又嚴謹，因為它是} 專門給子類用的public class MyServlet1 extends BaseServlet{protected void doService(HttpServletRequest request, HttpServletResponse response) throws IOExcetion,ServletException { 本Servlet只處理的具體業務邏輯代碼 } } |
父類方法中間的某段代碼不確定，留給子類干，就用模板方法設計模式。
abstract的method是否可同時是static,是否可同時是native，是否可同時是synchronized?
abstract的method 不可以是static的，因為抽象的方法是要被子類實現的，而static與子類扯不上關系！
native方法表示該方法要用另外一種依賴平臺的編程語言實現的，不存在著被子類實現的問題，所以，它也不能是抽象的，不能與abstract混用。例如，FileOutputSteam類要硬件打交道，底層的實現用的是操作系統相關的api實現，例如，在windows用C語言實現的，所以，查看jdk 的源代碼，可以發現FileOutputStream的open方法的定義如下：private native void open(String name) throws FileNotFoundException;
如果我們要用java調用別人寫的c語言函數，我們是無法直接調用的，我們需要按照java的要求寫一個c語言的函數，又我們的這個c語言函數去調用別人的c語言函數。由于我們的c語言函數是按java的要求來寫的，我們這個c語言函數就可以與java對接上，java那邊的對接方式就是定義出與我們這個c函數相對應的方法，java中對應的方法不需要寫具體的代碼，但需要在前面聲明native。
對于synchronized，方法上的synchronized同步所使用的同步鎖對象是this，而抽象方法上無法確定this是什么。
什么是內部類？Static Nested Class 和 Inner Class的不同。
內部類就是在一個類的內部定義的類，內部類中不能定義靜態成員，靜態成員不是對象的特性，只是為了找一個容身之處，所以需要放到一個類中而已，，內部類可以直接訪問外部類中的成員變量，內部類可以定義在外部類的方法外面，也可以定義在外部類的方法體中，如下所示：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
public class Outer{ int out_x = 0; public void method() { Inner1 inner1 = new Inner1(); public class Inner2 //在方法體內部定義的內部類 { public method() { out_x = 3; } } Inner2 inner2 = new Inner2(); } public class Inner1 //在方法體外面定義的內部類 { }} |
在方法體外面定義的內部類的訪問類型可以是public,protecte,默認的private等4種類型，這就好像類中定義的成員變量有4種訪問類型一樣，它們決定這個內部類的定義對其他類是否可見；對于這種情況，我們也可以在外面創建內部類的實例對象，創建內部類的實例對象時，一定要先創建外部類的實例對象，然后用這個外部類的實例對象去創建內部類的實例對象，代碼如下：
Outer outer = new Outer();
Outer.Inner1 inner1 = outer.new Innner1();
在方法內部定義的內部類前面不能有訪問類型修飾符，就好像方法中定義的局部變量一樣，但這種內部類的前面可以使用final或abstract修飾符。這種內部類對其他類是不可見的其他類無法引用這種內部類，但是這種內部類創建的實例對象可以傳遞給其他類訪問。這種內部類必須是先定義，后使用，即內部類的定義代碼必須出現在使用該類之前，這與方法中的局部變量必須先定義后使用的道理也是一樣的。這種內部類可以訪問方法體中的局部變量，但是，該局部變量前必須加final修飾符。
在方法體內部還可以采用如下語法來創建一種匿名內部類，即定義某一接口或類的子類的同時，還創建了該子類的實例對象，無需為該子類定義名稱：
|
1
2
3
4
5
6
7
8
9
10
|
public class Outer{ public void start() { new Thread( new Runable(){ public void run(){}; }).start(); }} |
最后，在方法外部定義的內部類前面可以加上static關鍵字，從而成為Static Nested Class，它不再具有內部類的特性，所有，從狹義上講，它不是內部類。Static Nested Class與普通類在運行時的行為和功能上沒有什么區別，只是在編程引用時的語法上有一些差別，它可以定義成public、protected、默認的、private等多種類型，而普通類只能定義成public和默認的這兩種類型。在外面引用Static Nested Class類的名稱為“外部類名.內部類名”。在外面不需要創建外部類的實例對象，就可以直接創建Static Nested Class，例如，假設Inner是定義在Outer類中的Static Nested Class，那么可以使用如下語句創建Inner類：
Outer.Inner inner = new Outer.Inner();
由于static Nested Class不依賴于外部類的實例對象，所以，static Nested Class能訪問外部類的非static成員變量。當在外部類中訪問Static Nested Class時，可以直接使用Static Nested Class的名字，而不需要加上外部類的名字了，在Static Nested Class中也可以直接引用外部類的static的成員變量，不需要加上外部類的名字。
在靜態方法中定義的內部類也是Static Nested Class，這時候不能在類前面加static關鍵字，靜態方法中的Static Nested Class與普通方法中的內部類的應用方式很相似，它除了可以直接訪問外部類中的static的成員變量，還可以訪問靜態方法中的局部變量，但是，該局部變量前必須加final修飾符。
內部類可以引用它的包含類的成員嗎？有沒有什么限制？
完全可以。如果不是靜態內部類，就沒有什么限制！
如果你把靜態嵌套類當作內部類的一種特例，那在這種情況下不可以訪問外部類的普通成員變量，而只能訪問外部類中的靜態成員，例如，下面的代碼：
|
1
2
3
4
5
6
7
8
9
10
11
12
|
class Outer{ static int x; static class Inner { void test() { syso(x); } }}} |
Anonymous Inner Class (匿名內部類) 是否可以extends(繼承)其它類，是否可以implements(實現)interface(接口)?
可以繼承其他類或實現其他接口。不僅是可以，而是必須!
例如：
|
1
2
3
4
5
6
7
8
9
10
|
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()); }} |
結果是Test
在test方法中，直接調用getClass().getName()方法，返回的是Test類名，由于getClass()在Object類中定義成了final，子類不能覆蓋該方法，所以，在test方法中調用getClass().getName()方法，其實就是在調用從父類繼承的getClass()方法，等效于調用super.getClass().getName()方法，所以，super.getClass().getName()方法返回的也應該是Test。如果想得到父類的名稱，應該用如下代碼：
getClass().getSuperClass().getName();
面向對象與面向過程有什么區別
1出發點不同。面向對象方法是用符合常規思維的方式來處理客觀世界的問題。強調把問題域的要領直接影射到對象與對象之間的接口上。而面向過程方法強調的則是過程的抽象化與模塊化，它是以過程為中心構造或處理客觀世界問題。
2層次邏輯不同，面向對象方法是用計算機邏輯來模擬客觀世界中的物理存在，以對象的集合類作為處理問題的基本單位，盡可能使計算機世界像客觀世界靠攏，以使問題的處理更加直接清晰直接，面向對象方法是用類的層次結構來體現類之間的繼承與發展，而面向對象過程方法處理問題的基本單位使能清晰準確的表達過程的模塊，用模塊的層次結構概括模塊或模塊間的關系與功能，把客觀世界的問題抽象成計算機可以處理的過程
3數據處理方式與控制程序方式不同。面向對象方法將數據與對應的代碼封裝成一個整體，原則上其他對象不能直接修改其數據，即對象的修改只能由自身的成員函數完成，控制程序方式上是通過“事件驅動”來激活和運行程序。而面向對象過程是直接通過程序來處理數據，處理完畢后即顯示處理結果，在控制程序方式上是按照設計調用或返回程序，不能由導航，各模塊之間存在控制與被控制，調用與被調用的關系。
4分析設計與編碼轉換方式不同。面向對象方法貫穿于軟件生命周期的分析。設計及編碼中，是一個平滑的過程，從分析到設計再到編碼是采用一致性的模型展示，即實現的是一種無縫連接。而面向對象過程方法強調分析設計以及編碼之間按規則進行轉換，貫穿 與軟件生命周期的分析，設計及編碼中，實現的是一種有縫連接。
面向對象開發方式有什么優點
1較高的開發效率。采用面向對象開發，可以對現實的事物進行抽象，可以把現實的實務直接映射為開發的對象。
2保證軟件的魯棒性，正是由于面向對象開發方法有很高的重用性，在開發過程中可以重用已有的而且在相關領域經過長期測試的代碼，因此，自然而然的對軟件的魯棒性起到很好的促進作用。
3保證軟件的高維護性。由于采用面向對象的開發方式，使得代碼的可讀性非常好，同時面向對象的設計模式使得代碼結構更加清晰明了，同時針對面向對象開發模式，已有許多非常成熟的設計模式，這些設計模式可以使程序在面對需求的變更時，只需要修改部分的模塊就可以滿足需求，因為維護起來更加方便。
This與super有什么區別
在JAVA語言中，this是指向當前實例對象，他的一個非常重要的作用就是用來區分對象的成員變量與方法的形參（當一個方法的形參與成員變量的名字相同時，就會覆蓋成員變量）。
Super可以用來訪問父類的方法或成員變量。當子類的方法或成員變量與父類有相同的名字時也會覆蓋父類的方法或成員變量，要想訪問父類的方法或成員變量只能通過super關鍵字來訪問
如何獲取父類的類名
Java語言中提供了獲取類名的方法：getClass().getName()，開發人員可以調用這個方法來獲取類名。但對于繼承，不能通過調用父類的getClass().getName()方法來獲取父類的類名例如：
|
1
2
3
4
5
6
7
8
9
|
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();}} |
程序運行結果為Test。原因是java語言中任何類都繼承自object類，getClass方法在object類中被定義為final何native，子類不能覆蓋該方法。因此this.getClass()和super.getClass()最終都調用的object類中的getClass()方法.而object類中的getClass()方法的釋義是：返回此object的運行時類。可以通過java的反射機制在子類中獲取父類的名字代碼如下：
|
1
2
3
4
5
6
7
8
9
|
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();}} |
組合與繼承有什么區別
組合和繼承是面向對象中兩種代碼復用的方式。組合是指在新類里面創建原有類的對象，重復利用已有類的功能。繼承是面向對象的主要特性之一，它允許設計人員根據其他類的實現來定義一個類的實現。組合和繼承都允許在新的類中設置子對象，只是組合是顯示的，而繼承是隱式的。組合和繼承存在著對應關系：組合中的整體類和繼承中的子類對應，組合中的局部類和繼承中的父類對應。在使用時遵循以下兩點原則：
1除非兩個類之間是“is-a”的關系，否則不要輕易使用繼承，因為過多的使用繼承會破壞代碼的可維護性，當父類被修改時，會影響到所有繼承自他的子類。
2,不要僅僅為了實現多態而使用繼承，如果類之間不是“is-a”的關系，就可以通過實現接口與組合的方式來達到相同的目的。
由于java語言只支持單繼承，如果想同時繼承兩個或多個類，在Java中是無法直接實現的，同時，在java語言中，如果繼承太多，也會使一個class里面的內容變得臃腫不堪，所以在Java語言中，能使用組合就盡量不使用繼承。
感謝閱讀，希望能幫助到大家，謝謝大家對本站的支持！
