java基础知识史上最强总结，不看一定后悔！！！包含设计模式

java基础

1、环境和环境变量

1、JVM、JRE和JDK的区别：

JVM(Java Virtual Machine):java虚拟机，用于保证java的跨平台的特性。
java语言是跨平台，jvm不是跨平台的。
JRE(Java Runtime Environment):java的运行环境,包括jvm+java的核心类库。
JDK(Java Development Kit):java的开发工具,包括jre+开发工具

2、环境变量path和classpath的作用是什么？

(1)path是配置Windows可执行文件的搜索路径，即扩展名为.exe的程序文件所在的目录，
用于指定DOS窗口命令的路径。
(2)Classpath是配置class文件所在的目录，用于指定类搜索路径，JVM就是通过它来寻找该类的class类文件的。

3、类加载过程

1. 将人能看懂的java文件编译成class文件 ，使用了javac编译器。

2. 将class文件加载到内存，生成一个Class对象。

   以上是一个静态过程，文件的内容没有变化

4、数据类型

基本数据类型 
//整数类型
byte 1个字节 
short 2个字节
int  4个字节
long  8个字节
//浮点数类型
float   4个字节
double  8个字节
//布尔类型
boolean 一个字节
//字符类型
char   两个字节
//引用数据类型
类、接口、数组
//精度从高到低
double float long int short(char) byte
自动类型转换：低精度到高精度
强制类型转换：高精度到低精度

5、定义变量

变量的作用

用来存储数据

为什么要定义变量

用来不断的存放同一类型的常量，并可以重复使用

什么时候定义变量？只要是数据不确定的时候，就定义变量

过程

定义 int i;

赋值 i = 5; 定义和赋值可以一起 int i = 5;

使用；

成员变量和局部变量区别

1、作用域

成员变量：针对整个类有效

局部变量：只在某个范围内有效（一般指的方法体，语句体内）

（2）存储位置

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

局部变量：在方法被调用，或者语句被执行时存在，存储在栈内存

(3)初始值
成员变量：有默认初始值。
局部变量：没有默认初始值，使用前必须赋值。

6、运算符

布尔运算

与 &： 串联
或 | ：并联
非 ！
&& 双语：  如果是false 直接  结果就是false 
|| 双或 ： 如果是true 直接   结果就是true
^  异或：  和或有点不一样。 两边结果一样，就为false。 两边结果不一样，就为true.

算术运算符

  +  -  *  /   %    ++   --   +=      -=

i++ 与 ++i

i++ 与 ++i 的主要区别有两个：
1、 i++ 返回原来的值，++i 返回加1后的值。
2、 i++ 不能作为左值，而++i 可以。

1、a = i++; 等校为 
   a = i; 
   i = i + 1; 
2.a = ++i; 等校为 
  i = i + 1; 
  a = i; 

数组

含义

同一种数据类型的集合。

好处

可以自动给数组中的元素从0开始编号，方便操作这些元素。

定义数组

类型[] 取得名字 = new 类型[长度];

int[]  array = new int[10];

定义及初始化

int[]  array = new int[]{1,2,3};
int[]  array = {1,2,3};

使用

1、打擂台的形式找最大值

2、循环遍历打印数组的每一个值

3、查找数组里存在的值

4、元素的位移

5、选择排序法

6、冒泡排序法

7、结构语句

switch：不支持lon

switch(条件){
    case 条件1：
    break；
    ..................
    default：
    break;
}
基础类型不能是long型 可以 byte short int 
String（String不是基础类型）  

for循环

定义条件变量    进入条件   ; 变量改变
    自增为了达到退出条件

while和do while

区别

do while无论如何都要先执行一下，然后才去判断

while 满足条件才能进入

while(条件){}

do{
    ...
}
while(条件)

关键字

break

无论如何都要结束当前的全部循环，程序会继续向下执行。

contiune

跳过本次循环继续下一次循环。

打标签

for循环可已打标签，使用break + 标签名可以 退出 被打标签的循环

8、三目运算符

条件 ？ 结果1 ： 结果二；

如果为true，执行结果1，否则执行结果2

9、内存结构

栈内存：用于存储局部变量，当数据使用完，所占空间会自动释放。
堆内存：数组和对象，通过new建立的实例都存放在堆内存中。
方法区：静态成员、构造函数、常量池、线程池
本地方法区：window系统占用
寄存器：

栈：先进后出，后进先出

堆

10、命名规范

元素、项目、包（文件夹）、类、接口、抽象类、接口的实现类、变量

面向对象

思想

面向对象是相对于面向过程而言的，面向过程强调的是功能，

面向对象强调的是将功能封装进对象，强调具备功能的对象；

比如我要达到某种结果，我就寻找能帮我达到该结果的功能的对象，如我要洗衣服我就买洗衣机，至于怎么洗我不管。

