Java基础知识笔记

-青辰-

已于 2022-04-25 10:46:22 修改

阅读量1k

点赞数 3

文章标签： java

于 2022-04-22 15:17:22 首次发布

本文链接：https://blog.csdn.net/qq_46170664/article/details/124346389

版权

之前刚开始学习Java的时候，记录的部分基础知识笔记，此处共享出来，也算是记录一下学习Java的历程。

注：因为我是用Typora记的笔记，如果那位小伙伴想要Typora的文件，留言邮箱发给你。

第一章：基本的DOS 命令

1：cd+空格+文件名称：用于在dos窗口打开文件夹，进入新目录；

2：cd…：用于进入文件的父目录；

3：dir：用于查看文件下的目录；

4：执行java文件：javac+空格+完整的代码文件名（要加文件类型的后缀）；完成这一步如果没有错误会生成class文件；

5：执行class文件：java+空格+文件名（不加后缀）；

6：cls：清屏；

7：上下箭头：用于查找输入过的命令；

8：Tab：用于自动补齐命令；

第二章：java基本知识

2.1 基本常识

1：一个java文件可以包含多个类，但是只有一个public类，执行之后一个类一个class文件；

2：main函数是程序的入口，有固定的格式（在IDEA中快捷键为psvm）：

		public static void main(String[] args){......}

3：java 中一个语句的结束是以";"结束，所以java中一个语句可以跨多行；

4：java中字母大小写非常重要；

5：注释和C语言基本相同，但是文档注释为：以"/**“开头，”/“结尾。如果想经行行内的注释则：”/ * “开头，”/"结束。

6：Java的输出语句：System.out.println(....);//这里的ln表示自动换行的意思，如果不想换行取消掉就行，在IDEA中输入sout快捷键就行//

7：输入语句：Scanner

使用时需要导包：import java.util.Scanner;

也要在主函数中要先创建：Scanner scanner = new Scanner(System.in);

这是一个输入语句； eg：int ages = scanner.nextInt();

2.2 IDEA的快捷键

运行：Ctrl + Shift +F10；

生成源文件语句：psvm；

生成输出语句：sout；

代码修复：ALT + 回车；

显示代码联想：ALT + /；

删除光标所在行：Ctrl + Y；

复制本行代码：Ctrl + D;

代码格式化，将代码对齐：Ctrl + Alt + L;

