java程序设计知识点总结 java程序设计基础知识点

文章目录

• 前言

• 1、面向对象

• 1.1、类
• 1.2、面向对象的基本特性

• 2、String 类
• 3、正则表达式
• 4、基本类型的包装类
• 5、抽象类
• 6、关键字 final
• 7、集合
• 8、异常
• 9、接口
• 10、文件
• 11、内部类
• 12、Java内存管理
• 13、线程

---

前言

梳理java基础知识点，记录温习中容易模糊的点，便于翻阅查找，温故而知新。

---

1、面向对象

面向对象（Object Oriented）是一种新兴的程序设计方法，或者是一种新的程序设计规范(paradigm)，其基本思想是使用对象、类、继承、封装、多态等基本概念来进行程序设计

1.1、类

类是具有相同属性和方法的一组对象的集合，它为属于该类的所有对象提供了统一的抽象描述，其内部包括属性和方法两个主要部分。在面向对象的编程语言中，类是一个独立的程序单位，它应该有一个类名并包括属性和方法两个主要部分。

Java中的类实现包括两个部分：类声明和类体。

• 类声明

[public][abstract|final] class className [extends superclassName] [implements interfaceNameList]{……}

其中，修饰符public,abstract,final 说明了类的属性，className为类名，superclassName为类的父类的名字，interfaceNameList为类所实现的接口列表。

• 类体

class className{
    [public | protected | private ] [static] [final] [transient] [volatile] type variableName;//成员变量
    [public | protected | private ] [static] [final | abstract] [native] [synchronized] returnType methodName([paramList]) [throws exceptionList]{
        statements
    }//成员方法
}

成员变量限定词的含义：

static: 静态变量（类变量）
final: 常量；transient: 暂时性变量，用于对象存档，用于对象的串行化
volatile: 贡献变量，用于并发线程的共享。

方法的实现也包括两部分内容：方法声明和方法体。

• 方法声明

方法声明中的限定词的含义：

static: 类方法，可通过类名直接调用
abstract: 抽象方法，没有方法体
final: 方法不能被重写
native: 集成其它语言的代码
synchronized: 控制多个并发线程的访问

方法声明包括方法名、返回类型和外部参数。其中参数的类型可以是简单数据类型，也可以是复合数据类型（又称引用数据类型）。
　　对于简单数据类型来说，java实现的是值传递，方法接收参数的值，但不能改变这些参数的值。如果要改变参数的值，则用引用数据类型，因为引用数据类型传递给方法的是数据在内存中的地址，方法中对数据的操作可以改变数据的值。

• 方法体

方法体是对方法的实现，它包括局部变量的声明以及所有合法的Java指令。方法体中声明的局部变量的作用域在该方法内部。若局部变量与类的成员变量同名，则类的成员变量被隐藏。
　　为了区别参数和类的成员变量，我们必须使用this。this用在一个方法中引用当前对象，它的值是调用该方法的对象。返回值须与返回类型一致，或者完全相同，或是其子类。当返回类型是接口时，返回值必须实现该接口。

• 构造方法

构造方法是一个特殊的方法。Java 中的每个类都有构造方法，用来初始化该类的一个对象。
构造方法具有和类名相同的名称，而且不返回任何数据类型。
重载经常用于构造方法。
构造方法只能由new运算符调用

1.2、面向对象的基本特性

• 封装

封装性就是尽可能的隐藏对象内部细节，对外形成一道边界，只保留有限的接口和方法与外界进行交互。封装的原则是使对象以外的部分不能随意的访问和操作对象的内部属性，从而避免了外界对对象内部属性的破坏。

可以通过对类的成员设置一定的访问权限，实现类中成员的信息隐藏。

private：类中限定为private的成员，只能被这个类本身访问。如果一个类的构造方法声明为private,则其它类不能生成该类的一个实例。
default：类中不加任何访问权限限定的成员属于缺省的（default）访问状态，可以被这个类本身和同一个包中的类所访问。
protected：类中限定为protected的成员，可以被这个类本身、它的子类（包括同一个包中以及不同包中的子类）和同一个包中的所有其他的类访问。
public：类中限定为public的成员，可以被所有的类访问。

• 继承

子类的对象拥有父类的全部属性与方法，称作子类对父类的继承。

Java中父类可以拥有多个子类，但是子类只能继承一个父类，称为单继承。
继承实现了代码的复用。
Java中所有的类都是通过直接或间接地继承java.lang.Object类得到的。
子类不能继承父类中访问权限为private的成员变量和方法。
子类可以重写父类的方法，即命名与父类同名的成员变量。
　　Java中通过super来实现对父类成员的访问，super用来引用当前对象的父类。super 的使用有三种情况：

