JAVA基础——整理总结

什么是方法（函数）：就是完成特定功能的代码块。函数就是方法，方法就是函数。如果非要说区别的话，方法应该是面向对象编程的产物，因为对象才具有某种方法，但是在具体表现上，两者没有任何区别。

 

方法重载：在同一个类中，允许存在一个以上的同名方法，只要它们的参数列表（参数个数和参数类型）不同，与返回值无关。

 

数组：是存储同一种数据类型多个元素的集合，也可以看成是一个容器。

 

栈：存放的是局部变量（是在方法定义中或者方法声明上的变量）。

堆：存放的是所有new出来的东西。

 

面向对象：是把功能类似的封装在一起，用的时候，找到对应的类。

属性：就是该事物的描述信息。——》成员变量

行为：就是该事物能够做什么。——》成员方法

类：是一组相关的属性和行为的集合。（类是该事物的描述信息）

对象：是该事物的具体体现。

 

成员变量和局部变量的区别：（1）在类中的位置不同：成员变量在类中，方法外；局部变量在方法定义中或者方法声明上。（2）在内存中的位置不同：成员变量在堆内存；局部变量在栈内存。（3）生命周期不同：成员变量随着对象的创建而存在，随着对象的消失而消失；局部变量随着方法的调用而存在，随着方法的完毕而消失。（4）初始化值不同：成员变量有默认初始化值；局部变量没有默认初始化值，必须定义，赋值，然后才能使用。注：局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。

 

形式参数：基本类型的形式参数的改变不影响实际参数；引用类型的形式参数的改变直接影响实际参数。

 

封装：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。好处：隐藏实现细节，提供公共访问方式；提高代码的复用性；提高安全性。

 

private关键字特点：是一个权限修饰符；可以修饰成员变量和成员方法；被其修饰的成员只能在本类中被访问。

 

this关键字特点：是当前类的对象引用。（代表当前类的一个对象。this是随着对象的创建而创建。）

 

构造方法：是创建对象，给对象中的成员进行初始化。特点：方法名与类型相同；没有返回值类型，连void都没有；没有具体的返回值。

 

static关键字特点：随着类的加载而加载；优先于对象存在；被类的所有对象共享；可以通过类名调用，本身也可以通过对象名调用。注：在静态方法中是没有this关键字的，因为this代表当前对象，而静态时，有可能没有对象，static是优先于对象，所以this无法使用。静态只能访问静态，而非静态可以访问静态和非静态。

 

静态变量和成员变量的区别：（1）所属不同：静态变量属于类，所以也称为类变量；成员变量属于对象，所以也称为实例变量（对象变量）。（2）内存中位置不同：静态变量存储于方法区的静态区；成员变量存储于堆内存。（3）内存出现时间不同：静态变量随着类的加载而加载，随着类的消失而消失；成员变量随着对象的创建而存在，随着对象的消失而消失。（4）调用不同：静态变量可以通过类名调用，也可以通过对象名调用；成员变量只能通过对象名调用。

 

代码块：是在Java中，使用{}括起来的代码。

常见代码块的应用：（1）局部代码块：在方法中出现，限定变量生命周期，及早释放，提高内存利用率。（2）构造代码块：在类中方法外出现，多个构造方法，方法中相同的代码存放到一起，每次调用构造都执行，并且在构造方法前执行。（3）静态代码块：在类中方法外出现，加上static修饰，用于给类进行初始化，在加载的时候执行，并且只执行一次。

 

继承：多个类中存在相同属性和行为时，将这些内容抽取到单独的一个类中，那么多个类无需在定义这些属性和行为，只要继承那个类即可。好处：提高代码复用性、维护性；让类与类之间产生了关系。

JAVA中类的继承特点：只支持单继承，不支持多继承，但是支持多层继承。

 

super关键字：是子类局部范围访问父类成员变量。

this和super的区别：this代表的是本类对象的引用；super代表的父类的引用，可以操作父类的成员。

 

方法重写：子类中出现了和父类中一模一样的方法声明（方法名、参数列表、返回值类型），也被称为方法覆盖，方法重写。

