java中核心知识点_Java核心知识点大全（持续更新中）

1.常用的快捷键

a:Ctrl+A 全选

b:Ctrl+C 复制

c:Ctrl+V 粘贴

d:Ctrl+X 剪切

e:Ctrl+Z 撤销

f:Ctrl+S 保存

g:Ctrl+Y 取消撤销

h: ALT + ESC 回到上一个操作的窗口

i: ALT + TAB 在多窗口之间进行切换

j:ALT + CTRL + TAB 使切换任务界面停留

k:WINDOWS + SPACE 快速显示桌面

l:WINDOWS + TAB 绚丽的切换

m:Ctrl + W 关闭当前界面

n:Ctrl + Shift + T 恢复浏览器刚刚关闭的界面

o:WINDOWS + L 锁定电脑

p:WINDOWS + D 显示桌面，再按一次还原

q:WINDOWS +Ｅ 打开资源管理器找文件

r:WINDOWS + M 最小化所有窗口

s:WINDOWS + 加号 放大镜

2.常用的DOS命令

d: 回车 盘符切换

dir(directory):列出当前目录下的文件以及文件夹

cd (change directory)改变指定目录(进入指定目录)

cd.. : 退回到上一级目录

cd: 退回到根目录

cls : (clear screen)清屏

exit : 退出dos命令行(分割线上的需要掌握,下的了解)

md (make directory) : 创建目录

rd (remove directory): 删除目录

del (delete): 删除文件,删除一堆后缀名一样的文件*.txt

notepad 创建文件

删除带内容的文件夹

rd + /s 文件夹名称(询问是否删除)

rd + /q + /s 文件夹名称(直接删除)

3.基本数据类型分类(四类八种)

整数型

* byte 占一个字节 -128到127

* short 占两个字 -215~215-1

* int 占四个字节 -231~231-1

* long 占八个字节 -263~263-1

浮点型

* float 占四个字节 -3.403E38~3.403E38

* double 占八个字节-1.798E308~1.798E308

字符型

* char 占两个字节 0~65535

布尔型

* boolean

* boolean理论上是占八分之一个字节,因为一个开关就可以决定是true和false了,但是java中boolean类型没有明确指定他的大小

4.常用排序

(1)冒泡排序：相邻元素两两比较，大的往后放，第一次完毕，最大值出现在了最大索引处

public void bubbleSort(int array[]) {

int t = 0;

for (int i = 0; i < array.length - 1; i++) {

for (int j = 0; j < array.length - 1 - i; j++) {

if (array[j] > array[j + 1]) {

t = array[j];

array[j] = array[j + 1];

array[j + 1] = t;

}

}

}

}

(2)选择排序：从0索引开始，依次和后面元素比较，小的往前放，第一次完毕，最小值出现在了最小索引处

public void selectSort(int array[]) {

int t = 0;

for (int i = 0; i < array.length - 1; i++) {

for (int j = i + 1; j < array.length; j++) {

if (array[i] > array[j]) {

t = array[i];

array[i] = array[j];

array[j] = t;

}

}

}

}

5.成员变量和局部变量的区别

A:在类中的位置不同

成员变量：在类中方法外

局部变量：在方法定义中或者方法声明上

B:在内存中的位置不同

成员变量：在堆内存(成员变量属于对象,对象进堆内存)

局部变量：在栈内存(局部变量属于方法,方法进栈内存)

C:生命周期不同

成员变量：随着对象的创建而存在，随着对象的消失而消失

局部变量：随着方法的调用而存在，随着方法的调用完毕而消失

D:初始化值不同

成员变量：有默认初始化值

局部变量：没有默认初始化值，必须定义，赋值，然后才能使用。

注意事项：

局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。

基本数据类型变量包括哪些:byte,short,int,long,float,double,boolean,char

引用数据类型变量包括哪些:数组,类,接口,枚举

6.static关键字的注意事项

* a:在静态方法中是没有this关键字的

* 如何理解呢?

* 静态是随着类的加载而加载，this是随着对象的创建而存在。

* 静态比对象先存在。

* b:静态方法只能访问静态的成员变量和静态的成员方法

* 静态方法：

* 成员变量：只能访问静态变量

* 成员方法：只能访问静态成员方法

* 非静态方法：

* 成员变量：可以是静态的，也可以是非静态的

* 成员方法：可是是静态的成员方法，也可以是非静态的成员方法。

* 简单记：