访问父类被隐藏的成员变量，如：super.variable;
调用父类中被重写的方法，如：super.Method([paramlist]),super()调用父类构造方法;
调用父类的构造函数，如：super([paramlist]);

• 多态

对象的多态性是指在父类中定义的属性或方法被子类继承之后，可以具有不同的数据类型或表现出不同的行为。这使得同一个属性或方法在父类及其各个子类中具有不同的语义。例如："几何图形"的"绘图"方法，"椭圆"和"多边形"都是"几何图"的子类，其"绘图"方法功能不同。

Java的多态性体现在两个方面：由方法重载实现的静态多态性（编译时多态）和方法重写实现的动态多态性（运行时多态）。

编译时多态：在编译阶段，具体调用哪个被重载的方法，编译器会根据参数的不同来静态确定调用相应的方法。
运行时多态：由于子类继承了父类所有的属性（私有的除外），所以子类对象可以作为父类对象使用。程序中凡是使用父类对象的地方，都可以用子类对象来代替。一个对象可以通过引用子类的实例来调用子类的方法。

• 重载（Overloading）

方法重载是让类以统一的方式处理不同数据类型的手段。
一个类中可以创建多个方法，它们具有相同的名字，但具有不同的参数和不同的定义。调用方法时通过传递给它们的不同参数个数和参数类型来决定具体使用哪个方法。
返回值类型可以相同也可以不相同，无法以返回型别作为重载函数的区分标准。

• 重写（Overriding）

子类对父类的方法进行重新编写。如果在子类中的方法与其父类有相同的的方法名、返回类型和参数表，我们说该方法被重写 (Overriding)。
如需父类中原有的方法，可使用super关键字，该关键字引用了当前类的父类。
子类函数的访问修饰权限不能低于父类的。

2、String 类

字符串的常用方法：

