类：类是一个模板，它描述一类对象的行为和状态。（比如一张汽车设计图纸）
对象：对象表示现实世界中一个具体的事物。对象是类的一个实例，有状态和行为。例如，一条狗是一个对象，它的状态有：颜色、名字、品种；行为有：摇尾巴、叫、吃等。（比如根据汽车设计图纸设计出来的汽车）【类是对象的类型，对象是类的实例】
方法：方法就是一段用来完成特定功能的代码片段，类似于其它语言的函数。方法用于定义该类或该类的实例的行为特征和功能实现。方法是类和对象行为特征的抽象。方法很类似于面向过程中的函数。面向过程中,函数是最基本单位,整个程序由一个个函数调用组成。面向对象中，整个程序的基本单位是类，方法是从属于类和对象的。

构造方法

定义：构造方法作用就是对类进行初始化。每个类都有构造方法。如果没有显式地为类定义构造方法，Java编译器将会为该类提供一个默认不带任何参数的构造方法。


**创建一个人的类**
class Person{
	public String name;
	public int age;
    
    public Person(){
    }//无参构造函数
 
	public Person(String n,int a){
		this.name=n;
		this.age=a;
	}//有参构造函数（此时默认构造函数失效，想要调用无参，必须自己定义）
 
}

方法的重载

在Java程序中，如果同一个类中存在两个方法同名，方法的签名(参数个数、参数类型、类型排列次序)上也一样，将无法编译通过。
但在Java中多个方法重名是允许的，只要保证方法签名不同即可，这种特性称为方法重载（overload）
上述两个构造方法public Person()，public Person(String n,int a)也是方法的重载。

访问修饰符

default(friendly): 默认访问修饰符，在同一包内可见；
private（私有的）：在同一类内可见，不能在类外看到，不能修饰类；
protected（受保护的）：允许类本身、同一包中的所有类和不同包中的子类访问，不能修饰类；
public（公共的）：对所有类可见。

继承

关键字：extends。运用继承，可以创建一个通用类定义一系列一般特性。
1、被继承的类称为父类
2、继承父类的类称为子类
3、执行继承时，子类将获得父类的属性，并具有自身特有的属性。

继承的特性：
1、子类拥有父类非 private 的属性、方法。
2、子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
3、子类可以用自己的方式实现父类的方法。
4、Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，这是 Java 继承区别于 C++ 继承的一个特性。（C++有多重继承，可以继承很多类，但是C++没有接口；Java没有多重继承，但是java有继承 + 接口）
5、提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。

为什么Java中不支持多重继承？

为什么Java中不支持多重继承？_java为什么不支持多继承_今昔在的博客-CSDN博客

Java 只能继承一个类，因为Java是面向对象语言，一个类可继承的属性不应该来自多个类，继承是类与类的关系，在Java中是对本身更高层次的抽象，而不是更多层次的抽象，不是人、猫、狗这样去抽象，而是人、动物这样的抽象方式。

所以Java的思想就不支持多重继承，但是支持对象的扩展，也就是接口。Java的面向对象思维把多重继承划分的更加对象化。
多重继承既可以实现更高层次的抽象又可以实现多次层次的扩展。

Java中不支持多重继承也是因为：

Java有单一继承这样的更高层次的抽象
也有实现多个接口这样的更多层次的扩展方式

注意：
1、没有extends，默认父类为Object
2、只能有一个父类，即单继承；但是一个父类可以有多个子类
3、子类继承父类的全部成员，除了private成员
4、子类与父类不在同包，使用默认访问权限的成员不能被继承
5、构造方法不能被继承（但是子类可以调用父类构造方法）

Java 与 C++ 的区别

Java 是纯粹的面向对象语言，所有的对象都继承自 java.lang.Object，C++ 为了兼容 C 即支持面向对象也支持面向过程。
Java 通过虚拟机从而实现跨平台特性，但是 C++ 依赖于特定的平台。
Java 没有指针，它的引用可以理解为安全指针，而 C++ 具有和 C 一样的指针。
Java 支持自动垃圾回收，而 C++ 需要手动回收。
Java 不支持多重继承，只能通过实现多个接口来达到相同目的，而 C++ 支持多重继承。
Java 不支持操作符重载，虽然可以对两个 String 对象执行加法运算，但是这是语言内置支持的操作，不属于操作符重载，而 C++ 可以。
Java 的 goto 是保留字，但是不可用，C++ 可以使用 goto。

