Java 笔记 | Rainnn の Blog

type

status

date

slug

summary

Ⅰ选择

一、知识点

1.对同一个package中的各个类，类的名称不能重复。定义在同一个包（package）内的类可以不经过import而直接相互使用。

2.Java中保留但不允许使用的标识符：goto const

3.逻辑/位运算结合性的优先级：非、与、或

4.用关键字static final修饰属性变量，必须同时定义变量的初始值。

(待确认)

5.byte 8 [-128,127] short 16 int 32 long 64 float 32 double 64 位

6.计算机是由硬件系统和软件系统两部分组成的。

7.在程序中书写注释不会影响程序的执行，可以多写一些详细的注释。（√）

8.基本数据类型是没有静态方法的，但是基本数据类型的包装类却有静态方法

9.默认的浮点数类型是double

10.Java中的接口(interface)没有继承Object类

11.java中的包和操作系统没有任何关系，java的包是用来组织文件的一种虚拟文件系统。

12.main方法的返回值类型只可以是void

13.方法main与方法Main在Java中被认为是不同的方法，可以同时在一个类中定义。

14.父类的引用指向子类对象，该引用只能调用父类中定义的方法和变量，如果子类中重写了父类中的一个方法，那么在调用这个方法的时候，将会调用子类中的这个方法。

15.关键字static修饰的方法（静态方法），不能直接调用实例方法（不用static修饰的方法）。

16.对于二进制文件的读取，读到文件末尾会抛出EOFException 异常。

17.各种数据类型混合运算结果

相同数据类型正常计算

short、byte、char等类型的变量在参与运算时会先被隐含地转换为int类型，再参与运算。

int和long做运算，则int转成long，最后结果是long类型。

int和float运算，先有float到double，再由int到double。最后结果是double。

18.将java文件编译成字节码文件（.class)，使用java虚拟机（JVM）（在不同操作系统上虚拟机不同）运行字节码文件（将字节码翻译为机器码），计算机硬件直接执行机器码。

19.String实例一旦创建完毕，就不能再修改其内容。（String不等同于char[]）

20.this是对象内部指代自身的引用，同时也是解决成员变量和局部变量同名问题

21.main函数遵循静态函数的规则，所以每个类都可以写一个main，但运行时要选定一个作为程序入口。（一个Java文件中可以有多个类，但只能有一个用public修饰的类，每个类里都可以有一个main方法。因此一个java文件可以有多个main方法。）

22.在一个类的main方法中，不能够使用super关键字调用父类的方法。

23.static变量可以不用初始化，默认为0

24.Java运行环境（JRE）能够自动完成常规的内存管理，不用显式的释放内存

25.Java程序的jar文件不可以双击执行

26.&&在逻辑上优先级要高于||，但在执行上要考虑其短路特性和结合性。

二、方法

1.字符串转换为数字

2.最大公约数最小公倍数

3.break 只能用于switch 语句和循环语句中

continue 只能用于循环语句中

4.return语句的返回值形式，和方法定义的返回值形式，可以存在默认类型转化关系

赋值语句

6.字符串获取长度的方法：.length()注意是方法而非属性。

数组有属性 .length 长度是属性而不是方法，不能写成.length()

7.main方法参数必须为字符串数组 (String [ ])，变量名可以随意，通常使用args

8.负数对正数取余结果为负数，正数对负数取余结果为正数

9.switch break default

三、类和对象

（一）变量

1.局部变量：在方法体中声明的变量

没有默认值，必须初始化

方法结束后，局部变量就会自动销毁

不可以是静态的

访问权限修饰符不能用于局部变量

2.实例（成员）变量：在类中但在方法体外声明的变量，成员变量定义了类的属性

在对象创建时创建，在对象销毁时销毁

byte short int long默认值为0，float double为0.0，String为null

可以被访问权限修饰符修饰

可以被类中方法、构造方法和特定类的语句块访问

3.静态变量：由所有的类实例共享。对于类的所有对象，只存在一个静态变量实体。随着类的加载而加载，随着类的销毁而销毁。有默认值，不必初始化。

（二）静态方法

1.静态方法：可以通过类名称来调用

2.非静态方法的调用必须先有一个实例，通过实例来调用

3.静态方法只能引用静态变量或局部变量