方法重写（Override）和方法重载（Overload）的区别？方法重载能改变返回值类型吗？答：区别：重写存在于子父类，或者子父接口中，方法声明相同；重载是同一个类中，方法名相同，参数列表不同。方法重载可以改变返回值的类型，因为它与返回值类型无关。

 

final关键字：是最终的意思，可以修饰类、变量、成员方法。

为什么会有final：由于继承中有一个方法重写的现象，而有时候我们不想让子类去重写父类的方法。

final特点：被修饰的类不能被继承；被修饰的方法不能被重写；被修饰的变量不能被重新赋值，因为这个量其实是一个常量。

 

多态：是某一个事物，在不同时刻表现出来的不同状态。好处：提高代码的维护性（继承保证）和扩展性（多态保证）。

 

抽象类：是如果一个父类中没有给出具体体现，而需要其它具体的子类来继承父类。（在JAVA中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类）

抽象类特点：（1）抽象类和抽象方法必须用abstract关键字修饰；（2）抽象类不一定有抽象方法，有抽象方法的类一定是抽象类；（3）抽象类中可以有构造方法，抽象类不能进行实例化，需要构造方法用于子类访问父类数据时的初始化作用；（4）抽象类不能直接实例化，需要间接实例化是按照多态的方式，由具体的的子类实例化。其实也是多态的一种，抽象类多态；（5）抽象类子类要么是抽象类，要么重写抽象类中的所有抽象方法。

一个类如果没有抽象方法，可不可以定义为抽象类？如果可以，有什么意义？答：可以。定义为抽象类后不能创建对象。

 

接口：是为了体现事物功能的扩展性。JAVA中提供了接口来定义这些额外的功能，并不需要给出具体实现，将来那些需要实现，只需要把这部分的额外的功能实现即可。

接口特点：（1）接口用关键字interface表示；（2）类实现接口用implements表示；（3）接口不能直接实例化，但是可以通过多态的形式对其进行间接实例化；（4）接口的子类可以是抽象类，但意义不大，可以是具体类，需要重写接口中的所有抽象方法。

 

抽象类和接口的区别：（1）抽象类的成员变量可以是变量也可以是常量，接口的成员变量只可以是常量；（2）抽象类有构造方法，接口没有构造方法；（3）抽象类的成员方法可以抽象也可以非抽象，接口的成员方法只可以抽象；（4）抽象类只能被继承，接口需要用implements实现；（5）设计理念不同，抽象类是“is a”，接口是“like a”；（6）一个类只能继承一个抽象类，而一个类却可以实现多个接口。

 

内部类：是把类定义在其它类的内部。访问特点：（1）内部类可以直接访问外部类的成员，包括私有的；（2）外部类要访问内部类的成员，必须要创建对象。

 

匿名内部类：就是定义在局部位置的类，是局部内部类的简化写法。前提：是存在一个类或者接口，这里的类可以是具体类也可以是抽象类。本质：是一个继承了该类或者实现了该接口的子类匿名对象。

 

Object类：是类层次结构的根类，所有类都直接或者间接的继承自该类。

==和equals的区别：==可以比较基本数据类型，也可以比较引用数据类型，但是比较引用数据类型的时候比较的是地址值；equals只能比较引用数据类型，默认比较的是地址值。

 

String概述：字符串是由多个字符组成的一串数据（字符序列），字符串可以看成是字符数组。

String s = new String(“hello”);和String s = “hello”;的区别：第一个是创建一个s对象，在堆内存中；第二个是创建一个s常量，在方法区中的常量池。

StringBuffer概述：是一个线程安全（这里指的是可以保证数据安全性，效率较低）的可变的字符序列。

StringBuffer和String的区别：StringBuffer是可变的字符序列；String是一个不可以被改变的字符序列。

StringBuilder概述：是一个可变的字符序列，线程不安全，效率高。单线程环境用。

StringBuilder,StringBuffer,String的区别：StringBuilder线程不安全，效率高，如果单线程环境，建议使用；StringBuffer线程安全，效率低；String是一个不可变的字符序列，而StringBuilder,StringBuffer是可变的字符序列。

 

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

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