JVM、JRE和JDK的关系

JVM，Java虚拟机(Java Virtual Machine)，Java程序需要运行在虚拟机上，不同的平台都有自己的虚拟机，所以Java语言实现了跨平台。
JRE，Java运行环境(Java Runtime Environment)，指的是Java的运行时环境，包括需要的大量的类库和Java的虚拟机。
JDK，Java开发工具包（Java Development Kit），提供了Java的开发环境和运行环境。

int和Integer的区别

1、数据类型不同：int 是基础数据类型，而 Integer 是包装数据类型；
2、默认值不同：int 的默认值是 0，而 Integer 的默认值是 null；
3、内存中存储的方式不同：int 在内存中直接存储的是数据值，而 Integer 实际存储的是对象引用，当 new 一个 Integer 时实际上是生成一个指针指向此对象；
4、实例化方式不同：Integer 必须实例化才可以使用，而 int 不需要；
5、变量的比较方式不同：int 可以使用 == 来对比两个变量是否相等，而 Integer 一定要使用 equals 来比较两个变量是否相等。
来源：Java基础 - Integer和int的区别_程序员老石的博客-CSDN博客_integer和int的区别

包装类及其作用

因为Java 的设计理念是一切皆是对象，在很多情况下，需要以对象的形式操作，比如 hashCode() 获取哈希值，或者 getClass() 获取类等。

包装类的作用：在 Java 中每个基本数据类型都对应了一个包装类，包装类的存在解决了基本数据类型无法做到的事情泛型类型参数、序列化、类型转换、高频区间数据缓存等问题。

Java基本数据类型		包装类型
4 种整型	byte: 占用1个字节，取值范围-128 ~ 127	Byte
	short: 占用2个字节，取值范围-215 ~ 215-1	Short
	int：占用4个字节，取值范围-231 ~ 231-1	Integer
	long：占用8个字节	Long
2 种浮点类型	float：占用4个字节	Float
2 种浮点类型	double：占用8个字节	Double
字符类型	char: 占用2个字节	Character
真假类型	boolean：占用大小根据实现虚拟机不同有所差异	Boolean

引用数据类型：String 类接口抽象类枚举数组

HashMap

HashMap 是一个散列表，它存储的内容是键值对(key-value)映射。

HashMap 实现了 Map 接口，根据键的 HashCode 值存储数据，具有很快的访问速度，最多允许一条记录的键为 null，不支持线程同步。

HashMap 是无序的，即不会记录插入的顺序。

HashMap 继承于AbstractMap，实现了 Map、Cloneable、java.io.Serializable 接口。

HashMap 的 key 与 value 类型可以相同也可以不同，可以是字符串（String）类型的 key 和 value，也可以是整型（Integer）的 key 和字符串（String）类型的 value。

HashMap 中的元素实际上是对象，一些常见的基本类型可以使用它的包装类。

HashMap 类位于 java.util 包中，使用前需要引入它，语法格式如下：

import java.util.HashMap; // 引入 HashMap 类

以下实例我们创建一个 HashMap 对象 Sites，整型（Integer）的 key 和字符串（String）类型的 value：

HashMap<Integer, String> Sites = new HashMap<Integer, String>();

Java HashMap 常用方法如下表

更多语法见：Java HashMap | 菜鸟教程

