面向對象，呃，別給我說程序員找不到對象，那是windows才會出現的情況~~~

　　就簡單記下筆記什么的吧。

?1、關于定義和賦值

　　之前總是搞混淆，說到底是沒有搞清楚。

shit bigOne=new shit();

　類型 ? 變量名 ? 定義

　　所以應該是先寫后面——定義——new 類名();然后是前面，賦值給一個變量；然后最前面，該變量的數據類型，這里，數據類型就是該類。

2、局部變量和成員變量

　　遵循就近原則，即局部變量和成員變量重復時，以局部變量為準。

3、關于構造方法

　　其實上面定義對象的時候，最后面那個不是變量，不是類，是該類的構造方法！！！

　　所以有參的對象定義，也就是在有參的構造函數的調用。

　　所以可以直接通過有參構造函數進行輸入，同時可以進行輸入控制——安全性，正確性等。

　　另外，關于有參和無參并存：

package imooc2;public class telephone {//屬性double size;String color;double cpu;double price;//方法void sendMessage(){System.out.println("Shit!"+size+color+cpu+price);}public telephone(){System.out.println("無參構造方法執行！");}public telephone(double sizeIn,String colorIn,double cpuIn,double priceIn){size=sizeIn;color=colorIn;cpu=cpuIn;price=priceIn;System.out.println("有參構造方法執行");}} package imooc2;public class initialTelephone {public static void main(String[] args) {// TODO Auto-generated method stubtelephone phone = new telephone(1,"black",2.3,1500);phone.sendMessage();phone.color="white";phone.cpu = 1.3;phone.sendMessage();telephone phone2 = new telephone();phone2.sendMessage();} }

?4、關于靜態變量

　　靜態成員屬于整個類，當系統第一次使用該類時，就會為其分配內存空間直到該類被卸載才會進行資源回收。

　　同樣，靜態方法也會有特殊情況：

　　

與靜態變量一樣，我們也可以使用 static 修飾方法，稱為靜態方法或類方法。其實之前我們一直寫的 main 方法就是靜態方法。靜態方法的使用如：

運行結果：

需要注意：

1）?靜態方法中可以直接調用同類中的靜態成員，但不能直接調用非靜態成員。如：

如果希望在靜態方法中調用非靜態變量，可以通過創建類的對象，然后通過對象來訪問非靜態變量。如：

2）?在普通成員方法中，則可以直接訪問同類的非靜態變量和靜態變量，如下所示：

3）?靜態方法中不能直接調用非靜態方法，需要通過對象來訪問非靜態方法。如：

?

與靜態變量一樣，我們也可以使用 static 修飾方法，稱為靜態方法或類方法。其實之前我們一直寫的 main 方法就是靜態方法。靜態方法的使用如：

運行結果：

需要注意：

1）靜態方法中可以直接調用同類中的靜態成員，但不能直接調用非靜態成員。如：

如果希望在靜態方法中調用非靜態變量，可以通過創建類的對象，然后通過對象來訪問非靜態變量。如：

2）?在普通成員方法中，則可以直接訪問同類的非靜態變量和靜態變量，如下所示：

3）?靜態方法中不能直接調用非靜態方法，需要通過對象來訪問非靜態方法。

public class HelloWorld {// 定義靜態變量score1static int score1 = 86;// 定義靜態變量score2static int score2 = 92; // 定義靜態方法sum，計算成績總分，并返回總分public static int sum() { int sum = score1+score2;return sum; }public static void main(String[] args) { // 調用靜態方法sum并接收返回值int allScore = HelloWorld.sum(); System.out.println("總分：" + allScore);} }

?

5、關于靜態初始化塊

　　這個我也是第一次知道，有點好玩，也是初始化塊——》靜態初始化塊的

public class HelloWorld {String name; // 聲明變量nameString sex; // 聲明變量sexstatic int age;// 聲明靜態變量age// 構造方法public HelloWorld() { System.out.println("通過構造方法初始化name");name = "tom";}// 初始化塊 { System.out.println("通過初始化塊初始化sex");sex = "男";}// 靜態初始化塊static { System.out.println("通過靜態初始化塊初始化age");age = 20;}public void show() {System.out.println("姓名：" + name + "，性別：" + sex + "，年齡：" + age);}public static void main(String[] args) {// 創建對象HelloWorld hello = new HelloWorld();// 調用對象的show方法 hello.show();} }

　　通過輸出結果，我們可以看到，程序運行時靜態初始化塊最先被執行，然后執行普通初始化塊，最后才執行構造方法。

　　需要特別注意：靜態初始化塊只在類加載時執行，且只會執行一次，同時靜態初始化塊只能給靜態變量賦值，不能初始化普通的成員變量。

?6、關于封裝

　　對象的三大特性：封裝、繼承和多態！

　　封裝：封裝是個動詞，動詞就有對象，這里的對象就是對象，也就是把對象進行封裝。什么叫做對象的封裝呢？就是外部不能直接訪問內部屬性。類比電子元器件的封裝，也就是用戶只能通過接口插口等對其進行訪問，不能直接接觸其中的元器件。

　　好處自然不用說。

　　另外，封裝三大步：private屬性——》set和get方法設定——》輸入輸出控制；

package imooc2;public class telephone {//屬性private double size;private String color;private double cpu;private double price;//方法public double getSize(){return size;}public void setSize(double sizeInput){size=sizeInput;}public String getColor(){return color;}public void setColor(String colorInput){color=colorInput;}void sendMessage(){System.out.println("Shit!"+size+color+cpu+price);}public telephone(){System.out.println("無參構造方法執行！");}public telephone(double sizeIn,String colorIn,double cpuIn,double priceIn){size=sizeIn;color=colorIn;cpu=cpuIn;price=priceIn;System.out.println("有參構造方法執行");}}

?

7、關于包

　　包也可以看成是一種封裝，只不過對象是各種類，也就是說包是各種類的文件夾。

　　包的存在是重名問題得到解決——比如你我都有一個姐姐，但定義一個類文件的時候，重名的是不能出現在同一個包的，所以有子包等概念出現。

　　這里就可以有兩個telephone.java；

　　調用的話，就在頭輸入import即可

package com.imooc; import com.imooc.second.telephone;

8、訪問修飾符

一圖以敝之

9、關于this關鍵字

　　this表示當前對象，于是setter和getter中就經常使用this了。

　　另外，eclipse中自帶生成setter和getter。

　　于是

public double getCpu() {return cpu;}public void setCpu(double cpu) {this.cpu = cpu;}

?10、關于內部類

　　即類中類，關鍵就是用一個關鍵字Inner

//外部類HelloWorld public class HelloWorld {// 內部類Inner，類Inner在類HelloWorld的內部public class Inner {// 內部類的方法public void show() {System.out.println("welcome to imooc!");}}public static void main(String[] args) {// 創建外部類對象HelloWorld hello = new HelloWorld();// 創建內部類對象Inner i = hello.new Inner();// 調用內部類對象的方法 i.show();} }

?　　內部類的存在原因是更好的封裝

//外部類HelloWorld public class HelloWorld{//外部類的私有屬性nameprivate String name = "imooc";//外部類的成員屬性int age = 20;//成員內部類Innerpublic class Inner {String name = "愛慕課";//內部類中的方法public void show() { System.out.println("外部類中的name：" + HelloWorld.this.name );System.out.println("內部類中的name：" + name );System.out.println("外部類中的age：" + age);}}//測試成員內部類public static void main(String[] args) {//創建外部類的對象HelloWorld o = new HelloWorld (); //創建內部類的對象Inner inn = o.new Inner() ;//調用內部類對象的show方法 inn.show();} }

?

　　以及靜態內部類

//外部類 public class HelloWorld {// 外部類中的靜態變量scoreprivate static int score = 84;// 創建靜態內部類public static class SInner {// 內部類中的變量scoreint score = 91;public void show() {System.out.println("訪問外部類中的score：" + HelloWorld.score );System.out.println("訪問內部類中的score：" + score);}}// 測試靜態內部類public static void main(String[] args) {// 直接創建內部類的對象SInner si = new SInner();// 調用show方法 si.show();} }

　　以及方法內部類，也就是方法中定義內部類，有點繁瑣，搞清楚調用的過程就行了?

//外部類 public class HelloWorld {private String name = "愛慕課";// 外部類中的show方法public void show() { // 定義方法內部類class MInner {int score = 83;public int getScore() {return score + 10;}}// 創建方法內部類的對象MInner mi = new MInner();// 調用內部類的方法 mi.getScore();System.out.println("姓名：" + name + "\n加分后的成績：" + newScore);}// 測試方法內部類public static void main(String[] args) {// 創建外部類的對象HelloWorld mo = new HelloWorld();// 調用外部類的方法 mo.show();} }

?

?

11、關于繼承

　　就是子類繼承父類的屬性和方法，說白了就是代碼復用，就是程序員懶省事兒，為了代碼整潔所做的工作。

　　需要注意父類的private是繼承不到的。

　　實際上初始化一個子類對象，是先初始化父類對象的屬性和構造方法，然后是子類的屬性和構造方法！

　　可以使用super關鍵詞調用父類的方法和屬性，注意super無法在static的方法中調用，比如主函數。

12、關于重寫

　　重寫，也是一個動詞，對象就是方法，是父類的方法。

　　就是子類對父類的方法不滿意，重新書寫該方法。

　　需要注意的是重寫要求函數投是要求完全相同的，才能實現重寫。

13、final關鍵字

14、關于Object類

　　所有類在沒有強調父類時，默認的父類都是Object類！

　　Object類中有兩個常用到的方法，toString()和equals()；前者默認返回對象地址信息，后者默認對比兩個對象引用地址是否相同；

　　由于對父類這兩個方法不滿意，所以我們在子類中進行重寫；

　　這兩個特殊的重寫，直接交給eclipse，方法和上面那個一樣，結果如下

package com.jicheng;public class Dog extends Animal {public int age=10;@Overridepublic int hashCode() {final int prime = 31;int result = 1;result = prime * result + age;return result;}@Overridepublic boolean equals(Object obj) {if (this == obj)//引用地址return true;if (obj == null)//比較空值return false;if (getClass() != obj.getClass())//類對象，就是把類的情況作為對象，類的類型是否相同return false;Dog other = (Dog) obj;if (age != other.age)//屬性值return false;return true;}public void eat(){}@Overridepublic String toString() {return "Dog [age=" + age + "]";}}

?主函數

package com.jicheng;public class initial {public static void main(String[] args) {// TODO Auto-generated method stubDog dd=new Dog();System.out.println(dd);Dog dog = new Dog(); // if(dog==dd){if(dog.equals(dd)){System.out.println("yes");}else{System.out.println("no");}}}

?15、關于多態

　　多態，一個形容詞，就是說多種形態，那么形容的對象是？是對象。也就是說對象具有多種形態。

　　那么，對象具有多種形態，其實說的是對象的引用和方法具有多種形態

　　直觀的看比較抽象，給出代碼示例

package com.duotai;public class initial {public static void main(String[] args) {// TODO Auto-generated method stubAnimal obj1 = new Animal();Animal obj2 = new Dog();//父類的引用可以指向子類的對象Dog obj3 = new Dog(); // Dog obj4 = new Animal();//錯誤 obj1.eat();obj2.eat();//同樣是父類的引用，但指向不同結果不同，稱為方法的多態} }

?

?

package com.duotai;public class Animal {public void eat(){System.out.println("Can eat");} }

?

?

package com.duotai;public class Dog extends Animal {public void eat(){System.out.println("Dog eats meat");} }

?

16、關于引用類型轉換

　　這里出現了父類引用子類的情況，也就是說有引用類型轉換的情況了。

　　關于引用類型轉換，分為向上轉換/隱式轉換和向下轉換/強制轉換；

　　考慮向上轉換為把水杯里的水倒回水壺，所以一般都是沒有問題的；向下則相反，會出現問題，于是會有強制轉換的需求。

package com.duotai;public class initial {public static void main(String[] args) {// TODO Auto-generated method stubDog dog = new Dog();Animal animal = dog;//向上轉換 // Dog dog2 = animal;//直接的向下轉換，不被允許Dog dog2 = (Dog)animal;//強制的向下轉換，可以執行Cat cat = (Cat)animal;//同樣可以執行，但會出現編譯問題} }

?

　　所以，一般使用強制使用的，需要先進行判斷，用instanceof

package com.duotai;public class initial {public static void main(String[] args) {// TODO Auto-generated method stubDog dog = new Dog();Animal animal = dog;//向上轉換if(animal instanceof Dog){Dog dog2 = (Dog)animal;}else{System.out.println("Shit");}if(animal instanceof Cat){Cat cat = (Cat)animal;}else{System.out.println("Shit");}} }

?

17、關于抽象類

　　說到引用類型轉換，有一個常用的場景：抽象類。

　　抽象對應具體，也就是說抽象的類；抽象類不關注子類的具體實現，只規定子類應該有什么樣的方法！！

package com.chouxianglei;public abstract class Telephone {public abstract void call();public abstract void message(); }

?

　　子類應該繼承它

package com.chouxianglei;public class cellPhone extends Telephone {@Overridepublic void call() {// TODO Auto-generated method stubSystem.out.println("鍵盤打電話");}@Overridepublic void message() {// TODO Auto-generated method stubSystem.out.println("鍵盤發短信");} }

　　使用的時候就可以父類引用子類，注意這里父類不能引用自己

package com.chouxianglei;public class initail {public static void main(String[] args) {// TODO Auto-generated method stubTelephone telephone = new cellPhone();telephone.call();Telephone t2 = new smartPhone();t2.call();t2.message();} }

?

18、關于接口

　　有了抽象類的概念，就不得不提一下接口的概念。

　　接口和抽象類類似，都是一種規范，但更加靈活，更加省事兒——比如有相同特征的，就可以針對相同特征設立接口，接口可以對接多個父接口，接口中都是abstract的，但不需要自己進行書寫；

　　所以舉例子，PSP和智能手機都有玩游戲的特征，但智能手機繼承自手機父類，PSP繼承自游戲機父類，但共同的特征是一個接口

package com.chouxianglei;public interface IPlayGame {public void playGame(); }

　　注意：接口的命名一般以I開頭，以和其他類進行區分；

package com.chouxianglei;public class PSP implements IPlayGame {@Overridepublic void playGame() {// TODO Auto-generated method stubSystem.out.println("PSP可以玩游戲");} }

??　　有父類的一定寫在接口前面

package com.chouxianglei;public class smartPhone extends Telephone implements IPlayGame{@Overridepublic void call() {// TODO Auto-generated method stubSystem.out.println("觸摸屏打電話");}@Overridepublic void message() {// TODO Auto-generated method stubSystem.out.println("觸摸屏發短信");}public void playGame(){System.out.println("手機可以玩游戲");} }

　　引用中，接口還是看成是父類的，依然可以父類引用子類

package com.chouxianglei;public class initail {public static void main(String[] args) {// TODO Auto-generated method stubTelephone telephone = new cellPhone();telephone.call();Telephone t2 = new smartPhone();t2.call();t2.message();IPlayGame psp = new PSP();psp.playGame();IPlayGame s1 = new smartPhone();s1.playGame();//匿名內部類IPlayGame tt = new IPlayGame(){public void playGame(){System.out.println("匿名內部類使用");} };tt.playGame();new IPlayGame(){public void playGame(){System.out.println("匿名內部類使用2");}}.playGame();}}

　　最后兩段是匿名內部類，即在程序中直接進行定義的類，直接使用！

?19、關于UML

　　初級的程序員能看懂這種設計類圖形語言就行了！

　　常見三種圖：類圖，用例圖，序列圖。

　　TMUML還能直接生成語言，天。。。

　　可以用visio畫圖http://blog.csdn.net/hyman_c/article/details/52586241

　　

轉載于:https://www.cnblogs.com/andy1202go/p/6756816.html

與50位技術專家面對面20年技術見證，附贈技術全景圖

總結

以上是生活随笔為你收集整理的Java之关于面向对象的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。