面對對象思想

一。面對對象定義：
1。面向對象的三個特徵：
a：繼續
b：多態
C：封閉
2。相關的說明
引用: 
概述面向對象設計（Java） 
(如今的程序領域，大家都在說，面向對象OOP,但是真正能理解面向對象的含義的程序員卻很少，究竟什麼是對象，怎樣面向對象)
一．面向對象：
1.何謂對象：在面向對象程序設計中，我們將問題空間中的元素以及他們在方案空間中的的表示物稱作對象（object）
Alan Kay總結了smalltalk中對象的5大基本特徵：
所有的東西都是對象。
程序是一大堆對象的集合，他們通過消息傳遞，各個對象之間知道要做些什麼。
每個對象都分配有自己的存儲空間，可容納其他對象。
每個對象都有一個類型。
同一類的所有對象能接收相同的消息。
-----而所有的編程語言的最終目的是提供一種抽象方法----
2．對象的接口：我們向對象發出請求是通過它的接口定義的，對象的類型決定了它的接口形式。
3．OOP中唯一關心的： 就是接口是什麼，就像汽車的發動機一樣，我們不必要知道它的結構是什麼，只要它能工作就行了。所有的程序是由一定的屬性（數據）和行爲（方法）組成的，不同的對象訪問通過函數調用來完成，對象間的所有交流都是通過方法調用，通過對封裝數據對象，很大程度上提高複用率。
4．對象的3個主要特徵：
behavior—說明這個對象能做什麼。
State—當對象施加方法時對象的反映。
Identity---與其他相似行爲對象的區分標誌，每一個對象有唯一的indentity, 而這3者是相互影響的。
5．面向對象中最重要的思想 就是類，類是模板是藍圖，從類中構造一個對象，即創建了一個類的實例。（類好比一個建材市場，其中有許多子類--各種各樣的裝飾材料，而我們裝修自己的房子就要選擇我們需要的材料，（爲了建立我們自己的程序，我們必須選 擇我們需要的類）這個比喻可以很形象的解釋類是什麼。
6．類之間的關係：
依賴關係：use-a A類中的一個方法操作了另一個類中的對象。
聚合關係：has-a A類中的對象包含B類的對象。
繼承關係：is-a A繼承了B類，此時A類不僅有了B類的方法，還加入了自己的方法。以便我們創建我們自己需要的對象。
Java中定義的每一個類都必須繼承另一個類，使用關鍵字extends，如果一個類在定義中不現實使用關鍵字extends,這個類就會隱式繼承Object類。Object類又叫根超類，或基類。，我們從根超類繼承來的叫子類。Java中每個類都是根超類的子類。
8．接口（interface）規定了可對特定的對象發出哪些請求。
9．繼承=重新使用接口：創建出一個數據類型後，當需要新建立一個數據類型去實現相同的功能，是很沒有意義的一件事，此時對其克隆後，再根據情況改進實現自己的目的就是繼承。
10．封裝：就是把數據和行爲結合在一起在一個包中，並對對象使用者隱藏數據的實現過程。Java用3個關鍵字來設置邊界，從而進行對數據的隱藏。Public(共有)的定義任何人都可使用.private（私有）意味着除你自己，類型創建者及那個類型的內部函數成員可以訪問外其他任何人使用都會產生錯誤。Friendly（友好）
意味在包(package)中是可以訪問的。（以上過程也可叫方案隱藏）
11．引用（Handle）操控對象：
當創建一個引用時必須要對其進行初始化
例: String s=”happy”（未建立連接）
String s=new string(“happy”)與一個新的對象連接使用new 。此句建立了一個引用，並且連接引用並初始化對象 賦值字符串“happy”.
12.對象的創建及存在時間：數據存放的地點
1：寄存器-速度快，數量少，在cpu內部，我們對寄存器沒有控制權。
2：堆棧：駐留長規內存中，堆棧指針下移建立新的內存，上移釋放內存。
3：堆：常用內存池，保存對象，有極大的靈活性，java的數據就存放在此，但是要以時間及效率爲代價。Java的對象建立是在程序運行時才決定。而c++是在設計時建立對象。
對象的生存時間（lifetime）java提出的垃圾收集器可以很好的發現無須再用的對象，使用GC（grabage collector）垃圾收集器。清除對象，釋放內存。
爲此我們就要付出一定的運行期的開銷。
13.在此我們就會有這樣一個印象,一個程序只是一系列對象的集合,他們的方法將其他對象作爲自己的變量使用.
14.主要類型: java的主要類型有:boolean,char,byte,short,int,long,float,double,void.這些主類型的大小都不隨機器的結構變化而變化,提供了java很好的可移植性.
15.字段方法:字段又叫數據成員,成員函數又叫方法,java的全部工作就是定義類,製作累得對象及發送消息.
16.一個程序只是一系列對象的集合,他們的方法將其他的對象作爲自己的變量使用,而且將消息發給那些對象.
17.名字的可見性:爲了使名字不重複,作者可以定義自己的庫,一般用自己域名的倒寫形式 如: COM.:Leeak.utility.foidles
18.static關鍵字:即使沒有創建對象,也需要一愕能調用的方法,此時可以使用static
19.java.lang默認自動的導入每個java程序中
20.OOP中對象使對屬性和方法的封裝,對象具有信息的隱蔽的性質,對細節的隱藏,對象只需要知道去這樣做,而不知道如何做的細節,類的方法應謹慎控制對java數據的訪問,可以用get讀取方法,用set修改方法.
21:pakage:Java API中每個類和接口屬於一個特定的包,包實際上市對類和接口進行組織的目錄結構,提供了一種軟件複用機制.
22.創建可複用的類得步驟:1.定義一個public類
2.選擇一個包名,並把pakage語句加到可複用的類的源碼中.
3.編譯這個類.
4.把可複用的類導入其他程序中即可.
23.java中提出在類定義的括號外的僅有2個語句,pakage和import.
24.軟件的複用性,軟件的複用性就是利用紫的已有的,定義良好的的經過仔細測試的文檔清晰的可移植的易於獲得的軟件構件開發新的軟件.
2。類和對象
（1）。類（class）是抽象的，概念上的定義，而對象纔是實在存在的，也稱爲類的實例（Instance）；舉一個不是很恰當的例子，類相當於模具，而對象纔是由於模具生產出來的產品。
（2）。類包括變量和函數，變量定義類的屬性，函數定義類的行爲。
引用: 
class Person
{
    int age;//類成員定義類的屬性
    void shout()//類方法定義類的行爲
    {
        System.out.println("Person class");
    }
}
3。類對象的產生和作用
（1）對象生成 
引用: 
Person p1 = new Person();
p1是Person 關的一個引用！產生對象後，成員變量自動賦值：
byte short int 全部爲“0”，long爲“0.0.L”， float爲“0.0F”，char爲"/u0000"表示爲空，boolean爲false。
看一個例子：
引用: 
class Person
{
    int age;
    void shout()
    {
        System.out.println(age);
    }
}
class TestPerson
{
    public static void main(String [] args)
    {
        Person p1 = new Person();
        Person p2 = new Person();
        p1.age=30;
        p1.shout();
        p2.shout();//默認賦值爲0
    }
}
（2）對象成爲垃圾的幾種情況
a：代碼執行完後，離開作用域外後，成爲垃圾
引用: 
Person p1 = new Person();
.
.
.
b：p1.null即p1爲空成爲垃圾
引用: 
Person p1 = new Person();
p1.null
.
.
.
c：這情況不成爲垃圾
引用: 
Person p1 = new Person();
Person p2 = p1;
p1.null;
.
.
.
（3）對象的比較即“==”和“equals”的區別
a：“==”比較內存地址是否爲同一地址，而“equals”只是引用的具體內容或者是值。
看例子：
引用: 
class Compare
{
     public static void main(String[] args)
     {
            String str1 = new String("abc");
            String str2 = new String("abc");
            String str3 = str1;
            if(str1==str2)
                System.out.println("str1==str2");
            else
                System.out.println("str1!=str2");    
            if(str1==str3)
                System.out.println("str1==str3");
            else
                System.out.println("str1!=str3");    
    }
}
//str1 == str3
//str1 != str2
//“abc”只是引用變量指向內存地址的值！
引用: 
class Compare
{
     public static void main(String[] args)
     {
            String str1 = new String("abc");
            String str2 = new String("abc");
            String str3 = str1;
            if(str1.equals(str2))
                System.out.println("str1 equal str2");
            else
                System.out.println("str1 not equal str2");    
            if(str1.equals(str3))
                System.out.println("str1 equal str2");
            else
                System.out.println("str1 not equal str3");    
    }
}
//str1 equal str2
//str1 equal str2
//判斷引用變量指向存儲在內存當中的具體值，而非判斷引用變量是否指向爲同一內存地址
（4）匿名對象
引用: 
Person p1= new Person()
p1.shout()
修改成：
引用: 
new Person().shout()
使用匿名對象一般有兩種：
a：只調用一次
b：將匿名對象做一個實參傳遞給函數
4。類的封裝
類的封裝是指在一個類中將成員變量聲明爲private，然後通過公用方法來修改和輸出這個成員變量，外部類能過這兩個函數來操作該成員變量，這就是類的封裝。
注：private只是被本類中訪問無法被外部類訪問
引用: 
class Person
{
    private int age;//靜態成員變量
    public void setAge(int i)//公用輸入函數
    {
        if(i130)
            return;
        age = i; 
    }
    public int getAge()//公用輸出函數
    { 
        return age;
    }
}
public class TestPerson//外部類
{
    public static void main(String args[])
    {
        Person p1 = new Person();
        p1.setAge(3);
        p1.setAge(-6);
        System.out.println(p1.getAge());
    }
}
封閉的作用：
a：隱藏類的細節
b：數據檢查
c：便於修改，增加代碼可維護性
d：限制對發生不合理的訪問
二。構造方法
1。定義
引用: 
class Person
{
public Person()//構造方法
{
        System.out.println("the constructor 1 is calling!");
    }
    private int age = 10;
    public void shout()
    {
        System.out.println("age is "+age); 
    }
}
class TestPerson
{
    public static void main(String[] args)
    {
        Person p1=new Person();
        p1.shout();
        Person p2=new Person();
        p2.shout();
        Person p3=new Person();
        p3.shout();
    }
}
構造方法的特徵：
a：與類名相同的函數並以public修飾
b：不含返回值，不能使用return
2。重載
引用: 
class Person
{
    private String name="unknown";
    private int age = -1;
    public Person()
    {
        System.out.println("constructor1 is calling");
    }
public Person(String n)
    {
name = n;
System.out.println("constructor2 is calling");
        System.out.println("name is "+name);
}
    public Person(String n,int a)
    {
name = n;
age = a;
System.out.println("constructor3 is calling");
        System.out.println("name and age is "+name+";"+age);
}
public void shout()
     {
         System.out.println("listen to me!!"); 
        }
}
class TestPerson
{
    public static void main(String[] args)
    {
        Person p1=new Person();
        P1.shout();
        Person p2=new Person("Jack");
        P2.shout();
        Person p3=new Person("Tom",18);
        P3.shout();
    }
}
注：
定義多個構造方法不要忘記把類默認的構造方法增加上，因爲你定義了一個非默認的構造方法，那麼java就會忽略掉默認的構造方法，所以要補上
三。this用法
最普遍的情況就是，在你的方法中的某個形參名與當前對象的某個成員有相同的名字，這時爲了不至於混淆，你便需要明確使用this關鍵字來指明你要使用某個成員，使用方法是“this.成員名”，而不帶this的那個便是形參。另外，還可以用“this.方法名”來引用當前對象的某個方法，但這時this就不是必須的了，你可以直接用方法名來訪問那個方法，編譯器會知道你要調用的是那一個。下面的代碼演示了上面的用法：
引用: 
public class DemoThis{
private String name;
private int age;
DemoThis(String name,int age){
setName(name); //你可以加上this來調用方法，像這樣：this.setName(name);但這並不是必須的
setAge(age);
this.print();
} 
public void setName(String name){
this.name=name;//此處必須指明你要引用成員變量
}
public void setAge(int age){
this.age=age;
}
public void print(){
System.out.println("Name="+name+" Age="+age);//在此行中並不需要用this，因爲沒有會導致混淆的東西
}
public static void main(String[] args){
DemoThis dt=new DemoThis("Kevin","22");
}
}
又熱又累呀，剩下的週末再說吧！
繼續：
四：函數參數傳遞
來看一個例子：
引用: 
class Passvalue
{
    public static void main(String [] args)
    {
        int x = 5;
        change(x);
        System.out.println(x);
    }
    public static void change(int x)
    {
        x = 3;
    }
}
注：結果爲5，基本類型的變量做爲實參傳遞時，並不改變這個變量的值
來看一個例子：
引用: 
class PassRef
{
    int x ;
    public static void main(String [] args)
    {
        PassRef obj = new PassRef();
        obj.x = 5;
        change(obj);
        System.out.println(obj.x);
    }
    public static void change(PassRef obj)
    {
        obj.x=3;
    }
}
再看這個例子：
引用: 
class PassRef
{
    int x;
    public static void main(String [] args)
    {
        PassRef obj = new PassRef();
        obj.x = 5;
        change(obj);//這裏的調用並不會改變其自身的值
        System.out.println(obj.x);        
    }
    public static void change(PassRef obj)
    {
        obj = new PassRef();//與上一個例子這裏不同，創建了一個新的引用.
        obj.x=3;
    }
}
五。static說明
1。static的變量 
我們定義了一個類，在定義了屬性和行爲，此時並沒有什麼對象的產品，需要new出來的，在變量上加上static不需要new就可直接使用。
看例子：
引用: 
class Chinese
{
    static String country="中國";
    String name;
    int age;
    void singOurCountry()
    {
        System.out.println("啊！，親愛的" + country);
        //類中的成員方法也可以直接訪問靜態成員變量
    }
}
class TestChinese
{
    public Static void main(String [] args)
    {
        System.out.println("Chinese country is " + Chinese.country);
        //上面的程序代碼直接使用了"類名.成員"的格式
        Chinese ch1 = new Chinese();
        System.out.println("Chines country is " + ch1.country);
        //上面的程序代碼直接使用了"對象名.成員"的格式
        ch1.singOurCountry();
    }
}
注：方法中不可以使用static
2。static靜態方法
引用: 
class Chinese
{
    static void Sing()
    {
        System.out.println("啊!");
    }
    void SingourCountry()
    {
        Sing();//直接訪問方法名
    }
    
}
class TestChinese
{
    public static void main(String [] args)
    {
        Chinese.Sing();
        //類名加方法名
        Chinese ch1 = new Chinese();
        ch1.Sing();
        //對象名加方法名        
    }
}
注：
a：在靜態方法中只能調同類中靜態變量
b：靜態方法不能以任何方式引用this和super關鍵字
3。static靜態代碼
看代碼：
引用: 
class StaticCode
{
    static String country;
    static
    {
        country = "china";
        System.out.println("StaticCode is loading");
    }
}
class TestStaticCode
{
    static
    {
        System.out.println("TestStaticCode is loading");
    }
    public static void main(String [] args)
    {
        System.out.println("begin executing main method");
        new StaticCode();
        new StaticCode();
    }
}
注：
靜態代碼只被執行一次
六。單態設計模式
單態設計模式就是在通過一些方法，保證一個類中只產生一個一個對象
代碼如下：
引用: 
class TestSingle
{
    private static final TestSingle onlyone = new TestSingle();
    public static TestSingle getTestSingle()
    {
        return onlyone;
    }
    private TestSingle()
    {
        
    }
}
六：內部類
1：類中定義內部類
代碼：
引用: 
class Outer
{
    int outer_i = 100;
    void test()
    {
        Inner in = new Inner();
        in.display();
    }
    class Inner
    {
        void display()
        {
        System.out.println("display: outer_i = " + outer_i);
        }
    }
}
class InnerClassDemo
{
    public static void main(String[] args)
    {
        Outer outer = new Outer();
        outer.test();
    }
}
注：
a：
存在A類與B類
A->使用B類的實例對象
B->A類使用B類的成員變量
b：
B類可以訪問到A類的成員，反之不成
c：
內部類只需要以public修飾將會被外部類所調用
d：
方法中定義內部類只能訪問方法中final，final定義的局部變量相當於定義了一個常量