1、java的单一继承使代码更可靠

1、Java是单继承，但是可以实现多个接口。为什么不能实现类的多继承？为了防止多个类中有相同的方法名，这个时候，子类不知道要重写哪一个方法，但是接口可以有多个，因为接口没有方法体，无论重写哪一个，没有区别。

2、定义一个接口使用的关键字为interface

3、this是当前对象的引用，super表示的是当前类的父类对象的引用

4、假设一个 list初始化为{2，9，5，4，8，1}。 在第一轮冒泡排序后，list变成了{2, 5, 4, 8, 1, 9}

1、首先先明白冒泡排序的机制：
    依次比较相邻的两个数，将小数放在前面，大数放在后面。
    即在第一趟：首先比较第1个和第2个数，将小数放前，大数放后。然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。至此第一趟结束，将最大的数放到了最后。
    在第二趟：仍从第一对数开始比较（因为可能由于第2个数和第3个数的交换，使得第1个数不再小于第2个数），将小数放前，大数放后，一直比较到倒数第二个数（倒数第一的位置上已经是最大的），第二趟结束，在倒数第二的位置上得到一个新的最大数（其实在整个数列中是第二大的数）。如此下去，重复以上过程，直至最终完成排序。

5、Java中所有的类都直接或间接继承自Object，无论是否明确的指明，无论其是否是抽象类。

1、Object是基类Java中的所有的类都直接或间接的继承。 2、从一个class派生的必然是另一个class。Object是一个class，如果interface继承自Object，那么interface必然是一个class 3、java中接口跟类是两个并行的概念，所有类都继承Object，但接口是接口，不继承Object. 4、接口是一系列方法声明的开放集合，即所有实现了该接口的类都具备该接口公开的方法，通常为了隐藏实现以及程序的可拓展性用到接口，因为在所有可以使用接口的地方都可以使用它的实现类来替换。

6、A有构造方法A(int a)，则在类A的其他构造方法中调用该构造方法和语句格式为 this(x)

1、this的作用其中一个就是在一个构造方法中调用另一个构造方法，格式为this(参数) 2、this.A(x)为调用普通方法的写法 3、super(x)为调用父类方法的写法 4、A(a)这种形式是在new一个类时使用

7、toString和valueOf返回的都是字符串，只有在char类型变成int类型是才返回的是对应的assic编码

public static String toString(char c) { return String.valueOf(c); }

public static String valueOf(char c) { char data[] = {c};  return new String(data, true); }

8、哪些具体实现类可以用于存储键，值对，并且方法调用提供了基本的多线程安全支持：

1、java.util.Hashtable：
    Hashtable是线程安全的哈希表，它是通过synchronized来保证线程安全的；
    即，多线程通过同一个“对象的同步锁”来实现并发控制。Hashtable在线程竞争激烈时，效率比较低（此时建议使用ConcurrentHashMap）。当一个线程访问Hashtable的同步方法时，其它线程如果也在访问Hashtable的同步方法时，可能会进入阻塞状态。 2、Collections.synchronizedMap()使用了synchronized同步关键字来保证对Map的操作是线程安全的。 3、ConcurrentHashMap是线程安全的哈希表。在JDK1.7中它是通过“锁分段”来保证线程安全的，本质上也是一个“可重入的互斥锁”（ReentrantLock）。多线程对同一个片段的访问，是互斥的；但是，对于不同片段的访问，却是可以同步进行的。在JDK1.8中是通过使用CAS原子更新、volatile关键字、synchronized可重入锁实现的。

9、final关键字：

1、final修饰的类不能被继承 2、final修饰变量，则等同于常量。 3、final修饰方法中的参数，称为最终参数 4、final修饰类，则类不能被继承 5、final修饰方法，则方法不能被重写。 6、final 不能修饰抽象类 7、final修饰的方法可以被重载 但不能被重写

10、抽象方法只能定义在抽象类中，抽象方法和抽象类必须由abstract修饰，abstract关键字只能描述类和方法，不能描述变量。抽象方法只定义方法声明，不定义方法实现。抽象类不可以被实例化（创建对象），只有通过子类继承抽象类并覆盖抽象类中的所有抽象方法后，该子类才可以被实例化，否则该子类还是一个抽象类。抽象类中有构造函数用于给子类对象进行初始化，同时抽象类中可以含有非抽象方法。abstract关键字不可以与final，private,static关键字共存，因为被final修饰的方法不可以被重写，意味着子类不可以重写该方法，如果abstract和final共同修饰父类中的方法，子类要实现抽象方法（abstract的作用），而final又不让该方法重写，这相互矛盾。如果private和abstract共同修饰父类中的方法，private修饰则该方法不可以被子类访问，但是abstract修饰需要子类去实现，两者产生矛盾。如果static和abstract共同修饰父类中的方法，static表示是静态的方法，随着类的加载而加载，则该方法不需要在子类中去实现，这与abstract关键字矛盾。

