java note 1:基础

注：本文内容都来自互联网，通过自己整理用于学习，不作任何其他作用！

？.单例模式？懒汉，饿汉
？抽象类和接口的区别？
？Docker?

内部类:可以在一个类中定义定义一个其他类，叫内部类。也可以定义内部接口，很少使用！
语法规则：可以使用访问修饰符，可以使用static。内部类和普通类语法规则相同。
访问内部类属性：InnerClass in = new Outer().new InnerClass(); in.xxx();
访问内部类方法：
    访问静态方法：InnerClass类名.method();
    访问非静态方法：Outer outer = new Outer();
                    InnerClass inner = new InnerClass();
                    inner.method();

局部内部类只能使用缺省的修饰。

**statis加在类上,**表示这是一个静态资源,不管创建(new)多少对象,只有一份。

内部类

jvm执行子类时，如果子类重写了父类的方法，父类的方法就会被直接被覆盖，除非用super显示调用！

静态语句块只执行一次

非静态语句块：相当于一个对象，用的少。每次构造都会执行！

public class StatementBlock {
//会在每次调用构造器之前执行一次
    {
        int num = 10;
    }
}

xxxAutoConfiguration**😗*向容器中自动配置组件
**xxxProperties:**自动配置类，装配配置文件中自定义的属性

springboot配置文件优先级：
1.项目目录下config/application.yml
2.项目路径下
3.代码路径下
4.代码路径下的resources

yaml的使用：

#k=v
#普通属性     属性：空格属性名称
name: Aruiea
#对象   对象:下一行属性名:空格属性名称
student:
  #对空格要求极其严格
  name: qinjiang
  age: 3
#行内写法
students: {name: Aruiea,age: 28}

#数组
pets:
  - cat
  - dog
  - pig

pets2: [cat,dog,pig]

yaml给对象赋值的方式

@Component
@ConfigurationProperties(prefix = "person")
public class Person

yml

person:
  name: Aruiea
  age: 27
  happy: true
  birth: 1994/11/2
  maps: {k1:v1,k2:v2}
  lists:
    - code
    - music
    - girl

  dog:
    name: 旺财
    age: 3

测试

@SpringBootTest
class Springboot01HelloworldApplicationTests {
    @Autowired
    private Person person;
    @Test
    void contextLoads() {
        System.out.println(person);
    }

}

springboot
两个主要的注释：
@SpringBootConfiguration//springboot配置，底层还是spring组件。
@EnableAutoConfiguration//自动配置

@SpringBootApplication做的四件事情：
1.判断项目类型
2.查找并加载所有可用初始化器，加载到initializers属性中
3.找出所有应用程序监听器，设置到Listeners属性中。
4.推断并设置main方法的定义类，找到运行的主类。
run开启了一个服务

@SpringBootApplication//标注这是一个springboot启动类
public class Springboot01HelloworldApplication 

**@SpringBootConfiguration//springBoot配置**
@Component//说明Configuration底层还是spring组件

**@EnableAutoConfiguration//自动配置**
@AutoConfigurationPackage//自动配置包
@Import(AutoConfigurationPackages.Registrar.class)//导入选择器

spring.factories中会导入所有的配置，要判断对应的配置是否生效，要看有没有响应的start,有对应的启动器，就会生效。
spring.factories在spring-boot-autoconfiguration下。

public class Printer {
//    单例在类中创建，不用private访问
    private static Printer printer = new Printer();
//      返回一个相同的printer实例
    public static Printer getInstance(){
        return printer;
    }

    public void pring(){
        System.out.println("开始打印!");
    }

}

public class Singleton {
    public static void main(String[] args) {
        Printer printer = Printer.getInstance();
        Printer printer2 = Printer.getInstance();
        System.out.println(printer==printer2);
    }
}

Java基础
基本数据类型

lang默认使用int数据类型，超过21忆时加L，否则报错。

float F = 2.2535是否有错？

不加f默认为double，会编译错误。
float精度为后7位，double为13位

三目元运算符

表达式1 ? 表达式2 ： 表达式3;
表达式必须返回一个确定的值。不能是语句块。

java语言的特点？

简易性（和c/c++很相似）
面向对象（封装，继承，多态）
平台无关性（Java虚拟机实现平台无关性）
支持网络编程并且很方便（Java语言诞生本身就是为简化网络编程设计的）
支持多线程（多线程机制使应用程序在同一时间并行执行多项任）
健壮性（Java语言的强类型机制、异常处理、垃圾的自动收集等）
安全性

Java和C++的区别

都是面向对象的语言，都支持封装、继承和多态
Java不提供指针来直接访问内存，程序内存更加安全
Java的类是单继承的，C++支持多重继承；虽然Java的类不可以多继承，但是接口可以多继承。
Java有自动内存管理机制，不需要程序员手动释放无用内存

Oracle JDK 和 OpenJDK
oracle更稳定

switch 表达式可以用什么？

长整型不行。
java 5，byte short int char
java 5以后，+enum
java 7,+String

最有效率的运算方法：移位运算

2*8 把2向左移3位。左乘右除。

Math.round()取值原理

+0.5，向下取整。

