Java复习

1.Java关键字总结梳理

首先这里总结一下在编写类时常常会碰到的一些关键字：

private，public，protected，default

关键字	同一个包中的其他类	不同包中的其他类	子类	自身
private	No	No	No	Yes
protected	Yes	No	Yes	Yes
public	Yes	Yes	Yes	Yes
无修饰（default）	Yes	No	No	Yes

注意：以上几个修饰词是和包有关的

static

static关键字修饰内容的几个特点：
1. static修饰的变量和类文件一同被加载到内存中
2. 被修饰的方法可以直接通过类名加点来引用，也就是说static修饰部分的引用是不需要将对象实例化的。

有关static一些注意事项：

• static方法只能访问static变量
• static方法中不能使用this,super这样的关键字，因为static优先于对象被加载到内存之中，static执行时对象可能还未被实例化。
• 内部类包含static修饰的属性或方法时，内部类必须也被static修饰，其实理解起来也很简答，应为static会优先被加载，如果内部类不被static修饰，那么内部变量是不会被提前加载的，这时static关键字修饰就不起作用了。

final

• final是一个修饰词，可修饰类，变量，函数
• final修饰的类不可被继承
• final修饰的函数无法被复写
• final修饰的变量只能赋值一次

abstract

• abstract同样是一个修饰词，能够修饰方法和类
• abstract修饰的类无法被实例化，只能够通过子类的继承并实现内部所有的抽象函数才能被实例化。
• abstract修饰的函数只需要申明方法名，参数，不需要写函数体。
• 抽象类中同样可以定义非抽象的方法，同时抽象类也有构造函数，这个构造函数提供给子类实例化时使用。
• 抽象类中也可以没有抽象的方法。
• abstract不可以和static，private，final公用，简单理解一下，static修饰说明优先加载，而abstract未被实现，所以无法被优先加载。final修饰表名为最终状态无法修改，而abstract修饰的需要子类去实现，必须可以修改。private表示私有化，自由自身能够访问到，而abstract需要子类访问并实现函数体。

instanceof

用于判断类是否实现了指定接口或实现了指定的类，举个简单的例子：

public class Test {

    public static void main(String[] args) {

        NullPointerException e = new NullPointerException();
        System.out.println(e instanceof Exception);
    }
}

输出结果为true

2.面向对象

面向对象最为主要的两个内容

• 过程，其实也就是函数
• 对象，则是对一些函数和属性进行了封装

所以，其实在面向对象的编程过程中，编写类，也就是完成对函数和成员变量的封装（当然，在编写前需要对类进行设计）。

接口和接口的实现

• 接口有interface关键字定义，内部函数默认为抽象的，所以接口无法实例化.
• 一个类在实现了接口中所有的方法时才能被实例化，否则这个类还是一个抽象类，无法被实例化，实现某个接口使用关键字implements
• 一个类可以实现多个接口，而且接口之间也可以相互继承，并且接口可以多继承，一个简单的例子：

public class Test {

    interface interface1 {
        void function1();
    }

    interface interface2 {
        void function2();
    }

    interface interface3 extends interface1, interface2 {

    }

    class MyClass implements interface3 {

        @Override
        public void function1() {
            // TODO Auto-generated method stub

        }

        @Override
        public void function2() {
            // TODO Auto-generated method stub

        }

    }
}

可以看到，当MyClass实现了interface3,并且interface3继承了interface1和interface2时，MyClass需要实现interface1和interface2中的所有方法。

继承

继承当中子类与父类之间的一些关系：

• 成员变量：当子类中出现与父类相同的成员变量时，在子类中调用优先调用子类的该变量，如果想要调用父类中的该成员，则需要使用super关键字。
• 成员函数：当子类中出现与父类之中相同的方法时，子类的方法会将父类中的方法覆盖。在外部调用时，会调用子类的方法。
• 构造函数：子类的构造函数中会默认调用super（）意味着在构造子类之前需要先对其父类进行构造。

多态

举一个简单的多态例子：
父类定义

class Father
{
    void sayHi()
    {
      System.out.println("father hello");
    }
}

子类定义:

class Son extends Father
{
    void sayHi()
    {
      System.out.println("son hello");
    }
}

测试代码：

    public static void main(String[] args) {

        Father f = new Son();
        f.sayHi();

    }

输出结果为“son hello”
可以看出，可以通过父类访问到子类的方法，这样为我们操作大量对象提供了方便，当我们需要操作大量不同对象时，我们只需要通过访问他们的父类来操作他们共性的一部分即可。
当然以上只是简单的多态的例子，动态在Java中有很多体现，接口的实现，继承，复写都体现着多态。

3.那些我们常常遇到的类

Exception

异常是程序运行期间发生的不正常的行为，Java中将异常进行了封装，并能够使用try catch语句对异常捕获和处理。所有异常的父类都是Exception,这些异常类的共有特点就是能够被抛出。
这里对比一下throws和throw的区别：

throws抛出的是异常的类名，出现在方法头部，throws只是存在抛出异常的可能并且自身无法处理，需要交给调用者来处理。