单行注释(//注释)：Ctrl + /;

多行注释(/*注释)；Ctrl + Shift + /;

自动生成代码：ALT + Insert；

选中内容进行整体的移动：Ctrl + Shift +上下键;

将一个方法中的相同名称的变量变换名称时：只要选中一个摁下：Shift + F6;

2.3 标识符

1：必须以字母，下划线，美元符$开头，不能是Java的关键字以及特殊字符，大小写很敏感；

2：其它部分可以进行任意的组合；

3：首字母最好是大写（非强制）；

4：如果表示方法和变量的标识符：第一个单词小写，从第二个开始首字母大写；------驼峰原则； eg: eatFoot();

5：Java使用的不是ASCII字符集，而是使用的是Unicode这样的标准国际字符集，所以首字母的表示不仅仅是字母，还包括汉字； eg: int 变量1=55；

2.4 关键字

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vvoDalnn-1650611326785)(C:\Users\MAYILIANG\AppData\Roaming\Typora\typora-user-images\image-20200731095452084.png)]

2.5 变量

1：局部变量：

与C相同，方法或语句块内（只在一个花括号内有效）；

2：成员变量（实例变量）

系统会自行的初始化，从属于类；

写在方法之外（main也是一个方法）；

各个类型系统自动赋予的处置：

int: 0; double:0.0; char:‘\u0000’; boolean:false;

3：静态变量（或类变量）

使用static定义，从属于类，伴随类的始终，从类加载到卸载，生命周期最长；

2.6 常量，final关键字

使用final定义的变量值不能改变，称为符号常量；

eg: final int x=5; 此时int已经变成了一个固定的值，之后的再次赋值会报错。

2.7 数据类型

数据类型

1个字节 = 8位；表数位：一个字节 = 2^(8*1);

	1.数值型（）；

1… 整数类型：byte:1个; short:2个; int:4个; long:8个;

2…浮点类型：float:4个; double:8个;

###:整形默认位int类型；如果使用long类型时，定义的数字要加L/l来表示长类型； eg: long a=7444444L;

###:浮点型默认为double类型，如果使用float类型，定义的数字后边要加F/f来表示float型； eg:float a=3.14F;

###:浮点型是不准确的，不能用于比较； 如果要进行比较，使用BigInteger或者BigDecimal这两个类进行比较；

###: 字符是char类型；字符串是String类型；

2.字符型(char,String)：2个; 3.布尔型(boolean):1位;

###：布尔类型用true和false表示，占了一位不是一个字节，所以**不能用0或非0表示；**

3：引用数据类型：占4个字节；

1.class类； 2.interface接口； 3.数组

进制表示

八进制：以0开头；

十六进制：以0x开头；

二进制：以0b或0B开头；

转义字符

后边的数值为Unicode值：

1: \b：退格 \u0008;

2: \n：换行 \u000a;

3: \r：回车 \u000d；

4: \t：制表符 \u0009;

5: \"：双引号 \u0022;

6: \'：单引号 \u0027;

7: \\：反斜杠 \u005c;

各种类型的默认初始值、

###只在数组或成员变量或成员方法中有默认值###

整形类型：默认为0；
浮点类型：默认为0.0；
字符类型：默认为'\u0000'；
布尔类型：默认为false；
引用类型：默认为null；

2.8 算术运算符

整数运算

1：有一个long，则全为long;

2：没有long时，结果为int，即使操作数全为short，byte，结果也是int；

eg: short a=1; byte b=2; byte c=a+b;(此时会报错，这里的c应该是int型，也可以是long型)；

浮点型运算

1：如果两个操作数有一个为double，则结果为double；

2：只有两个操作数都是float，则结果才为float；

取余运算

1：操作数可以是浮点型（C语言必须是整形）；

2：余数的符号和左边操作数的符号相同； eg: -7%3=-1; 7%-3=1;

3：++，–，和C语言的语法一样；

逻辑运算符

1：逻辑与 & ：两个操作全为true才是为true；

2：逻辑或 | ：一个为true便为true；

3：短路与 && ：有一个false直接返回false；(看完第一个是flase就可以不看第二个 )

4：短路或 || ：有一个true则为true；(看完第一个true就可以不看第二个 )

5：逻辑异或 ^ ：相同为false，不同为true；

###：一定要注意逻辑与（&&）优先级高于或（||）；

位运算

1：~ ：表示你取反； eg：~a;

2：<<：左移运算符

，左移一位相当于乘以2； eg：a=3<<2;//相当于3*4;

3：>>：右移运算符，右移一位相当于除以2； eg：b=12>>1;//相当于12/2;

2.9 字符串连接符

如果一个**字符串**在运算中出现“+”号，则表示将这两个东西连接起来。

eg：int a=1; String b=“avafvd”; a+b结果为：1avafvd；

2.10 Scanner类

1：导包：

只有java.lang 包下的内容不需要导包；

因为scanner是在java.util包下，所以需要写导包：import java.util.Scanner;

2：类名称：

其实在后边写上Scanner系统会自动加上导包;

类名称对象名 = new 类名称（System.in）；

eg：

Scanner str = new Scanner(System.in);	//scanner的构造方法是不同于普通的构造方法的，System.in表示从键盘输入//

3：使用：

其实next后边系统默认的是输入字符串，如果要变成其它类型后边加上你要输入的数据的类型就好，相当于强制类型转换;

对象名 . 成员方法名（）；

eg:

 
   int num1 = str.nextInt();	//从键盘获取一个int数字// 
   String num2 = str.next();	//从键盘获取一个字符串//

2.11 random

导包：

import java.util.Random;

创建：

Random 对象名称 = new Random(); //小括号留空//

eg：Random r = new Random( )；

使用：

生成的是int范围的所有数；

生成数的类型变量名称 = 对象名称.next类型();

eg：int num = r.nextInt();

生成有限范围数

只需要在最后使用的时候next类型后边的括号里加一个数字；

eg：int num = r.nextInt(6); //范围为[0,6);//

Meth生成随机数

eg ：double a = Math.random();

如果想生成一个范围的整数；

eg：int a =(int)(100*Math.random()) ; // 相当于生成[0,100)的随机整数//

2.12 pow

求次方的函数； eg：math pow(3,2); //相当于3的2次方//

2.13 switch语句

格式：

switch(表达式) //以前这里不能是字符串只能是整数，现在可以了//

//后边的数据类型有byte,short,char,int,String,enum枚举,没有long.

{

case 值1：语句序列1; break;

case 值2：语句序列2; break;

case 值3：语句序列3; break;

…

default: 默认语句； break;

}

2.14 带标签的continue，break；

用于跳到指定的位置：

格式： continue+标签； break+标签；

eg: in: for(i=1;i<6;i++)
{
for(j=1;j<6;j++)
{
if(j%2==0)

{

continue in;//直接跳到第一层的循环；

}

}
}

2.15 语句块

在一个程序中一个{}内定义的变量只在这个{}中有效；

eg: 在这段程序中，a对以后的语句都有作用，但是b仅仅对这个{}中有效；

int a;

{

int b;

…

}

第三章：java虚拟机的内存

分类：栈stack；堆heap；方法区methed area；

3.1 栈stack

栈描述的是**方法执行的内存模型**，每个方法被调用都会创建一个栈帧，JVM为每个线程会创建一个栈。

栈不能实现线程的共享；

储存特性是“先进后出，后进先出”，与弹夹类似；

栈由系统自动分配，是一个连续的内存空间，速度快；

存储局部变量和作用域；

方法一定在栈里运行，在运行时进栈，进栈运行完之后，会出栈;

3.2 堆heap

用于**存储创建好的对象和数组（数组也是对象**），就是每个类里边的变量名称；

JVM只有一个堆，用于所有的线程共享；

堆不是一个连续的空间，速度慢；

堆里都有一个16进制的地址；

堆内的数据都有默认值；

所有new的东西都在堆里；

3.3 方法区methed area

用于**存放程序中永远不变或唯一的内容**，如：类（class）信息，静态变量，字符串常量(双引号引起了的内容)…

jvm只有一个方法区，被所有的线程共享；（与堆一样）

方法区中有固定的空间存放static；

3.4 本地方法栈Native Method Stack

与操作系统有关；

3.5 寄存器

与CPU有关;

第四章：方法

4.1 方法与方法的重载：

与C语言中的子函数差不多，一个类里边有多个方法，方法没有先后顺序，方法不能有嵌套方法；

如果为void型，则如果要写return，则只写一个return就好；

格式：

public static void(返回值类型) 方法名称() { //普通方法要带static，而成员方法是不用带的//

}

eg：

public class Method {
public static void main(String[] args) {
Method str = new Method(); //固定格式,Method是定义的这个类的总名称,要提前声明一个new//
int sum1;
sum1=str.add(10, 20, 30)；

}
int add(int a,int b,int c)//如果不返回则写成void//
{
	int sum;
	sum=a+b+c;
	System.out.println(sum);
	return sum;
}

}

如果定义的方法的名称是一样的，但是它的内容不一样，就构成了方法的重载；

eg:

import java.util.Scanner;
public class Method {
public static void main(String[] args) {
Method str = new Method();
Scanner scanner = new Scanner(System.in);
int i = scanner.nextInt();
int j = scanner.nextInt();
int k = scanner.nextInt();
System.out.println(add(1,2)); //虽然名称一样，但是只要在赋实参时的形式不同系统就可以进行区分//
System.out.println(add(1,2,3));
System.out.println(add(1,2.0));
System.out.println(add(1.1,2));
}
//方法重载//
public static int add(int a,int b)
{
int sum;
sum=a+b;
return sum;
}
public static int add(int a,int b,int c)//前边为什么要加public static我也不知道，就当是固定的格式//
{
int sum;
sum=a+b+c;
return sum;
}
public static double add(int a,double b)
{
double sum;
sum=a+b;
return sum;
}
public static double add(double a,int b)
{
double sum;
sum=a+b;
return sum;
}
``
}

4.2 成员方法

格式：

public void(返回值类型) 方法名称() { //普通方法要带static，而成员方法是不用带的//

}

成员方法不用带static；

使用成员方法就要使用成员变量，成员变量定义在类之中，在方法的外边；

eg:

		public class classObject {
 		   String name;					//成员变量//
 		   int age;
 		   public void eat(){			//成员方法//
   		     System.out.println("吃饭饭！！");
 		   }
        }

4.3 构造方法，构造器

1：构造方法的名称必须与类的名称保持一致，而普通方法和成员方法可以自己定义名称；

2：构造方法不写返回的类型，void也不写；

3：构造方法不能return一个具体的返回值；

4：如果没有定义构造器，则下边调用不会出错，因为系统会自动添加一个构造方法，但是如果定义了一个构造方法，系统不会在自动添加；

定义构造方法：

eg:

		public capsulation3(){
 		   System.out.println("小马最帅！");
		}
使用构造方法(通过new来进行调用；)：
	eg:
		capsulation3 str = new capsulation3();

4：构造方法的重载与方法重载一模一样；

构造方法的第一句总是**super()**；这个东西可写可不写，不写系统会自动添加；

第五章：数组

1.1 在方法中可以返回一个数组，但是在定义方法时类型要为数组类型；

eg：

	public static void main(String[] args) {
	    int[] sum1 = sum(3,6);			//用数组来接收数组,直接接收就行，不用创建new//
	    for (int i = 0; i < sum1.length; i++) {
	        System.out.println(sum1[i]);
  	  }
	}
	  public static int[] sum(int a,int b){		//定义的返回数组的方法//
  	  	int a1 = a;
  		int b1 = b;
  	 	int[] arrave = new int[2];
  		arrave[0] = a1;
 	   	arrave[1] = b1;
 	   	return arrave;		//返回一个数组//
	}

在方法中作为参数传入数组作为参数：

eg: public static void print(int[] array)

###：不管是作为参数还是返回值，传递的都是数组的地址！！！

1.2 数组在程序运行期间，长度不可以发生改变，如果一个数组给它**重新new了一个值则，则这个新的会覆盖旧的**；

eg：

int[] num = new int[3];

`num = new int[5]; //此时就将长度3 变成了5//

1.3 数组不能直接打印，因为这样打印出的是数组的所在内存地址；

1.4 打印和C语言一样；

5.1 动态初始化数组

格式：数据类型 [ ] 数组名称 = new 数组类型 [数组长度]；

eg：int[] str = new int[10];

也可以写成：

double[] str6;
str6 = new double[5];
使用动态初始化数组时：内部元素会有一个默认值；

5.2 静态初始化

基本格式：数据类型 [ ] 数组名称 = new 数组类型 [ ] {元素1 ，元素2 ，元素3…}；

eg：int[] str3 = new int[] {1,2,3,4,5,6,7,8};

也可以写成：

			int[] str5;
			str5 = new int[]{5,6,2,8,5};

省略格式：数据类型 [ ] 数组名称 = {元素1 ，元素2 ，元素3…};

5.3 数组的应用

如果将一个数组A等于另外一个数组B时，则相当于将该数组A的地址给了另外一个数组B，另外一个数组B的值也就等于了该数组A的值，如果**被赋值的数组B的值发生了改变，则原数组A的值也发生改变**；//注意//

eg：

		int[] num3 = {1,2,3,4};
        int[] num5;
        num5 = num3;//将num3的地址给了num5//
        num5[3] = 2;
        num5[2] = 3;//原数组该位置的值也发生了改变//
        System.out.println();
        for(int i=0;i<4;i++){
            System.out.print(num5[i]+"  ");
        }
        System.out.println();
        for(int i=0;i<4;i++){
            System.out.print(num3[i]+"  ");
        }

5.4 数组两种典型的异常

1：ArreyIndexOutofBoundsException

就是一个数组应用时超出了数组定义的范围；

2：空指针异常：NullPointerException

就是给了数组一个null空值，在之后并没有进行具体的new创建内容，从而报错；

5.5 length关键字求出数组的长度

eg： int n = num.length; // n 是用来接收数组的长度，num是数组的名称//

5.6 数组遍历在IDEA中输出快捷语句

格式：数组名 + “.” + for + 要进行循环的变量名称

eg：num.fori；

会形成：for (int i = 0; i < num.length; i++)

5.7 对象数组

1：首先写一个标准类；

eg:

public class arrayObject {
    private String name;
    private int age;

    public arrayObject() {
    }

    public arrayObject(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;
    }
}

2：创建对象数组；

eg；

public static void main(String[] args) {
    arrayObject[] str = new arrayObject[3];		//创建对象数组,其中arrayObject是创建的类的名称//
    arrayObject one = new arrayObject("aaa",10);	//创建对象，然后进行赋值//
    arrayObject two = new arrayObject("bbb",20);	//创建对象，然后进行赋值//
    arrayObject three = new arrayObject("ccc",30);  //创建对象，然后进行赋值//
    str[0] = one;	//将对象的地址传给对象数组//
    str[1] = two;	//将对象的地址传给对象数组//
    str[2] = three; //将对象的地址传给对象数组//
    for (int i = 0; i < 3; i++) {		//输出数组//
        System.out.print(str[i].getName()+"  ");
        System.out.println(str[i].getAge());
    }
}

5.8 数组的遍历：foreach方法

这只是一个使用方法名称，并不是一个关键字，是java为了方便遍历而弄的一种更加简单的方式。

格式：

for(int 循环变量：数组){

System.out.println(循环变量)；

}

eg：

public class Protect1{
    public static void main(String[] args) {
        int[] num = new int[]{5,2,4,1,9,6,8,7};
        for (int i:num) {
            System.out.print(i+" ");
        }
    }
}

5.9 二维数组

Java中二维数组最大的特征是它的每一行元素的个数可以不相等；

1：定义

一定要记得除了最后一行，其它都要加【，】。数组结尾要加【；】。）

格式：

数组类型[ ] [ ] 数组名称 = {

{ 第一行元素 }，

{ 第二行元素 }，

…

{ 第N行元素 }

} ;

2：获取数组的元素个数

1：int 接收变量 = 数组名称 . length; // 输出二维数组的行数

2：int 接收变量 = 数组名称 [ 行数 ] . length; //输出第n行的元素个数

3：调用输出

其实和C语言没啥区别；

for(int i =0;i<num1.length;i++){
    for (int j=0;j<num1[i].length;j++){
        System.out.print(num1[i][j]+" ");
    }
    System.out.println();
}

6.0 枚举(enum)

以下是枚举最简单的说明：

枚举在我看来更加像是一个存储自己想要存储的元素的集合；

写在主方法之前；

1：格式：enum 枚举名{ 要存入的各种值（如果是字符串不需要加双引号直接写就好）}；

	eg： enum week{Mon,Tue,Wed,Thu,Fri,Sat,Sun};

#：最后的引号可以不加，但是如果其中含有方法，就必须要加；

2：枚举类型数据的调用：枚举名接受数据变量名 = 枚举名 . 枚举中具体的元素；

	eg: week day = week.Mon;

第六章：类

三大特征：封装，继承和多态；

类是对象的模板，对象是类的实体；

6.1 类的使用

具体格式

类不能直接使用需要根据类创建一个对象：

1：导包：

就是指出需要的类，在什么位置；

import 包名称.类名称； //就是整个类所存放的整个路径//

但是当类在同一个包下（即，同一个路径下时），可以不用写导包；

只有java.lang 包下的内容不需要导包，所以可以不写import；:

2：创建格式：

类名称对象名 = new 类名称（）；

eg：Student stu = new Student；

3：使用的两种情况：

使用成员方法：对象名.成员方法名（参数）;

eg：

public static void main(String[] args) {
    //1:创建导包//
    //同一个包day2下，不需要导包//
    //2:创建，格式//
    classObject str = new classObject();
    //3,使用成员变量//
    str.name = "马怡良";
    str.age = 20;
    System.out.println(str.name);
    System.out.println(str.age);
    //4:使用对象的成员方法名//
    str.eat();
}

1：在普通方法中无返回值引用类

eg：

public static void main(String[] args) {
    classuse1 one = new classuse1();
    one.price = 3200;
    one.color = "黑色";
    one.brand = "苹果";
    methed(one);    //传递进去一个地址值//
}
public static void methed(classuse1 str){	//str为自定义的名称//
    System.out.println(str.price);		//此时不能使用one这个名称，而应该使用刚在方法中定义的str//
    System.out.println(str.color);
    System.out.println(str.brand);
}

2：在普通方法中有返回值引用类，且在方法中进行类的赋值

eg：

public static void main(String[] args) {
    classuse1 two = methed();		//在这里接收方法返回的one的地址//
    System.out.println(two.brand);
    System.out.println(two.color);
    System.out.println(two.price);
    two.call("马怡良");
    two.sendMessage();
}
public static classuse1 methed(){		//无参数的方法//
    classuse1 one = new classuse1();	//定义名称，进行new的创建//
    one.brand = "魅族";
    one.color = "土豪金";
    one.price = 1999;
    return one;							//之后返回在该方法中创建的one的地址//
}

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

1：默认值不一样：

局部变量：没有默认值，需要手动赋值；

成员变量：系统有默认值的；

2：作用范围不一样：

局部变量：只有在方法中才能使用，出了方法是不能使用的（或者说只能在一个“{ }”中可以使用有作用）；

成员变量：在整个类之中都可以使用；

3：定义的位置不一样：

局部变量：定义在方法的内部；

成员变量：定义在方法的外部，直接在类中定义；

4：内存位置不一样

局部变量：位于**栈内存**中（因为它是跟着方法走的）；

成员变量：位于**堆内存**中（因为它是跟着new走的）；

5：生命周期不一样

成员变量的生命周期比局部变量的生命周期要长；

局部变量：随着方法的进栈而诞生，随着方法的出栈而消失；

成员变量：随着对象的产生而产生，随着对象被垃圾回收而消失；

6.2 封装

封装就是将一些细节信息隐藏起来，对外界不可见；

1：方法就是一种封装；

2：private也是一种封装的方法；

<1> private使用时是放在一个成员变量的前边，是用这个关键字之后，该变量在超出该类之后会不能直接应用，不然会报错;

eg: private int age;

<2> 使用后要在该方法后边定义它的使用范围（两个方法语句）；

(1).使用成员方法建立输入数据：

eg：

public void setAge(int num){	//名称的固定格式：void set..(set后边为设置的变量名称，它的第一个字母必须大写)//
    if(num < 100 && num>=9){    //设置条件//
        age = num;
    }
    else{
        System.out.println("数据不合理！");
    }
}

(2).使用成员方法设置输出数据：在布尔类型中（boolean）返回方法不能写成get…而应该写成is…

eg1：

public int getAge(){		名称的固定格式：数据类型 get..(set后边为设置的变量名称，它的第一个字母必须大写)//
    return age;
}

eg2：

public boolean isMale(){
    return male;
}

	###:
		对于set来说，不能有返回值，参数类型与成员变量相同；
		对于get来说，不能有参数，返回值类型和成员变量相同；

<3>在另一个类中应用时，不应该应用这个变量而是应用这个set…成员方法；
eg：

person.setAge(1);
person.getAge();

6.3 this关键字

静态变量和方法不能使用this；

一定是在一个方法的内部使用this；

当方法的参数变量（或局部变量）与类的成员变量重名的时候，会根据就近原则，优先使用局部变量;

如果要访问本类中的成员变量，需要用this关键字：格式 this.成员变量名；

this的地址为，通过谁调用的方法，this的地址就是谁.

6.4 标准类JAVA Bean

由以下4部分组成：

1：所有成员变量都要使用private关键字修饰；

2：每一个成员变量都要编写一对set和get；

3：编写一个无参构造方法；

4：编写一个全参构造方法；

完整的程序案例

<1>.成员变量，方法类的定义：

public class fullClass {
    private String name;
    private int age;
    //无参构造方法//
    public fullClass() {

    }
    //全参构造方法//
    public fullClass(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;
    }
}

<2>.成员变量，方法类的引用：

public class fullClass1 {
            public static void main(String[] args) {
                fullClass stu = new fullClass();
                stu.setName("小马");
                stu.setAge(20);
                System.out.println("姓名："+stu.getName()+"; 年龄："+stu.getAge()+";");
                System.out.println("======================");
                fullClass stu2 = new fullClass("马怡良",20);
                System.out.println("姓名："+stu2.getName()+"; 年龄："+stu2.getAge()+";");
                stu2.setAge(18);
        stu2.setName("马小哥");
        System.out.println("姓名："+stu.getName()+"; 年龄："+stu.getAge()+";");
    }
}

6.5 匿名对象

形式：new.对象名称 = 值；

eg：new name = “小马”;

匿名对象只能使用唯一的一次，如果下次再用就需要创建新的对象；

匿名对象大多数情况下只使用在：确定对象只适用一次，就可以用匿名对象；

6.6 ArrayList集合

和数组不同的是，它的存入数据的个数不是固定的；

集合内数据的类型

因为< >中是泛型，所以只能写String引用类型，其它就会报错；

如果想存放其它类型的数据，则要使用基本类型对于的“ 包装类 ”；

因为包装类的导包是java.lang.所以导包可以省略不写；

对于的基本类型包装类如下：

byte：Byte；

shout：Short；

int：Integar；

long：Long；

float：Float；

double：Double；

char：Character；

boolean：Boolean；

使用时只要把< >里边的东西改成包装类就行；

导包

import java.util.ArrayList;

创建

格式：ArrayList 集合名称 = new ArrayList< >( ); //后边的<>里可以写东西也可以不写，要写就写String//

使用

如果要使用和其它的基本差不多，格式：集合名称.add(存入集合的内容)；

输出的结果是带有一个“ [ ] ”的，如果里边没有内容则就只输出一个“ [ ] ”，不会和数组一样返回一个指针；

输出

输出的直接写一个集合名就好，这是和数组的一个区别；

eg：System.out.println(list);

常用的使用方法

1：添加元素

格式：集合名称.add(存入集合的内容)；

eg：list.add("马怡良");

2：读出集合中的某个元素

格式：数据类型接受的变量名 = 集合名称.get(存入集合的内容)；

eg：String num = list.get(2); //和数组一样位置从0 开始//

3：删除集合中的某个元素

格式：集合名称.remove(要删除的位置)；

可以在前边放一个变量接受要删掉的元素；

eg：String num1 = list.remove(0);   //删除第一个元素，将删除的第一个元素赋值给num1//

4：获取集合的长度

格式：数据类型接受个数的变量名 = 集合名称.size(存入集合的内容)；

eg：int num2 = list.size();

5：遍历

和数组差不多，只是后面的输入变成了：集合名.get(i)；

eg：

for (int i = 0; i < list.size(); i++) {
    System.out.println(list.get(i));
}

在方法中参数为集合，返回值为集合

eg:

import java.util.ArrayList;
import java.util.Random;

public class ArrayList7 {
    public static void main(String[] args) {
        Random num = new Random();
        ArrayList<Integer> list1 = new ArrayList<>();
        ArrayList<Integer> list2 = new ArrayList<>();
        for (int i = 0; i < 20; i++) {      //随机生成20个数存入集合//
            list1.add(num.nextInt(100)+1);
        }
        System.out.println(list1);
        //用集合接收方法返回是集合------亮点，小马牛逼//
        for (int i = 0; i < rank(list1).size(); i++) {
            int n = rank(list1).get(i);
            list2.add(n);
        }
        System.out.println(list2);
    }
    public static ArrayList<Integer> rank(ArrayList<Integer> list){     
    	//使用方法,其中参数为集合，返回值为集合//
        //将偶数存到一个集合然后返回//
        ArrayList<Integer> list2 = new ArrayList<>();
        for (int i = 0; i < list.size(); i++) {
            if(list.get(i) % 2 == 0){
                list2.add(list.get(i));
            }
        }
        return list2;
    }
}

6.7 字符串

1- 字符串的特点

1：字符串的内容永不改变；

2：字符串的效果相当于char[ ]字符数组，但是**底层的原理是byte[ ]字节数组**；

3：字符串不管new还是不，它都是字符串；

2-常见字符串的创建

1：public String( )；//创建空字符串//

eg:

String str1 = new String(); //后边括号留空表示没有内容//

2：public String(char[ ] array)；//根据字符数组的内容，创建对应的字符串//

eg:

char[] num = {'a','b','c'};
String str2 = new String(num);

3：public String(byte[ ] array); //根据字节数组的内容，创建对应的字符串//

eg:

byte[] num1 = {97,65,99};	//因为字符串底层的原理是byte[ ]字节数组，所以这里每一个数字代表一个字符//
String str3 = new String(num1);

4：String str4 = "......"; // 直接创建字符串

eg:

String str4 = "hello world!";

3-字符串的常量池

1：程序当中直接写上的双引号字符串，就在字符串常量池当中，但是new的不在常量池中；

2：对于基本类型：== 就是进行数值的比较；

对于引用类型：==就是进行地址值的比较；（数组就是引用类型，String就是字符的数组）；

3：字符串常量池在堆中；

4-字符串常用方法

1：比较两个字符串的数值大小，

<1>.使用equals方法（区分大小写）；

格式：要比较的一个字符串 . equals(要比较的另一个字符串)；

eg：System.out.println("hello".equals(str2));

equals具有对称性，两个字符串比较时的位置不是固定的，交换位置，效果也一样；

如果比较双方一个是常量，一个是变量，最好将常量写在前边：

eg：

String str2 = "hello";
System.out.println("hello".equals(str2));	//推荐这种写法//
System.out.println(str3.equals("hello"));	//不推荐这种写法//

<2>.使用equalsIgnoreCase方法（不区分大小写）；

eg:
	char[] num = {'h','e','l','l','o'};
    String str1 = new String(num);
	System.out.println("HELLO".equalsIgnoreCase(str1));

2：基本字符串处理方法

<1>.length获取字符串当中的字符个数；

length ：后边加括号则是求字符串的长度，

不加括行则是求字符数组的长度；

格式：字符串.length;

eg：int i = str1.length();

<2>.concat将当前字符串与参数字符串进行拼接；

格式：字符串1.concat(字符串2)；

eg：String str4 = str1.concat(str2);

<3>.charAt获取指定位置的单个字符；

格式：字符串.charAt(位置)；

eg：char a = str2.charAt(3);

<4>.indexOf查找参数字符串在本来字符串中第一次出现的索引位置，

如果没有则返回-1；

格式：字符串.indexOf("查找的字符串")；

eg：int b = str3.indexOf("o");//b用来接收位置//

<5>.substring截取一段字符串’

1:格式：字符串.substring(开始位置); //这种格式是从该位置到结尾//

eg:String ab = str1.substring(2);

2:格式：字符串.substring(开始位置，结束位置); //规定范围的截取，区间为 [ 开始，结束）前边为闭区间后边为开区间；

eg:String abc = str1.substring(1,3);

#####：注意，一个已经定义的字符串赋予了一个值，但是在之后又给它了一个值，他们只是给该字符串的地址发生了改变，而不是地址里边的值发生了改变；

eg：

String str = “abc”;

str = “bcd”; //只是给str的地址发生了改变，值没有变//

<6> toLowerCase/toUpperCase改变字符串大小写

如果是字符串则直接调用就好：字符.toLowerCase( );

但是字符就不一样要通过包装类调用了：eg: character.toLowerCase(字符)；

eg:

public class Tree  {
        public static void main(String args[])
        {
            String s,s1="";
            char c;
            s="JAVA exp";
            for (int i=0;i<s.length();i++){
                c=s.charAt(i);
                if(c>='a' && c<='z'){
                    s1=s1+Character.toUpperCase(c);//很特殊的一个点
                }
                else{
                    s1=s1+Character.toLowerCase(c);
                }
            }
            
            System.out.println(s1);
        }
}

注意：

java中字符串调用toLowerCase/toUpperCase不会修改原本的字符串。

toLowerCase：将字符串字符变成小写

toUpperCase：将字符串字符变成大写

eg：

public static void main(String[] args) {
    String a = "abdvdgv";
    String b = a.toLowerCase();
    String c = a.toUpperCase();
    System.out.println(a);
    System.out.println(b);
    System.out.println(c);
}
输出：
    abdvdgv
	abdvdgv
	ABDVDGV

<7> startsWith/endsWith判断开头结尾

返回布尔类型值！

1：startsWith(字符)----->判断字符串是否以该字符开始

2：endsWith(字符) ----->判断字符串是否以该字符结尾

<8> trim去掉字符串两端的多余的空格

需要一个新的变量来接收；

一定要注意只是丢掉字符串前后的空格，不能丢掉字符串内的空格；

eg:

String s = "   af gr g  ";
String s1 = s.trim();
System.out.println(s1);
运行结果：
    af gr g

3：字符串的转换；

<1>.toCharArray将字符串拆分成字符数组作为返回值

格式：字符串.toCharArray();

eg：char[] num1 = str1.toCharArray();

<2>.getBytes获得字符串底层的字节数据

格式：字符串.getBytes();

eg：byte[] num2= str1.getBytes();

<3>.replace将老字符串替换成新字符串，返回替换后的新字符串

格式：字符串.replace(被替换的字符，替换为的字符)；

eg：

String str11 = "how do you do!";
String str22 = str11.replace("o","*");

4：字符串的分割split；

格式：字符串.split(“分割的参照”)；

eg：

String str1 = "aaa,bbb,ccc";
String[] array = str1.split(",");

如果分割参照是一个英文的“ . ”，则里边的参照不能只写成一个“ . ”，而是应该写成“ \\.”；

eg；

String str2 = "aaa.bbb.ccc";
String[] array1 = str2.split("\\.");

5- 字符串的格式化输出

1：printf

使用时和C语言的输出很相似；

不能单独写，必须和System.out连用；

><使用方式

System.out.printf( )

1> 输出字符串

/*** 输出字符串 ***/
// %s表示输出字符串，也就是将后面的字符串替换模式中的%s
System.out.printf("%s", new Integer(1212));
// %n表示换行
System.out.printf("%s%n", "end line");
// 还可以支持多个参数
System.out.printf("%s = %s%n", "Name", "Zhangsan");
// %S将字符串以大写形式输出
System.out.printf("%S = %s%n", "Name", "Zhangsan");
// 支持多个参数时，可以在%s之间插入变量编号，1$表示第一个字符串，3$表示第3个字符串
System.out.printf("%1$s = %3$s %2$s%n", "Name", "san", "Zhang");

2> 输出boolean类型

 /*** 输出boolean类型 ***/
    System.out.printf("true = %b; false = ", true);
    System.out.printf("%b%n", false);

3> 输出整数类型

 /*** 输出整数类型***/
    Integer iObj = 342;
    // %d表示将整数格式化为10进制整数
    System.out.printf("%d; %d; %d%n", -500, 2343L, iObj);
    // %o表示将整数格式化为8进制整数
    System.out.printf("%o; %o; %o%n", -500, 2343L, iObj);
    // %x表示将整数格式化为16进制整数
    System.out.printf("%x; %x; %x%n", -500, 2343L, iObj);
    // %X表示将整数格式化为16进制整数，并且字母变成大写形式
    System.out.printf("%X; %X; %X%n", -500, 2343L, iObj);

4> 输出浮点类型

/*** 输出浮点类型***/
    Double dObj = 45.6d;
    // %e表示以科学技术法输出浮点数
    System.out.printf("%e; %e; %e%n", -756.403f, 7464.232641d, dObj);
    // %E表示以科学技术法输出浮点数，并且为大写形式            
    System.out.printf("%E; %E; %E%n", -756.403f, 7464.232641d, dObj);
    // %f表示以十进制格式化输出浮点数
    System.out.printf("%f; %f; %f%n", -756.403f, 7464.232641d, dObj);
    // 还可以限制小数点后的位数
    System.out.printf("%.1f; %.3f; %f%n", -756.403f, 7464.232641d, dObj);

5> 输出日期类型


    /*** 输出日期类型***/
    // %t表示格式化日期时间类型，%T是时间日期的大写形式，在%t之后用特定的字母表示不同的输出格式
    Date date = new Date();
    long dataL = date.getTime();
    // 格式化年月日
    // %t之后用y表示输出日期的年份（2位数的年，如99）
    // %t之后用m表示输出日期的月份，%t之后用d表示输出日期的日号
    System.out.printf("%1$ty-%1$tm-%1$td; %2$ty-%2$tm-%2$td%n", date, dataL);
    // %t之后用Y表示输出日期的年份（4位数的年），
    // %t之后用B表示输出日期的月份的完整名， %t之后用b表示输出日期的月份的简称
    System.out.printf("%1$tY-%1$tB-%1$td; %2$tY-%2$tb-%2$td%n", date, dataL);

    /*** 是常见的日期组合 ***/
    // %t之后用D表示以 "%tm/%td/%ty"格式化日期
    System.out.printf("%1$tD%n", date);
    //%t之后用F表示以"%tY-%tm-%td"格式化日期
    System.out.printf("%1$tF%n", date);

6> 输出时间类型

/*** 输出时间类型***/
// 输出时分秒
// %t之后用H表示输出时间的时（24进制），%t之后用I表示输出时间的时（12进制），
// %t之后用M表示输出时间的分，%t之后用S表示输出时间的秒
System.out.printf("%1$tH:%1$tM:%1$tS; %2$tI:%2$tM:%2$tS%n", date, dataL);
// %t之后用L表示输出时间的秒中的毫秒
System.out.printf("%1$tH:%1$tM:%1$tS %1$tL%n", date);
// %t之后p表示输出时间的上午或下午信息
System.out.printf("%1$tH:%1$tM:%1$tS %1$tL %1$tp%n", date);
// 以下是常见的时间组合
// %t之后用R表示以"%tH:%tM"格式化时间
System.out.printf("%1$tR%n", date);
// %t之后用T表示以"%tH:%tM:%tS"格式化时间
System.out.printf("%1$tT%n", date);
// %t之后用r表示以"%tI:%tM:%tS %Tp"格式化时间
System.out.printf("%1$tr%n", date);

7> 输出星期

/*** 输出星期***/
// %t之后用A表示得到星期几的全称
System.out.printf("%1$tF %1$tA%n", date);
// %t之后用a表示得到星期几的简称
System.out.printf("%1$tF %1$ta%n", date);

// 输出时间日期的完整信息
System.out.printf("%1$tc%n", date);

2：formate

>< 使用方式

String.format( )；

1> 格式符号代表的具体含义：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9cFY1gFK-1650611326787)(C:\Users\MAYILIANG\AppData\Roaming\Typora\typora-user-images\image-20201102180553206.png)]