11.static用于修饰成员变量和成员函数，想要实现对象中的共性数据的对象共享，可以将这个数据进行静态修饰，被静态修饰的成员可以直接被类名调用，静态随着类的加载而加载，而且优先于对象存在。静态方法只能访问静态成员（静态方法和静态变量），不可以访问非静态成员，这是因为静态方法加载时，优先于对象存在，所以没有办法访问对象中的成员。静态方法中不能使用this和super关键字，因为this代表本类对象，super代表父类对象，而静态时，有可能没有对象存在，所以this和super无法使用。

12.final关键字可以修饰类，方法，变量（成员变量内，局部变量，静态变量），被final修饰的类是一个最终类，不可以被继承，被final修饰的方法是一个最终方法，不可以被覆盖，但是可以被继承。被final修饰的变量只能是一个常量，只能赋值一次。内部类被定义在类中的局部位置上时，只能访问局部被final修饰的局部变量。

13、对于public修饰符，它具有最大的访问权限，可以访问任何一个在CLASSPATH下的类、接口、异常等。它往往用于对外的情况，也就是对象或类对外的一种接口的形式。 对于protected修饰符，它主要的作用就是用来保护子类的。它的含义在于子类可以用它修饰的成员，其他的不可以，它相当于传递给子类的一种继承的东西。 对于default来说，有点的时候也成为friendly（友员），它是针对本包访问而设计的，任何处于本包下的类、接口、异常等，都可以相互访问，即使是父类没有用protected修饰的成员也可以。 对于private来说，它的访问权限仅限于类的内部，是一种封装的体现，例如，大多数的成员变量都是修饰符为private的，它们不希望被其他任何外部的类访问。

14、接口可以继承接口，而且可以继承多个接口，但是不能实现接口，因为接口中的方法全部是抽象的，无法实现；普通类可以实现接口，并且可以实现多个接口，但是只能继承一个类，这个类可以是抽象类也可以是普通类，如果继承抽象类，必须实现抽象类中的所有抽象方法，否则这个普通类必须设置为抽象类；

拓展： 1、抽象类可以实现接口，可以继承具体类，可以继承抽象类，也可以继承有构造器的实体类。抽象类中可以有静态main方法；抽象类里可以没有抽象方法，没有抽象方法的抽象类就是不想让别人实例化它；另外，抽象类可以有构造方法，只是不能直接创建抽象类的实例对象而已。在继承了抽象类的子类中通过super(参数列表)调用抽象类中的构造方法，可以用于实例化抽象类的字段。
抽象类与接口的区别： 1、抽象类和接口都不能直接实例化，如果要实例化，抽象类变量必须指向实现所有抽象方法的子类对象，接口变量必须指向实现所有接口方法的类对象； 2、接口只能做方法申明，抽象类中可以做方法申明，也可以做方法实现（java8中 接口可以有实现方法 使用default修饰）； 3、接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量； 4、抽象类里的抽象方法必须全部被子类所实现，如果子类不能全部实现父类抽象方法，那么该子类只能是抽象类。同样，一个类实现接口的时候，如不能全部实现接口方法，那么该类也只能为抽象类； 5、抽象方法要被实现，所以不能是静态static的，也不能是私有private的，也不能被final修饰（试想一下，静态方法可以被类名直接调用，而类名直接调用一个没有实现的抽象方法没有意义）

15、常见的异常：

1、java.lang.NullPoninterException（空指针异常） 2、java.lang.NumberFormatException（数字格式异常） 3、java.lang.RuntimeException（运行时异常） 4、java.lang.ArrayindexOutOfBoundsException（数组下标越界异常）

16、线程： 1、线程通过使用synchronized关键字可获得对象的互斥锁定。
2、采用synchronized修饰符实现的同步机制叫做互斥锁机制，它所获得的锁叫做互斥锁。每个对象都有一个monitor(锁标记)，当线程拥有这个锁标记时才能访问这个资源，没有锁标记便进入锁池。任何一个对象系统都会为其创建一个互斥锁，这个锁是为了分配给线程的，防止打断原子操作。每个对象的锁只能分配给一个线程，因此叫做互斥锁。 3、对于线程而言，start是让线程从new变成runnable。run方法才是执行体的入口。但是在Thread中，run方法是个空方法，没有具体实现。Bground继承了Thread，但是没有重写run方法，那么调用run方法肯定是无输出。

17、我们在为Integer赋值的时候，java编译器会将其翻译成调用valueOf()方法。比如Integer i=127翻译为Integer i=Integer.valueOf(127)

