2023年之我拿起“java“

持续更新中…………

java

java基础

java是一门面向对象的语言

$了解java的语法，从HelloWorld开始$

//此处写类体
public class Test {
    //此处是主函数
    public static void main(String[] args) {
        //输出语句
        System.out.println("HelloWorld");
    }
}

$java语言的注释$

单行注释 //

//这是单行注释

多行注释 /* */

注意：多行注释本可以嵌套使用

/*
这是多行注释
*/

$一个类中的publicclass和class的区别$

  1. 一个 java 源文件中可以定义多个 class。
  2. 一个 java 源文件中 public 的 class 不是必须的。
  3.一个 class 会定义生成一个class字节码文件。
  4.一个 java 源文件中定义公开的类的话，只能有一个，并且该类名必须和 java 源文件名称一致。
  5.每一个 class 当中都可以设定程序的入口。

$java中的标识符$

什么是标识符

  1.在 Java 源文件中凡是程序员有权利自己命名的单词都是标识符。

标识符可以标识什么元素

  1.类名
  2.方法名
  3.变量名
  4.接口名
  5.常量名

这些名称我们在下面的知识中会介绍到的。

标识符的命名规则

  1.一个合法的标识符只能由 数字、下划线、字母、美元符号组成，无其他符号。
  2.不能数字开头。
  3.严格区分大小写.
  4.关键字不能做标识符.
5.理论上不能太长，但是 java 无长度限制。

标识符的命名规范

  1.最好见名知意。
  2.遵守驼峰命名方式。
    例如：UserService;SystemService;
  3.类名、接口名：首字母大写，后面每个单词首字母大写。
  4.变量名、方法名：首字母小写，后面每个单词首字母大写。
  5.变量名：全部大写。

$java中的关键字$

  关键字在 java 语言中全部小写。
    例如：int, double.

$java中的字面值$

  字面值就是数据。
    例如：10.00；“abc”；‘a’;

$java中的变量$

什么是变量

  1.变量本质上来说是内存中的一块空间，这快空间有数据类型、有名字、有面值。
  2.变量包含三部分：数据类型、名称、字面值【数据】。
  3.变量是内存中存储数据的结构的最基本单元。

数据类型的作用

  1.不同的数据类型有不同的类型，不同的数据类型底层分配不同的大小空间。
  2.数据类型是指导程序运行阶段应该分配多大的内存空间。

变量的要求

  1.数据与数据类型一致。

声明格式

  1.数据类型 变量名；
    例如：int a = 10;

什么是作用域

  1.变量出了大括号就消失了

变量的分类

  1.局部变量：在方法体中声明的变量叫局部变量。
  2.成员变量：在方法体外【类体之内】声明的变量叫成员变量。
  3.java遵循就近原则。
类体中不能直接编写 Java 语句【除声明变量之外】。

$数据类型$

数据类型的主要作用

  1.数据类型的主要作用是指导JVM(java 虚拟机)在运行程序的时候给该数据分配多大的空间。

基本数据类型

  1.基本数据类型包括四大类八大种。

整数型

$byte(1),short(2),int(4),long(8)$

浮点型

$float(4),double(8)$

布尔型

$boolean(1)$ 只有true,false两种值。

字符型

$char(2)$ 取值范围 0 - 65535

引用数据类型

  1.类。
  2.接口。
  3.数组。
  等等……

基本数据类型之间的相互转换

  1.八种数据类型除了 布尔值 之外，剩下的7种数据类型之间都可以相互转换。
  2.小容量向大容量转化，称为自动类型转换，容量从小到大的排序。

$byte<short(char)<int<long<float<double$

任何浮点型不管占用多少个字节，都比整数型容量大。
char 和 short 可表示的种类相同，但是char 可以取更加大的整数。
  3.大容量转化为小容量，叫做强制类型转换，需要加强制类型转换符，程序才能通过编译，但在运行阶段可能损失精度，所以谨慎使用。
  4.当整数字面值没有超出 byte,short,char的取值范围，可以直接赋值给 byte,short,char 类型的变量。
  5.byte,short,char混合运算的时候，先各自转化成 int 类型在做运算。
  6.多种数据类型混合运算，先转换成容量最大的那种类型在做运算。
  7.关系运算符的结果一定是布尔类型：true\flase。
  8.byte和short 不能直接转换成char类型。

$消化一下知识在接着往下看吧！！！$

$键盘录入$