二分查找原理：每一次都查中间的那个元素，比较大或者小就能减少一半的元素。前提：数组元素必须有序。

 

对象数组：就是用来存储对象的数组。

集合由来：是为方便对多个对象的操作。

数组和集合区别：（1）数组的长度是固定的，而集合的长度是可变的；（2）数组可以存储基本数据类型的元素，也可以存储引用数据类型的元素，而集合只能存储引用数据类型的元素；（3）数组只能存储同一种数据类型元素，而集合可以存储多种数据类型的元素。

Collection：是根接口，单列集合。

List：元素有序（指的是存储和取出的顺序一致），并且每一个元素都存在整数索引，元素可以重复。

ArrayList：底层数据结构是数组，查询快，增删慢。线程不安全，效率高。

Vector：底层数据结构是数组，查询快，增删慢。线程安全，效率低。

LinkedList：底层数据结构是链表，查询慢，增删快。线程不安全，效率高。

Set：无序（指的是存储和取出的顺序不一致），可以保证元素唯一性。

HashSet：底层数据结构是哈希表，保证元素唯一性，需要重写hashCode方法和equals方法。

TreeSet：底层数据结构是二叉树，元素唯一性，并且可以对元素进行排序，排序有两种方式，自然排序和比较器排序。

Map：将键映射到值的对象。一个映射不能包含重复的键，每个键最多只能映射一个值。

Map集合和Collection集合的区别：（1）Map集合是双列集合，Collection集合是单列集合；（2）Map集合的键是唯一的，而Collection集合中的Set集合可以保证元素的唯一性；（3）Map集合的数据结构只针对键有效，跟值无关，而Collection集合的数据结构和元素有效。

HashMap：底层数据结构是哈希表，保证元素唯一性，需要重写hashCode方法和equals方法。线程不安全，效率高。

TreeMap：底层数据结构是二叉树，元素唯一性，并且可以对元素进行排序，排序有两种方式，自然排序和比较器排序。线程是不安全的，效率比较高。

HashMap和Hashtable区别：HashMap底层数据结构是哈希表，线程不安全效率高，允许null值或者null键；Hashtable底层数据结构是哈希表，线程安全效率低，不允许null值或者null键。

 

扩展：1）数组：操作数据（增加）是将原数组的数据复制一份，再加上增加的对应位置的数据，形成一个新的数组，所以较慢；查找数据的数组是有下标的，根据下标进行查找。2）链表：一个链表的数据单元，结构是存储着一个数据，以及下一个链表单元数据的地址。3）哈希表：是数组和链表的结合体。

 

异常：就是在程序的编译或者运行过程中可能出现的问题。分类：严重问题（Error）（不予处理，不能解决，如：内存溢出）和非严重问题（Exception）（编译期异常（非RuntimeException的异常，必须处理）和运行期异常）。

JVM（JAVA虚拟机）默认是如何处理异常：main方法接收到问题后，自己可以处理和自己处理不了，交由调用者。

throw概述：在功能方法内部出现某种情况，程序不能继续运行，需要进行跳转时，就用throw把异常对象抛出。

throw和throws的区别：（1）throw用在方法体内，跟的是异常对象名；只能抛出一个异常对象名；表示抛出异常，由方法体内的语句处理；throw则是抛出异常，执行throw则一定抛出了某种异常。（2）throws用在方法声明后，跟的是异常类名；可以跟多个异常类名，用逗号隔开；表示抛出异常，由该方法的调用者来处理；throws表示出现异常的一种可能性，并不一定会发生这些异常。

finally特点：被finally控制的语句体一定会执行。

final,finally和finalize的区别：final是一个状态修饰符，可以用来修饰类、变量、成员方法，被修饰的类不能被子类继承，被修饰的变量其实是一个常量不能被再次赋值，被修饰的成员方法不能被子类重写；finally是用在try...catch语句中，作用是释放资源，特点是始终被执行；finalize是Object类中的一个方法，用来回收垃圾。

 

递归：是方法定义中调用方法本身的现象。

IO流：是用来处理设备之间的数据传输。流是一个抽象的概念。流的工作原理是通过二进制方式输入或输出。

