• 凉风有兴,秋月无边, 亏我思娇的情绪好比度日如年。
  • 虽然我不是玉树临风,潇洒倜傥, 可是我有我广阔的胸襟,加强健的臂腕!

Java基本知识点

网站推广 villain 4个月前 (12-07) 12次浏览 已收录 0个评论

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方法:

publicstaticbooleanequals(String str1, String str2) {

returnstr1== 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堆内存


Villain博客 , 版权所有丨如有问题请联系客服QQ:1004619丨
转载请注明Java基本知识点
喜欢 (0)
[gqakcom@126.com]
分享 (0)

您必须 登录 才能发表评论!