某公司（技术面）

多态是同一个行为具备多个不一样表现形式或形态的能力。
多态性是对象多种表现形式的体现。
好比咱们说"宠物"这个对象，它就有不少不一样的表达或实现，好比有小猫、小狗、蜥蜴等等。那么我到宠物店说"请给我一只宠物"，服务员给我小猫、小狗或者蜥蜴均可以，咱们就说"宠物"这个对象就具有多态性。
接下来让咱们经过实例来了解Java的多态。

public interface Vegetarian{} public class Animal{} public class Deer extends Animal implements Vegetarian{}
实现多态的两种方式：重载和覆盖

  覆盖，是指子类从新定义父类的虚函数的作法。数据库

  重载，是指容许存在多个同名函数，而这些函数的参数表不一样（或许参数个数不一样，或许参数类型不一样，或许二者都不一样）。数组

使用多态主要实现Java不能多继承的问题。

面向对象的三个基本特征是：封装、继承、多态。
Java语言的特性：面向对象、分布式、解释性、健壮、安全与系统无关、可移植、高性能、多线程和静态的语言。

懒汉式，线程不安全
public class Singleton {
    private static Singleton instance;
    private Singleton (){
    }
    public static Singleton getInstance() {
     if (instance == null) {
         instance = new Singleton();
     }
     return instance;
    }
}
这段代码简单明了，并且使用了懒加载模式，可是却存在致命的问题。当有多个线程并行调用 getInstance() 的时候，就会建立多个实例。也就是说在多线程下不能正常工做。
懒汉式，线程安全为了解决上面的问题，最简单的方法是将整个 getInstance() 方法设为同步（synchronized）。
public static synchronized Singleton getInstance() {
    if (instance == null) {
        instance = new Singleton();
    }
    return instance;
}

虽然作到了线程安全，而且解决了多实例的问题，可是它并不高效。由于在任什么时候候只能有一个线程调用 getInstance() 方法。可是同步操做只须要在第一次调用时才被须要，即第一次建立单例实例对象时。这就引出了双重检验锁。
双重检验锁双重检验锁模式（double checked locking pattern），是一种使用同步块加锁的方法。程序员称其为双重检查锁，由于会有两次检查 instance == null，一次是在同步块外，一次是在同步块内。为何在同步块内还要再检验一次？由于可能会有多个线程一块儿进入同步块外的 if，若是在同步块内不进行二次检验的话就会生成多个实例了。
public static Singleton getSingleton() {
    if (instance == null) {                         //Single Checked
        synchronized (Singleton.class) {
            if (instance == null) {                 //Double Checked
                instance = new Singleton();
            }
        }
    }
    return instance ;
}

这段代码看起来很完美，很惋惜，它是有问题。主要在于instance = new Singleton()这句，这并不是是一个原子操做，事实上在 JVM 中这句话大概作了下面 3 件事情。

    1. 给 instance 分配内存
    2. 调用 Singleton 的构造函数来初始化成员变量
    3. 将instance对象指向分配的内存空间（执行完这步 instance 就为非 null 了）

可是在 JVM 的即时编译器中存在指令重排序的优化。也就是说上面的第二步和第三步的顺序是不能保证的，最终的执行顺序多是 1-2-3 也多是 1-3-2。若是是后者，则在 3 执行完毕、2 未执行以前，被线程二抢占了，这时 instance 已是非 null 了（但却没有初始化），因此线程二会直接返回 instance，而后使用，而后瓜熟蒂落地报错。
咱们只须要将 instance 变量声明成 volatile 就能够了。
public class Singleton {
    private volatile static Singleton instance; //声明成 volatile
    private Singleton (){}