flush和close的区别：flush作用是刷新缓冲区，刷新完毕以后流对象可以继续使用；close方法是关闭流对象，但是在关闭之前需要刷新缓冲区，并且关闭以后流对象就不能再次使用。

 

进程：就是正在运行的程序，是系统进行资源分配和调用的独立单位，每一个进程都有它自己的内存空间和系统资源。

线程：在一个进程内部又可以执行多个任务，而这每一个任务就可以看成是一个线程。线程是程序使用CPU的基本单位。

多线程（随机性）：的意义是为了提高应用程序的使用率。

并行：是在逻辑上同时发生，指在某一个时间内同时运行多个程序。

并发：是在物理上同时发生，指在某一个时间点同时运行多个程序。

JAVA程序运行原理：JAVA命令会启动JVM，等于启动一个应用程序，也就是启动了一个进程，该进程会自动启动一个主线程，然后主线程去调用某个类的main方法，所以main方法运行在主线程中。

实现多线程的方式：继承Thread、实现Runnable接口

同步有两种方式：（1）使用同步代码块；（2）同步方法

解决多线程安全问题：把多个语句操作共享数据的代码锁起来，让任意时刻只能有一个线程执行即可。

死锁：如果出现同步嵌套，就容易产生死锁问题。两个或者两个以上的线程，在抢占CPU的执行权的时候，都处于等待状态。

线程池：就是一个具有指定数量线程的一个池子。

对象的六大原则：（七大原则）
1.单一职责原则（Single Responsibility Principle   SRP）
2.开闭原则（Open Close Principle   OCP）
3.里氏替换原则（Liskov Substitution Principle   LSP）
4.依赖倒转原则（Dependence Inversion Principle   DIP）
5.接口隔离原则（Interface Segregation Principle   ISP）
6.迪米特原则 （Least Knowledge Principle   LKP）
7.组合/聚合复用原则（哈姆雷特）

设计模式（Design pattern）：是一套被反复使用、多数人知晓、经过分类编目、代码设计经验的总结。

设计模式分类（23种）：

创建型模式（创建对象的）：单例模式、工厂模式、抽象工厂模式、原型模式、建造者模式

结构型模式（对象的组成）：代理模式、装饰模式、适配器模式、外观模式、桥接模式、组合模式、享元模式

行为型模式（对象的功能）：迭代器模式、命令模式、观察者模式、策略模式、解释器模式、模版方法模式、中介者模式、备忘录模式、状态模式、职责链模式、访问者模式

单例模式思想：保证类在内存中只有一个对象，并提供一个访问它的全局访问点。单例模式之饿汉式是在加载的时候，实例就已经创建；单例模式之懒汉式是当程序第一次访问实例才进行创建。

工厂模式：定义一个创建对象的接口，让其子类自己决定实例化那一个工厂类，工厂模式使其创建延迟到子类进行。

抽象工厂模式：提供一个创建一系列相关或者相互依赖对象的接口，而无需指定它们具体的类。

代理模式：为其它对象提供一种代理以控制对这个对象的访问。

装饰模式：动态的给一个对象添加一些额外的职责。

适配器模式：将一个类的接口转换成客户希望的另外一个接口。

外观模式：为子系统中的一组接口提供一个一致的界面，外观模式定义了一个高层接口，这个接口使得这一系统更加容易使用。

迭代器模式：提供一种方法顺序访问一个聚合对象中各个元素，而又无须暴露该对象的内部表示。

观察者模式：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

策略模式：定义一系列的算法，把它们一个个封装起来，并且使它们可以相互替换。

模板方法模式：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。

 

类加载器：就是负责将.class文件加载到内存中，并为之生成对应的Class对象。

 

反射：就是获取运行在JVM中的类的Class对象，然后对Class对象的各个组成部分进行剖析，将各个组成部分抽取映射成独立的JAVA类也就是独立的对象。

 

工作2年多点，第一次写java基础知识方面的，其实很多都是可以查询到的，但还是在博客里写上，让自己有一个再次熟悉的过程，写的有错误的地方，希望老司机们留言指点，谢谢各位老司机。