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

转载请注明出处：https://www.jianshu.com/p/ae12ea692f17

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 占两个字 -2^15~215-1
* int 占四个字节 -2^31~231-1
* long 占八个字节 -2^63~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:缺点
  - 如果算法骨架有修改的话，则需要修改抽象类