关键字 Scanner

需要使用关键字了，不同数据类型的录入，代码也会有些许差异。

//导包
import java.util.Scanner;

//此处写类体
public class Test {
    //此处是主函数
    public static void main(String[] args) {
        // 创建对象 需要使用关键字 Scanner 
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入数据");
        //这里我们录入 int 类型的数据
        int result =sc.nextInt();
        //打印我们录入的数据
        System.out.println("你录入的数据式："+result);
        //这里的 "+" 用于字符串的拼接
    }
}

分析以上代码：键盘录入的步骤
  1.导包

import java.util.Scanner;

  2.创建对象

 Scanner sc = new Scanner(System.in);

  3.接受数据

int result =sc.nextInt();

接受不同的数据，只需要修改步骤三 接受数据这一步

//接受byte类型的数据
 byte num = sc.nextByte();
 //接受short类型的数据
short num1 = sc.nextShort();
 //接受int类型的数据
int num2 = sc.nextInt();
//接受long类型的数据
long num3 = sc.nextLong();
//接受float类型的数据
float num4 = sc.nextFloat();
//接受double类型的数据
double num5 = sc.nextDouble();
//接受String类型的数据
String num6 = sc.next();

$生成随机数$

需要使用关键字，生成不同的数据类型的数据，代码也会有所差异

//导包
import java.util.Random;
//此处写类体
public class Test {
    //此处是主函数
    public static void main(String[] args) {
        //创建对象需要使用Random关键字
        Random random = new Random();
        //创建整数类型随机数
        int result = random.nextInt();
        
    }
}

分析以上代码：键盘录入的步骤
  1.导包

import java.util.Random;

  2.创建对象

Random random = new Random();

  3.接受数据

int result = random.nextInt();

创建不同的数据，只需要修改步骤三 接受数据这一步

具体方法参考上面Scanner的方法。

随机数扩展

生成区间的随机数：【最小值，最大值】

//导包
import java.util.Random;

//此处写类体
public class Test {
    //此处是主函数
    public static void main(String[] args) {
        //创建对象需要使用Random关键字
        Random random = new Random();
        //创建0 -10 的整数类型  [0,11)
        int result = random.nextInt(11);
    }
}

$循环$

for 循环

带索引的for循环

int n = 10;
for(int i = 0; i < n; i++){
	System.out.println(i);
}

快速结束嵌套循环

//外层循环起名 out
out:
for (int i = 0; i < 10; i++) {
    //内存循环起名 in
    in:
    for (int j = 0; j < 10; j++) {
        //当j等于5时，结束外层循环
        if(j==5){
            break out;
        }
    }
}

增强for循环

//ArrayList集合 这里不需要了解，我们重点看for循环
ArrayList<String> list  = new ArrayList<>()
for(String s : list){
    System.out.println(s);
}

while循环

//括号里面放boolean类型的值
while(true){
	System.out.println("这里是while循环");
}

do while循环

特点：循环至少循环一次

do{
	System.out.println("这里是do while循环");
}while(true)
//括号里面放boolean类型的值 

$java的Math包$

  1.导入包

import static java.lang.Math.*;

  2.列举几个常用方法

~求绝对值

int num = 10;
int result = Math.abs(num);

~求开方

double = 3.0;
double result = Math.sqrt(num);

等等等，还有很多方法，这里我们不一一列举。

$一维数组$

定义

  数组是一个容器用来储存相同数据类型数据的容器。

格式

数据类型[] 数组名；
int[] arr;

数组初始化

数组动态初始化

格式

数据类型[] 数组名 = new 数据类型[长度];
int[] arr = new int[3];

动态数组初始化取值

数组数据类型 变量名 = 数组名[索引];
int a = arr[0];

索引就是数组中每个初始化空间的编号。

静态数组初始化取值

数据类型[] 数组名 = new 数据类型[]{……};
int [] arr = new int[]{1,2,3,4,5,6,7,8,9};

数据类型[] 数组名 = {……};
int[] arr = {1,2,3,4,5,6,7,8,9};

数组求长度

数组名.length;
int len = arr.length;

数组遍历

int[] arr = new int[10];
for (int i = 0; i < arr.length; i++) {
	   int result1 = arr[i];
	   System.out.println("这是遍历数组");
}

查看数组

System.out.println(Arrays.toString(arr));

$二维数组$

二维数组动态初始化

数据类型 [][] 变量名 = new 数据类型 [m][n];