eg:

//演示
        String str=null;
        str=String.format("Hi,%s", "小明");
        System.out.println(str);  //Hi,小明
        str=String.format("Hi,%s %s %s", "小明","是个","大帅哥");
        System.out.println(str); //Hi,小明 是个 大帅哥               
        System.out.printf("字母c的大写是：%c %n", 'C');  //字母c的大写是：C   
        System.out.printf("布尔结果是：%b %n", "小明".equal("帅哥"));  //布尔的结果是：false
        System.out.printf("100的一半是：%d %n", 100/2);  //100的一半是：50
        System.out.printf("100的16进制数是：%x %n", 100);  // 100的16进制数是：64
        System.out.printf("100的8进制数是：%o %n", 100);  //100的8进制数是：144
        System.out.printf("50元的书打8.5折扣是：%f 元%n", 50*0.85);  //50元的书打8.5折扣是：42.500000 元  
        System.out.printf("上面价格的16进制数是：%a %n", 50*0.85);  //上面价格的16进制数是：0x1.54p5   
        System.out.printf("上面价格的指数表示：%e %n", 50*0.85);  //上面价格的指数表示：4.250000e+01   
        System.out.printf("上面价格的指数和浮点数结果的长度较短的是：%g %n", 50*0.85);  //上面价格的指数和浮点数结果的长度较短的是：42.5000   
        System.out.printf("上面的折扣是%d%% %n", 85);  //上面的折扣是85%   
        System.out.printf("字母A的散列码是：%h %n", 'A');//字母A的散列码是：41

