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

转载请注明出处：https://blog.csdn.net/mythmayor/article/details/79487586

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