二维数组遍历

int[][] arr1 = new int[3][4]; //3行4列的二维数组
for (int i = 0; i < arr1.length; i++) {
    for (int j = 0; j < arr1[i].length; j++) {
        System.out.println("这是二维数组的遍历");
    }
}

数组中不同数据类型的默认值

  1.整数数据类型
byte,short,int,long默认值为0。

  2.浮点数据类型
float,double 默认值0.0

  3.char数据类型
char 默认值 \u0000。

  4.boolean数据类型
boolean默认值false。

  5.引用数据类型
String 默认值时null。

升序排序的数组函数

Arrays.sort(arr);

$冒泡排序$

int[] arr = {4,2,5,1,3};
//排序只需要排序 总长度减1次
for (int i = 0; i < arr.length-1; i++) {
    //每次排序都会确定一个数据的位置
    for (int j = 0; j < arr.length-1-i; j++) {
        if(arr[j]>arr[j+1]){
            //创建一个中间遍历 tmp进行交换两个数据
            int tmp=arr[j];
            arr[j]=arr[j+1];
            arr[j+1]=tmp;
        }
    }
}

$初识方法$

概述

  1.方法就是解决问题的方法。

  2.编程中的方法，具有特定功能的代码快。

特点

  1.方法和方法之间时平行关系，不能嵌套定义。

  2.方法定义后不会自己执行，需要调用后才能执行。

  3.方法定义的先后顺序和方法执行的顺序无关，和方法调用的顺序有关，谁先调用，谁先执行。

这里我们浅做了解，具体在后面的学习中理解强化。

$初识类和对象$

面向对象和面向过程的思想对比

  1.面向过程：是一种以过程为中心的编程思想，实现功能的每一步，都是自己实现的。

  2.面向对象：是一种以对象为中心的编程思想，通过指挥对象实现具体的功能。

对象：指的是客观存在的食物，万物皆对象。

什么是类

  1.类是对现实生活中一类具有共同属性的行为的事物的抽象。

  2.类是事物，也就是对象的一种描述，可以将类理解为一张设计图，根据设计图，可以创造除具体存在的事物。

类的组成

  1.属性：该事物的各种特征。
在类中通过成员变量来体现。（类中方法外的变量）。

  2.行为：该事物存在的功能（能够做的事情）。
在类中通过成员方法来体现（和前面的方法想比较去掉static关键字就可以）。

类和对象的关系

  1.类：类是对现实生活中一类具有共同属性和行为的事物的抽象。

  2.对象：是能够看得到摸得到的真实存在的实体。

类是对象的描述。
对象是类的实体。

类的定义

public class 类名{
	成员变量
    成员方法
}

public class Student{
	//成员变量
	String name;
	int age;
    //成员方法 行为
    public void study(){
		 System.out.println("这是成员方法");
	}
}

创建对象

类名 对象名 = new 类名();

Student stu = new Student();

使用方法

对象名.变量名
stu.name;

//此处写类体
public class Test {
    //此处是主函数
    public static void main(String[] args) {
        Student stu = new Student();
        stu.age = 18;
        stu.name = "张三";
        stu.study();
    }
}

$消化一下知识在接着往下看吧！！！$

$构造方法$

  作用：用来创建对象和new 一起。

格式：

无参构造：

public 类名(){
}

public Price(){
	System.out.println("无参构造方法被调用");
}

有参构造：

public 类名(参数列表){
	……
	……
	……
}

public Price(String brand){
	this.brand = brand;
	System.out.println("有参构造方法被调用 brand");
}

特点

  1.如果本类中没有构造方法，JVM会默认提供一个无参的构造方法。

  2.构造方法可以重载。

  3.构造方法没有返回值，不能使用void。

  4.构造方法没有return关键字，可以写，但是没必要。

标准类的编写

  1.成员变量私有化，得到getXxx 和 setXxx方法。

  2.提供空参满参的构造方法。

$成员变量和局部变量的区别$

代码中的位置

  1.成员变量：类中方法外。

  2.局部变量：在方法的声明上，或者方法内部。

在内存中的位置

  1.成员变量：在堆中。

  2.局部变量：在栈中。

生命周期不一样

  1.成员变量：随着对象的创建而存在，随着对象的消失而消失。

  2.局部变量：随着方法的调用而存在，随着方法的弹栈而消失。

初始化值

  1.成员变量：有默认值。