4.静态方法中不能有this和super ，因为static属于类的范畴，this和 super 属于对象的范畴。同样静态方法中也不允许出现将成员变量赋值给局部变量的操作

5.方法的局部变量不允许被static 修饰

6.静态方法可以被子类重写，但两个静态方法各自属于各自的类，即当使用多态创建子类对象调用该静态方法时，由于是父类引用，所以会调用父类中的静态方法。若是子类引用指向子类对象调用该静态方法，则调用子类中的静态方法。

7.被static修饰的方法必然也可以重载

四、数组

数组是一种对象

1.定义数组：

数组有属性例：.length

数组创建后长度不可变

定义多维数组，第一维数组的大小必须初始化，其他的不必初始化

但是使用时必须先对要使用的其他维度的数组进行大小初始化才可以赋值

int[][][] arr = new int[3][][];

2.for-each

For-each版本的循环，每次把数组中的下一个元素拷贝到循环变量中，对于数组类型是基本数据类型的情况，不会改变原来数组内容

例：

3.可变长度参数表

使用某种特殊语法的形参表，使所定义的方法能接收任意个数的参数，并将参数自动存入数组以便在方法中进行处理。

参数可以是任何类型

可变参数必须写在形参表的最后，且一个方法不能接受两组可变参数

可以在构造方法中使用可变参数列表

4.二维数组

数组的每一维可以有不同的长度，所以高维数组有时也被称为不规则数组

五、异常

1.分类

错误catch无意义，无法修复

exception

checked exception 强制处理异常（非运行时异常）

ClassNotFoundException
NoSuchMethodException
IllegalAccessException

unchecked exception 非强制处理异常（运行时异常）

NullPointerException
IndexOutOfBoundsException
ArithmeticException
StringIndexOutofBoundsException
NumberFormatException
ClassCastException 强制类型转换

2.处理程序中的异常，可以使用 try-catch 语句

一个 try 块后跟一个或多个 catch 子句

当 try 块中发生异常时，处理会立即跳转到与异常类型匹配的第一个 catch 子句

try 语句可以有一个可选的 finally 子句，该子句始终执行

如果未生成异常，则在 try 块中的语句完成后执行 finally 子句中的语句
如果生成异常，则 finally 子句中的语句将在相应 catch 子句中的语句完成后执行

结论：finally中的语句无论如何都会被执行，即使之前有return语句，也要先finally，再return。例外是System.exit();

3.可以在方法定义中抛出异常而不是用catch语句块进行异常捕获

4.finally段中的语句，不允许再次出现异常。（×）

5.通过 throws 关键字在方法上声明该方法要拋出的异常，然后在方法内部通过 throw 拋出异常对象。

6.自定义异常的对象，只能由throw语句手动抛出

7.finally关键字的代码块中，允许再出现try…catch…再次捕获异常。

8.catch中的语句可以重抛或抛出新异常

9.所有的异常类是从 Exception 类继承的子类

10.Exception 类是 Throwable 类的子类。除了Exception类外，Throwable还有一个子类Error 。

11.Java 程序通常不捕获错误。错误一般发生在严重故障时，它们在Java程序处理的范畴之外。

12.Error 用来指示运行时环境发生的错误。

例如，JVM 内存溢出。一般地，程序不会从错误中恢复。

13.异常类有两个主要的子类：IOException 类和 RuntimeException 类。

# public String getMessage() //返回关于发生的异常的详细信息。 //这个消息在Throwable 类的构造函数中初始化了。

自定义异常类的对象可以打印属于自己的异常信息。

# public String toString() //返回此 Throwable 的简短描述。

六、继承

extends

java中允许“多层”继承，但不允许“多重”继承（多继承）

java中只允许父类引用指向子类对象，不允许子类引用指向父类对象

将一个父类对象强转为子类对象是无法通过编译的（父对象拥有的内存小于子对象需要的内存）

将一个子类对象强转为父类对象，再将强转后的父类对象强转为子类对象是可以的

（一）构造方法

constructor在一个对象被new时执行

1.一个类里可以有多个构造方法，一个构造方法可以通过this()调用另一个构造方法。同一个类中定义的构造方法可以相互调用，但只允许调用一个（this()必须出现在第一句，如果调用多个则会有不出现在第一句的this()）

