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 
public class A { 4 
   }

package singleton;

public class Sin {    //  单例类
    
    /*特点:
    某个类只能有一个实例
    它必须自行创建这个示例
    必须自行向整个系统提供这个实例*/
    
        int  x=10;
    
    private   static  final  Sin   s1=new Sin();
    
    
    private   Sin(){}

       //必须自行向整个系统提供这个实例
    public   static   Sin     getSin(){
        
        return  s1;
    } 
    
    public   void   abc(){}

    

}

package singleton;

public class Main9 {

    /**
     * @param args
     */
    public static void main(String[] args) {
          int  x=10;
        
          Sin   s1=Sin.getSin();
          System.out.println(s1.x);  
          
          
          
            
          Sin   s2=Sin.getSin();
          System.out.println(s2.x);  
          
          System.out.println(s1==s2);  
          
            A  a1=new A();
            A  a2=new A();
            System.out.println(a1==a2);  
          
          
    }

}

工厂模式

 接口

package factory;

public interface Toy {   //玩具接口---常量接口
    
    //常量
    String  name="玩具";
    double   price=10.0;
    //抽象方法
    public   void   show();     //单方法接口---最容易扩展需求

}

接口的实现类

package factory;

public class Car implements Toy {   //玩具汽车

    @Override    //重写接口的方法
    public void show() {
        System.out.println(Toy.name);    //直接使用接口名称调用常量
    }  
    
    //玩具车新增的方法
    public   void  run(String  battcell){   //接收参数电池
        System.out.println("玩具车需要有"+battcell+"才能向前跑");        
    }
    

}

package factory;

public class Dull implements Toy {    //玩偶

    @Override
    public void show() {        
        System.out.println(Toy.price); 
    }

}

package factory;

public class Brick implements Toy {   //积木

    @Override
    public void show() {
        
    }

}

工厂类

package factory;
/*
 * 
 *     ==      判定相等   ----  判定内存地址是否一致   (看是不是一个东西)
 *     equals  判定相等  ----  判定值是否一致                 (看是不是长的像)
 * 
 * 
 */
public class ToyFactory { // 工厂----生产玩具产品

    // 生产---返回值为接口类型
    public   static  Toy getToy(String material) { // 参数为原材料

        if ( "金属".equals(material)|| material=="金属" ) {  
            return new Car(); // 匿名对象
        } else if ("塑料".equals(material) || material=="塑料" ) {
            return new Dull();
        } else if ("木材".equals(material)||material=="木材") {
            return new Brick();
        } else {
            System.out.println("您的材料有误");
            return null;
        }

    }

}

主方法

package factory;

public class Main12 {

    /**
     * 向上转型:    父类  ----  子类构造方法                      接口  -----   实现类构造方法
     * 
     * 向下转型：   子类----- (子类)父类构造方法                   实现类    ------(实现类)返回接口类型
     * 
     */
    public static void main(String[] args) {
         // ToyFactory  toyFactory=new ToyFactory();
         // System.out.println(toyFactory.getToy("塑料"));  //直接输出对象，得到了对象的字符串表示
          //Dull   d1=(Dull)toyFactory.getToy("塑料");
         // d1.show();
        
        ((Dull)ToyFactory.getToy("塑料")).show();   //向下转型
        ((Car)ToyFactory.getToy("金属")).show();
        
    }

}

抽象类

package abstract1;

public abstract class Abs {   //抽象类
    
      // 抽象
    int  x;
    
    //抽象方法---没有具体实现方法的代码
    public abstract  void  show();
    
    
    //具体方法(不推荐)
    public  void  test(){
        System.out.println("Abs.test()");
    }

}

package abstract1;

public class AbsImp extends Abs {   //完成具体功能

    @Override //标注类型:  重写
    public void show() {
        
         System.out.println(1234567);
         
    }

}

接口

package interface1;

public interface Animal {   //动物接口
    
    //常量
      boolean   sleep=true;
      
      
      //抽象方法
      public   void    eat(String  x);

}

package interface1;

public class Horse implements Vehicle, Animal { //马

    @Override
    public void transport(String x) {
        
    }

    @Override
    public void eat(String x) {
    
    }  

}

 

内部类

package test;

public class Outer {     //类
    int x=1;
    public void show(){
        System.out.println("Outer.show()");
        Inter inter =new Inter();
        inter.test();
    }
    
    public  class  Inter{ //内部类
        public  void  test(){
            System.out.println(x);
        }    
    }
}