private void main() {
        try {
            function();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    private void function() throws IOException {
        Socket s = new Socket("", 11);
    }

可以看到，我们通过throws将异常抛出，并且在function被其他函数调用时，调用者任然需要对异常进行捕获和处理，当然调用者也可以继续讲异常抛出，等待其他的调用者对异常进行处理。

throw抛出的是异常的对象，出现在函数体内部，throw一定会抛出异常。看例子

public static void main(String[] args) {

        String real_pass_word = "123456768";
        String input_pass_word = "123456";

        try {
            if (!real_pass_word.equals(input_pass_word)) {

                throw new IOException();

            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

可以看到需要对当密码不相等时，我们使用throw抛出了异常IOException,并且在外层通过try catch对异常进行了捕获。

Thread

首选明确一下线程和进程的区别：

进程是程序在执行当中分配资源和管理资源的最小单位。进程之间通常不会共享资源，每个进程独有系统分配的资源，进程中可以包含多个线程。

线程是进程中的一个程序执行控制单元，同时也是一条执行路径，属于同一个进程的线程之间共享进程内的数据，并且可以相互之间进行通讯。

创建一个新的线程有两种办法：
- 通过Thread或继承至Thread的类创建线程对象
- 通过实现Runable接口，并将实现Runable接口的对象作为参数传入Thread()构造方法中（这里解释一下Runable接口出现的原因，由于，应为Java中类是单继承的，所以当一个类既想作为一个线程也有其他必须要继承的类时，就可以通过实现Runable接口来将需要作为线程执行的部分放入run方法之中）

这里有一个常见的面试题

public static void main(String[] args) {

        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("哈哈哈");
            }
        }) {
            public void run() {
                System.out.println("呵呵呵");
            };
        }.start();
    }

上面的代码运行结果输出的“呵呵呵”，简单的解释一下，上述代码首先创建了一个Thread对象，此时run中输出“哈哈哈”，然后我们通过Thread实现了一个匿名的内部类，这个类的run方法输出“呵呵呵”，最后运行输出的结果就是“呵呵呵”了。

多线程的好处当然是能够更好的利用cpu，但是多线程同样也带来了一些问题，由于同一个进程内的多个线程共享着进程内的资源，当多个线程同时运行时就容易出现共享资源的抢夺，一个常见的情况是多个线程在共同访问一个数据时，A线程正在操作数据，这个时候B线程进入并修改数据，这样会导致产生错误的结果，为了解决线程访问共享资源的问题，Java提供了关键字synchronized，以下提供一个synchronized关键的使用例子：

public class Test {

    public static void main(String[] args) {
        Example example = new Example();

        Thread t1 = new Thread1(example);
        Thread t2 = new Thread1(example);

        t1.start();
        t2.start();
    }

}

class Example {
    public synchronized void execute() {
        for (int i = 0; i < 10; ++i) {
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Hello: " + i);
        }
    }

}

class Thread1 extends Thread {
    private Example example;

    public Thread1(Example example) {
        this.example = example;
    }

    @Override
    public void run() {
        example.execute();
    }

}

上面的代码对于excute方法使用了synchronized修饰，执行结果为先打印一次0-9再打印一次0-9，而去除synchronized关键字后，会同步打印，输出结果为001122…..99。证明synchronized保证了函数被调用后执行完才能被其他调用者再次调用。

当然，处理synchronized方法以外，我们同样可以使用synchronized块来对小部分的代码进行同步，再来一个例子：

public class Test {

    private static Test instance;

    private Test() {
    }

    public static Test getInstance() {

        if (instance == null) {

            //锁是类的字节码文件，由于是静态方法
            synchronized (Test.class) {

                if (instance == null) {
                    instance = new Test();
                }

            }
        }

        return instance;
    }

}

上面的代码是一个典型的使用延迟加载的单例模式类，这种时候当多线程同事调用getInstance方法时，可能出现创建多个实体的情况，这样显然不符合单例模式的思想，所以我们需要在创建实体时加上代码同步。为了避免由于判断加锁和解锁的过程带来的低效，可以再同步部分再次添加判断，避免没有必要的同步。从Java 5 开始，推出了新的同步解决办法Lock。
这部分的内容这里有一个不错的博文，推荐给大家，传送门点这里。

String

String类，作为Java中使用最为频发的几个类之一，有必要好好熟悉一下，String类其实很简单，就是对字符串的封装，以及提供了很多方法方便我们操作字符串。这里整理了一些很好用的，但是可能被大家忽略的方法：

方法	作用
charAt	获取指定位置的字符
indexOf	顺序获取字符或字符串的位置，没有返回-1
lastIndexOf	倒序获取字符或字符串的位置，没有返回-1
subString	获取指定位置的子串
contain	判断字符串是否包含指定字符串
startWith	判断字符串是否以指定字符串开头
endWith	判断字符串是否以指定字符串结尾
equalsIgnoreCase	判断字符串是否相等，忽略大小写
toLowerCase	所有字母转换为小写
toUpperCase	所有字母转换为大写
replace	替换
trim	去除字符串首位空格

总结完String的一些方法，这里再简单的提一下StringBuilder和StringBuffer两个类。String是赋值后无法修改的（我们可以看到所有的关于String的操作返回结果都是一个新的String对象而不是原对象），而StringBuilder和StringBuffer是可修改的，这两个类作用类似都用于构建字符串，不同在于：StringBuffer对于多线程是安全的，而StringBuilder对于多线程是不安全的。所以推荐的使用情况如下：
- 单线程操作时推荐使用StringBuilder，效率更高。
- 多线程时操作推荐使用StringBuffer，更加安全。

集合

Java中提供了功能强大的集合类，这里我们对Java中的集合类进行整理：

• Iterator (访问集合的迭代器接口)
• Collection（单列）
  • List(有序，可存储重复元素，元素有索引)
  • Set(无序，不可存储重复元素，元素都是唯一的)
• Map（双列）
  • Hashtable
  • TreeMap

List接口下我们经常用到主要为以下几个类：

• ArrayList: 底层数组实现，查询速度很快，线程不同步
• LinkedList:底层链表实现，增删熟读很快，线程不同步
• Vector:底层数组实现，查询增删速度都很慢，线程同步

在通过Iterator对List接口对象进行迭代时，如果想要对集合对象进行操作，会出现ConcurrentModificationException的异常，错误原因是迭代过程中Iterator已经在操作集合对象了，这时我们再去操作集合对象会导致访问冲突。解决办法是使用iterator的子接口ListIterator,这个接口提供了对List集合对象的操作。

注意：由于在List集合中，判断元素是否存在或是删除元素都是通过元素的equals方法，所以在日常的开发过程中，通常需要自己重写集合元素对象的equals方法，这样能够提高List集合的操作效率。

Set接口下我们经常用到主要为以下几个类：
- HashSet：底层数据结构为Hash表，效率高，线程不同步
- LinkedHashSet:HashSet的子类，有序
- TreeSet：底层数据结构为二叉树，可以对之中的数据进行指定顺序的排序，线程不同步

简单介绍一下Hash表是什么：
1.对元素中特有数据进行Hash算法，并得到元素的Hash值
2.Hash值就是这个元素在表中的位置
3.在存储过程中，如果Hash值发生冲突，则需要进行冲突解决，最简单的一个Hash冲突解决办法为再次判断元素是否相同，如果相同则不存储，如果不同则存储，在原元素的Hash值的基础上加1。

（提供一个Hash冲突解决的博文链接）

4.存储Hash值的结构称之为Hash表
5.为了提高效率，应该尽量保证元素关键字的唯一性，这样能够提高Hash表的效率。

TreeSet中的元素需要是可比较的，为了保证元素可比较，需要元素实现Comparable接口，TreeSet中为保证元素的唯一，是通过Comparable接口的toCompare方法来实现的，当toCompare方法返回0时，表示两个元素相同。

Map
Map接口与Collection有很大的区别，Map一次存储一个键值对,并且需要保证Map中所有的健是唯一的。
迭代Map的方法:

• 通过Map.keySet()获取健的Set,然后再遍历时通过getKey方法迭代
• 通过Map.entrySet()方法获取到键值对set，直接遍历。

这里总结一下集合的使用规律：

当需要存储的是单个数据时考虑使用Collection，当需要存储的内容是键值对形式的数据使用Map

• 需要保证内部元素唯一用Set，不要需要使用List
• 看到Array说明底层数据结构是数组，证明查询速度快
• 看到Linked说明底层数据结构是链表，增加删除的速度开
• 看到Hash说明底层数据结构是Hash表，需要尽量保证内部元素的Hash值唯一，并且需要复写元素的hasCode方法和equals方法。
• 看到Tree就说明底层的数据结构是二叉树，需要相当排序，内部元素需要Comparable

泛型
泛型只是针对编译时期，在运行时期并不存在泛型的概念，泛型只是为了将一些类型强制转换的异常转化为编译错误。使用泛型时必须保证等式两边声明的泛型是一样的。
泛型的上限与下限：

• ？extends E 泛型指 接受E和E的所有子类
• ? super E 泛型指接受E和E的所有父类

IO Stream

• 首先明确一下字符流和字节流的区别（这个问题今天早上把我一个电话面阿里的同学给难住了，有必要好好记一下）

• 字节流：字节流可以处理几乎计算机当中的所有数据（凡是以InputStream和OutputStream结尾的都为字节流）

• 字符流：字符流的出现是应为，各个国家的语言不通，字符也不通，所以当将各总编码表和流封装在一起，为了方便字符的操作，所以设计到字符操作的时候优先考虑字符流（凡是以Reader和Writer结尾的都是字符流）

开发的时候如何明确该使用什么样的流呢：

1. 如果需要读入数据使用InputStream和Reader，写入数据使用OutputStream和Writer
2. 如果需要处理纯文本对象 使用Reader和Writer，否者使用InputStream和OutputStream
3. 明确使用那个具体的流，通过明确具体操作的数据设备：（磁盘）File,(内存)CharArray。。。
4. 是否需要利用缓存提高效率，如果需要可以使用Buffer对流进再一次的封装。