2.构造方法作用：初始化变量若没初始化，初始值为0

3.如果没有定义构造方法，java会给补充一个缺省的构造方法

4.创建子类时，必会先调用父类对象的构造方法

子类构造方法第一条语句：this() 或者 super()
若不主动调用，则java强制调用super()

5.构造方法没有返回类型

6.constructor可以调用自己类的其它constructor和方法

7.子类不会继承父类的构造方法

8.构造方法支持各种访问控制可以是private（若均为private的构造方法，无法被继承，也无法在其它类中创建对象，因为无可用的构造方法）

9.在创建一个对象时，至少要调用一个构造方法

10.成员方法中不允许有this()或super()

11.this()和super()的本质是构造方法，一个构造方法中只能有一个this()或 super()

12.this调用本类中的构造器随便调用不会有任何问题，但super受到父类中权限修饰符的限制

（二）修饰符

变量和属性是有区别的：变量是方法体中定义的，我们称为临时变量。属性是类体中定义的。 1. 而权限标示符只用于修饰属性和方法。不修饰变量。 2. 方法中定义的临时变量在方法调用完成之后就不存在了，不需要用修饰符定义！

public

类公开可见
（成员）数据、方法公开可见
一个Java文件中，只能有一个public类，遵循封装原则，public不应该修饰数据成员

protected

对于其子类，或者同一个包中的类可见
protected成员，在其他包中只能通过继承的方式来使用

缺省 default

整个类的访问权限是本地
对于同一个包中的类，可见
缺省类，其成员的最高访问权限为缺省，尽管可以用public，protected修饰，

private

私有，仅对本类或者其外部类公开

final

禁止变量被赋值（实现只读效果）
禁止方法被覆写
禁止类被继承

（三）重写方法/方法覆盖

1.子类中方法名、参数列表与父类中的方法名、参数列表一样时发生重写

2.返回值类型必须一致（新版本：返回值类型必须小于或者等于父类方法的返回值类型，可以类型转换）

3.子类方法访问权限＞=被覆盖的父类方法

4.子类不能重写父类中用final修饰的方法

5.子类不能重写父类的构造方法

6.子类无法继承父类的构造函数

方法重载（overloading）：
参数个数、类型或顺序不同，方法名相同（返回值类型可以不同）

java中方法的重写(overriding)和重载(overloading)是多态性的不同表现

7.父类被重写后，子类使用super调用的是父类的方法（被重写前的），其他情况下，直接调用被重写的方法，调用的就是子类中的方法。

8.java不支持super.super的用法

9.关键字final定义的方法，可以在同一个类中有重载（overloading）方法。（被继承后不能重写）

10.子类和父类的方法必须都是实例方法才会实现重写，若父类是静态方法，子类是实例方法或者相反都会报错，若父类和子类都是静态方法，那么子类会隐藏父类的静态方法，而不是覆盖。

（四）影子变量

1.子类中定义的与父类同名的变量

2.合法但不提倡

（五）Object类

1.所有的类都直接或间接的由Object类派生

2.Java程序的每一个类都继承toString方法和equals方法（都是public）

equals方法只能比较对象不能比较基本数据类型变量（int等）

3.Java中的接口(interface)没有继承Object类

（六）抽象类

public abstract class ABC{}
public abstract void run()；

1.abstract修饰符类为抽象类

2.抽象类中每一个抽象方法（例：public abstract void run(); ）都必须用abstract修饰符，但抽象类不必一定包含抽象方法（抽象方法必须在抽象类中，抽象类中可以有抽象方法和其他方法，也可以没有抽象方法）

3.不能实例化抽象类

4.抽象类的子类必须重写父类的所有抽象方法，否则它也将被视为抽象类

5.抽象类中可以有final修饰的方法

6.abstract类不能实例化对象。

7.抽象方法不能用final private和static修饰符（这三种修饰符修饰后无法被重写）

this与static互斥。abstract与static互斥通过对象引用才能实现多态行为，因此不能是静态方法。abstract与private互斥：抽象方法要求子类实现，因此子类必须能够访问该方法。abstract与final互斥抽象方法需要被覆写。private方法不可能被继承并覆写，所以隐含final修饰。

（七）接口