特征

封装：隐藏对象的属性和实现细节，仅对外提供公共访问方式
继承: 多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义，这些属性和行为，只要继承那个类即可。
多态: 一个对象在程序不同运行时刻代表的多种状态，父类或者接口的引用指向子类对象

1、权限修饰符

public

当前类、同package、其他package可带哦用

protected

当前类、同package可调用

private

当前类可调用

2、类和new对象

类：对现实世界中某类事物的描述,是抽象的，概念上的定义。
对象：事物具体存在的个体。

new对象其实是调用构造方法 ，但我们发现刚写的类里并没有构造方法 ,事实上，如果你的类没有构造 方法系统会送一个空的构造方法。

3、构造方法

名字和类名完全一样，大小写也不能有区别,没有返回类型，没有返回值。
一旦你定义了自己的构造方法，系统就不会赠送空的构造方法

作用

构造函数是用于创建对象，并对其进行初始化赋值，对象一建立就自动调用相对应的构造函数

//使用无参的构造方法
Dog teddy = new Dog();
//使用有参的构造方法，直接给name赋值
 Dog golden = new Dog("金毛");
//空的构造方法，方法必须和类名一样，不能有一点区别
public Dog(){
    
}
//构造方法和其他方法一样可以重载，可以有参数，名字必须和类名一样，不能有一点区别
    public Dog(String name)
    {
        System.out.println("验证构造方法被调用的时机：【" + name + "】被构造！");
         .name = name;
    }

构造方法和成员方法区别

A:格式区别
构造方法和类名相同，并且没有返回类型，也没有返回值。
普通成员方法可以任意起名，必须有返回类型，可以没有返回值。
B:作用区别
构造方法用于创建对象，并进行初始化值。
普通成员方法是用于完成特定功能的。
C:调用区别
构造方法是在创建对象时被调用的，一个对象建立，只调用一次相应构造函数
普通成员方法是由创建好的对象调用，可以调用多次

4、setter和getter

所有的属性必须私有化：
使用setter和getter，因为方法能控制取值和赋值的过程。

5、封装

集装箱改变了搬运，把零散的东西封装成一个整体

使用简单的基础数据类型（属性），方法封装可以封装成更复杂，更好用的类

参考：超级数组

好处：
将变化隔离；
方便使用；
提高复用性；
提高安全性

6、String

引用类型

注：使用string一定要注意，必须用一个新的String接受。

String substring = name.substring(1, 3);

用法

符串查找

字符串替换

字符串分割

字符串截串

字符串小写转大写

7、类加载器

把clss类，加载到内存里边，然后去运行

专业名称叫classloader

第一次主动使用类，加载的过程是静态的

8、静态过程

static的变量和方法，都在这个过程完成初始化并赋值给类对象

9、引用

放在栈里面，除了基本类型（byte、short、int、long、），但是String、数组、所有自己定义的类都是引用类型，都存在栈里面。存在栈里面的引用都是内存地址，指向内存的一片空间。只要碰到new，一定是从内存里面挖了一片空间去存数据。

栈帧

每个方法只要一执行，就会拉一个方法进来

方法里定义的变量，就是局部变量

10、对象和类对象的区别

对象：就是内存里边一块区域存的数据所表示的东西，是new出来的，在堆空间里面存的一堆数据所表示的

类对象：在类加载的时候把类加载到内存里面，形成了类对象，就像说明书，被static修饰。不能被调用。在内存里面只有一个

11、栈–先进后出

压栈

压入栈顶，一个数据结构

 //压栈（压入栈顶）
    public void push(int data){
        superArray.add(data);
    }

弹栈

有返回值，把最顶上面得值弹出来

public int pop(){
        return superArray.delete();
    }

12、继承

extends 单继承，一个爹可以有多个儿子，一个儿子只能有一个爹。
有个 顶级父类叫Object，所有的对象都有一个父类叫Object,这是规定，记住。

思想：一个对象调用方法的时候，首先去自己的类里边找，找不到的话就去父类找，父类找也不到，就 去父类的父类找，直到Object，找到为止！

new一个子类，一定会先new一个父类，子类的构造方法中第一句默认就是super（），意思就是构造子类一定会先构造一个父类

13、多态

存在的前提

1、要有继承

2、要有重写

3、要有父类引用指向子类对象

 //父类引用指向子类，子类能完成父类的一切工作
Animal dog = new Dog("小狗");
dog.eat();

存在的好处

灵活

14、抽象类

1、有些类天然就是为了让子类继承，而不是为了在父类中调用，这类方法存在的目的就是规定了子类，必须要有这些方法，比如动物类就规定，你实现了我这个类，就必须有eat方法，而且你必须重写

2、抽象方法必须使用abstract修饰