public static Integer valueOf(int i) { //high为127 if(i >= -128 && i <= IntegerCache.high)
            return IntegerCache.***[i + 128]; else return new Integer(i);
    }

这样可以看出对于-128到127之间的数，Java会对其进行缓存。而超出这个范围则新建一个对象。 所以现在回到这道问题i1和i2为128，超出范围，所以都需要新建对象，对象比较为false； i5和i6为100，在范围之内，在执行Integer i5=100时，就会直接缓存到内存中，但执行执行Integer i6=100时，就直接从缓存里取，而不需要新建对象，所以为true。

18、volatile：

1、synchronized保证三大性，原子性，有序性，可见性，volatile保证有序性，可见性，不能保证原子性

拓展： volatile到底做了什么？ 1、禁止了指令重排； 2、保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量值，这个新值对其他线程是立即可见的； 3、不保证原子性（线程不安全） synchronized与volatile关键字比较： 1、volatile关键字是线程同步的轻量级实现，所以volatile性能肯定比synchronized关键字要好。但是volatile关键字只能用于变量而synchronized关键字可以修饰方法以及代码块。synchronized关键字在JavaSE1.6之后进行了主要包括为了减少获得锁和释放锁带来的性能消耗而引入的偏向锁和轻量级锁以及其它各种优化之后执行效率有了显著提升，实际开发中使用 synchronized 关键字的场景还是更多一些。 2、多线程访问volatile关键字不会发生阻塞，而synchronized关键字可能会发生阻塞。 3、volatile关键字能保证数据的可见性，但不能保证数据的原子性。synchronized关键字两者都能保证。 4、volatile关键字主要用于解决变量在多个线程之间的可见性，而 synchronized关键字解决的是多个线程之间访问资源的同步性。

TCP客户端： 1、建立连接套接字，设置Ip和端口监听，socket()； 2、建立连接 connect； 3、write() 获取网络流对象 发送数据 4、read()获取网络流对象 接收数据； 5、关闭套接字

TCP服务器端: 1、建立端口监听 socket() 2、绑定指定端口 bind() 3、listen 进行端口监听 4、accept() 阻塞式 直到有客户端访问 5、read()获取客户端发送数据 6、write()发送返回数据 7、close关闭端口监听
概述来说：
首先是服务器初始化Socket，然后是与端口进行绑定(blind()),端口创建ServerSocket进行监听(listen()),然后调用阻塞(accept()),等待客户端连接。与客户端发生连接后，会进行相关的读写操作(read(),write())，最后调用close()关闭连接

1、System.in （标准输入） 2、System.out （标准输出 ） 3、System.err   （输出错误） 4、System.exit()（结束程序）

public class Demo{  public static void main(String args[]){  int num = 10;  System.out.println(test(num));
} public static int test(int b){  try  {  b += 10;  return b;  }  catch(RuntimeException e)  {  }  catch(Exception e2)  {  }  finally  {  b += 10;  return b;  }  }
}

1、ArrayList插入和现有项的删除开销很大,除非在末端 2、LinkedList插入和删除开销很小 3、ArrayList和LinkedList都是实现了List接口
HashMap可以用null值和空字符串作为K,不过只能有一个

共享资源 1、 堆  由于堆是在进程空间中开辟出来的，所以它是理所当然地被共享的；因此new出来的都是共享的（16位平台上分全局堆和局部堆，局部堆是独享的） 2、全局变量 它是与具体某一函数无关的，所以也与特定线程无关；因此也是共享的 3、静态变量 虽然对于局部变量来说，它在代码中是“放”在某一函数中的，但是其存放位置和全局变量一样，存于堆中开辟的.bss和.data段，是共享的 4、文件等公用资源  这个是共享的，使用这些公共资源的线程必须同步。Win32 提供了几种同步资源的方式，包括信号、临界区、事件和互斥体。
私有资源： 1、栈 栈是独享的 2、寄存器  这个可能会误解，因为电脑的寄存器是物理的，每个线程去取值难道不一样吗？其实线程里存放的是副本，包括程序计数器PC

1.从地址栏显示来说
forward是服务器请求资源,服务器直接访问目标地址的URL,把那个URL的响应内容读取过来,然后把这些内容再发给浏览器.浏览器根本不知道服务器发送的内容从哪里来的,所以它的地址栏还是原来的地址.

redirect是服务端根据逻辑,发送一个状态码,告诉浏览器重新去请求那个地址.所以地址栏显示的是新的URL. 2.从数据共享来说
forward:转发页面和转发到的页面可以共享request里面的数据.
redirect:不能共享数据. 3.从运用地方来说
forward:一般用于用户登陆的时候,根据角色转发到相应的模块.
redirect:一般用于用户注销登陆时返回主页面和跳转到其它的网站  等. 4.从效率来说

forward:高.
redirect:低.