2> 搭配转换符

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Aqa8uC8s-1650611326788)(C:\Users\MAYILIANG\AppData\Roaming\Typora\typora-user-images\image-20201102180754014.png)]

3> 日期的格式化输出:

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HXOKCq9W-1650611326789)(C:\Users\MAYILIANG\AppData\Roaming\Typora\typora-user-images\image-20201102180820967.png)]

eg:

Date date=new Date();
//c的使用  
System.out.printf("全部日期和时间信息：%tc%n",date);//全部日期和时间信息：星期三 九月 21 22:43:36 CST 2016        
//f的使用  
System.out.printf("年-月-日格式：%tF%n",date);//年-月-日格式：2016-09-21  
//d的使用  
System.out.printf("月/日/年格式：%tD%n",date);//月/日/年格式：16/10/21   
//r的使用  
System.out.printf("HH:MM:SS PM格式（12时制）：%tr%n",date);//HH:MM:SS PM格式（12时制）：10:43:36 下午  
//t的使用  
System.out.printf("HH:MM:SS格式（24时制）：%tT%n",date);  //HH:MM:SS格式（24时制）：22:43:36  
//R的使用  
System.out.printf("HH:MM格式（24时制）：%tR",date); //HH:MM格式（24时制）：22:43

6- String，StringBuilder，StringBuffer原理

1> String类：

字符串是一个常量；它的值在创建之后不能更改。

字符串的底层是一个被final修饰的数组，是一个常量。

<1> 字符串的两种连接注意事项：

这两种是不同的，如果将字符串放在前边则它后边部分也会是字符串，如果将字符串放到前边则输出时会先计算前边部分再进行输出；

1：String s1 = “123”+45+678; ---->输出：12345678

2：String s2 = 12+34+“567”; ---->输出：46567

<2> valueOf 将各种类型值转化成字符串类型

必须通过String来调用；

（1）String.valueOf(boolean b) : 将 boolean 变量 b 转换成字符串
（2）String.valueOf(char c) : 将 char 变量 c 转换成字符串
（3）String.valueOf(char[] data) : 将 char 数组 data 转换成字符串
（4）String.valueOf(char[] data, int offset, int count) : 将 char 数组 data 中由 data[offset] 开始取 count 个元素转换成字符串

（5）String.valueOf(double d) : 将 double 变量 d 转换成字符串
（6）String.valueOf(float f) : 将 float 变量 f 转换成字符串
（7）String.valueOf(int i) : 将 int 变量 i 转换成字符串
（8）String.valueOf(long l) : 将 long 变量 l 转换成字符串
（9）String.valueOf(Object obj) : 将 obj 对象转换成字符串, 等于 obj.toString()

2> StringBuilder类：

字符串缓冲区，可提高字符串的操作效率，可以看成一个长度可以变化的字符串。

底层也是一个数组，但是没有被final修饰，可以改变长度，始终是一个数组，如果超出StringBuilder容量，系统会自动扩容。

1：使用StringBuilder构造方法

1> 构造方法：

//空参构造方法
StringBuilder bu1 = new StringBuilder();
System.out.println("bu1="+bu1);
//带字符串的构造方法
StringBuilder bu2 = new StringBuilder("abc");
System.out.println("bu2="+bu2);