short s1 = 1; s1 = s1 + 1;有错吗?
short s1 = 1; s1 += 1;有错吗？

第一个有错，1默认位Int类型，需要强制类型转换。
第二个没错，s1+=1 是s1=short(s1+1);包含默认隐式类型转换。

Java语言采用何种编码方案？有何特点？

Unicode编码。每个字符有唯一数值，可以在任何平台安全使用。

访问修饰符 public,private,protected,以及不写（默认）时的区别
从四个方面看：当前类private，同包default,同包+子类protected,所有Public

&和&&的区别

&按位与，逻辑与。
&&短路与 左边是FALSE直接短路掉。

final的作用？

final修饰的类不能被继承，方法不能被overwrite，变量引用不可改变（引用的值可变）

this关键字

代表指向对象本身的一个指针。this.attribute this()；表示引用当前对象构造器。

super关键字

代表指向自己直接父类的一个指针。

super和this的比较

super()和this()均需放在构造方法内第一行。
super()在子类中调用父类的构造方法，this()在本类内调用本类的其它构造方法。
可以用this调用一个构造器，但却不能调用两个。
this和super不能同时出现在一个构造函数里面，因为this构造其他构造有父类super函数，二义性。
this()和super()都指的是对象，所以，均不可以在static环境中使用。包括：static变量,static方法，static语句块。
this是一个指向本对象的指针, 然而super是一个Java关键字。

static的意义

创建独立于对象的变量或方法。属于类级别class级别，所有对象共享。
static修饰在类第一次使用时加载，只被加载一次。
static变量值在类加载时分配固定空间，但值可以被改变。

static的应用场景

某个变量/方法/代码块是被所有对象所共享的，那么这个成员变量就应该定义为静态的。
*static修饰的方法/变量只能使用static修饰的值，作用域的问题。

break ,continue ,return 的区别及作用

break 跳出当前循环
continue 跳出当前循环，进行下一次循环
return 程序直接返回的当前得结果。结束当前方法，直接返回。

java中如何跳出多层嵌套？

标识符：
for(){break 标识符;}

面向对象三大特性：

封装，继承，多态。
多态：引用变量的具体类型要等程序运行时确定。这个变量指向哪个类的对象，具体方法是哪个类的。

多态

方法重载（overload）实现的是编译时的多态性（前绑定）
方法重写（override）实现的是运行时的多态性（后绑定）

多态的实现

继承，重写，向上转型

动态绑定

动态绑定是指在执行期间（非编译期）判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。

继承

子类拥有父类非private的所有方法和属性。
子类可以重写和拓展父类的方法。
里氏替换原则。

抽象类和接口

抽象类是对对象通用特征的抽象提取。
接口时一系列行为的集合。
抽象类可以有构造器，接口不能。
接口修饰符只能时Public或者default
接口字段默认都是static和final的
抽象类不能被final修饰，否则无法被继承,接口也一样。

内部类

定义在一个类里面的类。分为四种：成员内部类，局部内部类，匿名内部类，静态内部类。
静态内部类：static class StaticInner {} 使用：new 外部类.静态内部类() 只能访问外部类的所有静态资源。
成员内部类：依赖于外部类实例，可以访问所有外部类资源。外部实例.new 内部类();
局部内部类：定义在方法内部。作用域和方法一样。
匿名内部类：没有名字的内部类。 使用：new 类/接口{}

匿名内部类有哪些特点

匿名内部类必须继承一个抽象类或者实现一个接口。
匿名内部类不能定义任何静态成员和静态方法。
???当所在的方法的形参需要被匿名内部类使用时，必须声明为 final
匿名内部类不能是抽象的，它必须要实现继承的类或者实现的接口的所有抽象方法。
匿名内部类不能是public,protected,private,static。

实参/形参

功能都是数据传送。
.形参变量只有在被调用时才分配内存单元，在调用结束时， 即刻释放所分配的内存单元。
实参必须有实际值，把这些值传送给形参。

值传递/引用传递

java用的时值传递。先把实参值复制给形参。
引用传递，实参传递的是一个地址的引用，通过形参可以改变实际的值。

局部内部类和匿名内部类访问局部变量的时候，为什么变量必须要加上final？

生命周期！方法存放在栈中，会被释放。类和对象存放在堆中。final常量存放在常量区中，在堆里面。保证了生命周期的一致性。

构造器能被继承嘛？

不能。也不能被重写。

重载根据什么区分

方法参数类型，个数，顺序。和方法返回值，修饰符无关。
重写：发生在父子类中，方法名、参数列表必须相同，返回值小于等于父类，抛出的异常小于等于父类，访问修饰符大于等于父类（里氏代换原则）；如果父类方法访问修饰符为private则子类中就不是重写。

==和equals的区别是什么？

：基本数据类型比较的是值，引用数据类型比较的是地址。
：equals比较的是两个对象是否相等。
equals没有被覆盖时，等价于通过比较两个对象。
equals被覆盖时，比较内容相等。

方法重载时，基本数据类型会向上转型，参数为Double方法涵盖了其他小范围的基本数据类型方法，因此不需要重载多个

方法参数过多，可以使用数组传递数据，效率不高

