Java基礎部分--面向對象高級特性（2）

一.開發模式

　　單例模式　　工廠模式　　MVC架構　　dao開發模型　　代理模式　　觀察者模式

1.單例模式

– 一個類只有一個對象,而且自動向整個系統提供這個對象

– 生產,獲取惟一一個對象的方法

單例模式實現：

– 擁有一個私有構造器
– 提供一個自身靜態私有的成員變量
– 提供一個公有的靜態公有的方法

final關鍵字
　 final能夠修飾的元素：
　　　　　　類：不能被繼承
　　　　　　變量(屬性和局部變量)：不能被從新賦值 在聲明時賦值，或在構造器中賦值，系統不會對final屬性默認的賦初始值
　　　　　　方法：不能在子類中被覆蓋，即不能修改

2.工廠模式

–批量生產有共同特色的一類對象 

 簡單工廠(靜態工廠)  : 靜態工廠的生產方法生產出了具備接口共性特色的不一樣產品

3.抽象類    extends    

–抽象方法和具體方法的集合 

–抽象方法有abstract修飾，沒有方法體的方法,沒有具體實現方法的代碼,只有方法聲明，沒有方法實現的方法

      單繼承

抽象類的規則

　　注意：
 抽象類不能被實例化；
 其包含的抽象方法必須在其子類中被實現，不然該子類只能聲明爲abstract；
 抽象方法不能爲static；
 在下列狀況下，一個類必須聲明爲抽象類：
 當一個類的一個或多個方法是抽象方法時；
 當類是一個抽象類的子類，而且沒有實現父類的全部抽象方法，即只實現部分；
 當一個類實現一個接口，而且不能爲所有抽象方法都提供實現時；

4.接口　　implements  

 接口中只包含常量和抽象方法，而沒有變量和方法的實現
 接口對類來講是一套規範，是一套行爲協議
 接口不是一個類，不能實例化

接口是常量和抽象方法的集合

　　能夠多重實現

 注意：

 接口不是一個類，沒有構造器，不能被實例化
 接口使用interface關鍵字來定義，而不是class
  接口默認：
 常量：public static final
 抽象方法： public abstract

5.內部類 

  裏面的類能夠直接使用外部類的屬性和方法

    外部類使用裏面的類的屬性方法時，須要實例化裏面的類

 

 

單例模式

 1 package singleton; 2 
 3 public class A { 4 
 5    }
 6 

 1 package singleton;
 2 
 3 public class Sin {    //  單例類
 4     
 5     /*特色:
 6     某個類只能有一個實例
 7     它必須自行建立這個示例
 8     必須自行向整個系統提供這個實例*/
 9     
10         int  x=10;
11     
12     private   static  final  Sin   s1=new Sin();
13     
14     
15     private   Sin(){}
16 
17        //必須自行向整個系統提供這個實例
18     public   static   Sin     getSin(){
19         
20         return  s1;
21     } 
22     
23     public   void   abc(){}
24 
25     
26 
27 }

 1 package singleton;
 2 
 3 public class Main9 {
 4 
 5     /**
 6      * @param args
 7      */
 8     public static void main(String[] args) {
 9           int  x=10;
10         
11           Sin   s1=Sin.getSin();
12           System.out.println(s1.x);  
13           
14           
15           
16             
17           Sin   s2=Sin.getSin();
18           System.out.println(s2.x);  
19           
20           System.out.println(s1==s2);  
21           
22             A  a1=new A();
23             A  a2=new A();
24             System.out.println(a1==a2);  
25           
26           
27     }
28 
29 }

 

工廠模式

 接口

 1 package factory;
 2 
 3 public interface Toy {   //玩具接口---常量接口
 4     
 5     //常量
 6     String  name="玩具";
 7     double   price=10.0;
 8     //抽象方法
 9     public   void   show();     //單方法接口---最容易擴展需求
10 
11 }