2> append关键字为StringBuilder添加数据：

如果要添加数据则可以使用append关键字，返回的是this关键字，就是在修改其原本的对象，所以可以不用一个新的StringBuilder对象来接收。

append可以添加任何类型的元素，因为append只修改其本身的对象，所以可以练习调用；

eg:

StringBuilder bu = new StringBuilder();
//使用append往StringBuilder添加数据//
StringBuilder bu2 = bu.append("av");//这种可以，但是不会把值给bu2，还是修改的bu的值//
bu.append("abc");
bu.append(1);
bu.append(true);
bu.append(5.5);
System.out.println(bu);
//可以连续调用
bu.append("abc").bu.append(1).bu.append(true).bu.append(5.5);
System.out.println(bu);

2：String 和StringBuilder之间的转换

1：将String转换成StringBuilder类型

格式：StringBuilder 对象名 = new StringBuilde（String类型对象名/字符串）;

eg:

String str = "hello";
StringBuilder str1 = new StringBuilder(str);

2：将StringBuilder转换成String类型

使用StringBuilder中的toString方法：

eg:

String s = str1.toString();

3> StringBuffer类：

这是一个单独的东西 (和一个存数据的变量差不多) ，进行以下这些操作时不需要一个对象接收；

1: append

将数据存到StringBuffer对象中，直接调用就好-----> 对象 . append( 字符串)；

2: insert

对字符串中的某个位置添加固定字符-------> 对象 . insert（位置，添加内容）;

3: delete 、deleteCharAt

delete：对一整个字符串进行删除------> 对象 . delete(起始位置，终止位置)；

deleteCharAt：对一固定位置的字符进行删除-------->对象 . deleteCharAt(删除位置) ;

4: reverse

进行字符串的逆序----------> 对象 . reverse () ;

eg:

StringBuffer str2 = new StringBuffer(str1);
System.out.print("字符串的的倒序为：");
System.out.println(str2.reverse());  //str2.reverse不能有东西接收，除非在用一个StringBuffer创建对象接收//

5: toString

将StringBuffer类型转化成String类型；

6.8 static关键字

static只能被继承不能被重写；

方法区中有固定的空间存放static；

用途：使用了static关键字那么这个内容就不是属于对象，而是属于类，使得这个内容可以被本类中的各个对象同时分享公用；

在类中static不用写private;

1：静态变量的写法

eg:

`在类里边的定义：`
private String name;
private int age;
static String room;

在对象中的使用：
public static void main(String[] args) {
    static1 one = new static1("小马",18);
    static1 two = new static1("小王",20);
    one.room = "101教室";	//只要给一个定义内容，其他的就自动使用了；
    System.out.println("姓名："+one.getName()+"; 年龄："+one.getAge()+"; 教室："+one.room+";");
    System.out.println("姓名："+two.getName()+"; 年龄："+two.getAge()+"; 教室："+one.room+";");
}

2：计数器的写法

类里边的定义：
private int id;	//接受计数器的值//
private static int idCounter = 0;   //学号计数器，每new一个对象计数器++//
public static1() {
}
//对id进行例行的set和get//
public int getId() {
    return id;
}

public void setId(int id) {
    this.id = id;
}
//在全参的构造器中将计数器的值赋给id,构造器每使用一次，计数器加一//
public static1(String name, int age) {
    this.name = name;
    this.age = age;
    this.id = ++idCounter;
}

在对象中的使用：
public static void main(String[] args) {
    static1 one = new static1("小马",18);
    static1 two = new static1("小王",20);
	System.out.println("姓名："+one.getName()+"; 年龄："+one.getAge()+
        "; 教室："+one.room+"; 学号："+one.getId()+";");
	System.out.println("姓名："+two.getName()+"; 年龄："+two.getAge()+
        "; 教室："+one.room+"; 学号："+two.getId()+";");
    }

3：静态方法的写法

1：一个成员方法如果被static修饰，则它就变成了一个静态方法//
2：成员方法需要创建一个对象才能调用,格式：对象名.成员变量//
3：静态方法不需要创建对象就可以调用,格式：类名称.静态变量//
4：对于本身当中的静态方法，可以省略类名称//

eg:

类中的定义：
public class static3 {
    public void method(){
        System.out.println("成员方法！");
    }
    public static void methodStatic(){
        System.out.println("静态方法！");
    }
}

对象中的使用：
public class static4 {
    public static void main(String[] args) {
        static3 str = new static3();
        str.method();
        str.methodStatic();//这种写法在编译后也会被翻译成“类名称.静态方法名”这种格式//
        static3.methodStatic();//标准使用方法//
    }
}

4：方法调用变量规则

1：系统是【先】生成静态方法，【后】生成成员方法；

成员方法：可以调用成员变量，也可以调用静态变量；

静态方法：不可以调用非静态变量，可以调用静态变量；

3：静态方法不能使用this关键字；

4：根据类名称访问静态成员变量的时候，内存中全程和对象没关系，只和类有关系；

5：静态代码块

1：和构造方法基本差不多，但是，静态代码块只执行唯一的一次，而构造方法是new一次执行一次；

2：用来一次性给静态成员变量赋值;

格式：

static{

//静态代码块的内容//

}

eg :

类中构造：
public class static5 {
    static{
        System.out.println("静态代码块！");
    }
    public static5(){
        System.out.println("构造方法！");
    }
}

对象使用：
public class static6 {
    public static void main(String[] args) {
        static5 str = new static5();
        static5 str1 = new static5();
    }
}
执行结果：
    静态代码块！
    构造方法！
    构造方法！

6.9 Arrays类

是一个与数组相关的类，实现数组的常见操作；

导包：import java.util.Arrays;

1：将参数数组变成字符串(toString)

格式：Arrays.toString(数组名称)；

eg:
    int[] str1 = {1,2,3,4,5,6};
    String str2 = Arrays.toString(str1);

2:对数组进行升序排序

不需要新数组接收；

如果是自定义的类型，需要有Comparable或Comparator接口支持；

格式：Arrays.sort(数组名)；

eg:

    int[] str1 = {1,2,3,4,5,6};	
    Arrays.sort(str1);

    String[] str3 = {"sdfa","argr","AWDA"};
    Arrays.sort(str3);

6.10 Math类

导包：import java.util.Math;

1：绝对值

格式：Math.abs(数)；

2：向上取整

格式：Math.ceil(数)；

3：想下取整

格式：Math.floor(数)；

4：四舍五入

格式：Math.round(数)；

5:PI的值

及其的精确

格式：格式：Math.PI；

6.11 继承性

##注意##

1：当父类写了无参构造方法之后，子类就可以不用再写，直接写有参构造方法就可以了；

2：在子类中给父类传参时可以使用super关键字：eg：super（参数1，参数2…）

3：super(…)是将参数传到父类的有参构造方法中，而不是传到父类中成员变量，如果不在父类中写有参构造方法则使用这条语句会报错。

eg:

public class super11 {			//父类
    int age;
    public super11(int age) {
        this.age = age;
    }
}
public class super11_Son extends super11{		//子类
    public super11_Son(int age) {
        super(age);			//核心步骤-->>作用是将参数传到父类的有参构造方法中，而不是传到成员变量//
    }

    public static void main(String[] args) {		//主方法
        super11_Son str = new super11_Son(10);
    }
}

1：主要解决的问题是：共性抽取；

系统默认添加：Extand import java.lang Object；

2：类别

父类（基类，超类），子类（派生类）

父类：拥有子类共同的内容；

子类：拥有父类的内容，也拥有自己特有的内容；

3：格式：

父类的格式：(普通类的定义)

public class 父类名称{

…

}

子类的格式：

public class 子类名称 extends 父类名称{

…

}

###：定义了子类，则父类的内容会自动的传递给子类，之后可以通过调用子类就可以输出父类的内容；

4：特点：

<1：父类只能找到自己的内容看不到子类的内容；

<2：子类既能看到自己的内容也能看到父类的内容；

❤️：如果子类和父类有重复的成员变量，则调用时 / 如果成员方法重复则满足第一条：

<<1：直接调用：左边等于谁，就调用谁；没有往上找；

<<2：间接调用：在子类和父类中各自创建引用的方法，在之后调用方法就好；

<4：在子类的一个方法中如果要调用父类中的一个重复变量，则可以使用super关键字；

在子类的一个方法中如果要调用本子类中的一个重复变量，则可以使用this关键字；

eg:

        int num = 200;
        public void method(){
            int num = 30;
            System.out.println(num);//30
            System.out.println(this.num);//200
            System.out.println(super.num);//父类100
        }

5：重写

只有成员方法才能进行覆盖重写，而成员变量不行；

重写：方法的名称一样，参数列表【也一样】；又称：覆盖，覆写；

重载：方法的名称一样，参数类别【不一样】；

检测是否为方法重写，在方法的前边加一行**“ @Override ”**,来进行重写检测；

重写主要是父类和子类的方法重写；

<1：子类方法的返回值必须【小于等于】父类方法的返回值范围；

Object是所有类的公共最高父类，是在继承关系的顶端；String是Object的子类；

eg；

public class fu1 {			//父类
    public Object method(){
        return null;
    }
}

public class zi1 extends fu1 {		//子类
    public String method(){		//这里的String要比比Object小，要么等于
        return null;
    }
}

<2：子类方法的权限必须【大于等于】父类方法的权限修饰符；

权限修饰符的大小关系：public > protected > (default) > private;

重写用途：如果一个已经投入使用的类，要修改一些里边的内容，不需要再源代码上进行修改，而是重新定义一个新的子类，利用重写，利用共性内容，添加改动内容；

eg；

public class fu1 {		//父类
    public void method(){
        System.out.println("打电话！");
    }
    public void send(){
        System.out.println("发短信！");
    }
    public void show(){
        System.out.println("显示号码！");
    }
}

public class zi1 extends fu1 {		//子类
    @Override
    public void show() {
        super.show();
        System.out.println("显示姓名！");
        System.out.println("显示头像！");
    }
}

public class zhu1 {
    public static void main(String[] args) {		//主方法
        fu1 str = new fu1();
        str.method();
        str.send();
        str.show();
        System.out.println("===========");
        zi1 str1 = new zi1();
        str1.method();
        str1.send();
        str1.show();
    }
}

6：构造方法的访问特点

1：当一个子类和父类都有构造方法时，在主方法中如果new一个子类对象，则输出时，先输出父类构造方法再输出子类构造方法；因为在子类中有一个默认的隐含的**“super( )”**调用，所以是先调用父类再执行子类构造；

2：只有在子类的构造方法中才能调用父类的构造方法；

3：【重点】在子类的构造方法中**super( )语句的含义就是调用父类的构造方法，必须放在第一行；如果在父类中有出现构造方法的重载，则则通过给super( )**括号里放对应的参数来进行调用父类重载的构造方法；

####：**super( )**只能放在首行，如果不写，则系统会自动添加；