* 静态只能访问静态。

7.静态变量和成员变量的区别

静态变量也叫类变量 成员变量也叫对象变量

A:所属不同

静态变量属于类，所以也称为为类变量

成员变量属于对象，所以也称为实例变量(对象变量)

B:内存中位置不同

静态变量存储于方法区的静态区

成员变量存储于堆内存

C:内存出现时间不同

静态变量随着类的加载而加载，随着类的消失而消失

成员变量随着对象的创建而存在，随着对象的消失而消失

D:调用不同

静态变量可以通过类名调用，也可以通过对象调用

成员变量只能通过对 象名调用

如果一个类中所有的方法都是静态的，需要私有构造方法 private ArrayTools() {}

8.继承

(1) 继承(extends)

* 让类与类之间产生关系,子父类关系

(2)继承的好处

* a:提高了代码的复用性

* b:提高了代码的维护性

* c:让类与类之间产生了关系，是多态的前提

(3)继承的弊端

* 类的耦合性增强了。

* 开发的原则：高内聚，低耦合。

* 耦合：类与类的关系

* 内聚：就是自己完成某件事情的能力

9.this和super的区别和应用

A:this和super都代表什么

this:代表当前对象的引用,谁来调用我,我就代表谁

super:代表当前对象父类的引用

B:this和super的使用区别

a:调用成员变量

this.成员变量 调用本类的成员变量,也可以调用父类的成员变量

super.成员变量 调用父类的成员变量

b:调用构造方法

this(...) 调用本类的构造方法

super(...) 调用父类的构造方法

c:调用成员方法

this.成员方法 调用本类的成员方法,也可以调用父类的方法

super.成员方法 调用父类的成员方法

10.多态的概述

A:多态(polymorphic)概述

事物存在的多种形态

B:多态前提

a:要有继承关系。

b:要有方法重写。

c:要有父类引用指向子类对象。

C:abstract不能和哪些关键字共存？

static final private

11.多态中的成员访问特点

成员变量

编译看左边(父类)，运行看左边(父类)。

成员方法

编译看左边(父类)，运行看右边(子类)。

静态方法

编译看左边(父类)，运行看左边(父类)。

(静态和类相关，算不上重写，所以，访问还是左边的)

只有非静态的成员方法,编译看左边,运行看右边

12.接口的概述及其特点

A:接口概述

从狭义的角度讲就是指java中的interface

从广义的角度讲对外提供规则的都是接口

B:接口特点

a:接口用关键字interface表示

interface 接口名 {}

b:类实现接口用implements表示

class 类名 implements 接口名 {}

c:接口不能实例化

那么，接口如何实例化呢?

按照多态的方式来实例化。

d:接口的子类

a:可以是抽象类。但是意义不大。

b:可以是具体类。要重写接口中的所有抽象方法。(推荐方案)

e:接口中所有的方法都是抽象的

13.抽象类和接口的区别

A:成员区别

抽象类：

成员变量：可以变量，也可以常量

构造方法：有

成员方法：可以抽象，也可以非抽象

接口：

成员变量：只可以常量(默认public static final修饰)

构造方法：无

成员方法：只可以抽象(默认public abstract修饰)

B:关系区别

类与类

继承，单继承

类与接口

实现，单实现，多实现

接口与接口

继承，单继承，多继承

C:设计理念区别

抽象类 被继承体现的是：”is a”的关系。抽象类中定义的是该继承体系的共性功能。

接口 被实现体现的是：”like a”的关系。接口中定义的是该继承体系的扩展功能。

14.四种权限修饰符的测试

权限\类 | 本类 | 同一个包下(子类和无关类) | 不同包下(子类) | 不同包下(无关类)

private Y

默认 Y Y

protected Y Y Y

public Y Y Y Y

15.类及其组成所使用的常见修饰符

A:修饰符：

权限修饰符：private，默认的，protected，public

状态修饰符：static，final

抽象修饰符：abstract

B:类：

权限修饰符：默认修饰符，public

状态修饰符：final

抽象修饰符：abstract

用的最多的就是：public

C:成员变量：

权限修饰符：private，默认的，protected，public

状态修饰符：static，final

用的最多的就是：private

D:构造方法：

权限修饰符：private，默认的，protected，public

用的最多的就是：public

E:成员方法：

权限修饰符：private，默认的，protected，public

状态修饰符：static，final

抽象修饰符：abstract