变长参数

(数据类型… nums)可以传入变长的参数

ideal中可以在右上角edit configuration的programe中配置主类返回参数，通过变长参数取出

java中的new做了什么？

是一个运算符
实例化：创建一个java对象，分配内存并返回地址

赋值对象的地址空间相同吗？如何让一个对象指向另外对象的内存空间地址？

值传递和引用传递？

java默认采用值传递，引用数据类型使用引用传递（传递内存地址）。

case:

case后不能跟多个值，但是可以写多个case:一个break;
case i: case 2: case 3: 语句; break;

面向对象6大原则

SRP, Single Responsibility Principle 单一职责原则
一个类的职责单一

LSP , Liskov Substitution Principle 里氏替换原则
依赖于继承，多态。父类出现的地方都可以用子类替换。

DIP, Dependence Inversion Principle 依赖倒置原则
面向接口编程。低层次模型依赖于高层次模型。具体依赖于抽象。

ISP,Interface Segregation Principles 接口隔离原则
类之间的依赖建立在最小的接口上。
让客户端依赖的接口尽可能的小。

LOD,Law of Demeter, 迪米特原则 or LKP,Least Knowledge Principle 最少知识原则
一个类应该对自己需要耦合或调用的类知道的最少

OCP ,Open Close Principle 开闭原则
对拓展开放，对修改封闭

String类
一旦创建无法通过方法更改，除非重新赋值，字符串不变。
String s = new String(char[]);创建一个字符串，通过字节数组。
String用Final修饰，除非重新赋值，其他操作都无法造成它最终值的改变。
public final class String implements java.io.Serializable, Comparable, CharSequence {

String中的方法：
split(String regex)：分割此字符串，从regex处分割。
tocharArray():转换成字符数组
valueOf(int):把int转换成字符串
valueOf(int,fromIndex,EndIndex):把int从-到-转换成字符串。
String concat(str):加上str字符串
+:也能实现字符串拼接功能
String.join(",",…:“i”,“am”,“the”,“man”):把后面的多个字符串参数之间加上“，”
matches:Pattern获得正则表达式。matches比较字符串是否符合。
substring(index,endindex):从下标index截取到endindex-1。

StringBuilder
不保证线程安全，不同步。
append:追加字符串
insert:插入字符串
toString:转换成字符串
deleteCharAt:删除index处的字符

compareTo和comparable?
a.compareTo(b):返回一个int数值，负数a<b.整数a>b

equals方法
object中，等同于==，比较引用数据类型的内存地址，比较基本数据类型的值。
String的equals重写了这个方法。拓展了object的equlas方法，地址相同算相同。地址不同，内容相等，也算相同。

正则表达式(regular expression)
描述了一种字符串匹配的模式（pattern），可以用来检查一个串是否含有某种子串、将匹配的子串替换或者从某个串中取出符合某个条件的子串等。

x:x字符
[abc]：每次获取一个
[a-z]:26个英文字母
[0-9]:10数字
\d:10数字
![\W：匹配包括下划线的任何单词字符，等价于 [A-Z a-z 0-9_]
\W：匹配任何非单词字符，等价于 [^A-Z a-z 0-9_]
[\w._] 相当于[0-9a-zA-Z._] ，就是比\w多匹配 ‘.’ 和 ‘_’ 两种字符。

预定义字符串：
.代表任意字符串

\:单词字符(字母，数字）

出现次数：
*:0~n次
+:1~n次
?:0或1次
{n}:n次
{m,n}:>=m次，<=n次
{m,}:>=m次
运算符：
XY:x后跟y
x|y:x或y
(x):x作为捕获组

    public static void main(String[] args) {
        String mobile="13666289182";
        String mobileCompile="1[37][\\d]{9}";

//        第一种方式
        //创建一个Pattern.compile用于编译正则表达式
        Pattern pattern = Pattern.compile(mobileCompile);
        //创建要匹配的字符串matcher
        Matcher m = pattern.matcher(mobile);
//        m.matches()执行两者之间的判断
        System.out.println(m.matches());

//        第二种方式
        String mobile2 = "15877778888";
        String mobileRequlr = "1[3578][0-9]{9}";//[abc]只出现一次，[0-9]只能是数字0-9，{9}后面重复9次
//        用目标字符串.matches(正则表达式)
        System.out.println(mobile2.matches(mobileRequlr));
    }

包装类中
Integer a == Integer b?
-128-127是包装类Integer的缓存，在这期间Integer的引用都是指向同一个缓存。
当直接给Integer a赋值时，超过缓存区的数会被重新分配新的内存空间。

Doublle包装类中没有缓存

自动拆箱/装箱
int a=10;Integer b=10; a==b?true!

包装类传参还是值传递

继承：
1.父类有无参构造器，子类默认隐式super()调用父类无参构造器
2.父类没有无参构造器。子类构造器中必须明确调用/到父类某个构造器。

调用super()父类构造方法，和this()一样，必须放在第一行。

抽象类
含抽象方法的类必须声明为抽象类。

抽象类不能被实例化

抽象类的子类修饰符只能比它大。

抽象类被继承，必须重写全部抽象方法。