JAVA
基础
快捷键
- psvm 快速创建main 方法
- sout 快速print输入
- array.for for循环
- array.fori for循环
- alt + insert 导入get/set方法
注释
- 单行注释 //xxx
- 多行注释 /xxx/
- 文档注释 /* xxx */
数据类型
-
整数类型 byte short int long
1.byte b;//指定变量b为byte型 (最小值-128 最大值127) 一个常量，保存 byte 类型可取的最大值，即 2^7-1。(127) 一个常量，保存 byte 类型可取的最小值，即 -2^7。(-128) 2.short s;//指定变量s为short型 保存 short 可取的最大值的常量，最大值为 215-1。（32 767） 保存 short 可取的最小值的常量，最小值为 -215。（-32 768） 只要知道short是32位就可以参考上byte的求法 3.int i;//指定变量i为int型 值为 231－1 的常量，它表示 int 类型能够表示的最大值。 值为 －231 的常量，它表示 int 类型能够表示的最小值。 只要知道int是32位就可以参考上byte的求法 4.long l;//指定变量l为long型 保持 long 类型的最大值的常量，该值为 263-1。 保持 long 类型的最小值的常量，该值为 -263。 只要知道int是64位就可以参考上byte的求法 -
浮点类型 float double
-
字符类型 char
-
布尔类型 boolean
基本类型和包装类型的区别
java的每个基本类型都对应了一个包装类型；比如int的包装类型为Integer,double的包装类型为Double
1.包装类型可以为null,而基本类型不可以
2.包装类型可用于泛型，而基本类型不可以
List<int> list = new ArrayList<>(); // 提示 Syntaxerror, insert "Dimensions" to complete ReferenceType
List<Integer> list = new ArrayList<>();
3.基本类型比包装类型更高效
基本类型在栈中直接存储的具体数值，而包装类型则存储的是堆中的引用
4.两个包装类型的值可以相同，但却不相等
Integer chenmo = new Integer(10);
Integer wanger = new Integer(10);
System.out.println(chenmo == wanger); // false
System.out.println(chenmo.equals(wanger )); // true
自动装箱和自动拆箱
既然有了基本类型和包装类型，肯定有些时候要在它们之间进行转换。把基本类型转换成包装类型的过程叫做装箱（boxing）。反之，把包装类型转换成基本类型的过程叫做拆箱（unboxing）
Java SE5 之前：
Integer chenmo = new Integer(10); // 手动装箱
int wanger = chenmo.intValue(); // 手动拆箱
之后
Integer chenmo = 10; // 自动装箱
int wanger = chenmo; // 自动拆箱
Integer类的缓存机制
public static Integer valueOf(int i) {
assert IntegerCache.high >= 127;
//当前值在缓存数组区间段，则直接返回该缓存值
if (i >= IntegerCache.low && i <= IntegerCache.high)
return IntegerCache.cache[i + (-IntegerCache.low)];
//否则创建新的Integer实例
return new Integer(i);
}
private static class IntegerCache {
static final int low = -128;
static final int high;
static final Integer cache[];
//IntegerCache初始化时，缓存数值为-128-127的Integer实例(默认是从-128到127)。
static {
// high value may be configured by property
int h = 127;
String integerCacheHighPropValue =
sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
if (integerCacheHighPropValue != null) {
int i = parseInt(integerCacheHighPropValue);
i = Math.max(i, 127);
// Maximum array size is Integer.MAX_VALUE
h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
}
high = h;
cache = new Integer[(high - low) + 1];
int j = low;
//填充缓存数组
for(int k = 0; k < cache.length; k++)
cache[k] = new Integer(j++);
}
private IntegerCache() {}
}
Integer的源码，就会发现里面有个静态内部类
该类的作用是将数值等于-128-127(默认)区间的Integer实例缓存到cache数组中。通过valueOf()方法很明显发现，当再次创建值在-128-127区间的Integer实例时，会复用缓存中的实例，也就是直接指向缓存中的Integer实例。注意，这里的创建不包括用new创建，new创建对象不会复用缓存实例
Integer的默认缓存范围为-128到127，可以通过jvm参数改变这个范围。
缓存上界high可以通过jvm参数-XX:AutoBoxCacheMax=size指定，取指定值与127的最大值并且不超过Integer表示范围，
下界不能指定，只能为-128。
类型转换
优先级从低到高 byte, short, char, int, long, float, double
自增自减
int a =3;
int b = a++; 执行完这行代码后，先给b赋值，再自增
int c = ++a; 执行完这行代码前，先自增，再给c赋值
输出结果为：
5
3
5
Scanner对象（类似于python input)
Scanner scanner = new Scanner(System.in);
System.out.println("使用next方法接受：");
if (scanner.hasNext()){
//String str1 = scanner.next();
String str = scanner.nextLine();
//System.out.println("输出的内容为："+str1);
System.out.println("输出的内容为："+str);
}
scanner.close();
switch多选择结构
swith case 语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支switch 语句中的变量类型可以是： byte short int char switch 支持字符串String类型 case标签必须为字符串常量或字面量
public class Switch1 {
public static void main(String[] args) {
char grade = 'F';
switch (grade){
case 'A':
System.out.println("好");
break;
case 'B':
System.out.println("良");
break;
case 'C':
System.out.println("差");
break;
default:
System.out.println("未知");
}
}
}
java修饰符
java分为主要两类修饰符
1. 访问修饰符
default 默认访问修饰符（即默认，什么也不写）：在同一包内可见，不使用任何修饰符。使用对象：类,接 口，变量，方法
private 私有访问修饰符:在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）
public 公有访问修饰符:对所有类可见。使用对象：类、接口、变量、方法
protected 受保护的访问修饰符: 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。
2. 非访问修饰符
static 修饰符，用来修饰类方法和类变量。
静态变量：static 关键字用来声明独立于对象的静态变量，无论一个类实例化多少对象，它的静态变量只有一份拷贝。 静态变量也被称为类变量。局部变量不能被声明为 static 变量。
静态方法：static 关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。静态方法从参数列表得到数据，然后计算这些数据。
final 修饰符
final 变量 表示"最后的、最终的"含义，变量一旦赋值后，不能被重新赋值。被 final 修饰的实例变量必须显式指定初始值。 final 修饰符通常和 static 修饰符一起使用来创建类常量。
final 方法 父类中的 final 方法可以被子类继承，但是不能被子类重写.声明 final 方法的主要目的是防止该方法的内容被修改
final 类 final 类不能被继承，没有类能够继承 final 类的任何特性。
java数组常用方法
-
获取数组元素 ： Arrays.toString(array)
System.out.println(Arrays.deepToString(test)); 打印多维数组 System.out.println(Arrays.toString(test)); 打印一维数组 不常用的打印： StreamArrays.asList(test).stream().forEach(s -> System.out.println(s)); Stream.of(test).forEach(System.out::println);// Arrays.stream(test).forEach(System.out::println); -
数组排序 ： Arrays.sort(array)
-
比较两个数组的元素是否相等： Arrays.equals(arr1,arr2)
-
截取数组(切片)： Array.copyOfRange(array,startindex,endindex)
面向对象
封装
private 私有属性和变量，可通过get/set方法获取或者定义这个私有变量以供其他对象使用
继承
extends关键词
语法：public class 子类 extends 父类(){}
private修饰符 无法被继承final 定义的类 无法被继承super
注意点： 1. super调用父类的构造方法，必须在构造方法的第一行，
2. super必须只能出现在子类的方法或者构造方法中
3. super和this 不能同时调用构造方法
super 和 this 的不同：
1.代表对象不同 this 代表调用者本身 super 代表父类对象
2.前置条件 this 没有继承也能使用 super 只有继承才能使用
3.构造方法 this() 本类的构造 super() 父类的构造
方法重写
需要有继承关系，子类从父类的方法 @override
1 方法名必须相同
2 参数列表必须相同
3 修饰符，范围可以扩大但不能缩小 public>protected>default>private4 抛出的异常，范围可以缩小但不能扩大
多态
1.多态是方法的多态，属性没有多态
2.父类和子类有联系或是继承关系，不然会报类型转换异常
3.存在条件，继承关系，方法需要重写，父类引用指向子类对象 : Father f1 = new Son()
接口
关键词 interface 定义一个接口 接口中定义的方法都是抽象的 public obstract 接口中定义的常量是静态的 public statci final关键词 implements 实现接口，同时必须重写接口中的方法利用接口可多继承
Spring-Boot
常用注解
1.@SpringBootApplication
1. @SpringBootApplication
这个注解是 Spring Boot 项目的基石，创建 SpringBoot 项目之后会默认在主类加上,可以把 @SpringBootApplication看作是 @Configuration、@EnableAutoConfiguration、@ComponentScan 注解的集合
2. @EnableAutoConfiguration：启用 SpringBoot 的自动配置机制
3. @ComponentScan：扫描被@Component (@Service,@Controller)注解的 bean，注解默认会扫描该类所在的包下所有的类
4. @Configuration：允许在 Spring 上下文中注册额外的 bean 或导入其他配置类5
2.Spring Bean 相关
1. @Autowired : 自动导入对象到类中，被注入进的类同样要被 Spring 容器管理比如：Service 类注入到 Controller 类中
2. @Component ：通用的注解，可标注任意类为 Spring 组件。如果一个 Bean 不知道属于哪个层，可以使用@Component 注解标注。
3. @Repository : 对应持久层即 Dao 层，主要用于数据库相关操作。
4. @Service : 对应服务层，主要涉及一些复杂的逻辑，需要用到 Dao 层。
5. @Controller : 对应 Spring MVC 控制层，主要用户接受用户请求并调用 Service 层返回数据给前端页面。
6. @RestController : @RestController注解是@Controller和@ResponseBody的合集,表示这是个控制器 bean,并且是将函数的返回值直 接填入 HTTP 响应体中,是 REST 风格的控制器
7. @Scope : 声明 Spring Bean 的作用域
@Bean
@Scope("singleton")
public Person personSingleton() {
return new Person();
}
四种常见的 Spring Bean 的作用域：
singleton : 唯一 bean 实例，Spring 中的 bean 默认都是单例的。
prototype : 每次请求都会创建一个新的 bean 实例。
request : 每一次 HTTP 请求都会产生一个新的 bean，该 bean 仅在当前 HTTP request 内有效。
session : 每一次 HTTP 请求都会产生一个新的 bean，该 bean 仅在当前 HTTP session 内有效。
8. @Component : 一般用来声明配置类，可以使用 @Component注解替代，不过使用Configuration注解声明配置类更加 语义化
3.请求相关
1.GET: @GetMapping("users") 等价于@RequestMapping(value="/users",method=RequestMethod.GET)
2.POST: @PostMapping("users") 等价于@RequestMapping(value="/users",method=RequestMethod.POST)
3.PUT: @PutMapping("/users/{userId}") 等价于@RequestMapping(value="/users/{userId}",method=RequestMethod.PUT)
4.DELETE: @DeleteMapping("/users/{userId}")等价于@RequestMapping(value="/users/{userId}",method=RequestMethod.DELETE)
5.PATCH: @PutMapping("/users/{userId}")等价于@RequestMapping(value="/users/{userId}",method=RequestMethod.Put)
4.前后端传值
1.@PathVariable : 用于获取路径参数
2.@RequestParam : 用于获取查询参数
3.@RequestBody : 用于读取 Request 请求（可能是 POST,PUT,DELETE,GET 请求）的 body 部分并且Content-Type 为 application/json 格式的数据，接收到数据之后会自动将数据绑定到 Java 对象上去。系统会使用HttpMessageConverter或者自定义的HttpMessageConverter将请求的 body 中的 json 字符串转换为 java 对象
5.读取配置信息
我们的数据源application.yml内容如下：
JAVA！
my-profile:
name: XXX
email: XXX
library:
location: XXX
books:
- name: XXX
description: XXX
1. @value: 使用 @Value("${property}") 读取比较简单的配置信息：
@Value("${XXX}")
String XXX;
2. @ConfigurationProperties: 通过@ConfigurationProperties读取配置信息并与 bean 绑定
@Component
@ConfigurationProperties(prefix = "library")
class LibraryProperties {
@NotEmpty
private String location;
private List<Book> books;
@Setter
@Getter
@ToString
static class Book {
String name;
String description;
}
省略getter/setter ......
}
3. @PropertySource（不常用）: @PropertySource读取指定 properties 文件
@Component
@PropertySource("classpath:website.properties")
class WebSite {
@Value("${url}")
private String url;
省略getter/setter
......
}
6.参数校验
@NotEmpty 被注释的字符串的不能为 null 也不能为空
@NotBlank 被注释的字符串非 null，并且必须包含一个非空白字符
@Null 被注释的元素必须为 null
@NotNull 被注释的元素必须不为 null
@AssertTrue 被注释的元素必须为 true
@AssertFalse 被注释的元素必须为 false
@Pattern(regex=,flag=)被注释的元素必须符合指定的正则表达式@Email 被注释的元素必须是 Email 格式。@Min(value)被注释的元素必须是一个数字，其值必须大于等于指定的最小值
@Max(value)被注释的元素必须是一个数字，其值必须小于等于指定的最大值
@DecimalMin(value)被注释的元素必须是一个数字，其值必须大于等于指定的最小值
@DecimalMax(value) 被注释的元素必须是一个数字，其值必须小于等于指定的最大值
@Size(max=, min=)被注释的元素的大小必须在指定的范围内
@Digits (integer, fraction)被注释的元素必须是一个数字，其值必须在可接受的范围内
@Past被注释的元素必须是一个过去的日期
@Future 被注释的元素必须是一个将来的日期
7.全局处理Controller层异常
1.@ControllerAdvice :注解定义全局异常处理类
2.@ExceptionHandler :注解声明异常处理方法
8.JPA相关
1.@Entity声明一个类对应一个数据库实体。
2.@Table 设置表名
3.@Id ：声明一个字段为主键。 使用@Id声明之后，我们还需要定义主键的生成策略。我们可以使用 @GeneratedValue 指定主键生成策略。
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
4.@Column 声明字段。
5.@Transient ：声明不需要与数据库映射的字段，在保存的时候不需要保存进数据库
6.@Lob:声明某个字段为大字段。
7.@Enumerated:声明枚举类型的字段
8.@Modifying 注解提示 JPA 该操作是修改操作,注意还要配合@Transactional注解使用
@Repository
public interface UserRepository extends JpaRepository<User, Integer> {
@Modifying
@Transactional(rollbackFor = Exception.class)
void deleteByUserName(String userName);
}
9.关联关系： @OneToOne 声明一对一关系
@OneToMany 声明一对多关系
@ManyToOne声明多对一关系
@ManyToMany声明多对多关系
10. @Transactional ：在要开启事务的方法上使用@Transactional注解即可
作用于类：当把@Transactional 注解放在类上时，表示所有该类的public 方法都配置相同的事务属性信息
作用于方法：当类配置了@Transactional，方法也配置了@Transactional，方法的事务会覆盖类的事务配置信息。
9.json数据处理
1.@JsonIgnoreProperties 作用在类上用于过滤掉特定字段不返回或者不解析。
2.@JsonIgnore一般用于类的属性上，作用和上面的@JsonIgnoreProperties 一样。
3.@JsonFormat一般用来格式化 json 数据。
4.@JsonUnwrapped 扁平化对象
10.测试相关
1.@ActiveProfiles一般作用于测试类上， 用于声明生效的 Spring 配置文件
2.@Test声明一个方法为测试方法
3.@Transactional被声明的测试方法的数据会回滚，避免污染测试数据
4.@WithMockUser Spring Security 提供的，用来模拟一个真实用户，并且可以赋予权限
扫一扫
160
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