3、抽象方法是对子类的约束，不管是猫是狗，他必须是能吃东西

4、子类必须实现的定义成抽象类

public abstract void eat();

注意：

1、不能new，因为某些方法没有方法体。这些方法就是用来重写的，就是定义了子类必须有这些方法

2、他必须被继承才能用，必须实现所有的抽象方法

3、如果一个类继承了抽象类，要么，把自己声明成一个抽象类；要么，实现抽象类的所有方法；要么，实现抽象类的所有方法

15、接口

概念

当一个类里全是抽象方法，我们称这类方法叫接口，省略abstract，class改为interface。

注意：

1、接口里省略权限修饰符，默认为public，一个原因是因为他是给子类去实现（即成立叫重写）的

2、接口要被实现，关键字implements，必须实现里边所有的方法

3、java是单继承，但是是多实现，一个类可以实现多个接口，但只能继承一个父类

4、实现接口，必须实现接口里全部方法

5、接口里只能有静态常量、抽象方法

6、静态常量可以在任何的类、抽象类、接口中定义，他和继承、封装、多态以及new不new没有关系

public static final int num  = 1；

16、对象转型

强制转换

从父类的类型强制转换为子类，如果传入的真的是该类型，则强转没有问题；如果不是就会报错

合适的方法是使用instanceof，首先进行判断，确定类型后再处理

17、数组和链表区别

数组：调料盒，必须是连续存储，顺序存储，所有元素一次存储，插入时需要扩容，不便新增和删除

链表：不连续，可以分散的存储，链式存储，通过指针，插入删除不需要移动，长度容易扩充，查找比较难（需要从头开始，一个一个查找，费时）

链式存储：一个一个查找

集合和数组的区别

1：数组是固定长度的；

​ 集合可变长度的。
2：数组可以存储基本数据类型，也可以存储引用数据类型；

​ 集合只能存储引用数据类型。
3：数组存储的元素必须是同一个数据类型；

​ 集合存储的对象可以是不同数据类型。

18、List集合

也叫容器，装东西

概念

1、集合存放的都是对象引用，而非对象本身，出于表达上的便利，我们称集合中的对象就是指集合中对象的引用（reference）

2、集合就是能存东西的类，有的是只存值比如list、set，有的是存键值对，一个键一个值比如map，有的是数组实现，有的是列表实现的，有的是红黑树实现的，把一堆数据集合在一起就是集合

类型

有序的：set（集）、---------- HashSet、TreeSet

无序的：list（列表）、---------- ArrayList、LinkedList

map（映射） ---------- HashMap、TreeMap

集合接口分类

Collection和Map、list、set

**注意：**集合是一个动态的数组，数组的长度是不可变的、集合长度是可变的

collection：所有结合的父类

Collection接口

表示一组对象，这些对象也称为collection的元素。一些collection允许有重复的元素（例如List），但是另一些不允许有重复元素，例如（set）

List集合

元素有序，每一个元素都存在一个索引，元素可以重复

Set集合

元素无序，元素是通过链表进行存储的，元素不可以重复

Map集合

元素无序，通过键值对的方式进行存储，键不可以重复，值可以重复

ArrayList集合

参考SuperArray超级数组

注意

1、集合只能存储引用类型

2、ArrayList是顺序存储

3、特点：查询快、增删慢、线程不安全、效率高

4、容量会自动增加

5、初始化为10，有一个父类是List

//构造方法
List<String> strings = new ArrayList<>();

add方法

直接add，add（int index，String element），指定下标插入一个新的元素

clear方法

删除所有的元素

contains方法

如果此类表包含指定元素，则返回true

indexof方法索引

找元素，看元素在第几个位置，找不到就是-1

isEmpty

看看元素是否为空

迭代器

iterator()：以正确的顺序返回该列表中的元素迭代器

remove(int index)

按照下标删除 names.remove(2);

remove（Object o）

从列表中删除指定元素的第一个出现（如果存在）

removeRange（int fromIndex，int toIndex）

删除列表fromIndex（包含）和toIndex之间的元素

set（int index，E element）

用指定的元素替换此列表中指定位置的元素

size（）

int类型，返回此列表中的元素数

subList（int fromIndex，int toIndex）

返回此列表中指定的fromIndex（包括）和toIndex之间的独占视图

例如（1,4）：1、2、3会出来

toArray（）

以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中所有元素的数组

简而言之，将他们变成数组

Object[] objects = strings.toArray();

LinkList集合

底层数据结构是链表

特点：查询慢，增删快，线程不安全，效率高

Map

1、通过名字获取

Map是父类，父类引用指向子类

2、有两个泛型

public static void main(String[] args) {
        //通过名字获取
        Map<String,User> map = new HashMap<>();
        //map存数据
        map.put("xxx",new User("xxx",18,2));
        //map取数据
        User wss = map.get("xxx");
        System.out.println(wss.getName());
    }
