java实训第九次可后笔记

1.纯抽象类不能继承接口。

2.设计模式（战术）和架构模式（战略）

3.设计模式的选择依据其适用性和代码的美观程度。

4.架构分为  B/S和C/S

  B/S的逻辑代码堆积在服务器上，客户端很轻，方便升级和修改。B/S适合于企业管理。

  C/S的逻辑代码房子客户端，有一个庞大的客户机，减轻了服务器的压力。缺点是需要升级和下载，比较麻烦。C/S适合于运算（不需要服务器）。

5.简单工厂：工厂方法和抽象工厂的入门模式。

6.创建型设计模式（简单工厂）专门负责常见对象。

 

public interface SPY {

      publicvoid 找钱();

      publicvoid 查询();

      publicvoid
出票();

}

class 张学友 implementsSPY{

    public void 出票() {

       System.out.println("张学友出票");

    }

    public void 找钱() {

       System.out.println("张学友找钱");

    }

    public void 查询() {

       System.out.println("张学友查询");

    }  

}

class 李宇春 implementsSPY{

    public void 出票() {

       System.out.println("李宇春出票");

    }

    public void 找钱() {

       System.out.println("李宇春找钱");

    }

    public void 查询() {

       System.out.println("李宇春查询");

    }

}

class 成龙 implementsSPY{

    public void 出票() {

       System.out.println("成龙出票");

    }

    public void 找钱() {

       System.out.println("成龙找钱");

    }

    public void 查询() {

       System.out.println("成龙查询");

    }  

}

class 李四 implementsSPY{

    public void 出票() {

       System.out.println("李四出票");

    }

    public void 找钱() {

       System.out.println("李四找钱");

    }

    public void 查询() {

       System.out.println("李四查询");

    }  

}

class 李宇春2 extends 李宇春{

    public void 找钱() {

       System.out.println("李宇春准确找钱");

    }

}

public interface 唱歌 {

    public void 唱();

}

class 张学友2  extends 张学友
implements 唱歌{

    public void 唱() {

       System.out.println("张学友唱歌");

    }  

}

public class 工厂 {

     public  SPY  create(String name){    

    if(name.equals("李宇春"))

    {

       return new 李宇春2();

    }else

       if(name.equals("成龙"))

       {

       return new 成龙();

    }else

       if(name.equals("张学友"))

       {

       return new 张学友2();

    }else

       return null;

}}

public class Test1 {

   publicstatic void main(String[] as){

         工厂 m=new 工厂();

       SPY s=m.create("张学友");

       s.出票();

       s.找钱();

       s.查询();

       唱歌 c=(唱歌)s;

       c.唱();

       工厂 n=new 工厂();

       SPY a=n.create("李宇春");

       a.出票();

       a.找钱();

       a.查询();

   }

}

7.单态（又叫单例，单个对象，单个实例）属于创建型设计模式，让一个类只出一个对象。保证一个类只出一个对象的方法：将构造器便成为私有的  private Dog(){}

 

8.单态分为饿汉式单态和懒汉式单态

9. 饿汉试模式：提前构造对象。

  优点：速度快；缺点：提前加载资源，有可能会浪费资源                           

public class Dog {

   privateDog(){ 

   }

   //private static Dog d=new Dog();

     privatestatic Dog d;//提前加载资源

     {  

        d=new Dog();

     }

 

public static DoggetDog(){

    return d;

}

}

10.懒汉式模式：什么时候用，什么时候构造对象。

    优点：不提前噪声资源的浪费；缺点：访问速度慢。

    懒汉模式是不安全的单例，在多用户下出多个对象。

public class Dog1 {

     private static Dog1 d;

       public static synchronized Dog1 getDog1(){  //synchronized表示今后执行此方法时必须排列执行

          if(d==null){     //什么时候用什么时候构造对象，没有的话再构造对象

              d=newDog1();

          }

          return d;

       }

}

11.同类名直接访问的是静态属性 System.out.println();

                                类  静态属性

12.用单例的条件：

   想要让一些类只出一个对象，必须用单例。

   ‚类的访问次数过高，但类又不作任何信息记载，用单例。

嵌套类

1.    内部类看成属性。

2.    对象.静态方法或静态属性或者实例

3.    如果内部类是静态的，则只能访问外部类的静态属性；如果内部类是实例的，则可以访问外部类的实例方法和实例属性。

私有的内部属性只能自己使用。

4.public class 帽子 {

    privatestatic String[] tName = {"白兔","黑兔","流氓兔","灰兔",   "呕兔" };

    private兔子[] ts = null;

    privateString hatName;

    class兔子 {

       privateString name;

       public兔子(String name) {

           this.name= name;

       }

       publicString toString() {

           returnname;

       }

    }

    public帽子(String name) {

       hatName= name;

       ts= new 兔子[(int) (Math.random() *100)+1];

       for(int i = 0; i < ts.length; i++) {

           ts[i]= new 兔子(tName[(int) (Math.random()* 5)]);

       }

    }

    publicString toString() {

       Stringtxt = "帽子:" +hatName + "  开始跳!\n";

       for(兔子 t : ts) {

           txt= txt + t + "\t";

       }

       txt= txt + "\n";

       returntxt;

    }

}

public class 表演魔术 {

    publicstatic void main(String[] args) {

       帽子 m1 = new 帽子("红帽子");

       帽子 m2 = new 帽子("灰帽子");

       帽子 m3 = new 帽子("蓝帽子");

       System.out.println(m1);

       System.out.println(m2);

       System.out.println(m3);

    }

}

匿名内部类

public interface H{

  publicvoid method();

}

public class Test1{

 finalString name=”lise”;

   Hh=new H(){           //无名内部类

    public void method(){

   System.out.println(name);

}

};

h.method();

new H(){

  public void method(){

   System.out.println(name);

}

}.method();

}

}