1.接口的所有成员都是public的，不涉及protected和private等

2.子接口继承父接口所有的抽象方法和常量，任何实现子接口的类都必须实现所有的抽象方法

3.只有定义没有实现接口中所有方法都没有body

4.只能继承一个类，却可以继承多个接口

5.Comparable interface只有一个compareTo方法

6.接口继承另一个接口，用extends关键字标明，可以继承多个接口

7.如果类B实现了接口A（即 B implements A），如果B不是抽象类，则必须实现A中定义的所有方法。（B是抽象类，则不必全部实现）

8.interface中不可以定义属性

9.接口不能实例化对象，但可以声明对象引用

10.Serializable接口是一个空接口，没有定义任何方法

七、多态

（一）多态

1.Father obj=new Son();先调用父类构造方法再调用子类构造方法

（二）排序

1.选择排序：

2.插入排序

八、递归

九、链表

（一）基本用语

（二）具体方法实现

1.添加头节点

2.插入一个节点到链表尾部

3.指定位置插入

4.删除指定位置n的节点

5.删除data为data的所有节点

6.删除data为data的第一个节点

7.对链表节点排序

8.获取链表长度

9.打印节点

10.查找正数第k个元素

11.查找倒数第k个元素

12.反转链表

13.寻找单链表的中间节点

14.返回尾节点

15.在不知道头结点的情况下删除指定节点

16.两个有序链表排序

17.去重

18.取模（取余）

Ⅱ阅读程序

1.基础

1.对下列程序，输出结果是：

T1: x=1, y=4; T2: x=3, y=4

2.设x=1,y=2,z=3,则表达式y*=x + z的值是 8

3.下列代码的执行结果是（）

a=2;b=-2,c=19
逻辑/位运算结合性的优先级：非、与、或、

public class Test { public static int a = 1; public static void main(String[] args) { int a = 10; a++; Test.a++; Test t=new Test(); System.out.println("a=" + a + " t.a=" + t.a); } }

a=11 t.a=2

public class NameClass { private static int x; public static void name(int x) { x++; } public static void main(String[] args) { name(x); System.out.println(x); } }

0

1

2.控制流程+数组

例1.

1 5 9 13 0 6 10 14 0 0 11 15 0 0 0 16

例2.

10 11 12 13 14 15 16 17 18 10 19 20 21 10 10 22 23 10 10 10 24 10 10 10 10

3.异常

（1）做题方法

①抛出异常，在该方法中寻找catch

找到：执行该catch中语句，执行方法中剩余语句（finally先与return执行）

未找到：执行finally语句，再去调用该方法的方法中寻找catch，以此类推

在方法中抛出异常，只有被catch了才能执行剩下的语句，否则无法执行
Exception是其他异常类的父类，可以捕获所有异常

（2）例题

例1.

Finally 1 End. Finally 2 Divide by Zero! Finally 1 Finally 2 End. Finally 2

例2.

handle ArithmeticException finally m2 ends
1 finally m2 ends
finally handle Exception m1 runs

4.重载与多态

（1）创建对象

（2）调用方法

①先去父类中找该方法（一定可以找到，否则编译时会报错，参数类型可以类型转换）

②去子类中看该方法是否被重写（子类中方法名、参数列表、返回值类型与父类中的必须一致才发生重写）

若被重写：调用子类方法

未被重写：调用父类方法

①去子类找该方法

子类有该方法：使用

子类无该方法：去父类找该方法

父类中有该方法：使用
父类中无该方法：使用子类中相似的（类型转换，选形参类型大于当前类型的）

①父类中寻找该方法（类型转换，选形参类型大于当前类型的）

②去子类中看是否被重写

重写：用重写后方法

未重写：用重写前方法

①在本类中找

有（参数类型相同）：使用该子类方法

无：去父类中找

有（参数类型相同）：使用父类该方法
无：去子类中寻找类似的方法（参数类型不同，可类型转换）

5.递归

例1.

2340 2430 3240 4230 3420 4320

例2.用递归求第i个斐波纳契数列数

例3.

3 0 2 3

例4.

S disk from a to c M disk from a to b S disk from c to b
***
L disk from a to c S disk from b to a M disk from b to c S disk from a to c

Ⅲ写程序

1.字符串转换为数字

2.字符串