weixin_44893467的博客

1，实例变量–instance variable从属于一个实例2，静态变量–static variable整个Class共享这个变量例子：public class Yzx { public String name;//实例变量 public static int age;//静态变量}实例变量调用方式 Yzx yzx=new Yzx();//这个变量只属于这个yzx实例 yzx.name="afsa";静态变量调用方式 Yzx.age=26;//这个age变量属于整

JDBC–Java Database Connectivity(Java数据库连接)JDBC就是SUN公司规定的一个开发接口，让各个数据库厂商去实现，制定相应的数据库驱动。举例：sun公司提供接口/** * Sun制定了一套接口，各个数据库厂商需要根据我得规范去制定驱动 * */public interface JDBC { void getConnection();}各个厂商实现该接口，也就是数据库驱动public class MySQL implements JDBC {

java三大控制结构顺序结构不多说，就是从头到尾的执行，分支结构选择分支if else面试题：if else一般不建议超过三层，否则会严重降低代码的可读性，怎么降低嵌套次数？把接口分为外部和内部接口，所有空值判断放在外部接口完成；而内部接口传入的变量由外部接口保证不为空，从而减少空值判断。利用多态，把业务判断消除，各子类分别关注自己的实现，并实现子类的创建方法，避免用户了解过多的类。把分支状态信息预先缓存在Map里，直接get获取具体值，消除分支。参考链接（https://blog.c

概念：Shell是一个命令行解析器，它接收应用程序/用户命令，然后调用操作系统内核。Shell还是一个功能强大的编程语言，易编写，易调试，灵活性强。2，在windows下使用shell。我安装了git应用程序，直接将该目录放入path即可3，测试是否可行，创建1.sh内容#!/bin/shtouch //////指定解析器a.txtsleep 10echo "testtesttesttest">>a.txt能正常生成a.txt，并写入内容即可4，首先进入shell的编

过滤器：Filter即为过滤器，用于在servlet之外对request和response进行修改。它主要用于对用户请求进行预处理，也可以对HttpAervletResponse进行后处理。使用Filter的完整流程，Filter对用户请求进行预处理，接着将请求交给Servlet进行处理并生成响应，最后Filter再对服务器响应进行后处理。在一个web应用中，可以开发编写多个Filter，这些Filter组合起来称为Filter链。过滤器链：执行顺序为，先配置的先执行，后配置的后执行响应时顺序则相反

应用场景：有一个service，里边有增删改查等方法，可是在对其进行开发的时候，并没有对输入参数进行校验，以及对日志进行打印，所以我们想在每个方法前进行数据校验，执行完进行日志打印，此时在每个方法中都增加，即浪费经历，又使得代码更加冗余。此时就需要面向切面编程。在执行方法前执行一个方法，执行后再执行一个方法。public interface UserService { String add(); void delete(); void update(); void

1，spring是一个轻量级控制反转和面向切面编程的框架（容器）。2，spring boot是一个快速开发的脚手架，基于spring的，可以快速开发单个微服务。3，springcloud是基于springboot的，是多个微服务的集合。4，spring由七大部分组成，core aop dao orm web web-mvc context组成。5，缺点：配置繁琐。6，IOC是一种思想之前的开发思路interface UserDaoUserDaoImplUesrServiceUserSe

sentinel2的数据是未经过辐射校正和大气校正的数据，如图下载的是sentinel2数据文件格式S2B_MSIL1C_20201031T025839_N0209_R032_T50TNK_20201031T050601.SAFE此时我们需要用人家提供的插件进行辐射校正和大气校正。第一步：下载Sen2Cor(可以去官网下载，也可以加我扣扣获取525356610)第二步：然后解压双击第三步：配置环境变量（放进环境变量）此时我们就可以用命令行进行校正了L2A_Process S2A_MSIL1C

第一种模式：懒加载模式延迟加载，只有真正使用的时候才会实例化。package lazysingleton;public class LazySingLetonTest { public static void main(String[] args) { myThread myThread = new myThread(); Thread thread = new Thread(myThread); thread.start();

强引用强引用是使用最普遍的引用。如果一个对象具有强引用，那垃圾回收器宁愿抛出OOM（OutOfMemoryError）也不会回收它。String a=new String("123");当你声明一个变量a，并指向一个实例的时候，其实就是在创造一个强引用。此时强引用体现在什么地方？？？这主要体现在JVM进行GC的时候，只要对象有强引用与其关联，就绝对不会对它进行回收，即使已经内存不足了也不会收回有强引用指向的对象。也就是说只要你不进行手动清理，这个a永远不会消失。此时我们可以显示的消除引用。当

代码如下：分别是继承Thread，实现Runable,，事项Callable。此时运行代码是主线程里分别在跑三个子线程。package com.cloud.test;import java.util.concurrent.Callable;import java.util.concurrent.ExecutionException;import java.util.concurrent.FutureTask;public class Test { public static voi.

一、什么是泛型1.背景：JAVA推出泛型以前，程序员可以构建一个元素类型为Object的集合，该集合能够存储任意的数据类型对象，而在使用该集合的过程中，需要程序员明确知道存储每个元素的数据类型，否则很容易引发ClassCastException异常。（例如4.理解里的list,遍历时就会出现强制类型转换，出现错误）2.概念：Java泛型（generics）是JDK5中引入的一个新特性，泛型提供了编译时类型安全监测机制，该机制允许我们在编译时检测到非法的类型数据结构。泛型的本质就是参数化类型，也就是所

可以查看改程序对内存的消耗：s0（servive0）s1（servive1）E（Eden）O（old）M (元空间)CCS (压缩使用比例)YGC(Young GC) Young GC次数YGCT(Young GC Time)Young GC用的时间FGC(Full GC)Full GC次数FGCT(Full GC Time)Full GC用的时间GCT(代表Young & Full GC共计耗时。)...

三大特性分别是原子性 ，可见性，有序性原子性：指一个操作是不可中断的，即使是多个线程一起执行的时候，一个操作一旦开始，就不会被其他线程干扰可见性：指当一个线程修改了某一个共享变量的值，其他线程是否能够立即知道这个修改。显然，对于串行程序来说，可见性问题 是不存在。因为你在任何一个操作步骤中修改某个变量，那么在后续的步骤中，读取这个变量的值，一定是修改后的新值。但是这个问题在并行程序中就不见得了。如果一个线程修改了某一个全局变量，那么其他线程未必可以马上知道这个改动。有序性：对于一个线程的执行代码而言

计算机硬件的内存模型。java内存模型（jvm）Java内存模型和硬件内存模型的关系来一段代码解释public class JMM { public static boolean initFlag = false; public static void main(String[] args) { new Thread(new Runnable() { @Override public void run() {

import java.util.Iterator;public class LinkList<T> implements Iterable<T>{ //整个链表反转 public void reverse(){ if(isEmpty()){ return; } reverse(head.next); } //节点反转 public Node reverse(Node curr.

import java.util.ArrayList;import java.util.Iterator;import java.util.List;public class CollectionSetlist { public static void main(String[] args) { List<String> list=new ArrayList(); list.add("hello"); list.add("word"

String str = "good"; char[] ch = {'a', 'b', 'c'}; public static void main(String[] args) { Temp ex = new Temp(); ex.change(ex.str, ex.ch); System.out.print(ex.str + "and"); System.out.print(ex.ch); } publi.

public static void main(String[] args) { A ab = new B(); ab = new B(); }}class A{ static{ System.out.print("1"); } public A(){ System.out.print("2"); }}class B extends A{ static{ System.out.prin

第一点：在计算机中默认浮点数是double型，所以float定义时必须加个f或F。（有些东西默认就是默认，我们没办法深究，例如在计算byte取值范围时1000 0000就代表-128，别问我为什么，你去问规定的人去）第二点：在精确运算时最好别用double float。因为会有舍入误差。 double a=3.0; double b=2.9; float c=3.0f; float d=2.9f; System.out.p

java程序自行处理内存的回收释放，jvm上增加了垃圾回收机制，用以在适当的时间触发垃圾回收，将不需要的内存空间回收释放，避免无限制增长的内存导致OOM（OUT OF MEMOR内存溢出）。垃圾回收对象原则：堆区标记要删除的对象（3种删除办法）：young区 old区 s1 s0 E区讲解...

函数的基本类型存储函数的引用类型存储

稳定性初解说到稳定性，与之对应就是不稳定性，那么排序算法的稳定性又为何意呢？通俗地讲就是，能保证排序前两个相等的数其在序列的前后位置顺序与排序后它们的前后位置顺序一致。形式化解释如下：一列数中，如果Ai = Aj，Ai位于Aj的前置位，那么经过升降序排序后Ai仍然位于Aj的前置位。稳定性优劣那么排序稳定性又有什么优势和劣势呢？首先优势应该是比较明显的，比如：1. 能够节约时间，稳定性算法会减少一次交换时间（但多了不交换这个限制后，稳定排序的冒泡／插入／选择都是O(n^2);而不稳定排序快排／堆排却是O

public class Student implements Comparable<Student> { private String usenname; private int age; @Override public String toString() { return "Student{" + "usenname='" + usenname + '\'' + "

一）Collection接口：存储单列数据：(1)List：单列有序集合（可以重复）：A、ArrayList：底层结构是数组，底层查询快，增删慢（非线程安全）；B、LinkedList：底层结构是链表型的，增删快，查询慢；C、vector：底层结构是数组，线程安全的，增删慢，查询慢（不常用）；(2)Set：单列无序集合（不可重复）：A、HashSet：按照哈希算法来存取集合中的元素，存取速度比较快；B、TreeSet：基于红黑树数据结构，实现元素的“自然排序”；二）Map接口：存储键、值的双

十进制转八进制十进制转十六进制(10、11、12、13、14、15 分别用A、B、C、D、E、F表示)十进制转十六进制小数位怎么算比如这里的0.9032转化成16进制小数0.9032*16=14.4512 取整数14 即E0.4512*16=7.2192 取整数70.2192*16=3.5072 取整数30.5072*16=8.1152 取整数80.1152*16=1.8432 取整数1十进制转二进制十进制转二进制小数演示（乘二取整，顺序排列，取到精确位）...

float：4字节，32位，默认0.0fdouble：8字节，64位，默认0.0dfloat的有效数字：输出的是8位有效数字，前7位是可靠数字，第8位是存疑数字（是第九位进行四舍五入上来的）。public class FloatAndDouble { public static void main(String[] args) { float a=0.123456789f; float b=1.123456789f; float c=12.345

//外部类class OuterClass { private int num; //外部类怎么访问内部类成员（创建内部类对象） public void function0() { System.out.println("我是外部类里的方法！！！"); Inner1 inner1 = new Inner1();//外部类访问内部类 //inner1.function(); int a = inner1.a;

InputStream 和OutputStream,两个是为字节流设计的,主要用来处理字节或二进制对象。Reader和 Writer.两个是为字符流（一个字符占两个字节）设计的,主要用来处理字符或字符串。

1、序列化和反序列化的定义：(1)Java序列化就是指把Java对象转换为字节序列的过程 Java反序列化就是指把字节序列恢复为Java对象的过程。(2)序列化最重要的作用：在传递和保存对象时.保证对象的完整性和可传递性。对象转换为有序字节流,以便在网络上传输或者保存在本地文件中。 反序列化的最重要的作用：根据字节流中保存的对象状态及描述信息，通过反序列化重建对象。总结：核心作用就是对象状态的保存和重建。（整个过程核心点就是字节流中所保存的对象状态及描述信息）2、json/xml

public class Temp implements Cloneable { public static void main(String[] args) throws IllegalAccessException, InstantiationException, CloneNotSupportedException { //1，利用new关键字创建对象 Temp temp=new Temp(); System.out.println(temp);

方法名可以和类名一样吗？？？可以！！只是不符合规范而已。。。。。如图public class Temp { public static void main(String[] args) { Temp(); } public static void Temp(){ System.out.println("方法名与类名相同"); }}java中default的两种用法？？？1，在switch中的默认分支。2，在接口中修饰方法，defa

public static void main(String[] args) { File file=new File("C://Users//52535//Desktop//周报//cloud1三月二十九"); traverse(file); } public static void traverse(File file){ File []files=file.listFiles(); if (files==null){

Integer a=1;Integer变量指向的是 java 常量池中的对象new Integer(1);new Integer() 的变量指向堆中新建的对象,两者在内存中的地址不同。int 变量与 Integer、 int 变量与new Integer() 比较时，只要两个的值是相等，则为true因为包装类Integer 和 基本数据类型int 比较时，java会自动拆包装为int ，然后进行比较，实际上就变为两个int变量的比较。 Integer a=1; int

向上转型（父类引用指向子类对象）Father f1 = new Son();无需强制转换向下转型Son son=(Son)f1需要强制转换多态存在的三个必要条件1，继承父类 Perpson子类 Man extends Person子类 Women extends Person2，重写 function dance（父类） function dance(子类重写方法) Man function dance(子类重写方法) Women3，向上转型Person

public，可以修饰类，成员变量，成员方法，修饰的类，成员变量，成员方法可以在任意位置使用，protected，protected是受保护的，受到该类所在的包所保护。被protected所修饰的成员会被位于同一package中的所有类访问到。同时，被protected所修饰的成员也能被该类的所有子类继承下来。(注意：这里是指同一个package或者不同的package中的子类都能访问)default，即在成员的前面不写任何的访问修饰符的时候，默认就是友好的。所谓友好的，是对同一package

public String toString() { return getClass().getName() + "@" + Integer.toHexString(hashCode());}getClass()获取类对象getName()以String形式返回类对象的名称Integer.toHexString(hashCode())以对象的哈希码为参数，以16进制无符号整数形式返回此哈希码的字符串表示形式；在实体类中我们一般会重写toString方法。（1、在大量代码调试的时候它的作

object类是所有类的父类，这里定义了equals方法。可以看到里边用的是==也就是比较的两个对象的内存地址。object1.equals(object2)为true，则表示equals1和equals2实际上是引用同一个对象。 public boolean equals(Object obj) { return (this == obj); }所以八种基本数据类型直接用==比较即可对应的包装类(八种基本数据类型不面向对象，为了使用方便和解决这个不足，在设计类时为每个基本数

1，获取哈希码public native int hashCode();解释：hash是一个函数，该函数中的实现就是一种算法，就是通过一系列的算法来得到一个hash值。通过hash算法得到的hash值在hash表中存储。对象的物理地址跟这个hashcode地址不一样，hashcode代表对象的地址说的是对象在hash表中的位置，物理地址说的对象存放在内存中的地址。通过对象的内部地址(也就是物理地址)转换成一个整数，然后该整数通过hash函数的算法就得到了hashcode。作用为了查找的快捷性，H

abstract用来修饰类和方法修饰类：这个类需要被继承使用，不能生成实例对象。图一其中抽象方法，不能实现，需要被子类继承时重写实现。图一抽象类里可以有普通方法，被子类实例化后使用。图二抽象类里可以有构造函数，但是本身自己不能实例化，所以需要子类使用。图三抽象类里的普通方法可以调用抽象方法。图四修饰方法：抽象方法必定存在于抽象类里。其他的在上边已经陈述。final关键字用来修饰类，方法，属性************其中修饰方法不能是构造方法。修饰类：被final修饰的类不能被