    public static Singleton getSingleton() {
        if (instance == null) {                         
            synchronized (Singleton.class) {
                if (instance == null) {       
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
   
}

有些人认为使用 volatile 的缘由是可见性，也就是能够保证线程在本地不会存有 instance 的副本，每次都是去主内存中读取。但实际上是不对的。使用 volatile 的主要缘由是其另外一个特性：禁止指令重排序优化。也就是说，在 volatile 变量的赋值操做后面会有一个内存屏障（生成的汇编代码上），读操做不会被重排序到内存屏障以前。好比上面的例子，取操做必须在执行完 1-2-3 以后或者 1-3-2 以后，不存在执行到 1-3 而后取到值的状况。从「先行发生原则」的角度理解的话，就是对于一个 volatile 变量的写操做都先行发生于后面对这个变量的读操做（这里的“后面”是时间上的前后顺序）。
可是特别注意在 Java 5 之前的版本使用了 volatile 的双检锁仍是有问题的。其缘由是 Java 5 之前的 JMM （Java 内存模型）是存在缺陷的，即时将变量声明成 volatile 也不能彻底避免重排序，主要是 volatile 变量先后的代码仍然存在重排序问题。这个 volatile 屏蔽重排序的问题在 Java 5 中才得以修复，因此在这以后才能够放心使用 volatile。
相信你不会喜欢这种复杂又隐含问题的方式，固然咱们有更好的实现线程安全的单例模式的办法。
饿汉式 static final field这种方法很是简单，由于单例的实例被声明成 static 和 final 变量了，在第一次加载类到内存中时就会初始化，因此建立实例自己是线程安全的。
public class Singleton{
    //类加载时就初始化
    private static final Singleton instance = new Singleton();
    
    private Singleton(){}

    public static Singleton getInstance(){
        return instance;
    }
}

这种写法若是完美的话，就不必在啰嗦那么多双检锁的问题了。缺点是它不是一种懒加载模式（lazy initialization），单例会在加载类后一开始就被初始化，即便客户端没有调用 getInstance()方法。饿汉式的建立方式在一些场景中将没法使用：譬如 Singleton 实例的建立是依赖参数或者配置文件的，在 getInstance() 以前必须调用某个方法设置参数给它，那样这种单例写法就没法使用了。
静态内部类 static nested class我比较倾向于使用静态内部类的方法，这种方法也是《Effective Java》上所推荐的。
public class Singleton {  
    private static class SingletonHolder {  
        private static final Singleton INSTANCE = new Singleton();  
    }  
    private Singleton (){}  
    public static final Singleton getInstance() {  
        return SingletonHolder.INSTANCE; 
    }  
}

这种写法仍然使用JVM自己机制保证了线程安全问题；因为 SingletonHolder 是私有的，除了 getInstance() 以外没有办法访问它，所以它是懒汉式的；同时读取实例的时候不会进行同步，没有性能缺陷；也不依赖 JDK 版本。
枚举 Enum用枚举写单例实在太简单了！这也是它最大的优势。下面这段代码就是声明枚举实例的一般作法。
public enum EasySingleton{
    INSTANCE;
}

咱们能够经过EasySingleton.INSTANCE来访问实例，这比调用getInstance()方法简单多了。建立枚举默认就是线程安全的，因此不须要担忧double checked locking，并且还能防止反序列化致使从新建立新的对象。可是仍是不多看到有人这样写，多是由于不太熟悉吧。
总结通常来讲，单例模式有五种写法：懒汉、饿汉、双重检验锁、静态内部类、枚举。上述所说都是线程安全的实现，文章开头给出的第一种方法不算正确的写法。
就我我的而言，通常状况下直接使用饿汉式就行了，若是明确要求要懒加载（lazy initialization）会倾向于使用静态内部类，若是涉及到反序列化建立对象时会试着使用枚举的方式来实现单例。

(1) final：修饰符（关键字），若是一个类被声明为final，意味着它不能再派生出新的子类，不能做为父类被继承。所以一个类不能既被声明为 abstract的，又被声明为final的。将变量或方法声明为final，能够保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在之后的引用中只能读取，不可修改。被声明为final的方法也一样只能使用，不能重载

(2) finally：在异常处理时提供 finally 块来执行任何清除操做。若是抛出一个异常，那么相匹配的 catch 子句就会执行，而后控制就会进入 finally块（若是有的话）。

(3) finalize：方法名。Java 技术容许使用 finalize() 方法在垃圾收集器将对象从内存中清除出去以前作必要的清理工做。这个方法是由垃圾收集器在肯定这个对象没有被引用时对这个对象调用的。它是在 Object 类中定义的，所以全部的类都继承了它。子类覆盖 finalize() 方法以整理系统资源或者执行其余清理工做。finalize() 方法是在垃圾收集器删除对象以前对这个对象调用的。

接口的概念其实并不难理解， 接口关键字Interface， 在使用时能够只定义函数体而不需求详细的实现。 再类的继承过程当中能够实现多个接口而取代了类的多继承。

在使用抽象类时须要注意几点：
         1、抽象类不能被实例化，实例化的工做应该交由它的子类来完成，它只须要有一个引用便可。
         2、抽象方法必须由子类来进行重写。
         3、只要包含一个抽象方法的抽象类，该方法必需要定义成抽象类，无论是否还包含有其余方法。
         4、抽象类中能够包含具体的方法，固然也能够不包含抽象方法。
         5、子类中的抽象方法不能与父类的抽象方法同名。
         6、abstract不能与final并列修饰同一个类。
         七、abstract 不能与private、static、final或native并列修饰同一个方法。

抽象类--抽象类是用来捕捉子类的通用特性的 。它不能被实例化，只能被用做子类的超类。抽象类是被用来建立继承层级里子类的模板

接口-- -接口是抽象方法的集合。若是一个类实现了某个接口，那么它就继承了这个接口的抽象方法。这就像契约模式，若是实现了这个接口，那么就必须确保使用这些方法。接口只是一种形式，接口自身不能作任何事情。

何时使用抽象类和接口

若是你拥有一些方法而且想让它们中的一些有默认实现，那么使用抽象类吧。
若是你想实现多重继承，那么你必须使用接口。因为Java不支持多继承，子类不可以继承多个类，但能够实现多个接口。所以你就可使用接口来解决它。
若是基本功能在不断改变，那么就须要使用抽象类。若是不断改变基本功能而且使用接口，那么就须要改变全部实现了该接口的类。

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence
{
    /** The value is used for character storage. */
    private final char value[]; //用来存储字符串转换而来的字符数组

    /** The offset is the first index of the storage that is used. */
    private final int offset; //字符串起始字符在字符数组的位置

    /** The count is the number of characters in the String. */
    private final int count; //字符串分解成字符数组后字符的数目
}

 1 增:  
 2 insert into 表名 values(0,'测试');  
 3 注：如上语句，表结构中有自动增加的列，也必须为其指定一个值，一般为0  
 4 insert into 表名(id,name) values(0,'尹当')--同上  
 5 2.删数据:  
 6 delete from 表名;  
 7 delete from 表名 where id=1;  
 8 删除结构：  
 9 删数据库：drop database 数据库名;  
10 删除表：drop table 表名;  
11 删除表中的列:alter table 表名 drop column 列名;  
12 3. 改:  
13 修改全部：updata 表名 set 列名='新的值，非数字加单引号' ;  
14 带条件的修改：updata 表名 set 列名='新的值，非数字加单引号' where id=6;  
15 4.查:  
16 查询全部的数据：select *from 表名;  
17 带条件的查询：  
18 select *from 表名 where 列名=条件值;  
19 Select * from 表名 where 列名 not like（like） '字符值'  
20 分页查询：select *from 表名 limit 每页数量 offset 偏移量; 

order    by    　是按字段排序    group    by    　是按字段分类 

1.ls – List
ls会列举出当前工做目录的内容（文件或文件夹），就跟你在GUI中打开一个文件夹去看里面的内容同样。

2.mkdir – Make Directory
mkdir <new-directory-name>常见一个新目录

3.pwd – Print Working Directory
pwd显示当前工做目录

4.cd – Change Directory
对于当前在终端运行的会中中，cd <directory>将给定的文件夹（或目录）设置成当前工做目录。

5.rmdir – Remove Directory
rmdir <directory-name>删除给定的目录。

6.rm – Remove
rm <file-name>会删除给定的文件或文件夹，可使用rm -r <directory-name>递归删除文件夹

7.cp – Copy
cp <source-file> <destination-file>命令对文件或文件夹进行复制，可使用cp -r <source-folder> <destination-folder> 选项来递归复制文件夹。

8.mv – MoVe
mv <source> <destination>命令对文件或文件夹进行移动，若是文件或文件夹存在于当前工做目录，还能够对文件或文件夹进行重命名。

9.cat – concatenate and print files
cat <file>用于在标准输出（监控器或屏幕）上查看文件内容。

10.tail – print TAIL (from last) >
tail <file-name>默认在标准输出上显示给定文件的最后10行内容，可使用tail -n N <file-name>指定在标准输出上显示文件的最后N行内容。

11.less – print LESS
less <file-name>按页或按窗口打印文件内容。在查看包含大量文本数据的大文件时是很是有用和高效的。你可使用Ctrl+F向前翻页，Ctrl+B向后翻页。

12.grep
grep "<string>" <file-name>在给定的文件中搜寻指定的字符串。grep -i "<string>" <file-name>在搜寻时会忽略字符串的大小写，而grep -r "<string>" <file-name>则会在当前工做目录的文件中递归搜寻指定的字符串。

13.Find
这个命令会在给定位置搜寻与条件匹配的文件。你可使用find <folder-to-search> -name <file-name>的-name选项来进行区分大小写的搜寻，find <folder-to-search> -iname <file-name>来进行不区分大小写的搜寻。

find <folder-to-search> -iname <file-name>


14.tar
tar命令能建立、查看和提取tar压缩文件。tar -cvf <archive-name.tar> <file1-OR-file2-OR-both-to-archive>是建立对应压缩文件，tar -tvf <archive-to-view.tar>来查看对应压缩文件，tar -xvf <archive-to-extract.tar>来提取对应压缩文件。

15.gzip
gzip <filename>命令建立和提取gzip压缩文件，还能够用gzip -d <filename>来提取压缩文件。

16.unzip
unzip <archive-to-extract.zip>对gzip文档进行解压。在解压以前，可使用unzip -l <archive-to-extract.zip>命令查看文件内容。

17.help
<command-name> --help会在终端列出全部可用的命令,可使用任何命令的-h或-help选项来查看该命令的具体用法。

18.whatis – What is this command
whatis <command-name>会用单行来描述给定的命令。

19.man – Manual
man <command-name>会为给定的命令显示一个手册页面。

20.exit
exit用于结束当前的终端会话。

21.ping
ping <remote-host-address>经过发送数据包ping远程主机(服务器)，经常使用与检测网络链接和服务器状态。

22.who – Who Is logged in
who能列出当前登陆的用户名。

23.su – Switch User
su <username>用于切换不一样的用户。即便没有使用密码，超级用户也能切换到其它用户。

24.uname
uname会显示出关于系统的重要信息，如内核名称、主机名、内核版本、处理机类型等等，使用uname -a能够查看全部信息。

25.free – Free memory
free会显示出系统的空闲内存、已经占用内存、可利用的交换内存等信息，free -m将结果中的单位转换成KB，而free –g则转换成GB。

26.df – Disk space Free
df查看文件系统中磁盘的使用状况–硬盘已用和可用的存储空间以及其它存储设备。你可使用df -h将结果以人类可读的方式显示。

27.ps – ProcesseS
ps显示系统的运行进程。

28.Top – TOP processes
top命令会默认按照CPU的占用状况，显示占用量较大的进程,可使用top -u <username>查看某个用户的CPU使用排名状况。

29.shutdown
shutdown用于关闭计算机，而shutdown -r用于重启计算机。