默认值在上面的知识点中提到过。

  2.局部变量：没有默认值。

$初始引用类型String$

next和nextLine

next()

==next()==只能录入连续的字符串，这里的连续值没有空格的字符串。
换而言之：当遇到空格或者回车就会结束键盘录入

//创建Scanner对象
Scanner sc = new Scanner(System.in);
//键盘录入
String s = sc.next();
//比如我们想录入 welcome to CSDN

//但是实际的s为 welcome

nextLine()

nextLIne() 当遇到回车的时候才会结束键盘录入，遇到空格不会结束键盘录入。

//创建Scanner对象
Scanner sc = new Scanner(System.in);
//键盘录入
String s = sc.nextLine();
//比如我们想录入 welcome to CSDN

//但是实际的s为 welcome to CSDN

new String();

传输byte类型的数组

byte[] arr = {65,66,67,68,69};
String s = new String(arr);
System.out.println(s);
//打印结果ABCDE

分析一下代码，为什么传输进去的整数类型，但是打印的ABCDE呢？

其实是将整数类型转化为ASCLL值打印输出。

传输byte类型的数组，索引，长度

byte[] arr = {65,66,67,68,69};
String s1 = new String(arr,    1,   3);
//                     数组  索引  长度
//打印结果 BCD

代码含义，将数组arr从 1 索引开始，向后数 3 个长度，交给字符串S1。

传输 char类型的数组

char[] chars = {'a','b','c','d','e','f'};
String s = new String(chars);
System.out.println(s);
// 打印结果 abcdef

将字符数组转化成字符串。

传输 char类型的数组，索引，长度

char[] chars = {'a','b','c','d','e','f'};
String s = new String(chars,    1,   3);
//                    数组  索引  长度
System.out.println(s);
//打印结果bcd

String类型对应同一字符串，是否相等

String name1 = "张三";
String name2 = "张三";
//true

值创建后不能更改，是对象的话，一般放在堆内存中，这就意味者地址值是相等的，比较的是同一快内存地址，所以相等。

String name1 = new String("张三");
String name2 = new String("张三");
//false

在这里“张三”的地址值是一样的，但是这里new 的对象，但是“张三”重复了，为了节省内存，new的对象指向了“张三”。但是这里比较的是new的地址，地址内存不一样。

创建空的字符串

String s = "";

String s1 = new string();

//s和s1都是空的字符串。

$字节码$

关键：getBytes();

String name = "张三";
 byte[] arr = name.getBytes();
 System.out.println(Arrays.toString(arr));
 //打印的字节码[-27, -68, -96, -28, -72, -119]

可以使用字节码反推字符串

byte[] arr1 = {-27, -68, -96, -28, -72, -119};
//这里我们运用上面介绍的知识
String name1 = new String(arr1);
System.out.println(name1);
//打印的结果为 张三

$字符串常用方法$

equals

查看字符串是否相等.返回值是boolean类型的数据

String s1 = "abc";
String s2 = "abc";
if(s1.equals(s2)){
    System.out.println("相等");
}else{
    System.out.println("不相等");
}

//打印的结果 相等

因为s1和s2相等，所以s1.equals(s2) 结果为true。

charAt

返回指定索引处的值。返回值是char类型的数据。

String s = "abcdef";
char ch = s.charAt(1);
System.out.println(ch);
//打印结果 b

字符串s 1索引的值为 b。

endWith

测试字符串是否以指定后缀结尾，返回值是boolean类型的数据

String s = "2023年01月16日";
//判断字符串是否以 日 结尾
boolean result = s.endsWith("日");
System.out.println(result);
//打印结果 true

startWith

测试字符串是否以指定前缀开头，返回值是boolean类型的数据

String s = "2023年01月16日";
//判断字符串是否以 2023 开头
boolean result = s.startsWith("2023");
System.out.println(result);
//打印结果 true

isEmpty

判断字符串是否为空，返回值是boolean类型的数据

//空的字符串
String s = new String();
boolean result = s.isEmpty();
System.out.println(result);
//打印结果为true

length()

求字符串长度，返回值是int类型的数据

String s = "abcdef";
int len = s.length();
System.out.println(len);
//打印结果为 6

replace

指定字符串的替代，返回值是String类型的数据。

String s = "你真是TMD";
String result = s.replace("TMD","***");
//                        替换   被替换
System.out.println(result);
//打印结果 你真是***

//将TMD替换为***

java基础进阶

MYSQL