charAt(i) 获取指定位置的字符
length() 字符串长度，字符的数量
indexof（）找第一个子串出现的初始位置，找不到返回-1
indexof（子串，start）从执行位置向后找
lastIndexof(子串) 从后向前找
subString（start）截取start到末尾
subString[start,end ）截取[start,end ）范围
trim（）去除两端的空白字符
matches（）用来判断是否匹配正则表达式

StringBuilder: 可变的字符序列，封装char[]数组，提供了一组方法，可以对内部封装的字符进行修改，常用来代替字符串做高效的字符串连接。

append（） 追加字符内容，内部数组默认初始容量16，放满后翻倍+2；
delete(start,end) 删除区间(start,end)；
deleteCharAt（i）删除指定位置 i；
insert（i，内容） 在指定位置插入内容；
insertCharAt（i，字符）在指定位置插入单个字符；
replace（start，end，内容）替换指定范围的内容；
StringBuilder和StringBuffer
StringBuilder:线程不安全，效率高；JDK1.5版本后的新类。
StringBuffer:线程安全，旧版本的类。

3、正则表达式

一般用来判断用户的输入内容是否符合格式要求

• matches（）字符串的方法，用来判断是否匹配

if(s.matches(regex)) {}

• split（正则）：用匹配的子串来拆分字符串

String s = "aaa,bbb,ccc";
    String[] a = s.split(",");

4、基本类型的包装类

把基本类型当做对象来使用
byte – Byte
short – Short
int – Integer
long – Long
float – Float
double – Double
char – Character
boolean – Boolean

BigDcimal和BigInteger 类：
BigDcimal精确的浮点数运算
BigInteger 超大的整数运算

创建对象：

BigDecimal bd = BigDecimal.valueOf(2);

方法：

add(BigDecimal bd)
subtract(BigDecimal bd)
multiply(BigDecimal bd)
divide(BigDecimal bd)
divide(BigDecimal bd,保留位数,舍入方式)
setScale(保留位数,舍入方式)

自动装箱，自动拆箱
基本类型值，自动装箱成包装对象

Integer a = 6;    编译器编译成： Integer a = Integer.valueOf(6);

自动拆箱（自动拆箱要注意null值）

int i = a;    	 编译器编译成：		int i = a.intValue();

5、抽象类

半成品类，没有完成的类；抽象方法：没有代码，只有方法的定义，抽象类不能创建实例，主要用来被继承。

public abstract void f();

包含抽象方法的类一定是抽象类

public abstract class A { }；

抽象方法的作用：
作为通用方法，在父类中定义；要求子类，必须实现这个方法。
1）抽象类可以有自己的构造方法
2）抽象类可以有具体的方法
3）包含抽象方法的类一定是抽象类，必须使用abstract关键字修饰，这个方法必须由子类来实现。
4）抽象类不能使用new关键字来创建实例
5）当一个类中只要有一个抽象方法，这个类就必须是抽象类
6）抽象类可以定义实例变量和静态变量以及常量
7）抽象类可以再继承抽象类，也可以继承普通的类

6、关键字 final

内存地址不可变，可以修饰常量、类、方法

1. final 常量：值不可变，但引用类型因为保存的是地址，所以内容可以变。

final Point a = new Point(3,4);
a.x = 30;//对
a.y = 40;//对

2. final 方法不能在子类重写，但可以被继承。；final不能用于修饰构造方法，父类的private成员方法是不能被子类方法覆盖的，因此private类型的方法默认是final类型的。
3. final 类 不能被继承，没有子类
   Static — 静态 共享的数据
   静态成员属于类，而不属于实例

静态成员
用类来调用静态成员 Soldier.count
实例成员
用实例来调用实例成员 s1.id
工具方法
Math.Random() Arrays.toString() String.valueOf()
静态方法中不能直接调用实例的成员（非静态），只能用实例调用

class A {
public static void main(String[] args) {
    f();//静态调静态
}
static void f() {
   g();//错，静态不能直接调用非静态
    A a = new A();
    a.g();//只能用实例调用
}
void g(){
}
}

静态初始化块

class A {
static {
    静态初始化块
    类被加载时，只执行一次
}
}

静态变量保存在方法区类的空间中，只保存一份可以在所有实例中共享的数据

对象的加载过程
加载类
1.加载父类，为父类静态变量分配内存 – 后台执行不可见
2. 加载子类，为子类静态变量分配内存
3. 执行父类静态变量的赋值运算，和静态初始化块
4. 执行子类静态变量的赋值运算，和静态初始化块
新建实例
5. 新建父类实例，为父类实例变量分配内存
6. 新建子类实例，为子类实例变量分配内存
7. 执行父类的实例变量赋值运算
8. 执行父类的构造方法
9. 执行子类的实例变量赋值运算
10. 执行子类的构造方法

7、集合

用来存放一组数据的数据结构
数组的缺点： 长度固定 ; 访问方式单一只能下标访问; 前面增删数据操作繁琐
集合的继承结构:

Collection 是对象集合， Collection 有两个子接口 List 和 Set,
List 可以通过下标 (1,2…) 来取得值，值可以重复,而 Set 只能通过游标来取值，并且值是不能重复的
ArrayList ， Vector ， LinkedList 是 List 的实现类
ArrayList 是线程不安全的， Vector 是线程安全的，这两个类底层都是由数组实现的
LinkedList 是线程不安全的，底层是由链表实现的
Map 是键值对集合
HashTable 和 HashMap 是 Map 的实现类
HashTable 是线程安全的，不能存储 null 值
HashMap 不是线程安全的，可以存储 null 值
ArrayList
数组列表，封装了一个数组，及其操作代码和更便捷的方法，内部数组默认初始容量10 放满后，1.5倍增长
方法
add（数据）— 添加数据；get（int i）—访问指定下标数据； remove（int i）移除指定位置数据，返回被移除的数据； remove（数据）— 找到第一个相等的数据，找到移除并返回true，找不到返回false； size（） 元素的数量；iterator（） 辅助新建迭代器
效率
访问任意位置效率高，增删数据效率可能降低

LinkedList — 双向链表
方法
和ArrayList有相同的方法
LinkedList 两端数据操作方法

addFirst（数据）；addLast（数据）；getFirst（）；getLast（）；removeFisrt（）
removeLast（）

效率
两端效率高
HashMap — 哈希表、散列表 （面试必问） ★ ★ ★ ★ ★
存放键值对数据，用键来快速定位数据，来提取键对应的值
键：不重复，无序
Hashmap中的key-value都是储存中entry数组中的
Hashmap的实现不是同步的，意味着它不是线程安全的
Hashmap的实例有两个参数影响其性能：初始容量，和加载因子
方法

put（key,value）放入键值对数据，重复的键会覆盖旧值
get（key）获得键对应的值，键不存在，得到null
remove（key）移除键值对数据，返回被移除的值
size（）键值对的数量

8、异常

封装错误信息的对象

错误信息：类型、提示消息、行号

异常的继承结构

RuntimeException 和 其他Exception
RuntimeException— 非检查异常，编译器不检查是否有异常处理代码，存在默认的抛出管道
其他异常 — 编译器检查是否有处理代码，不处理，不能编译。

9、接口

极端的抽象类，结构设计工具，用来解耦合，隔离现实
Implements代替extends
Interface 代替class
接口的定义：
 公开的抽象方法  公开的常量  公开的内部类、内部接口
1）接口只能定义常量
2）接口只能定义抽象方法
3）接口只能继承接口，不能继承普通的类和抽象类
4）接口是没有构造方法
注意：
1）在接口中定义常量时，可以不用final static修饰，因为编译器在编译时会自动加上。
2）在接口中定义抽象方法时可以省略abstract关键字，编译器在编译时同样会加上。

类可以同时继承多个接口

class A implements X,Y,Z {}
class A extends B implements X,Y,Z {}

接口和接口的继承

interface A extends X,Y,Z {}

10、文件

File
封装一个磁盘路径字符串，提供了一组对文件、文件夹的操作方法，可以封装文件夹路径、文件路径、不存在的路径。 {path=“d:/abc”}
方法

getName（） 获取文件名
getPatrent（） 获取父目录
getAbsolutePath（）完整路径
length（） 文件字节量，对文件夹无效，会返回假数据
isFile（） 判断是否是文件
isDirectory（）是否是文件夹
创建、删除
createNewFile（）新建文件，文件已存在不会新建，返回false;文件夹不存在会出现异常
mkdirs（）逐层创建多层文件夹
delete（）删除文件、空目录
目录列表
list（）得到String[] 包含所有文件名 [“a.txt”, “b.mp3”, “c.jpg”]
listFiles() 得到 File[]，包含所有文件的封装的File对象 [{…}, {…}, {…}]

11、内部类

定义在类内部、方法内部或局部代码块内部的类，用来辅助外部实例运算，封装局部数据，或局部的运算逻辑。

非静态内部类、属于实例的内部类 非静态内部类实例，必须依赖于一个外部类的实例才能存在。
静态内部类 静态内部类，与普通的类没有区别。
局部内部类
局部定义的类型，类似于局部变量，有作用范围，只能在局部代码块内使用这种类型
局部内部类中，使用外面的局部变量，必须加 final，jdk1.8，缺省。

匿名内部类

Weapon w = new Weapon() {...};

 {} - 匿名类
 new - 新建匿名类的实例
 Weapon - 父类型
 () - super()，可传参数super(1,2,3)

12、Java内存管理

堆内存 用来存放由new创建的对象实例和数组。Java堆是所有线程共享的一块内存区域，在虚拟机启动时创建，此内存区域的唯一目的就是存放对象实例。注意创建出来的对象只包含属于各自的成员变量，并不包括成员方法。
栈内存 保存的是堆内存空间的访问地址，或者说栈中的变量指向堆内存中的变量（Java中的指针）
l 栈：保存局部变量的值，包括：1.用来保存基本数据类型的值；2.保存类的实例，即堆区对象的引用(指针)。也可以用来保存加载方法时的帧。常量池存在于堆中（1.7b后的新版本）。
普通类型的变量在栈中直接保存它所对应的值，而引用类型的变量保存的是一个指向堆区的指针，通过这个指针，就可以找到这个实例在堆区对应的对象。因此，普通类型变量只在栈区占用一块内存，而引用类型变量要在栈区和堆区各占一块内存。
方法区是各个线程共享的内存区域，它用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。

13、线程

在进程内部，并行执行的任务
创建线程（两种方式）
 继承 Thread
 实现 Runnable
继承 Thread
编写 Thread 的子类，并重写 run() 方法。启动之后，自动运行 run() 方法中的代码
实现 Runnable
实现 Runnable 接口，实现它的 run() 方法，Runnable 封装在线程中执行的代码，新建线程对象时，把Runnable对象放在线程内，启动
线程的状态

线程的方法
Thread.currentThread() 获得正在执行的线程实例
Thread.sleep(毫秒值) 让正在执行的线程，暂停指定的毫秒值时长
getName()，setName() 线程名
start() 启动线程 interrupt() 打断线程的暂停状态
join() 当前线程暂停，等待被调用的线程结束
setDaemon(true) 后台线程、守护线程
JVM虚拟机退出条件，是所有前台线程结束，当所有前台线程结束，虚拟机会自动退出
不会等待后台线程结束 例如：垃圾回收器是一个后台线程。
线程同步 synchronized
让多个线程共享访问数据时，步调一致的执行。一个线程修改时，其他线程等待修改完成后才能执行；一个线程访问时，其他线程等待访问结束
任何实例，都有一个“同步锁”，synchronized 关键字，要求一个线程必须抢到同步锁才能执行

synchronized(对象) {
    共享的数据访问代码
} --抢对象的锁
synchronized void f() {
}  -- 抢当前实例的锁
static synchronized void f() {
}  --抢类的锁

生产者、消费者模型
线程之间传递数据
等待和通知方法必须在synchronized 代码内调用， 等待和通知的对象，必须是加锁的对象。