方法	描述
clear()	删除 hashMap 中的所有键/值对
clone()	复制一份 hashMap
isEmpty()	判断 hashMap 是否为空
size()	计算 hashMap 中键/值对的数量
put()	将键/值对添加到 hashMap 中
putAll()	将所有键/值对添加到 hashMap 中
putIfAbsent()	如果 hashMap 中不存在指定的键，则将指定的键/值对插入到 hashMap 中。
remove()	删除 hashMap 中指定键 key 的映射关系
containsKey()	检查 hashMap 中是否存在指定的 key 对应的映射关系。
containsValue()	检查 hashMap 中是否存在指定的 value 对应的映射关系。
replace()	替换 hashMap 中是指定的 key 对应的 value。
replaceAll()	将 hashMap 中的所有映射关系替换成给定的函数所执行的结果。
get()	获取指定 key 对应对 value
getOrDefault()	获取指定 key 对应对 value，如果找不到 key ，则返回设置的默认值
forEach()	对 hashMap 中的每个映射执行指定的操作。
entrySet()	返回 hashMap 中所有映射项的集合集合视图。
keySet()	返回 hashMap 中所有 key 组成的集合视图。
values()	返回 hashMap 中存在的所有 value 值。
merge()	添加键值对到 hashMap 中
compute()	对 hashMap 中指定 key 的值进行重新计算
computeIfAbsent()	对 hashMap 中指定 key 的值进行重新计算，如果不存在这个 key，则添加到 hasMap 中
computeIfPresent()	对 hashMap 中指定 key 的值进行重新计算，前提是该 key 存在于 hashMap 中。

HashMap为什么线程不安全？如何保障HashMap线程安全？

Hashmap如何保证线程安全_马腾.♔的博客-CSDN博客_hashmap如何保证线程安全

在JDK1.7中，HashMap采用头插法插入元素，因此并发情况下会导致环形链表，产生死循环。
虽然JDK1.8采用了尾插法解决了这个问题，但是并发下的put操作也会使前一个key被后一个key覆盖。
由于HashMap有扩容机制存在，也存在A线程进行扩容后，B线程执行get方法出现失误的情况。

（扩容容量必须是 2 的幂次方、最大容量为 1<< 30 、若当前数据/总数据容量>加载因子，Hashmap将执行扩容操作，默认加载因子为0.75）

线程安全Map的三种方法：

Key为什么不重复?哈希冲突...

引入哈希表的目的是使查找和处理一个数时（不经过比较）让时间复杂度保持在O(1)，这样就是为了加快查询效率，这里我们需要了解有关如何设计哈希函数以及尽可能地避免哈希冲突的方法。

JVM(Java虚拟机)运行时数据区怎么分？

JVM: Java Virtual Machine(Java虚拟机)，是用来执行Java字节码（二进制的形式）的虚拟机计算机。JVM是运行在操作系统之上的，与硬件没有任何关系。

JVM - 运行时数据区详细篇_星辰与晨曦的博客-CSDN博客

JVM——运行时数据区域_喵喵超牛的博客-CSDN博客_jvm运行时数据区

如上图，运行时数据区包括五个部分，蓝色区域多个线程共享，黄色区域每一个线程独占，在java API ，一个java虚拟机就对应一个Runtime类，一个Runtime就对应一个运行时数据区。

程序计数器（Program Counter Register）：程序计数器是一块较小的内存空间，可以把它看作是当前线程所执行的字节码的行号指示器。
Java虚拟机栈（Java Virtual Machine Stack）：描述的是Java方法执行的内存模式，每个方法在执行的同时都会创建一个线帧（Stack Frame）用于存储局部变量表、操作数栈、动态链接、方法出口等信息，每个方法从调用直至执行完成的过程，都对应着一个线帧在虚拟机栈中入栈到出栈的过程。
本地方法栈（Native Method Stack）：与虚拟机栈的作用一样，只不过虚拟机栈是服务于Java方法的，而本地方法栈是为虚拟机调用Native（本地）方法服务的。
Java堆（Java Heap）：是Java虚拟机中内存最大的一块，是被所有线程所共享的，在虚拟机启动的时候就创建好了，Java堆唯一的目的就是存放对象的实例，几乎所有的对象实例都是在这里分配内存的。
方法区（Method Area）（也叫元空间）：方法区就是用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译后的代码等数。方法区是很重要的系统资源，是硬盘和CPU的中间桥梁，承载着操作系统和应用程序的实时运行。

（栈是运行时的单位，堆是存储时的单位）

JMM（Java内存模型）

JMM（Java内存模型）详解_加油进大厂的博客-CSDN博客_jmm

1.什么是JMM？