用的最多的就是：public

F:除此以外的组合规则：

成员变量：public static final

成员方法：

public static

public abstract

public final

16.Eclipse中快捷键的使用

A:新建 ctrl + n

B:格式化 ctrl+shift+f

C:导入包 ctrl+shift+o

D:注释 ctrl+/,ctrl+shift+/,ctrl+shift+\

E:代码上下移动 选中代码alt+上/下箭头

F:查看源码 选中类名(F3或者Ctrl+鼠标点击)

G:查找具体的类 ctrl + shift + t

H:查找具体类的具体方法 ctrl + o

I:给建议 ctrl+1,根据右边生成左边的数据类型,生成方法

J:删除代码行 ctrl + d

K:抽取方法alt + shift + m

L:改名alt + shift + r

M:查找 ctrl + f

N:向上/向下复制一行：ctrl + alt + 上/下箭头

O:抽取局部变量：alt + shift + L

17.==号和equals方法的区别

相同点:都是作比较的，返回的都是布尔类型。

不同点：

(1)==:

==是一个比较运算符号,既可以比较基本数据类型,也可以比较引用数据类型,

基本数据类型比较的是值, 引用数据类型比较的是地址值

(2)equals:

equals方法是一个方法,只能比较引用数据类型,所有的对象都会继承Object类中的方法,

如果没有重写Object类中的equals方法,equals方法和==号比较引用数据类型无区别,

重写后的equals方法比较的是对象中的属性

18.集合部分总结

Collection

* List(存取有序,有索引,可以重复)

* ArrayList

底层是数组实现的,线程不安全,查找和修改快,增和删比较慢

* LinkedList

底层是链表实现的,线程不安全,增和删比较快,查找和修改比较慢

* Vector

底层是数组实现的,线程安全的,无论增删改查都慢

如果查找和修改多,用ArrayList

如果增和删多,用LinkedList

如果都多,用ArrayList

* Set(存取无序,无索引,不可以重复)

* HashSet

底层是哈希算法实现

LinkedHashSet

底层是链表实现,但是也是可以保证元素唯一,和HashSet原理一样

* TreeSet

底层是二叉树算法实现

一般在开发的时候不需要对存储的元素排序,所以在开发的时候大多用HashSet,HashSet的效率比较高

TreeSet在面试的时候比较多,问你有几种排序方式,和几种排序方式的区别

Map

* HashMap

底层是哈希算法,针对键

* LinkedHashMap

底层是链表,针对键

* TreeMap

底层是二叉树算法,针对键

开发中用HashMap比较多

19.内存输出流

1.什么是内存输出流

该输出流可以向内存中写数据, 把内存当作一个缓冲区, 写出之后可以一次性获取出所有数据

2.使用方式

创建对象: new ByteArrayOutputStream()

写出数据: write(int), write(byte[])

获取数据: toByteArray()

FileInputStream fis = new FileInputStream("a.txt");

ByteArrayOutputStream baos = new ByteArrayOutputStream();

int b;

while((b = fis.read()) != -1) {

baos.write(b);

}

//将内存缓冲区中所有的字节存储在newArr中

//byte[] newArr = baos.toByteArray();

//System.out.println(new String(newArr));

System.out.println(baos);

fis.close();

20.单例设计模式(掌握)

* 单例设计模式：保证类在内存中只有一个对象。

如何保证类在内存中只有一个对象呢？

(1)控制类的创建，不让其他类来创建本类的对象。private

(2)在本类中定义一个本类的对象。Singleton s;

(3)提供公共的访问方式。 public static Singleton getInstance(){return s}

饿汉式和懒汉式的区别：

饿汉式:类一加载就生成对象。安全，效率高。相对懒汉式会在未使用之前就占用内存。

懒汉式:存在线程安全漏洞，可能会创建多个对象,可以利用同步解决，但是效率会变低。

单例写法两种：

(1)饿汉式 开发用这种方式。

//饿汉式

class Singleton {

//1,私有构造函数

private Singleton(){}

//2,创建本类对象

private static Singleton s = new Singleton();

//3,对外提供公共的访问方法

public static Singleton getInstance() {

return s;

}

public static void print() {

System.out.println("11111111111");

}

}

* (2)懒汉式 面试写这种方式。多线程的问题？

//懒汉式,单例的延迟加载模式

