java 笔试整理【持续整理中】

• 数据库方面：

　　1、删除表中所有数据：

　　　　delete from tableName;

　　　　truncate table tableName;

　　　　执行速度：truncate > delete

　　2、删除表结构：

　　　　drop table  tableName；

• jQuery方面：

　　1、Math.round(x) ，x必须为数字。方法返回与 x 最接近的整数。对于 0.5，该方法将进行上舍入。比如：3.5 上舍入为 4 ，- 3.5  上舍入为 - 3；

　　2、jQuery里隐藏/显示div

　　　　$("# id").hide()

　　　　$("# id").show()

 

• 23种设计模式

　　　　① 创建型模式【5】：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。

　　　　② 结构型模式【7】：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式

　　　　③ 行为型模式【11】：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介模式、解释器模式。

　　　　六大原则：

　　　　　　开闭原则【总原则】---》

　　　　　　单一职责原则：每个类应该实现单一的职责，如若不然，就应该把类拆分

　　　　　　里氏替换原则：任何基类可以出现的地方，子类一定可以出现

　　　　　　依赖倒转原则：面向接口编程，依赖于抽象而不依赖于具体。写代码时用到具体类时，不与具体类交互，而与具体类的上层接口交互。

　　　　　　接口隔离原则：每个接口中不存在子类用不到却必须实现的方法，如果不然，就要将接口拆分。

　　　　　　最少知道原则：一个类对自己依赖的类知道的越少越好。也就是说无论被依赖的类多么复杂，都应该将逻辑封装在方法的内部，

　　　　通过public方法提供给外部。这样当被依赖的类变化时，才能最小的影响该类。

　　　　　　合成复用原则：原则是尽量首先使用合成/聚合的方式，而不是使用继承

　　　各种模式具体实例

　　　　简单工厂模式【不属于23种设计模式】

　　　　　　①普通　　　　　　

//简单工厂模式就是建立一个工厂类，对实现了同一接口的一些类进行实例的创建。
//例如:举例发邮件或者发短信的例子：
//1、首先创建二者的共同接口
public interface sender {
      public void send();  
}

//2、创建具体实现类
public class MailSender implements Sender {
        @override
        public void send(){
        System.out.println("this is MailSender !");
    }  
}

public class SmsSender implements Sender {
        @override
        public void send(){
        System.out.println("this is SmsSender");
      }   
}

//3、建工厂类
public class SendFactory{
        
         public Sender produce(String type) {
                if("main".equals(type)) {
                        return new MailSender ();
               }else if("sms".equals(type)) {
                        return new SmsSender ();
               }else {
                        System.out.println("error input!");
               }
        }
}    
//测试一下
public class FactoryTest {  
  publicstaticvoid main(String[] args) {  

        SendFactory factory = new SendFactory();  

        Sender sender = factory.produce("sms");  

        sender.Send();  

    }  

}  

//输出：this is sms sender!

 　　　　　　

　　　　　　②多个方法

//1、创建二者的共同接口
public inteface Sender{
    public void send();
}

//2、创建具体实现类
public class SmsSender implements Sender{
    @override
    public void send(){
        system.out.println("this is sms message!");
    }
}

public class MailSender implements Sender{
    @override
    public void send(){
        system.out.println("this is mail message!");
    }
}

//3.创建工厂类
public class SendFactory{
    public Sender SmsProduce(){
        return new SmsSender();
    }
    
    public Sender MailProduce(){
        return new MailSender();
    }
}

//4.测试
public class FactoryTest {  
  
    public static void main(String[] args) {  
        SendFactory factory = new SendFactory();  
        Sender sender = factory.produceMail();  
        sender.Send();  
    }  
} 
//this is mail message!

 　　　　　　

　　　　　　③多个静态方法

//1、创建接口
public inteface Sender{
    public void send();
}

//2、创建具体实现类
public class MsmSender implements sender {
    @override
    public void send(){
        system.out.println("this is a msmMessage!");
    }
}

public class MailSender implements sender {
    @override
    public void send(){
        system.out.println("this is a MainMessage!")；
    }
}

//3.创建静态多方法工厂类
public class SendFactory{
    public static Sender SmsProduce(){
        return new MsmSender();
    }
    
    public static sender mailProduce(){
        retrn new MailSender();
    }
}

//测试  多个工厂方法模式里的方法置为静态的，不需要创建实例，直接调用即可
public class test {
    public void main(String[] args) { 
        Sender send = Sender.MailSender();
        send.send();
    }
}
//this is a MainMessage!

 总体来说，工厂模式适合：凡是出现了大量的产品需要创建，并且具有共同的接口时，可以通过工厂方法模式进行创建。在以上的三种模式中，第一种如果传入的字符串有误，不能正确创建对象，第三种相对于第二种，不需要实例化工厂类，所以，大多数情况下，我们会选用第三种——静态工厂方法模式

 

　　　　一、工厂方法模式

　　简单工厂模式有一个问题就是，类的创建依赖工厂类，也就是说，如果想要拓展程序，必须对工厂类进行修改，这违背了闭包原则，所以，从设计角度考虑，有一定的问题，如何解决？就用到工厂方法模式，创建一个工厂接口和创建多个工厂实现类，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。

　　　　　　　　　　　　　　　　

//1、创建共同接口
public inteface Sender{
    public void send();
}

//2、创建具体实现类
public class MsmSender implements Sender{
    @override
    public void send(){
        system.out.println("this is a MsmMessage!")
}

public class MailSender implements Sender{
    @override
    public void send(){
        system.out.println("this is a MailMessage!");
    }
}

//3、创建工厂接口
public inteface Provider{
    public Sender produce();
}

//4、创建工厂类实现工厂接口
public class MailFacory implements Provider{
    @override
    public Sender produce(){
        return new MailSender();
    }
}

public class MsmFactory implements Provider{
    @override
    public Sender produce(){
        return new MsmSender();
    }
}

//测试
public class test{
    public void main(String[] args){
        Provider provider = new MailFacory();
        Sender sender = provider.produce();
        sender.send();
    }
}

 

 

　　　　二、抽象工厂模式

　　我

　　　三、单例模式　

　　在Java应用中，单例对象能保证在一个JVM中，该对象只有一个实例存在。这样的模式有几个好处：

1、某些类创建比较频繁，对于一些大型的对象，这是一笔很大的系统开销。

2、省去了new操作符，降低了系统内存的使用频率，减轻GC压力。

3、有些类如交易所的核心交易引擎，控制着交易流程，如果该类可以创建多个的话，系统完全乱了。（比如一个军队出现了多个司令员同时指挥，肯定会乱成一团），所以只有使用单例模式，才能保证核心交易服务器独立控制整个流程。

//单例模式
//1、创建类
public class Singleton {
    //静态私有实例，防止被引用
    private static Singleton singleton = null;
    
    //私有构造方法，防止被实例化
    private Singleton(){
    }
    
    //静态工程方法，创建实例
    public static Singleton getInstence(){
        if(singleton==null){
            singleton = new Singleton();
        }
        return singleton;
    }
}

//2、多线程下synchorized
public static synchoSingleton Singleton getInstence(){
    if(singleton==null){
            singleton = new Singleton();
        }
        return singleton;
}
//synchronized关键字锁住的是这个对象，这样的用法，在性能上会有所下降，因为每次调用getInstance()，都要对对象上锁，事实上，只有在第一次创建对象的时候需要加锁，之后就不需要了，所以，这个地方需要改进。我们改成下面这个：
public static Singleton getInstence(){
    if(singleton==null){
        synchorized(singleton){
            singleton = new Singleton();
        }
    }
    return singleton;
}