7：super关键字的三种用法：

1：在子类的成员方法中访问父类的成员变量；

2：在子类的成员方法中访问父类的成员方法；

3：在子类的构造方法中访问父类的构造方法；

8：this关键字的三种用法：

1：在本类的成员方法中访问本类的成员变量；

2：在本类的成员方法中访问本类的另一个成员方法；

3：在本类的构造方法中访问本类的另一个构造方法；

###注意事项：

《1：this( …) 必须也是在构造方法的第一句，唯一一个，和super(…) 的用法相同；

《2：如果在子类的构造方法中使用了this则就不再产生super；

9：Java语言的继承的特点

1：Java是单继承性的语言：一个子类只能有一个父类，而一个父类可以有多个子类；

2：Java可以是多级继承：一个子类有一个父类，而一个父类可以有它自己的父类，但是有一个最高类Object(是最顶端的类)；

10：抽象

定义在父类之中；

1：格式：

<1：在定义抽象方法时，在方法的返回值类型前加abstract，然后该方法后边不加大括号“{ }”；

<2：在类中，在public后边要加上abstract；

eg：

    public abstract  class str {
        public abstract void eat();     //抽象方法//
    }

2：使用：

<1：不能直接创建new抽象类对象；

<2：必须用一个子类来继承抽象父类；

在执行这个操作时，必须要覆盖重写（又称：实现）：

覆盖重写：在子类中去掉父类中抽象方法的abstract关键字，然后补上方法体的大括号；

eg：

    public class abs2 extends abs1 {
        public void eat(){	//覆盖重写，删掉abstract//
            System.out.println("猫吃鱼！");
        }
    }

❤️：在主方法中调用时，不能使用父类进行调用，只能使用子类进行调用，即父类不能创建对象；

eg：

public class abs3 {
    public static void main(String[] args) {
        abs2 str = new abs2();	//不能通过创建父类对象进行调用//
        str.eat();
    }
}

3：抽象类的注意事项

1：一个抽象类不一定含有抽象方法，只要保证抽象方法所在的类是抽象类就好，没有抽象方法的抽象类也不能直接创建对象；

2：如果抽象的父类中含有构造方法，其主方法中也不能进行父类创建调用，只能通过子类构造方法中的super进行间接调用；

3：在主方法中调用时，父类不能创建对象；

4：如果子类也是抽象，那么再创建一个子类，一直往下继承，直到不是抽象停止，在主方法中调用时抽象的子类也不能进行调用；

5：子类不一定要覆盖重写了父类的所有的抽象方法，这种的其子类就也是抽象；

11：接口

1：本质：

是一种引用类型，最基本的部分是其中的：抽象方法；

2：格式：

定义类的时候不再是class而是变成了interface，但是生成的还是.class文件；

public interface 接口名称{ }

3：引用：

不能直接引用（new）使用接口，只能通过一个实现类来实现接口，并且在接口类中要将所有的抽象方法覆盖重写（快捷键：Alt+Enter）：

所有的抽象方法必须全部重写，不然该实现类就还是一个抽象类；

格式：public class 实现类名称 implements 接口名称{ }； //和定义子类差不多，只不过是将extends变成了impements；

4：注意事项：

4：接口没有构造方法；

5：接口没有静态代码块；

6：一个类只有一个父类，但是可以有多个接口；

要在一个实现类中实现多个接口则只要在implements后将各个接口用逗号隔开就好了；

eg：

		public class static2 implements static1,static3,static3 {  }

5：总结：

接口的使用和子类和父类带抽象的样式差不多，但是，就是子类引用父类的关键字不同，其它的基本一样；

6：接口抽象方法

1：接口当中的抽象方法，修饰符必须是两个固定的关键字：public abstract；

2：这两个关键字可以省略，因为系统会默认添加；

eg：四种全部都是抽象方法；

        public abstract void method();
        void method1();
        public void method2();
        abstract void method3();

3：只要有一个抽象方法没有被覆盖重写，那么这个引用类就是抽象类；

4：如果有多个接口的抽象方法是一样的，则在实现类中覆盖重写时，只需要写一遍就好；

7：默认方法（default关键字）

1：使用的地方

当已经定义好了一个接口，之后的引用类也全都重写好了，但是在接口中又重写加了一个抽象方法，这时，如果要改就要把后边的引用方法都要改，很麻烦，所以这里使用默认方法，就可以解决这个问题；

2：使用格式：在接口中，**将以前的定义抽象方法的abstract改成default；**而且这时后边要加入{ }，在{ }里边要将本应该重写的方法加进去；

eg:

本来抽象方法的定义方式：public abstract void method( );

   现在的默认方法的定义方式：
    public default void method4(){
        System.out.println("默认方法！");
    }

3：引用：在主方法中被调用时，虽然在实现类中没有被重写，但是在调用时是可以找到接口中的这个默认方法；

4：覆盖重写：

《1：一般不需要在实现类中覆盖重写，但是要重写也可以；

《2：如果在多个接口中出现冲突的默认方法，则在实现类中必须覆盖重写；

《3：多个父接口的默认方法如果重复，则子接口必须进行默认方法的覆盖重写【且必须对default关键字】；

5：注意事项：

《1：接口与接口中默认方法冲突：进行覆盖重写；

《1：接口与父类中默认方法冲突，首先调用父类；

8：私有方法（java9以上）

1：使用的目的：

是为了解决在多个方法中有重复代码的问题，将这些代码提取出来成一个单独的方法，让这个方法，只被这些默认方法使用，不被实现类去使用，也就是私有化；

2：类别：

《1：普通私有方法

解决默认方法的代码重复问题：private 返回值类型方法名称（参数）{ }

《2：静态私有方法

解决静态方法的代码重复问题：private static 返回值类型方法名称（参数）{ }

9：static接口静态方法

接口没有静态代码块；

1：定义格式：

public static void method( ); //将abstract 变成static//

2：调用（注意注意）：

不能通过实现类去调用，要通过接口直接去调用，这也是一个和普通类不同之处；

10：接口成员变量、常量

成员变量定义时必须添加：public static final 这三个关键字（这三个关键字可以省略），因为有final 所以相当于定义了成员常量，不可改变；

定义该名称时，推荐用大写，下划线进行定义；

必须进行赋值，因为这里不会自动赋值；

格式：public static final 数据类型常量名称 = 数据值；

eg：

    public static final int NUM_1 = 10;
    public static final int NUM_2 = 11;
    public static final int NUM_3 = 12;
    public static final int NUM_4 = 13;

使用：直接在主方法中，用接口进行调用；

11：小结

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4QonqG5f-1650611326790)(C:\Users\MAYILIANG\AppData\Roaming\Typora\typora-user-images\image-20200731095352373.png)]

12：接口的多继承性

1：一个父接口可以有多个子接口，(这里的父接口不是父类)

2：这其中也是用extends进行连接成父子关系；

3：多个父接口的抽象方法如果重复，则没关系；

4：多个父接口的默认方法如果重复，则子接口必须进行默认方法的覆盖重写【且必须写default关键字】；//默认方法一般不进行覆盖重写//

6.12 多态

1：特点：

一个对象既具有父类的特征又具有子类的特征，则称为多态；

2：格式：

1：父类名称对象名 = new 子类名称( ) ； //将左侧父类的引用指向右侧子类的对象//

2：接口名称对象名 = new 实现类名称( )；

3：执行：

1：成员方法：

主方法中看new的是谁，先执行谁；

编译看左边(执行的时候看左边的有没有，没有会报错)，运行看右边(编译完没有报错则开始执行右边)；

2：成员变量：

编译，运行都看左边；

1：直接通过对象名称访问成员变量：看等号左边是谁，就优先用谁，没有则往上找；

2：间接通过成员方法访问成员变量：看方法属于谁，则优先用谁，没有则往上找；

4：好处以及具体结构

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eRtPQO12-1650611326791)(C:\Users\MAYILIANG\AppData\Roaming\Typora\typora-user-images\image-20200731154251457.png)]

5：转型

1：对象的向上转型

1：建立在抽象的父子类关系基础之上；

2：父类引用指向子类；

3：就是将子类看成父类调用；将小范围变成大范围；

4：一旦子类转型为父类，则子类特有的方法就不能再被调用；

5：如果子类中重写了父类中的某个成员方法，则向上转型之后，还是调用子类的成员方法；------>特殊情况

6：如果向上转型之后，想要调用子类中的方法则需要将父类返回成它本来的子类再调用；

7：向上转型之后，要返回一定要对号入座，以前是什么，就返回成什么；

8：格式：父类名称对象名 = new 子类名称；

2：对象的向下转型

1：子类引用指向父类；

2：相当于一个还原的过程，将原本的父类对象还原成为本来的子类对象；

3：格式：子类名称对象名 = （子类名称）父类对象名称；

4：转型时，要看之前的向上转型的是谁，向下转型时不要搞错了，如果写错当时不会报错，只会执行时才显示以下错误(ClassCastExceotion)；

3：二者的具体结构

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-og1BqmA0-1650611326792)(C:\Users\MAYILIANG\AppData\Roaming\Typora\typora-user-images\image-20200731155803416.png)]

4：instanceof关键字

用来判断父类是不是对应的子类；

###：注意：如果使用 instanceof 关键字用于判断向上转型后的对象与父类，则其也是返回true；

###：就是看向上转型之后的对象到底是属于以前的那个子类？

子类的实例对象同时也是父类的实例对象；但反过来，由父类的构造方法创建的实例对象一般不是子类的实例对象

向下转型最好进行instanceof判断；

格式：对象 instanceof 类名称；（常常与if语句连用，会返回boolean值）

eg:

    if(usb instanceof monse){
        monse monse1 = (monse) usb;//向下转型
        monse1.type();//使用特有的方法
    }
    else if(usb instanceof keyboard){
        keyboard keyboard1 = (keyboard) usb;//向下转型
        keyboard1.type();//使用特有的方法
    }

6.13 final关键字

1：修饰一个类

格式：public final class 类名称{ }

含义：这个类不能有任何子类，但是有父类；

注意：final类，其中的所有方法都不能覆盖重写，因为没有子类；

2：修饰成员方法

含义：方法就是一个最终方法，不能进行覆盖重写；

格式：public final 返回值类型方法名称（）{ }

注意事项：abstract 关键字和 final 关键字不能同时出现使用；

3：修饰一个局部变量

格式：final 数据类型 = 数值；

含义：

1：引用类型：变量的地址值不能改变，但是内容可以改变；

eg；

//不加final
        finalclass stu1 = new finalclass("小马");
        System.out.println(stu1.getName());
        stu1 = new finalclass("马良");	//地址值发生改变，
        System.out.println("===================");
//加final
        final finalclass stu2 = new finalclass("马怡良");
//      stu2 = new finalclass("良良");        错误写法，地址值发生了改变
        stu2.setName("良良");		//地址值不变，只是内容变化，是可以的//
        System.out.println(stu2.getName());

