Java基础知识
1、关键字
2、标识符
3、基本类型和引用类型
4、public、default、protected、private
5、static、Final、abstract
6、构造方法：
7、this 和 super
8、== 和 equals
9、字符容器（String、StringBuffer、StringBuilder）
10、File(Java 文件操作)
11、流
12、常用类(内部类、匿名类、抽象类)
13、字符问题
14、三大特性(封装、继承、多态)
15、继承（extends）
16、接口（implements）
17、重写和重载
18、数组
19、泛型
20、枚举
21、语法基础
22、hashcode和equals (MD5的计算是目前最广泛的哈希算法)
23、类的加载执行、初始化
24、网络通信（Socket）
25、调用方法的参数传递问题
26、public static void main(String[] args){}
27、system.out.print(): 类名.成员变量.静态方法
// 陌生单词：compile编译、deprecation过时、PermGen永久代(方法区)、Heap堆内存
准备明年开始找工作，所有刷了牛客app上的900多道Java相关的笔试题，
整理了答案下面的 精华知识，以备不时之需。如有不合理之处，万望知会。
1、关键字
修饰符： abstract、class、final、private、protected、public、static、7
数据类型：boolean、byte、char、double、float、int、long、short、void、9
语句组成：break、case、catch、continue、default、do、else、extends、finally、 for、if、implements、import、instanceof、interface、new、package、 return、super、switch、sychronized、this、throw、throws、try、while26
特殊含义关键字：assert、const、goto、enum、native、strictfp、transient、volatile、7
assert: 断言，用于调试，多被junit代替，IDE默认不开启。
const：预留关键字。
goto：预留关键字。
enum: 枚举。
native: 本地方法。
strictfp: 精确浮点，可用于类、接口、方法。
transient: 免除变量序列化。
volatile: 被设计用来修饰被不同线程访问和修改的变量。
非java关键字：true、false、sizeof、null、serilizable、
2、标识符
标识符是用来标识类名、变量名、方法名、类型名、数组名及文件名的有效字符序列。
1、标识符由字母、数字、下划线、美元符号组成，长度不受限制。
2、第一个字符不能为数字。
3、标识符不能是关键字。
4、标识符不能是true、false、null(字面常量)
3、基本类型和引用类型
Java中基本类型有四类八种，也称为原生类、内置类。其余的都属于引用类型
整数：(byte、short、int、long) 引用类型：(Byte、Short、Integer、Long)
浮点：(float、double) 引用类型：(Float、Double)
字符型：(char2) 引用类型：(Character)
逻辑型：(bolean1) 引用类型：(Boolean)
nume(枚举)是基本类型
String是基本类型
一个字符常量表示一个字符或一个转义字符，被一列ASCII单引号包裹。
数组无论是定义实例变量还是局部变量，若没有初始化，都会被自动初始化。
char[] ch = new char[3]; //默认空格
int [] arr = new int[2]; //默认0
String[] string = new String[2]; //默认null
Byte类型引用包装类默认为null,byte的默认值为0，byte[-128,127]
char类型存储unicode码，占两个字节16位，默认值为’’,默认使用GBK编码，可存中文汉字。UTF-8一个汉字占3个字节，GBK占两个字节。
java中的小数类型默认值为double.
包装类型：Integer a=1; a=2; 在方法内===>等于重新new一个a对象，
在方法外===>等于改变a的指向地址，
包装类对象做基本操作(拆比较、计算)会拆箱，不再是引用传递。
引用类型一般有 数组(数组是一种对象，有行为，大小一旦确定，不能改变)、类、接口。
a = Integer.parseInt(“1024”);==>parseInt把String对象类型转换为 int。
b= Integer.ValueOf(“1024”).intValue(); ===>ValueOf把String转换为Integer类型，(JDK支持装箱拆箱)，intValue(); 把Integer类型转化为int类型。
Integer i01 = 59;会调用Integer的valueOf方法，判断是否在[-128,127]之间，返回引用或新建对象。
int i02 = 59;基本类型，存储在栈中。
Integer i03 = Integer.valueOf(59);直接返回引用(IntegerCache中的对象引用)
Integer i04 = new Integer(59); 直接创建一个新的对象
i01 == i02; ===>Integer会拆箱成int,做值之间比较 true
i02 == i04; ====>Integer会拆箱成int,做值之间比较 true
4、public、default、protected、private
访问权限
5、static、Final、abstract
static : 在编译器就确定了函数和地址，不存在多态情况
静态方法属于类，静态方法在对象实例创建前已经存在了，它的使用不依赖对象是否被创建，当我们通过实例来调用方法时，实际上还是把实例对象转换成类去调用方法，这里的null没有意义。((TestClass) null).testMethod()；可以写成TestClass t = null; t.testMethod(); null可以被强制转换成任意类型对象。(空指针可以操作 类变量和类方法)
静态方法不能引用非静态变量。不能调用类的对象方法，在类方法中不能使用this、super。但可以new对象，有了对象就可以实现实例的成员变量和方法。
static修饰的为类变量和类方法，在类初始化时加载完成，可以被成员方法调用或访问。
Final: 可以用来修饰类、变量、方法、引用。类不能被继承，方法不能被重写，可以继承和重载。变量经修饰变为常量，引用不能变，在编译期就确定，变为宏变量。
final修饰的对象引用不能变，即地址不可变，但地址中的值可变。 p.name = ”aaa”; p.name=”bbb”;但对于String(只读类型的引用？？？)特殊，final String str=”aaa”; str=”bbb”; //编译不通过，引用被改变。
final修饰方法：声明final就是防止功能被修改。
final修饰局部变量可以在声明时初始化，也可以在第一次使用时通过方法或表达式赋值，
final修饰的成员变量可以在类方法、声明、初始化块中赋值，==>没有默认值，声明同时赋值。
6、构造方法：
构造方法可以被public、private、Protected修饰，不能被继承。
7、this 和 super
this: 表示某个对象，this可以出现在实例方法和构造方法中，但不可出现在类方法中。
this出现在构造方法中，代表当前对象，一般省略。
this出现在实例方法中，代表正在调用当前方法的对象，成员变量和局部变量重名时出现，多出现在set方法中，对象的成员变量。
super：子类一旦隐藏了继承的成员变量，那么子类创建的对象就不再拥有该变量，该变量就归super关键字所拥有。
在子类的构造函数中默认有super();
父类没有无参构造时，需在子类的构造方法中显式调用super(“xxx”);
只有在重写了父类的方法之后，再调用父类的方法需要使用super调用。
父类静态方法不能被子类重写，只是被隐藏，也需要使用super调用。
8、== 和 equals
== 比较类型和值(也可以说是比较地址)
equals 底层也采用 == 做比较，但String中重写了Object中的此方法，用于比较字符串的内容。
Object中equals的源码，没有重写equals时，底层直接用“==”做判断。而String中重写了方法。
public boolean equals(Object obj){
return (this==obj);
}
重写后的equals方法：
public static boolean equals(String str1, String str2) {
return str1 == null ? str2 == null : str1.equals(str2);
}
9、字符容器（String、StringBuffer、StringBuilder）
String传递是引用传递，StringBuffer是引用传递===>可改变内容，不可改变引用地址。
String s = new String(“xyz”); 分常量池和堆。
xyz可能存在于两个地方，编译期遇到”xyz”,检测到常量池没有xyz存在，就在常量池中创建一个xyz常量。
new String(“xyz”)会在执行时，在堆中创建一个实例。
10、File(Java 文件操作)
1)File类是对文件整体或者文件属性操作的类，例如：创建文件，删除文件等，文件内容用IO流操作。
2)能用文本文档打开的都是文本文件(文本打开乱码都不是文本文件)，用特殊应用打开的都是二进制文件。
3)输出过程到达文件或流的末尾，会抛出EOFException，正常情况异常 会被处理返回特殊值(read()会返回-1)。
11、流
字节流继承于InputStream、OutputStream
字符流继承 InputStreamReader/OutputStreamWriter
1)InputStreamReader的构造函数：
InputStreamReader(InputStream in): 创建一个使用默认字符集的InputStreamReader.
InputStreamReader(InputStream in,Charset cs):创建使用给定字符集的InputStreamReader
InputStreamReader(InputStream in,CharsetDecoder dec):创建使用给定解码字符集的InputSt..
InputStreamReader(InputStream in,String charsetName):创建使用给定字符集的InputStream..
BufferedReader的构造函数：
BufferedReader(Reader in):创建使用默认大小输入缓冲区的缓冲字符输入流
BufferedReader(Reader in,int size):创建使用指定大小输入缓冲区的缓冲字符输入流
Writer的构造函数：
Protected ... Writer( ):创建一个字符流writer，其作用是同步到writer自身，
Protected...Writer(Object lock):创建一个字符流writer，作用是同步到给定的对象
管道流：管道实际上是一个大小固定的缓冲区，管程对于管道两端的进程而言，就是一个文件，但它不是普通文件，它单独构成一种文件系统，并且只存在内存中，类似于半双工通信。管道的内存大小通常是内存上的一页，它的大小并不受磁盘容量大小的限制。当管道空时，进程读操作会堵塞，管道满时，写操作会堵塞。
PipedInputStream的构造函数：
PipedInputStream():创建一个尚未连接的PipedInputStream.
PipedInputStream(int pipeSize):创建尚未连接的PipedInputStream，并指定管道缓冲区的大小
PipedInputStream(PipedOutStream src):创建PipedInputStream，连接到管道输出流src
PipedInputStream(PipedOutputStream sc,int pipeSize):创建PipedInputSt...，指定大小,连接src。
12、常用类(内部类、匿名类、抽象类)
对于局部类、方法、变量，只针对特定区域有效，访问权限无效。
外部类的修饰符可以为 public 和 默认缺省修饰符(default)。因为外部类在包中，只有包可见和包不可见。
外部类中的内部类可以看做是外部类的成员变量。
内部类：(常规内部类、静态内部类、局部内部类、匿名内部类)
常规内部类：没有用static修饰且定义在外部类类体中，可直接访问外部类成员变量、方法。
静态内部类：与静态内部方法相似，只能访问外部类的static成员，可通过对象引用访问外部类的成员变量。(实例变量、方法)
局部内部类：存在于方法体或语句块中(包括方法、局部块、静态初始化块)不能加任何修饰符，只对局部有作用。
匿名内部类：定义一个类的同时创建一个没有名字的类称为匿名内部类，只用一次。
静态内部类才可以定义static方法，
内部类权限修饰符可以为public、protected(同包子类)、默认(同包)、private(同类有效)，所以说一个java文件可以有多个public修饰的类。
为什么使用内部类？每个内部类都能独立的继承一个(接口)实现，无论是外部类是否已继承。最大的优点就是它能够非常好的解决多重继承的问题。
1)内部类可以有多个实例，且每个实例有自己的状态信息，相互独立。
2)在单个外部类中，可以让多个内部类以不同方式来实现同一个接口，或者继承同一个类。
3)创建内部类实例对象不依赖外部类。
4)内部类没有令人迷惑的” is--a ”关系，它就是一个独立的实体。
5)内部类提供了更好的封装，除了外部类，其他类不可访问。
匿名类：
匿名内部类：用在任何允许存在表达式的地方，只能用一次。
局部内部类：用在任何允许出现局部变量的地方，可以在自己的定义域中多次使用。
抽象类：一般使用Protected修饰
abstract不可与final、static、private共存，因为需要被继承，重写方法。
抽象方法中不能有方法体，抽象类中可以没有抽象方法。
抽象类有构造方法，可以给子类初始化，但不可实例化，(可用在匿名内部类？？)
抽象类可以实现接口，也可以继承自抽象类。
抽象类有构造方法，但不是用来实例化的，而是用来初始化的。
抽象类可以定义普通成员变量而接口不可以，但是两者都可以定义静态成员变量。
13、字符问题
java语言使用Unicode字符集，而ASCII是国际上使用最广泛的字符编码，BCD是一种数字压缩存储编码Unicode(又称统一码、万国码、单一码)是计算机学领域上的一项业界标准，包括字符集、编码方案等，为每种语言的每个字符设定了统一并且唯一的二进制编码，以满足跨语言，跨平台的文本转换。一个unicode(中英文一样)占两个字节(16bit)。
UTF-8、UTF-16、UTF-32都是将Unicode装换到程序数据的编码方案。
JVM使用UTF-16保存字符。
编码(Unicode)就是一个编号(数字)到字符的一种映射关系，一对一的映射表。
编码格式(UTF-8)就是序列化或存储编码中的那个编码的一种”格式”。
中文汉字在java(Unicode)中占两个字节，在utf-8中占三个字节，在gbk中占两个字节。
标准ASCII 只使用7个bit,扩展的ASCII 使用8个bit,ASCII 中包括一些不可打印字符，0-31分配给不可打印字符，
ANSI通常使用0x00--0x7f范围的一个字节来表示1个英文字符，即扩展的ASCII编码。代表本地编码格式。
简体中文windows中，ANSI代表GBK,GB2312 是国标。
繁体中文 ANSI代表 Big5。
日文中 ANSI 代表shift_JIS。
14、三大特性(封装、继承、多态)
15、继承（extends）
继承：基类和派生类是父子关系，超类和子类也是父子关系，父类中类方法不会被继承，属于super关键字所拥有。
16、接口（implements）
接口变量用public static final修饰，为常量。方法没有方法体，为抽象方法。
接口的方法修饰符为 public abstract，接口是通用的，不设访问权限。
接口中没有构造函数，
接口没有构造函数，所以不能实例化，
17、重写和重载
多态包括重载和重写，
重载是方法的多态，调用方法时通过传递给方法的不同参数(参数个数、参数类型)来确定具体使用哪个方法。(向上转型，编译看左边，决定哪些方法编译，运行看实际类型选择)
方法名一致，返回值类型和访问权限没有要求。
重载选择执行方法时，是参考传入参数的实际类型，而不是静态类型(特别注意上转型)
重写存在于子父类中，遵循两同两小一大原则，
方法名、参数相同。
返回值类型、抛出异常要小。
访问权限要大。
对于成员变量，编译和运行都参考左边。
对于成员函数(非静态)：编译看左边，运行看右边。
对于静态函数：编译和运行都看左边。
18、数组
19、泛型
泛型防止代码编写出错，在编译期，泛型会被擦除，并不会影响运行速度。
20、枚举
枚举是JDK1.5新增的特性，它是一种新的类型，表示特定的数据片段，类型安全，是特殊类，拥有成员变量和方法。 (写一个根据输入输出星期程序)
所有的枚举值都是类静态常量，在初始化时会对所有的枚举值对象进行一次初始化。
21、语法基础
1、if(x=y)==>会出错，发生类型强转异常。(mismatch) 。
2、int x=1;float y=2; x/y=1.0/2.0=0.5==>发生自动转型，byte-short-char-int-long-float-double
3、public class A extends B implements C{} ===>先继承再实现
4、package在程序文件的第一句，且没有注释。
5、float f = 1.0f; f必须有。
6、int a[] = null; a[0] = 1; 抛出NullPointException。
7、<< 左移，乘以2的n次方， << 无符号左移，末尾补0， >>> 无符号左移
8、instanceOf运算符用来判断一个变量所引用的对象的实际类型，(重点考察上转型看实际)
9、强制转int型，会向下取整。 int(5.7) = 5
10、包装类相关：
两种不同类型的引用不能进行”==”比较,例如：Integer和Double
s.equals(q);在进行equals比较之前，会对q调用Integer.valueOf;进行自动装箱，由于IntegerCache中已经存在q,所以，直接创建了一个新的Integer实例，但值也是q,满足条件，返回真。
包装类也重写equals,没有常量池，Integer s = new Integer(q)；Integer t = new Integer(q)；强制在堆内存创建 q 对象实例。
11、String str1 = new String(“hello”); //正常创建对象保存在堆区
String str2 = “Hello”; //创建的字符串，保存在字符串常量区
12、当使用Integer赋值的时候，java编译器会将其翻译成调用ValueOf()方法，比如 Integer i = 127,对于-128到127之间的数，Java会对其进行缓存，超过这个范围则新建一个对象。
13、求数组的长度(容量)：length。
求字符串的长度：length()。
求集合的长度：size().
22、hashcode和equals (MD5的计算是目前最广泛的哈希算法)
哈希又称散列，通过散列算法将任意长度的输入变成固定长度的输出，又称散列值，是一种压缩映射，散列值可能相同。
1) 如果两个对象相等，那么他们一定有相同的哈希值。
2) 如果两个对象哈希值相等，它们不一定相等。需要用equals判断。
hash值： 具有等幂性(对象不变,做多少次计算hash值都不变)、
对等性(equals计算两个对象相等，而hash值一定对等)、
互异性(若两个对象equals为false，而hash值最好也不同)
hash值的计算一般采用 多个成员变量的hash值相加，或 加权值
对象的hash值做key。
23、类的加载执行、初始化
类的加载顺序:
父类静态块--子类静态块--父类初始化块--父类构造方法--子类初始化块--子类构造方法
静态块---main()---初始化构造块-----构造方法
静态域最先初始化，静态域包括静态变量和静态方法，
new一个对象==初始化静态块+执行构造函数。
初始化父类静态变量、静态代码块，
初始化子类静态变量、静态代码块，
初始化父类普通成员变量、代码块、父类构造方法，
初始化子类普通成员变量、代码块、子类构造方法，
在继承存在的情况下，类的执行：
父类静态对象、父类静态代码块
子类静态对象、子类静态代码块
父类非静态对象、父类非静态代码块、父类构造函数
子类非静态对象、子类非静态代码块、子类构造函数
Java中对字段属性是静态绑定(编译出错)，方法成员是动态绑定(运行出错)。
对象的初始化方式(实例化对象)：
1)new时初始化 ：调用构造函数，分配内存空间，
2)静态工厂newInstance ：
3)反射Class.forName()：使用构造方法
4)clone方式：clone只是复制拷贝(深拷贝需要new，浅拷贝不需要，原来的对象的改变不反应在拷贝对象上)
5)反序列化：readObject是从文件中还原对象
24、网络通信（Socket）
服务器端：ServerSocket server = new ServerSocket(端口号)；
服务器端的常用方法：
ServerSocket(int port)、accept()、close()、getInetAddress()、getLocalPort()
客户端： Socket soc = new Socket(ip地址，端口号);
客户端的常用方法：
Socket(InetAddress address, int port)、 Socket(String host, int port)、close()
25、调用方法的参数传递问题
26、public static void main(String[] args){}
main方法中的变量也是局部变量，
27、system.out.print(): 类名.成员变量.静态方法
system是java.lang的一个类，out是system内的一个成员变量，这个变量是java.io.PrintStream类的对象。println()是java.io.PrintStream类的方法，所以可以调用类.成员变量.println()方法。
// 陌生单词：compile编译、deprecation过时、PermGen永久代(方法区)、Heap堆内存
8120
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
