目录
1.循环
2.switch多分支选择结构
3.大数值
4.浅拷贝&深拷贝
5.Arrays.sort排序
6.面向对象
7.更改器&访问器
1.循环
for-each循环
在 Java 中，for-each 循环（也称为增强型 for 循环）是一种用于遍历数组或集合（如 List、Set 等）的简洁方式。相比于传统的 for 循环，for-each 循环更加简洁且易于阅读，因为它隐藏了迭代器的复杂性。
int[][] arr3={
{1,2,3,4,5}
{3,3,5}
{4,4,4,4,4,5,6}
}
for(int[] x:arr3){
for(int z: x){
System.out.print(","+z);
}
System.out.println("")
}
2.switch多分支选择结构
其中case标签可以是：
- 类型为char、byte、short或int的常量表达式
- 枚举常量
- 从Java SE7开始，case标签还可以是字符串字面量
int a=10;
String b="3qe"
int c=22;
switch(a){
case 10;
System.out.println("======1")
break;
case "3qe";
System.out.println("======2")
break;
case "mm";
System.out.println("======3")
break;
case 40;
System.out.println("======4")
break;
case 50;
System.out.println("======5")
break;
default:
System.out.println("======6")
break;
}switch击穿？是什么
运行过程中如果没有遇到break，就会一直循环，直到遇到break.才会停止
int a=10;
String b="3qe"
int c=22;
switch(b){
case 10;
System.out.println("======1")
break;
case "aaa";
System.out.println("======2")
break;
case "3qe";
System.out.println("======3")
//break;
case 40;
System.out.println("======4")
//break;
case 50;
System.out.println("======5")
break;
default:
System.out.println("======6")
break;
} 
break&continue
break打断循环，continue跳过循环。
3.大数值
如果基本的整数和浮点数精度不能够满足需求，那么可以使用java.math包中的两个很有用的类：BigInteger和BigDecimal。这两个类可以处理包含任意长度数字序列的数值。
BigInteger类实现了任意精度的整数运算，而BigDecimal则实现了任意精度的浮点数运算。
要使用这些类，你可以通过它们的静态valueOf方法将普通的数值转换为大数值。但遗憾的是，我们不能使用人们熟悉的算术运算符（如加号+和乘号*）直接处理这些大数值。相反，你需要使用大数值类中的add和multiply等方法来进行运算。
BigInteger a = BigInteger.valueOf(100);BigInteger:代表无限大的整数
BigInteger x1=new BigInteger("20000000000000000000");
x1=x1.multiply(x1);
System.out.println(x1);BigDecimal:代表无限大的浮点数
需要引入库java.math.BigInteger
4.浅拷贝&深拷贝
浅拷贝——指向相同
int[] arr4=arr;深拷贝——自己开辟内存，把对方值拷贝一份存在自己的内存
int[] arr5 =new int[arr.length];
for(int i=0;i<arr.length;i++){
arr5[i]=arr[i];
}我们通过一段代码来具体了解一下区别
public static void main(String[] args) {
int[] arr = {1, 2, 3};
int[] arr2 = new int[4]; // 初始化数组arr2，长度为4，Java数组默认元素值为0，与C语言不同
int[] arr3 = new int[]{2, 3, 4, 5};
int x = arr3.length; // 计算数组arr3的长度
int[] arr4 = arr; // 浅拷贝，arr4和arr指向同一个数组
int[] arr5 = new int[arr.length];
for (int i = 0; i < arr.length; i++) {
arr5[i] = arr[i]; // 深拷贝，将arr的值复制到arr5中
}
arr4[1] = 99; // 修改arr4（也即arr）的第二个元素为99
System.out.println(arr[1]); // 打印arr的第二个元素，输出99
int[] arr6 = Arrays.copyOf(arr, 3); // 复制arr的前3个元素到arr6中
arr6[1] = 88; // 修改arr6的第二个元素为88
System.out.println(Arrays.toString(arr6)); // 打印arr6，输出[1, 88, 3]
System.out.println(arr[1]); // 再次打印arr的第二个元素，输出99，因为arr4的修改影响了arr
}
5.Arrays.sort排序
Arrays.sort(arr)
Arrays.sort(arr,(a,b)->a.age-b.age);//按对象的某个属性排序
//排序后倒序输出
Arrays.sort(arr,(a,b)->b-a);
Arrays.sort(arr,Collections.reverseOrder());这个方法也可以给字符串排序
String[] arr={"abc","acb","bb","wsdf","knm","abddd"};
Arrays.sort(arr);排序规则是按首字母大小排序，首字母相同时顺延看后面的字母
binarySearch快速查找
Arrays.binarySearch(arr,8);//快速查找arr数组中8的下标6.面向对象
特征：封装，继承，多态，抽象
一定要认识到： 一个对象变量并没有实际包含一个对象，而仅仅引用一个对象。 在 Java 中，任何对象变量的值都是对存储在另外一个地方的一个对象的引用。new 操作 符的返回值也是一个引用。
首先我们定义一个person类。
System.out.println(x1);本质上是调用x1.toString方法。这输出的是他的类型和内存地址。
Person x1 =new Person(10,177); //Person(age,hight)
System.out.println(x1);
当我们在Person类里重写了toString时，再次调用toString时，就会调用我们自己写的方法。
类名引用的是静态方法，通过对象名调用的是非静态方法。
7.更改器&访问器
在一个类中我们定义如下方法：
public类型可以被其他类随意操作，可读可写。但是private类，不允许被调用。但是我们可以通过写一个public方法方法控制只读，只写。（这就是访问器和更改器）这样的调用比较灵活方便。
那我们再看一个例子，我们为flag3设置一个只读操作。但是这样会暴露flag3的真实地址。是不安全的。
但是getflag2()是安全的！因为flag2是基本类型，它的调用默认就是深拷贝。
我们现在将getFlag3()修改为如下形式。将flag3深拷贝给ss。
public int[] getFlag3(){
int[] ss =new int[flag3.length];
for(int k=0;k<ss.length;k++){
ss[k]=flag3[k];
}
return ss;
}这样，访问器里面必须是深拷贝。这样才能保证安全。
再注意！！！！！！！getFlag4()方法也是安全的。因为字符串是不可变的！