class Singleton {

//1,私有构造函数

private Singleton(){}

//2,声明一个本类的引用

private static Singleton s;

//3,对外提供公共的访问方法

public static Singleton getInstance() {

if(s == null)

//线程1,线程2

s = new Singleton();

return s;

}

public static void print() {

System.out.println("11111111111");

}

}

* (3)第三种格式

class Singleton {

private Singleton() {}

//final是最终的意思,被final修饰的变量不可以被更改

public static final Singleton s = new Singleton();

}

21.简单工厂模式概述和使用

A:简单工厂模式概述

又叫静态工厂方法模式，它定义一个具体的工厂类负责创建一些类的实例

B:优点

客户端不需要在负责对象的创建，从而明确了各个类的职责

C:缺点

这个静态工厂类负责所有对象的创建，如果有新的对象增加，或者某些对象的创建方式不同，就需要不断的修改工厂类，不利于后期的维护

D:案例演示

动物抽象类：public abstract Animal { public abstract void eat(); }

具体狗类：public class Dog extends Animal {}

具体猫类：public class Cat extends Animal {}

开始，在测试类中每个具体的内容自己创建对象，但是，创建对象的工作如果比较麻烦，就需要有人专门做这个事情，所以就知道了一个专门的类来创建对象。

22.工厂方法模式的概述和使用

A:工厂方法模式概述

工厂方法模式中抽象工厂类负责定义创建对象的接口，具体对象的创建工作由继承抽象工厂的具体类实现。

B:优点

客户端不需要在负责对象的创建，从而明确了各个类的职责，如果有新的对象增加，只需要增加一个具体的类和具体的工厂类即可，不影响已有的代码，后期维护容易，增强了系统的扩展性

C:缺点

需要额外的编写代码，增加了工作量

23.适配器设计模式(掌握)

a.什么是适配器

在使用监听器的时候, 需要定义一个类事件监听器接口.

通常接口中有多个方法, 而程序中不一定所有的都用到, 但又必须重写, 这很繁琐.

适配器简化了这些操作, 我们定义监听器时只要继承适配器, 然后重写需要的方法即可.

b.适配器原理

适配器就是一个类, 实现了监听器接口, 所有抽象方法都重写了, 但是方法全是空的.

适配器类需要定义成抽象的,因为创建该类对象,调用空方法是没有意义的

目的就是为了简化程序员的操作, 定义监听器时继承适配器, 只重写需要的方法就可以了

24.网络编程三要素协议

为计算机网络中进行数据交换而建立的规则、标准或约定的集合。

UDP

用户数据报协议(User Datagram Protocol)

面向无连接，数据不安全，速度快。不区分客户端与服务端。

TCP

传输控制协议(Transmission Control Protocol)

面向连接(三次握手)，数据安全，速度略低。分为客户端和服务端。

三次握手: 客户端先向服务端发起请求, 服务端响应请求, 传输数据

25.TCP协议

传输控制协议(Transmission Control Protocol)

1.客户端

* 创建Socket连接服务端(指定ip地址,端口号)通过ip地址找对应的服务器

* 调用Socket的getInputStream()和getOutputStream()方法获取和服务端相连的IO流

* 输入流可以读取服务端输出流写出的数据

* 输出流可以写出数据到服务端的输入流

2.服务端

* 创建ServerSocket(需要指定端口号)

* 调用ServerSocket的accept()方法接收一个客户端请求，得到一个Socket

* 调用Socket的getInputStream()和getOutputStream()方法获取和客户端相连的IO流

* 输入流可以读取客户端输出流写出的数据

* 输出流可以写出数据到客户端的输入流

26.反射概述

A:反射概述

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；

对于任意一个对象，都能够调用它的任意一个方法和属性；

这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

要想解剖一个类,必须先要获取到该类的字节码文件对象。

而解剖使用的就是Class类中的方法，所以先要获取到每一个字节码文件对应的Class类型的对象。

B:三种方式

a:Object类的getClass()方法,判断两个对象是否是同一个字节码文件

b:静态属性class,锁对象

c:Class类中静态方法forName(),读取配置文件

27.模版(Template)设计模式概述和使用

A:模版设计模式概述

模版方法模式就是定义一个算法的骨架，而将具体的算法延迟到子类中来实现

B:优点和缺点

a:优点

使用模版方法模式，在定义算法骨架的同时，可以很灵活的实现具体的算法，满足用户灵活多变的需求

b:缺点

如果算法骨架有修改的话，则需要修改抽象类