前端路径 E:\sky\nginx-1.20.2

localhost:80

后端部署 1. git本地推送

常量.getBytes()是字符串转化为 字节数组的方法

1
2
3
4
5
6
7
String password = "123456";

byte[] bytes = password.getBytes();


[49, 50, 51, 52, 53, 54]

Controller控制层->service业务层->Mapper持久层->Database数据库

来补一下基础知识，参考网址

1
2
3
4
5
public class Hello{
	public static void main(String[] args){
		System.out.println("Hello world!")
	}
}

一个程序的基本单位就是class

入口方法名

1
2
3
4
5
public class Hello{
	public status void main(String[] args){
	
	}
}

类里面定义了一个方法，该方法的方法名是main，返回值是void

字符串引用

1
String s = "hello";

常量

1
final double PI = 3,14;

var

1
StringBulider sb = new StringBulider();//StringBulider:String类型的加强版

如果想忽略变量类型，用var

1
var sb = new StringBulider();

移位运算

可以对整数进行移位运算。对整数7左移1位将得到整数14，左移两位将得到整数28：

1
2
3
4
5
6
int n = 7;       // 00000000 00000000 00000000 00000111 = 7
int a = n << 1;  // 00000000 00000000 00000000 00001110 = 14
int b = n << 2;  // 00000000 00000000 00000000 00011100 = 28
int c = n << 28; // 01110000 00000000 00000000 00000000 = 1879048192
int d = n << 29; // 11100000 00000000 00000000 00000000 = -536870912

左移29位时，由于最高位变成1，因此结果变成了负数。

字符是char，字符串是String

最后用加号连接，加号外不加“”

数组

1
2
3
4
5
6
7
8
9
public class Main{
	public static void main(String[] args){
		iny[] ns new int[5];
		ns[0] = 68;
		ns[1] = 78;
		ns[3] = 99;
		...
	}
}

获取数组大小

1
System.out.println(ns.length);

oop

类

1
2
3
4
class Person{
	public String name;
	public int age;
}

实例

1
2
Person ming = new Person();

创建了一个Person类的实例，并通过变量ming指向它

Person ming 定义Person类型的变量ming

new Person()创建Person实例

访问实例变量可以用 变量.实例

1
2
ming.name = "xiaoming";
ming.age = 12;

方法：class属性设置成private后外部main函数不能直接通过访问属性的方式修改内部属性，所以在class类里面添加方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
public class Main{
	public static void main(String[] args){ 
		Person ming = new Person();
		ming.setName("xiaoming");
		ming.setAge(12);
	}
}

class Person{
	private String name;
	private int age;
	
	public String getname(){
		return this.name;
	}
	
	public void setName(String name){
		if(name == null || name.isBlank()){
			throw new IllegalArgumentException("invailid name")
		}
		this.name = name;
		
	}
	
	public int getAge(){
		return this.age;
	}
	
	public void setAge(int age){
		if(age < 0 || age > 100){
			throw new IllegalArgumentException("invalid age value");
		}
		this.age = age;
	}
	
}

因为json提交过来的数据所以加@RequestBody注解

mapper,service,controller

1
2
3
4
修饰符 返回类型 方法名(传参){
	语句
	return;
}

方法可以封装一个类的对外接口

不知道传参数量时用类型...定义

1
2
3
4
5
6
7
class Group{
	private String[] names;
	
	public void setNames(String... names){
	this.names = names;
	}
}

数组

1
2
String[] fullname = new String[]{"111","222"
}

构造方法

类里面创造一个和类名一样的方法名，new的时候可以同时创建对象和调用方法

如果既要想使用带参数的构造方法，又想保留不带参数的构造方法，那就创建两个对象

可以构造多个构造方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Person{
	private String name;
	private int age;
	
	public Person(String name , int age){
		this.name = name;
		this.age = age;
		
	}
	
	public Person(String name){
		this.name = name;
		this.age = 12;
	}
	
	public Person(){
	}
}

