Java 基础知识（三）

1.Constructor是否被重写或重载？

构造器不可被继承，所以不能被重写，可以被重载

2.访问修饰符

1）private: 同一个类中访问

2）default: 同一个类、同一个包中不同类访问

3）protected: 同一个类、同一个包中不同类访问

4）public：同一个类、同一个包中不同类、任意类（不同包）访问

3.抽象类中可以没有抽象方法

4.普通类与抽象类

1）普通类：可实例化；没有抽象方法；public class xxx

2) 抽象类：只可以实例化抽象类的子类；可以有抽象方法；public abstract class xxx

5.抽象的（abstract）方法是否可同时是静态的（static），是否可同时是本地方法（native），是否可同时被 synchronized 修饰？

不可以抽象方法需要子类重写

静态方法不可以被重写；本地方法是由本地代码实现的方法；synchronized与实现细节有关都是与抽象方法相矛盾

6.接口与抽象类

1）接口：无构造方法；都是抽象方法（jdk1.8 可以可以有 default 修饰的非抽象方法）；多继承；属性是public static final【常量】

2）抽象类：存在构造方法；可以有非抽象方法；单继承；

7.静态嵌套类和内部类的不同

1）静态嵌套类 Static Nested Class ：被声明为静态的内部类，它可以不依赖于外部类实例被实例

2）内部类 Inner Class :需要在外部类实例化后才能实例化

public class Outer {
    class Inner{};

    public static void Foo(){
        new Inner();//报错，静态方法访问非静态对象
    }

    public void bar(){
        new Inner();
    }

    public static void main(String[] args) {
        new Inner();//报错，访问Outer的内部类不符合规则
    }
}

8.Marker Interface

标记性接口：一个类实现某个没有任何方法的标记接口，实际上标记接口从某种意义上说就成为了这个类的元数据之一。运行时，通过编程语言的反射机制，我们就可以在代码里拿到这种元数据。

常用的标记接口有：Serializable[序列序列化],Cloneable[克隆接口]

9.面向对象设计原则

1）单一原则 SRP：一个类应该只负责一件事情，让每个类只专心处理自己的方法

2）开闭原则 OCP：软件中的对象(类，模块，函数等)应该对于扩展是开放的，但是对于修改是关闭的。

3）里氏替换原则 LSP：子类可以去扩展父类的功能，但是不能改变父类原有的功能，

包含以下几层意思：

子类可以实现父类的抽象方法，但是不能覆盖父类的非抽象方法。
子类可以增加自己独有的方法。
当子类的方法重载父类的方法时候，方法的形参要比父类的方法的输入参数更加宽松。
当子类的方法实现父类的抽象方法时，方法的返回值要比父类更严格。

4）依赖倒置原则 DIP：高层模块不应该依赖底层模块，两者都应该依赖其抽象抽象不应该依赖细节细节应该依赖抽象

指模块间的依赖是通过抽象来发生的，实现类之间不发生直接的依赖关系，其依赖关系是通过接口是来实现的。这就是俗称的面向接口编程

5）接口隔离原则 ISP：客户端不应该依赖他不需要的接口

6）合成复用原则 CRP/CARP：通过将已有的对象纳入新对象中，作为新对象的成员对象来实现的，新对象可以调用已有对象的功能，从而达到复用。

满足这个5个原则的程序也被称为满足了SOLID准则

6）迪米特原则 LOD：低耦合，高内聚

10.常见设计模式

1）工厂模式：有工厂创建所需要的的对象，如：Spring 的IOC、SqlSessionFactory

2）代理模式：给对象提供一个代理对象，由代理对象控制原对象的引用，如：SpringAOP

3）适配器模式：把一个类的接口变换成客户端所期待的另一种接口，从而使原本因接口不匹配而无法在一起使用的类能够一起工作

4）单例模式：在内存中创建有限个对象

懒汉式：当第一次去使用Singleton对象的时候才会为其产生实例化对象的操作，先定义引用

class Singleton {

    /**
     * 声明变量
     */
    private static volatile Singleton singleton = null;

    /**
     * 私有构造方法
     */
    private Singleton() {}
    /**
     * 提供对外方法
     * @return 
     */
    public static Singleton getInstance() {
        // 还未实例化
        if (singleton == null) {
            synchronized (Singleton.class) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
    public void print() {
        System.out.println("Hello World");
    }
}

饿汉式：构造方法私有化，外部无法产生新的实例化对象，只能通过static方法取得实例化对象，先定义实例

class Singleton {
    /**
     * 在类的内部可以访问私有结构，所以可以在类的内部产生实例化对象
     */
    private static Singleton instance = new Singleton();
    /**
     * private 声明构造
     */
    private Singleton() { }
    /**
     * 返回对象实例
     */
    public static Singleton getInstance() {
        return instance;
    }
    public void print() {
        System.out.println("Hello Singleton...");
    }
}