2：基本类型：变量的数值不会改变；

eg：

		final int a = 3;
//      a = 4;	//不能再次赋值

4：修饰成员变量

1：因为成员变量具有默认值，所以使用之后必须手动赋值，不然会将第一次赋值给了默认值；

2：final成员变量，要么使用直接赋值，要么通过构造方法进行赋值；

3：如果给一个private final变量已经进行了赋值，那么set，get时就不能再写set(因为set是用来给构造方法赋值的，所以final成员变量赋过值后，在进行赋值会报错)；

4：如果是通过构造方法进行赋值，那么对构造方法的重载中，必须要保证对final成员变量进行赋值；

6.14 权限修饰符

1：修饰符总表

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rGByjiEa-1650611326793)(C:\Users\MAYILIANG\AppData\Roaming\Typora\typora-user-images\image-20200802094516965.png)]

###：default表示不写修饰符；

2：protected修饰符

1：保护访问控制符 protected：用 protected 修饰的成员变量可以被三种类所引用：①该类自身；②同一个包中的其它类；③其它包中的子类。

2：使用修饰符 protected 的主要作用是允许其它包中的子类来访问父类的特定属性。

3：最主要的作用还是来让子类来进行调用的，但是调用时不能通过父类来直接调用，只能通过继承(this/super)关键字来调用；

eg:

public class Animal{
    protected String name;
    public int age;
}
// 不同包的子类
public class Cat extends Animal{
    public void print(){
        /*********通过父类直接访问*********/
        Animal a = new Animal();
        System.out.println(a.name);   //不允许
        System.out.println(a.age);   //允许
        /*********通过继承访问*********/
        System.out.println(this.name);   //允许
        System.out.println(this.age);   //允许
    }
}

6.15 内部类

#：权限修饰符：

1：外部类：public / (default)

2：成员内部类：public / (default)在同一个包下使用 / default / private

3：局部内部类：都不能写，直接class

1：成员内部类

<1：格式

修饰符 class 外部类名称{

修饰符 class 内部类名称{

…

}

…

}

<2：使用

1：在类中调用：内用外，任意访问；外用内，需要new一个内部对象；

eg:

    public class inclass1 {
        public class baby{
            public void method1(){
                System.out.println("内部类方法！");
                setName("小马");
                System.out.println("我叫"+name+";");
            }
        }
        private String name;
        public String getName() {
            return name;
        }

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

        public void method(){
            System.out.println("外部类方法！");
        }

    }

2：在内部类的一个方法中如果和外部类出现重名的情况：

<1>：如果内部方法调用内部重名变量：则通过this关键字进行调用；

<2>：如果内部方法调用外部重名变量：则通过格式：（外部类名称 . this . 变量名称）调用；

eg：

public class inclassname1 {			//外部类
    int num=10;
    public class inclass {			//内部类
        int num =20;
        public void num1(){			//内部类方法
            int num = 30;
            System.out.println(num);
            System.out.println(this.num);
            System.out.println(inclassname1.this.num);
        }
    }
}

3：在主方法中：

如果要调用一个内部类格式为：

外部类名称 . 内部类名称对象名 = new 外部类名称（）. new 内部类名称（）；

eg：

public class inclassname2 {
    public static void main(String[] args) {
        inclassname1.inclass obj = new inclassname1().new inclass();
        obj.num1();		//num1是内部类的一个方法//
    }
}

2：局部内部类

<1：定义

如果一个内部类是定义在一个方法的内部，那么这就是一个局部内部类；

只有在当前所属的这个方法中才能使用，出了这个方法就不能使用，在主方法也不能调用；

<2：格式

修饰符 class 外部类名称{

修饰符返回值类型外部类方法名称（参数列表）{ //定义方法

class 局部内部类名称{

…

}

eg:

public class inclass3 {
    public void method1(){      //外部类方法
        class inclass{          //局部内部类
            int num = 10;
            public void method2(){      //局部内部类方法
                System.out.println(this.num);
            }
        }
        inclass intn = new inclass();   //外部类方法调用局部内部类
        intn.method2();
        System.out.println(intn.num);   //外部类方法调用局部内部类方法
    }
}

❤️：使用

1：在主方法中如果要调用，直接调用外部类方法就好，不能直接调用局部内部类；

2：如果在一个局部内部类中调用一个外部类方法的一个局部变量：

则一定要保证该方法的局部变量必须是【有效的final】，即不能改变，java8之前要必须写final关键字，现在只要保证不变就好；

eg:

public class inclass3 {
    public void method1(){      //外部类方法
        final int num1 =10;		//外部类方法中的局部变量
        class inclass{          //局部内部类
            int num = 10;
            public void method2(){      //局部内部类方法
                System.out.println(this.num);	//在局部内部类方法中调用局部内部类中的变量
            	System.out.println(num1);	//在局部内部类方法中调用外部类方法中的变量
            }
        }
    }
}

<4：匿名内部类

1：使用范围

如果接口的实现类（或者是父类的子类）只需要使用唯一一次，这种情况下可以省略该实现类（或者子类）的定义，使用【匿名内部类】；

2：格式

接口名称对象名 = new 接口名称（）{

//---覆盖重写抽象方法----//

};

eg:

public class inclass7 {
    public static void main(String[] args) {
//        inclass6 obj = new inclass6();	//正常写法
//        obj.method();
        inclass5 obj = new inclass5() {     //匿名内部类写法//
            @Override
            public void method() {
                System.out.println("匿名内部类实现方法！");
            }
        };
        obj.method();	//调用匿名内部类的方法//
    }
}

3：特点

<1：匿名内部类，在【创建对象的时候】只能使用唯一的一次；

<2：匿名对象，在【调用方法】的时候只能使用唯一的一次；

❤️：匿名内部类是省略了【实现类和子类】；

匿名对象是省略了【对象名称】；

6.16 类作为成员变量使用

String在java中也是一个单独的类。所以说平时使用String就是将一个类做为一个成员变量来使用；

调用是要对这个类单独的new一个对象，之后就可以通过把这个类当成变量去使用它的类中的内容；

eg:

//被当成成员变量的类//
public class classmethod {
    private String code;
    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }
}

//在该类中将类作为一个成员变量//
public class use1 {
    private String name;
    private int age;
    private classmethod classmethod;
    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;
    }

    public day20.classmethod getClassmethod() {
        return classmethod;
    }

    public void setClassmethod(day20.classmethod classmethod) {
        this.classmethod = classmethod;
    }
}

//主方法//
public class main1 {
    public static void main(String[] args) {
        use1 hero = new use1();
        hero.setAge(20);
        hero.setName("小马");
        classmethod weapen = new classmethod();		//调用时需药重新new对象//
        weapen.setCode("噗！");
    }
}

6.17 接口也可以作为成员变量

6.18 object类中的toString方法

重写一个类toString方法可以打印出这个类的属性，如果这个类的toString没有被重写，则如果输出会输出这个类的地址值，不会输出这个类的属性；

**默认打印的是地址值，所以要给它进行重写；**

eg:

public class person  {
    public String name;
    public int age;
    //在这重写toString方法，可以使用快捷键，fn + alt + insert//
    @Override
    public String toString() {
        return "person{" + "name='" + name + '\'' + ", age=" + age + '}';
    }

   //笔记省略了get，set//
}

public class objectmain {
    public static void main(String[] args) {
        person p = new person("小马",20);
        String s = p.toString();
        System.out.println(s);
        System.out.println(p);
    }
}

输出： person{name=‘小马’, age=20}
person{name=‘小马’, age=20}

6.19 object类中的equals方法

1：用于比较两个对象的地址值，返回一个布尔类型的数据；因为这是在object类下的一个方法，所以比较的对象要来自于一个object这个根目录的类。

eg；

public class objectmain1 {
    public static void main(String[] args) {
        person p1 = new person("小马",20);
        person p2 = new person("小马",20);
        boolean b = p1.equals(p2);	//比较的是地址值//
        System.out.println(b);
        p1 = p2;
        boolean b1 = p1.equals(p2);
        System.out.println(b1);
    }
}

输出： false
true

2：也可以通过重写进行让他进行对成员变量的属性比较；

eg:

import java.util.Objects;

public class person  {
    public String name;
    public int age;
    //手动重写
//    //重写equals方法，让它比较属性//
//    @Override
//    public boolean equals(Object obj) {
//        //比较两个对象的属性一个是this(p1)的,另一个是obj的//
//        //判断一下obj是不是person类型//
//        if(obj instanceof person){
//            //向下转型，将obj转成person类型//
//            person p = (person)obj;     //确保类型一致，因为equals是一个进行地址比较的关键字，这里是给他要赋予一个新的功能去比较属性，所以需要他们的类型一致//
//            boolean b = this.name.equals(p.name) && this.age==p.age;    //将属性进行比较//
//            return b;
//        }
//        //完善一下其他的情况，让效率更高//
//        if(obj == null){
//            return false;
//        }
//        if(obj == this){
//            return true;
//        }
//        return false;
//    }

//快捷键进行重写fn+alt+insert//
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        person person = (person) o;
        return age == person.age &&
                Objects.equals(name, person.name);
    }
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
	//笔记中省略了set，get//
}

public class objectmain1 {
    public static void main(String[] args) {
        person p1 = new person("小马",20);
        person p2 = new person("小马",20);
        boolean b = p1.equals(p2);  //重写之后就可以比较两个对象的属性//
        System.out.println(b);
        p1 = p2;
        boolean b1 = p1.equals(p2);
        System.out.println(b1);
        ArrayList<String> list = new ArrayList<>();
        boolean b2 = p1.equals(list);
        System.out.println(b2);
    }
}

6.20 objects类中的equals方法

与object中的equals方法的区别是，objects可以容忍空指针异常，具体如下：

1：object：如果重写之后，判断时如果一个是null，一个是非空，的则它会报错；

2：objects：如果重写之后，判断时如果一个是null，一个是非空，则会判断他们的地址值，如果同时都不是null则会继续判断他们的属性。

6.21 泛型类

传入的参数只能是引用数据类型,不能是基本数据类型;

完整的泛型类的定义和引用:

public class Protect1<T>{
    T m;
    //以下的部分就相当于是进行构造器的定义,以及对成员变量的get,set操作//
    Protect1(T t){
        m = t;
    }
    public T getM(){
        return m;
    }
    public void print(){
        System.out.println("base print:"+m);
    }

    public static void main(String[] args) {
        Protect1<String> base = new Protect1<String>("base class is general");
        //貌似用set传不进去参数,不知道为什么,还要试试//
        System.out.println(base.getM());
    }
}

6.22 DATE 类

导包：Java.util

一：普通使用方法

主要作用：用于表示日期和时间的类，精确到毫秒，千分之一秒；

毫秒值的作用：可以进行日期之间的转换，将日期化成毫秒计算之后再转化成日期；

具体使用：要先定义一个时间原点（0毫秒）：XXXX 年 X 月 X 日 00:00:00【这个不是中国时间，是英国时间】中国时间要加8小时；