JMM 是Java内存模型（ Java Memory Model）。它本身只是一个抽象的概念，并不真实存在，它描述的是一种规则或规范，是和多线程相关的一组规范。通过这组规范，定义了程序中对各个变量（包括实例字段，静态字段和构成数组对象的元素）的访问方式。每个JVM 的实现都要遵守这样的规范，有了JMM规范的保障，并发程序运行在不同的虚拟机上时，得到的程序结果才是安全可靠可信赖的。如果没有JMM 内存模型来规范，就可能会出现，经过不同 JVM 翻译之后，运行的结果不相同也不正确的情况。

计算机在执行程序时，每条指令都是在CPU中执行的。而执行指令的过程中，势必涉及到数据的读取和写入。由于程序运行过程中的临时数据是存放在主存（物理内存）当中的，这时就存在一个问题，由于CPU执行速度很快，而从内存读取数据和向内存写入数据的过程，跟CPU执行指令的速度比起来要慢的多（硬盘 < 内存 <缓存cache < CPU）。因此如果任何时候对数据的操作都要通过和内存的交互来进行，会大大降低指令执行的速度。因此在CPU里面就有了高速缓存。也就是当程序在运行过程中，会将运算需要的数据从主存复制一份到CPU的高速缓存当中，那么CPU进行计算时，就可以直接从它的高速缓存中读取数据或向其写入数据了。当运算结束之后，再将高速缓存中的数据刷新到主存当中。

JMM 抽象出主存储器（Main Memory）和工作存储器（Working Memory）两种。

主存储器是实例对象所在的区域，所有的实例都存在于主存储器内。比如，实例所拥有的字段即位于主存储器内，主存储器是所有的线程所共享的。
工作存储器是线程所拥有的作业区，每个线程都有其专用的工作存储器。工作存储器存有主存储器中必要部分的拷贝，称之为工作拷贝（Working Copy）。

所以，线程无法直接对主内存进行操作，此外，线程A想要和线程B通信，只能通过主存进行。

2.JMM的三大特性：原子性、可见性、有序性

1.原子性
一个或多个操作，要么全部执行，要么全部不执行（执行的过程中是不会被任何因素打断的）。

2.可见性
只要有一个线程对共享变量的值做了修改，其他线程都将马上收到通知，立即获得最新值。volatile,synchronized,final都能保证可见性。

3.有序性
有序性可以总结为：在本线程内观察，所有的操作都是有序的；而在一个线程内观察另一个线程，所有操作都是无序的。前半句指 as-if-serial 语义：线程内似表现为串行，后半句是指：“指令重排序现象”和“工作内存与主内存同步延迟现象”。处理器为了提高程序的运行效率，提高并行效率，可能会对代码进行优化。编译器认为，重排序后的代码执行效率更优。这样一来，代码的执行顺序就未必是编写代码时候的顺序了，在多线程的情况下就可能会出错。

在代码顺序结构中，我们可以直观的指定代码的执行顺序, 即从上到下按序执行。但编译器和CPU处理器会根据自己的决策，对代码的执行顺序进行重新排序，优化指令的执行顺序，提升程序的性能和执行速度，使语句执行顺序发生改变，出现重排序，但最终结果看起来没什么变化（在单线程情况下）。

有序性问题指的是在多线程的环境下，由于执行语句重排序后，重排序的这一部分没有一起执行完，就切换到了其它线程，导致计算结果与预期不符的问题。这就是编译器的编译优化给并发编程带来的程序有序性问题。

Java 语言提供了 volatile 和 synchronized 两个关键字来保证线程之间操作的有序性，volatile 是因为其本身包含“禁止指令重排序”的语义，synchronized 是由“一个变量在同一个时刻只允许一条线程对其进行 lock 操作”这条规则获得的，此规则决定了持有同一个对象锁的两个同步块只能串行进入。

简述java中volatile关键字作用

保证变量对所有线程的可见性。当一条线程修改了变量值，新值对于其他线程来说是立即可以得知的。
禁止指令重排序优化。使用 volatile 变量进行写操作，汇编指令带有 lock 前缀，相当于一个内存屏障，编译器不会将后面的指令重排到内存屏障之前。