------------------------------------

结果：xxx

HashMap–entryset

1、存的是一个键值对，叫做entryset，里面封装了内部类

2、通过键，找到值

3、首先会在内存生成数组，初始大小为16，用node存数据（里面有key、value、nextnode）。首先拿key算哈希值，得到一个数字，除以8，两个同样的形成一个链表，至少能挂8个，之后会树化，变成红黑树

4、HashMap不能根据key来排序

5、TreeMap可以排序，整体都是一棵树

6、V是泛型

7、HashMap的key不能重复，会直接覆盖

getOrDefault（Object key，V defaultValue）

1、返回到指定键的值，或defaultValue

2、M安排有两个泛型，一个是key的，一个是value的

isEmpty

看看元素是否为空

keySet（）

返回此地图中包含的键的set视图，就是拿到所有的key

通过哈希值一算，就会散列，分散成列

//返回所有的key
        Set<String> strings = map.keySet();

Remove

删除

replace（K key，V value）

将某一个key替换为别的值

keyset拿到所有的key，拿key去找值

拿到所有的键值对遍历

map的便利

//map的便利，map不能排序
        //map存的都是entry这种键值对，使用增强for循环拿到一个个键值对遍历
        for (Map.Entry<String,User> entry : map.entrySet()){
            System.out.println(entry.getKey());
            System.out.println(entry.getValue());
        }

TreeMap–有序

有序的，在你添加时自动排序

HashCode

1、任何都能通HashCode它生成一个数字

1、每一个字符串都能生成一个Hash，所有的字符串生成的数字都不一样

3、运用了哈希、数组、链表

HashSet-自动排序

1、不能重复，重复会被直接覆盖

TreeSet-自动排序

不能重复，而List可以，可以自动排序

first（）

返回当前第一个元素

利用set去重

19、重载override

概念

在同一个类中，允许存在一个以上的同名函数，只要它们的参数个数或者参数类型不同即可。

特点

与返回值类型无关，只看参数列表（参数类型以及参数个数）

好处

方便阅读，优化了程序设计

20、重写

概念

1、在不同类中(子父类中)，方法声明相同(返回类型，方法名，参数列表均相同)。

注意：

子类方法的访问权限要大于等于父类方法的访问权限

静态只能在重写静态。但是这种情况一般不会出现

重载与重写区别

重载在一个类中，切除了方法名、返回值、参数类型都可以不一样；

重写在子类中重写，重写是方法名，返回类型，参数必须完全一样，切必须要有继承

21、date

SimpleDateFormat（String pattern）

使用给定模式SimpleDateFormat并使用默认的FORMAT语言环境的默认日期格式符号

HH：24小时制

hh：12小时制

时间戳

1、英国伦敦1970年1月1日 0:0:0 到现在的毫秒数
2、在任何地域都一样

22、Calander日历类

//设置了一个月历，适用于零点抢购
        calendar.set(2020,Calendar.JANUARY,12,12,12,12);

23、Math静态方法

数学操作类:该类没有构造函数，方法均为静态的

//向上取整
System.out.println(Math.ceil(3.3));
//向下取整
System.out.println(Math.floor(3.3));
//取一个最大值
System.out.println(Math.max(2,4));
//取一个最小值
ystem.out.println(Math.min(2,4));
//取一个随机数
System.out.println(Math.random());

24、单例模式

(1)设计模式：
解决某类问题行之有效的方法，是一种思想，是规律的总结
(2)用来保证某个类在内存中只有一个对象
(3)保证唯一性的思想及步骤
为了避免其他程序建立该类对象，先禁止其他程序建立该类对象，即将构造函数私有化

为了其他程序访问到该类对象，须在本类中创建一个该类私有对象
为了方便其他程序访问到该类对象，可对外提供一个公共访问方式

比如API中的Runtime类就是单例设计模式。

(4)单例设计模式的两种方式
A:饿汉式 当类加载的时候，就创建对象。

B:懒汉式 当使用的使用，才去创建对象。

饿汉式和懒汉式的区别：

**
饿汉式是类一加载进内存就创建好了对象；
懒汉式则是类才加载进内存的时候，对象还没有存在，只有调用了getInstance()方法时，
对象才开始创建。
**
懒汉式是延迟加载，如果多个线程同时操作懒汉式时就有可能出现线程安全问题，解决线程安全问题
可以加同步来解决。但是加了同步之后，每一次都要比较锁，效率就变慢了，
所以可以加双重判断来提高程序效率。
注：开发常用饿汉式，因为饿汉式简单安全。懒汉式多线程的时候容易发生问题。
下一篇：MySql数据库总结，敬请期待！！！