使用1：将当前时间转化成毫秒值

使用System.currentTimeMillis();语句进行将当前时间与时间原点计算看经历了多少毫秒。

public static void main(String[] args) {
    System.out.println(System.currentTimeMillis());//将当前时间计算到时间原点的毫秒值//
    Long i = System.currentTimeMillis();
    System.out.println(i);
}

使用2：打印当前时间

Date date = new Date();
System.out.println(date);

使用3：传入一个毫秒值，计算时间

Date date = new Date(135461661);
System.out.println(date);

使用4：将日期转化成毫秒值

Date date3 = new Date();
long time = date3.getTime();
System.out.println(time);

二：文本格式化

使用DateFormat方法，存放在Java.text类中；

1：作用：

1：格式化（日期 -> 文本）；

2：解析（文本 -> 日期）；

2：使用方法：

1：String format(Date date) 按照指定的模式，把Date日期，格式化为符号模式的字符串。

2：Date parse(String source) 把符号模式的字符串解析成Date日期。

3：DateForma具体Format使用：

因为DateForma是一个抽象类，不能直接创建对象使用，所以可以使用其子类。

eg: Java.text.SimpleDateForma extends DateFormat

构造方法：SimpleDateForma这个是它自己是固定的。

SimpleDateForma(String pattern)

用指定的模式和默认语言环境的日期格式符号进行构造。

参数：String pattern : 传递指定的模式；

区分大小写，不同的字母代表不同的大小写；

日常使用表示符号：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WAEWe5sg-1650611326794)(C:\Users\MAYILIANG\AppData\Roaming\Typora\typora-user-images\image-20200926150227797.png)]

全部表示符号：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4UWuUgbs-1650611326794)(C:\Users\MAYILIANG\AppData\Roaming\Typora\typora-user-images\image-20200926150106118.png)]

具体书写格式：“yyyy-MM-dd HH:mm:ss"

##：字母不能改变，但是之间的连接符号可以改变；

eg；
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class date1 {
    public static void main(String[] args) {
        date11();
    }
    private static void date11(){
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy 年 MM 月 dd 日：HH 时 mm 分 ss 秒 ");
        Date date = new Date();
        String d = sdf.format(date);//进行格式化
        System.out.println(date);//输入系统的默认时间
        System.out.println(d);//输出格式化时间
    }
}

4：DateForma具体parse使用：

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class date1 {
    public static void main(String[] args) throws ParseException  {	//写了一个申请异常,如果给定的格式和要转化的格式不一样，那么就会报错,可以使用ALT + 回车键//
        date22();
    }
    private static void date22() throws ParseException {    //写一个申请异常
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy 年 MM 月 dd 日：HH 时 mm 分 ss 秒 ");
        Date date = sdf.parse("2010 年 12 月 25 日：13 时 25 分 55 秒 ");
        System.out.println(date);

    }
}

5：综合使用

1：使用两种方法的整体代码：

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class date1 {
    public static void main(String[] args) throws ParseException {
        //1
        System.out.println(System.currentTimeMillis());//将当前时间计算到时间原点的毫秒值//
        Long i = System.currentTimeMillis();
        System.out.println(i);
        //2
        Date date1 = new Date();
        System.out.println(date1);
        //3
        Date date2 = new Date(1601281936);
        System.out.println(date2);
        //4
        Date date3 = new Date();
        long time = date3.getTime();
        System.out.println(time);
        //5
//        date11();
        date22();
    }
    private static void date11() {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy 年 MM 月 dd 日：HH 时 mm 分 ss 秒 ");
        Date date = new Date();
        String d = sdf.format(date);//进行格式化
        System.out.println(date);
        System.out.println(d);
    }
    private static void date22() throws ParseException {    //申请异常
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy 年 MM 月 dd 日：HH 时 mm 分 ss 秒 ");
        Date date = sdf.parse("2010 年 12 月 25 日：13 时 25 分 55 秒 ");
        System.out.println(date);
    }
}

2：计算你出生的天数：

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

public class date1 {
    public static void main(String[] args) throws ParseException {
        Scanner str = new Scanner(System.in);
        System.out.println("请输入你的出生日期：(yyyy-MM-dd)");
        String birthday = str.next();
        //解析日期
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd ");
        Date birthdayDate = sdf.parse(birthday);//传入字符串，对其进行解析
        //传入解析后的时间，然后转化成毫秒
        long birth = birthdayDate.getTime();
        //读取现在的时间，并且转化为毫秒
        long today = new Date().getTime();
        //用毫秒进行计算
        long time = today - birth;
        //将最终的毫秒结果算成天数
        System.out.println(time/1000/60/60/24);
    }
}

6.23 calendar类

Calendar time = Calendar.getInstance(); //用多态的方式给它进行父类的调用//
System.out.println(time);

Calender是一个抽象类，用于对日历的一些操作。

1：调用具体的日历

#：通过使用调用子类getInstance()来调用具体的日历

前边必须要调用Calendar类中的子类getInstance( )类

eg: Calendar c = Calendar.getInstance();

格式：接受类型变量名称 = 对象 . get(Calendar . 具体的作用)；

天是DATE，不是DAY；

//通过使用调用子类getInstance()来调用具体的日历//
private static void demo1(){
    Calendar c = Calendar.getInstance();
    int year = c.get(Calendar.YEAR);
    System.out.println(year);
    int month = c.get(Calendar.MONTH);//西方月份是1~11//
    System.out.println(month);
    int day = c.get(Calendar.DAY_OF_MONTH);//月中某一天
    System.out.println(day);
    int day1 = c.get(Calendar.DAY_OF_WEEK);//周中某一天
    System.out.println(day1);
    int day2 = c.get(Calendar.DATE);//具体的天
    System.out.println(day2);
}

2：设置日期

也是先要进行调用Calendar类中的子类getInstance( )类

然后同过set进行修改；

格式：对象名 . set(Calender . 修改的类型 , 具体数值 )

//设置日期
private static void demo2(){
     	Calendar c = Calendar.getInstance();
        c.set(Calendar.YEAR,2000);
        c.set(Calendar.MONTH,6);
        c.set(Calendar.DAY_OF_MONTH,10);
        c.set(Calendar.DATE,5);
        c.set(1111,5,6);//直接修改年月日，相当于一个重载方法
        System.out.println(c.get(Calendar.YEAR));
        System.out.println(c.get(Calendar.MONTH));
        System.out.println(c.get(Calendar.DAY_OF_WEEK));
        System.out.println(c.get(Calendar.DATE));
}

6.24 System类

在java.lang.System包中，里边全是静态方法，可以获取与系统相关的信息或系统级操作；

常用方法：

1：获取当前时间的毫秒值（因为是静态方法直接可以通过类名来调用）：

long s = System.currentTimeMillis();

eg:

public class System1 {
    public static void main(String[] args) {
        demo1();
    }
    //计算for循环打印1-9999多需要的时间//
    private static void demo1(){
        //程序执行前获取一次毫秒值//
        long s = System.currentTimeMillis();
        for (int i =1; i < 9999; i++){
            System.out.println(i);
        }
        //程序结束获取一次毫秒值//
        long e = System.currentTimeMillis();
        System.out.println("程序共耗时："+(e-s)+"毫秒");
    }
}

2：使用Arrayscope进行字符串的指定位置拷贝：

格式：System.arraycope(原字符串的名称，起始位置，目标字符串的名称，起始位置，拷贝元素个数)；

-------> System.arraycopy(src,0,dest,0,3);

eg:

//将一个数组的前三个元素复制到另一个数组的前三个元素//
private static void demo2(){
    //定义原数组
    int[] src = {1,2,3,4,5};
    //定义目标数组
    int[] dest = {6,7,8,9,10};
    System.out.println("复制前："+ Arrays.toString(dest));
    //使用arraycopy把原数组的前三个元素复制到目标数组的前3个位置//
    System.arraycopy(src,0,dest,0,3);
    System.out.println("复制后："+ Arrays.toString(dest));
}

6.25 包装类

1：包装类的概念

基本数据类型，使用很方便但是没有对应的方法来操作这些基本类型的数据，所以可以使用一个类，把基本的数据类型给包装起来，在类中定义一些方法，这种类叫做包装类，因此可以使用这些方法来操作这些基本类型的数据；

2：基本类型对应的包装类：

基本类型包装类（java.lang）

byte： Byte；

shout： Short；

int： Integar；

long： Long；

float： Float；

double Double；

char： Character；

boolean： Boolean；

6.26 并发并行

并发：两个或多个时间在同一时间段内发生，交替执行

并行：两个或多个早同一时间同时发生，同时进行

第七章 Maven工具

是一款项目构建和管理工具；

1：默认的各功能文件类型：

Src/main/java-------------------java代码

Src/main/resources----------资源代码（属性文件，HTML5 文件，javascript…）

Src/test/java------------------对 java/main/src 中的代码进行测试的测试代码

Src/test/resources---------放测试用的资源代码

2：项目对象模型(POM)

通过（pom.xml）来进行项目的配置管理；

3：构建自动化 ----> 所执行的操作：生命周期，编译，测试，打包，部署；

4：特点：约定大于配置

5：创建Maven文件：·

1>：Maven有很多插件，插件名格式：maven-名称-plugin.jar

2>：用来创建Mavenue项目的插件是：maven-archetyle-plugin.jar

3>：每一个插件都有一个唯一的坐标；

groupId(开发的公司) ， artifactId(具体的项目下的分支名) ，version(版本) 这3个为项目的坐标；

4>：Maven本地仓库位置

数据结构：青岛大学——王卓

过使用调用子类getInstance()来调用具体的日历//
private static void demo1(){
Calendar c = Calendar.getInstance();
int year = c.get(Calendar.YEAR);
System.out.println(year);
int month = c.get(Calendar.MONTH);//西方月份是1~11//
System.out.println(month);
int day = c.get(Calendar.DAY_OF_MONTH);//月中某一天
System.out.println(day);
int day1 = c.get(Calendar.DAY_OF_WEEK);//周中某一天
System.out.println(day1);
int day2 = c.get(Calendar.DATE);//具体的天
System.out.println(day2);
}


#### 2：设置日期

也是先要进行调用Calendar类中的子类getInstance( )类

然后同过set进行修改；

		格式：对象名  .  set(Calender . 修改的类型 ,  具体数值 )

```java
//设置日期
private static void demo2(){
     	Calendar c = Calendar.getInstance();
        c.set(Calendar.YEAR,2000);
        c.set(Calendar.MONTH,6);
        c.set(Calendar.DAY_OF_MONTH,10);
        c.set(Calendar.DATE,5);
        c.set(1111,5,6);//直接修改年月日，相当于一个重载方法
        System.out.println(c.get(Calendar.YEAR));
        System.out.println(c.get(Calendar.MONTH));
        System.out.println(c.get(Calendar.DAY_OF_WEEK));
        System.out.println(c.get(Calendar.DATE));
}