3.关于同步的规定

线程解锁前，必须把共享变量的值刷新回主内存。
线程加锁前，必须将主内存的最新值读取到自己的工作内存。
加锁解锁是同一把锁。

4.解释说明

在JVM中，栈负责运行（主要是方法），堆负责存储（比如new的对象）。由于JVM运行程序的实体是线程，而每个线程在创建时，JVM都会为其创建一个工作内存（有些地方称为栈空间），工作内存是每个线程的私有数据区域。而JAVA内存模型中规定，所有变量都存储在主内存中，主内存是共享内存区域，所有线程都可以访问。

但线程对变量的操作（读取赋值等）必须在自己的工作内存中进行。首先要将变量从主内存拷贝到自己的工作内存空间，然后对变量进行操作，操作完成后，再将变量写回到主内存。由于不能直接操作主内存中的变量，各个线程的工作内存中存储着主内存中的变量副本，因此，不同的线程之间无法直接访问对方的工作内存，线程间的通信（传值）必须通过主内存来完成。

JMM中的八种操作

为了支持 JMM，Java 定义了8种原子操作，用来控制主存与工作内存之间的交互：

read 读取：作用于主内存，将共享变量从主内存传送到线程的工作内存中。
load 载入：作用于工作内存，把 read 读取的值放到工作内存中的副本变量中。
store 存储：作用于工作内存，把工作内存中的变量传送到主内存中。
write 写入：作用于主内存，把从工作内存中 store 传送过来的值写到主内存的变量中。
use 使用：作用于工作内存，把工作内存的值传递给执行引擎，当虚拟机遇到一个需要使用这个变量的指令时，就会执行这个动作。
assign 赋值：作用于工作内存，把执行引擎获取到的值赋值给工作内存中的变量，当虚拟机栈遇到给变量赋值的指令时，就执行此操作。
lock锁定：作用于主内存，把变量标记为线程独占状态。
unlock解锁：作用于主内存，它将释放独占状态。

Java有哪些锁？syn底层是什么？

java中都有哪些锁?_羡羡ˇ的博客-CSDN博客

Java中常见的各种锁-超全面_【JAVA】玩家的博客-CSDN博客

Synchronized 同步锁

Java提供的一种原子性内置锁(关键字)，用于解决多个线程间访问资源同步性问题，保证其修饰的方法或代码块任意时刻只能有一个线程访问synchronized，它可以把任非NULL 的对象当作锁。它属于独占式悲观锁，同时属于可重入锁。每个对象都可以使用它当作同步监视器, 当线程进入使用Synchronized修饰的代码块中会自动获取内部锁 , 此时其他线程想要访问此同步代码时只能被阻塞, 等待锁的释放(前一个线程执行完, 或者出现异常,调用了wait()方法等), 在进入synchronized会从主内存把变量读取到自己工作内存，在退出的时候会把工作内存的值写入到主内存，保证了原子性。

synchronized的实现是通过字节码指令完成的 , 我们可以通过反编译去看具体的底层实现。

Java 对象底层都关联一个的 monitor，使用 synchronized 时 JVM 会根据使用环境找到对象的monitor，根据 monitor 的状态进行加解锁的判断。如果成功加锁就成为该 monitor 的唯一持有者，
monitor 在被释放前不能再被其他线程获取。

synchronized在JVM编译后会产生monitorenter 和 monitorexit 这两个字节码指令，获取和释放monitor。这两个字节码指令都需要一个引用类型的参数指明要锁定和解锁的对象，对于同步普通方法，锁是当前实例对象；对于静态同步方法，锁是当前类的 Class 对象；对于同步方法块，锁是
synchronized 括号里的对象。

代码块的同步是利用monitorenter和monitorexit这两个字节码指令。在虚拟机执行到monitorenter指令时，首先要尝试获取对象的锁。当前线程拥有了这个对象的锁，把锁的计数器+1；当执行 monitorexit指令时将模计数器-1；当计数器为 0 时，锁就被释放了。

另外synchronized 通过在对象头设置标记，达到了获取锁和释放锁的目的。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/花生_TL007/article/detail/467980