接口的實現類

 1 package factory;
 2 
 3 public class Car implements Toy {   //玩具汽車
 4 
 5     @Override    //重寫接口的方法
 6     public void show() {
 7         System.out.println(Toy.name);    //直接使用接口名稱調用常量
 8     }  
 9     
10     //玩具車新增的方法
11     public   void  run(String  battcell){   //接收參數電池
12         System.out.println("玩具車須要有"+battcell+"才能向前跑");        
13     }
14     
15 
16 }

 1 package factory;
 2 
 3 public class Dull implements Toy {    //玩偶
 4 
 5     @Override
 6     public void show() {        
 7         System.out.println(Toy.price); 
 8     }
 9 
10 }

 1 package factory;
 2 
 3 public class Brick implements Toy {   //積木
 4 
 5     @Override
 6     public void show() {
 7         
 8     }
 9 
10 }

工廠類

 1 package factory;
 2 /*
 3  * 
 4  *     ==      斷定相等   ----  斷定內存地址是否一致   (看是否是一個東西)
 5  *     equals  斷定相等  ----  斷定值是否一致                 (看是否是長的像)
 6  * 
 7  * 
 8  */
 9 public class ToyFactory { // 工廠----生產玩具產品
10 
11     // 生產---返回值爲接口類型
12     public   static  Toy getToy(String material) { // 參數爲原材料
13 
14         if ( "金屬".equals(material)|| material=="金屬" ) {  
15             return new Car(); // 匿名對象
16         } else if ("塑料".equals(material) || material=="塑料" ) {
17             return new Dull();
18         } else if ("木材".equals(material)||material=="木材") {
19             return new Brick();
20         } else {
21             System.out.println("您的材料有誤");
22             return null;
23         }
24 
25     }
26 
27 }

主方法

 1 package factory;
 2 
 3 public class Main12 {
 4 
 5     /**
 6      * 向上轉型:    父類  ----  子類構造方法                      接口  -----   實現類構造方法
 7      * 
 8      * 向下轉型：   子類----- (子類)父類構造方法                   實現類    ------(實現類)返回接口類型
 9      * 
10      */
11     public static void main(String[] args) {
12          // ToyFactory  toyFactory=new ToyFactory();
13          // System.out.println(toyFactory.getToy("塑料"));  //直接輸出對象，獲得了對象的字符串表示
14           //Dull   d1=(Dull)toyFactory.getToy("塑料");
15          // d1.show();
16         
17         ((Dull)ToyFactory.getToy("塑料")).show();   //向下轉型
18         ((Car)ToyFactory.getToy("金屬")).show();
19         
20     }
21 
22 }

 

抽象類

 1 package abstract1;
 2 
 3 public abstract class Abs {   //抽象類
 4     
 5       // 抽象
 6     int  x;
 7     
 8     //抽象方法---沒有具體實現方法的代碼
 9     public abstract  void  show();
10     
11     
12     //具體方法(不推薦)
13     public  void  test(){
14         System.out.println("Abs.test()");
15     }
16 
17 }

 1 package abstract1;
 2 
 3 public class AbsImp extends Abs {   //完成具體功能
 4 
 5     @Override //標註類型:  重寫
 6     public void show() {
 7         
 8          System.out.println(1234567);
 9          
10     }
11 
12 }

 

接口

 1 package interface1;
 2 
 3 public interface Animal {   //動物接口
 4     
 5     //常量
 6       boolean   sleep=true;
 7       
 8       
 9       //抽象方法
10       public   void    eat(String  x);
11 
12 }

 1 package interface1;
 2 
 3 public class Horse implements Vehicle, Animal { //馬
 4 
 5     @Override
 6     public void transport(String x) {
 7         
 8     }
 9 
10     @Override
11     public void eat(String x) {
12     
13     }  
14 
15 }

 

內部類

 1 package test;
 2 
 3 public class Outer {     //類
 4     int x=1;
 5     public void show(){
 6         System.out.println("Outer.show()");
 7         Inter inter =new Inter();
 8         inter.test();
 9     }
10     
11     public  class  Inter{ //內部類
12         public  void  test(){
13             System.out.println(x);
14         }    
15     }
16 }