Java基本知识点

Java基础知识

一、关键字

二、标识符

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、标识符

  标识符是用来标识类名、变量名、方法名、类型名、数组名及文件名的有效字符序列。

一、标识符由字母、数字、下划线、美圆符号组成，长度不受限制。

二、第一个字符不能为数字。

三、标识符不能是关键字。

四、标识符不能是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、三大特性(封装、继承、多态)

  

 

 

1五、继承（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堆内存