一个构造方法可以调用其他构造方法，用this()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Person{
	prirvate String name;
	private intv age;
	
	public Person(String name ,int age){
		this.name = name;
		this.age = age;
	}
	public Person(String name){
		this(name,18);//调用第一个方法
	}
	public Person(){
		this("Unnamed");//???
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public class Main {
    public static void main(String[] args) {
        // TODO: 给Person增加构造方法:
        Person ming = new Person("小明", 12);
        System.out.println(ming.getName());
        System.out.println(ming.getAge());
    }
}

class Person {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
    
    public Person(String name,int age){
    	this.name=name;
    	this.age=age;
    }
}

方法重载

功能类似但是参数不同：同名方法

调用同名方法就叫方法重载

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public class Main {
    public static void main(String[] args) {
        Person ming = new Person();
        Person hong = new Person();
        ming.setName("Xiao Ming");
        // TODO: 给Person增加重载方法setName(String, String):
        hong.setName("Xiao", "Hong");
        System.out.println(ming.getName());
        System.out.println(hong.getName());
    }
}

class Person {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    public void setName(String name1,String name2){
    	this.name = name1+name2;
    }
}

继承

可以复用，关键字extend

1
2
3
class Student extends Person{
	private int score;
}

要想成功继承，父类属性得是protect,不能是private

1
2
3
4
5
6
7
8
9
10
11
class Person{
	protect String name;
	protect int age;
}

class Student extends Person{
	public String hello(){
		return "Hello," + name;//或super.name,this.name
	}
	
}

任何class的构造方法，第一行语句必须是调用父类的构造方法。如果没有明确地调用父类的构造方法，编译器会帮我们自动加一句super();

1
2
3
4
5
6
7
8
class Student extends Person{
	protected int score;
	
	public Student(String name,int age,int score){
		super(name,age);
		this.score = score;
	}
}

阻止继承

父类挂sealed和permits,子类挂final有更好的封装性

1
2
public sealed class Shape permits Rect,Circle{}
public final class Rect extends Shape{}

向上转型

1
2
Person p = new Student();
//引用preson类的变量指向student对象

向下转型

1
2
3
4
5
6
7
8
public class Main{
	public static void main(String[] args){
		Object obj = "Hello";
		if(obj instanceof String s){
			System.out.println(s.toUpperCase());//toUpperCase()转成大写
		}
	}
}

组合

1
2
3
4
class Student extends Person{
	protected Book book;
	Protected int score;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
public class Main {
    public static void main(String[] args) {
        Person p = new Person("小明", 12);
        Student s = new Student("小红", 20, 99);
        // TODO: 定义PrimaryStudent，从Student继承，新增grade字段:
        Student ps = new PrimaryStudent("小军", 9, 100, 5);
        System.out.println(ps.getScore());
    }
}

class Person {
    protected String name;
    protected int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() { return name; }
    public void setName(String name) { this.name = name; }

    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }
}

class Student extends Person {
    protected int score;

    public Student(String name, int age, int score) {
        super(name, age);
        this.score = score;
    }

    public int getScore() { return score; }
}

class PrimaryStudent extends Student{
    protected int gread;
    public PrimaryStudent(String name, int age, int score,int gread){
    	super(name,age,score);
    	this.gread = gread;
    }
}

多态

Override要保证参数和返回值相同

加上@Override可以让编译器帮助检查是否进行了正确的覆写。希望进行覆写，但是不小心写错了方法签名，编译器会报错。

@Override不是必需的。

1
2
3
编译看左边
运行看右边

1
2
3
4
5
6
7
public double totalTax(Income... incomes){//变量名是incomes，对象是income
	double total = 0;
	for(Income income: income){//遍历incomes数组里的每一个对象
		total = total + income.getTax();
	}
	return total;
}

覆写Object方法

因为所有的class最终都继承自Object，而Object定义了几个重要的方法：

  • toString()：把instance输出为String；
  • equals()：判断两个instance是否逻辑相等；
  • hashCode()：计算一个instance的哈希值。

抽象类

1
2
3
class Person{
	public abstract void run();
}

抽象方法无法执行，不用写{}（执行语句）

抽象类无法被实例化，无法执行抽象方法

抽象相当于规范

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class Main{
	public static void main(String[] args){
		Person p = new Student();
		p.run();
	}
}

abstract class Person{
	public adstract void run();
}

class Student extends Person{
	@overeide
	public void run(){
		System.out.println("Student run");
	}
}

接口

声明

1
2
3
4
interface Person{
	void run();
	String getname();
}

所谓interface，就是比抽象类还要抽象的纯抽象接口，因为它连字段都不能有。因为接口定义的所有方法默认都是public abstract的，所以这两个修饰符不需要写出来（写不写效果都一样）。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Student implements Person{
	private String name;
	
	public Student(String name){
		this.name= name;
	}
}

@Override
public void run(){
	System.out.println(this.name + " run");
}

@Override
public String getName(){
	return this.name;
}

接口继承

1
2
3
4
5
6
7
8
interface Hello{
	void hello();
}

interface Person extends Hello{
	void run();
	String getName();
}

静态字段和静态方法

静态字段并不属于实例

静态字段修改的是类的属性

包

不用public、protected、private修饰的字段和方法就是包作用域

1
2
3
4
5
6
7
package hello;

public class Person{
	void hello(){
		System.out.println("Hello!");
	}
}
1
2
3
4
5
6
7
8
9
package test;

import java.text.Foemat;

public class Main{
	public static void main(String[] args){
		Format format = null;
	}
}

作用域

在方法内部定义的变量称为局部变量

内部类

1
Outer.Inner inner = outer.new Inner();

匿名类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
// Anonymous Class
public class Main {
    public static void main(String[] args) {
        Outer outer = new Outer("Nested");
        outer.asyncHello();
    }
}

class Outer {
    private String name;

    Outer(String name) {
        this.name = name;
    }

    void asyncHello() {
        Runnable r = new Runnable() {
        //创建一个匿名类，实现Runnable接口
            @Override
            public void run() {
                System.out.println("Hello, " + Outer.this.name);//this指runnable对象
            }
        };
        new Thread(r).start();//创建并启动线程
    }
}

静态内部类

classpath和jar

模块

声明依赖关系

在src目录下

java核心类

字符串和编码

StringBuilder

1
delete(start, end)

toString:把StringBulider转成String对象

如有错误，多多指教

valine