1.Math.random
Math.random()*10 输出随机变量方法，使用:"Math.random()*数量"
如:(int)(Math.random()*10); //随机取一个10以内的整数
例如：定义一个随机1到5(取不到5)的变量 [1,5)
Math.random()*(n-m)+m，生成大于等于m小于n的随机数；
int number=(int)(Math.random()(5-1)+1)； int number = (int)(Math.random()4+1)；取值正好是[1,5)
2.length
length() 方法用于返回字符串的长度。
1 //例
2 public class Test {
3 public static void main(String args[]) {
4 String Str1 = new String("www.runoob.com");
5 String Str2 = new String("runoob" );
6
7 System.out.print("字符串 Str1 长度 :");
8 System.out.println(Str1.length());
9 System.out.print("字符串 Str2 长度 :");
10 System.out.println(Str2.length());
11 }
12 }
13 //随机输入一个100以内数组
14 int[] arr=new int[10];
15 for(int i=0;i<arr.length;i++){
16 int value= (int)Math.random()*100;
17 arr[i]=value;
18 }
19 System.out.println(Arrays.toString(arr));
（Scanner/if/equals）
1.equals
使用方法 ''变量1.equals(变量2)” //变量一定要保证有一个具体的数据，排除null值
2.Math.pow
Math.pow(数字,几次幂) 使用:sum=Math.pow(3,2);
3.Math.PI=3.14
4.Sanner
Sanner input = new Scanner(System.in); //需要导包,程序开头加 "import java.util.*";(*可以换成Scanner)
*使用：int 变量 = input.nextInt(); //读一个int netxDouble/Float/Byte/Short() 只能读取空格之前的内容(空格后的数据会保留传给下一个变量)，光标依然在10的后面 String 变量 = input.nextLine(); //读一个字符串 String 变量 = input.next()； //只能读取空格之前的内容(空格后的数据会保留传给下一个变量)
*如果使用netxLine之前有netxDouble/Float/Byte/Short/next()，nextLine只能读到一个换行，不让用户录入数据，使用netLine()或者添加一行"input.nextIine();"解决
5.boolean嵌套
合理使用boolean嵌套，优化程序
6.debug部分快捷键
debug调试:双击添加断点，F6:逐行运行程序，F5:进入底层代码，F8:运行到下一个断点
*input.close()//关闭该变量，会关闭该程序所有的该变量
＞简单登入系统？？
1 while("n".equals(answer)) {
2 System.out.println("输入账号");
3 answer = input.nextLine();
4 }
5 if("y".equals(answer)) {
6 System.out.println("********");
7 }
卫语句
例：
1 if (true){
2 if (true){
3 if (true){
4 for (){
5 if (true){
6 业务代码
7 }
8 }
9 }
10 }
11 }
在有比较复杂的判断和需要遍历处理业务时候，经常会出现上面这种情况，这些代码在执行起来是没问题。但是这样的代码是一次性代码，过一段时间，可能自己都不敢动这里的逻辑了，更何况下一个接盘侠呢。 这样的代码很难弄明白每个条件的作用和执行的流程，当你读到最里面一层的时候，估计你已经记不起来当初是为什么走进这个if的了，对代码的执行流程完全不可控了。因为执行你预期的流程并不明显，为了简化这种情况，需要将特殊情况隔离到立即结束执行的单独条件中。 这样就能把箭头代码给拉平.
if (false){
}
if (false){
}
if (false){
}
for (){
if (false){
continue;
}
业务代码
}
这是其中一类，可以将失败前置。只要有一个条件不通过，就快速返回失败，如果到了最后一行，说明所有判断都通过，剩下的就是你预期的结果。而不是一直查成功。
if（obj != null）{
doSomething();
}
转换成卫语句以后的代码如下：
if(obj == null){
return;
}
doSomething();
（排序/数组）
1.数组
使用:
初始化: 数据类型[] 变量名 = new 数据类型[length]
int[] array = new int[3]; // 空间大小为3的array数组
int[] array = {a,b,c,d,e};
2.Aeeays
2.1Arrays.toString
Arrays：将数组元素转换成字符串进行打印(需要导包)
使用：Arrays.toString(数组名)
数组.length：获得数组长度
二维数组不能直接使用，需要Arrays.deepToString(二维数组[]);
2.2Arrays.copyOf
复制数组元素到新数组
int[] newArray = Arrays.copyOf(源数组，新数组的长度)；
2.3Array.equals
比较数组元素是否一致
例：System.out.println(Arrays.equals(arr1,arr2));
*数组间不能以"=="或者"equals"直接比较，这样比较的是数组的地址
5.增强for循环
foreach：for(数组元素数据类型 变量：数组变量名称)
将数组里面的每个元素赋值给变量，不能索引具体元素
6.冒泡法
1 for(int i=1;len = arrlength;i<len;i++){
2 for(int j=0;j<len-i;j++){
3 //相邻元素互相比较
4 if(arr[j]>arr[j+1]){
5 //交换位置
6 int temp = arr[j];
7 arr[j] = arr[j+1];
8 arr[j+1] = temp;
9 }
10 }
11 }
12
7.选择排序
1 for(int i=0,len = arr.length;i<;en-1;i++){
2 int min = arr[i];
3 int minIndex = i;
4 for(int j=i+1;j<len;j++){
5 if(min>arr[j]){
6 min = arr[j];
7 minIndex = j;
8 }
9 }
10 }
11
8.插入排序（升/降）
1 for(int i=1,len = arr.length;i<len;i++){
2 int temp = arr[i];
3 int leftIndex = i-1;
4 while(leftIndex>=0 && arr[leftIndex]>temp){
5 arr[leftIndex+1] = arr[leftIndex];//左边元素要移动，大数向右
6 leftIndex--;
7 }
8 arr[leftIndex+1] = temp;
9 }
10 倒叙
11 for(int i=1;i<arr1.length;i++) {
12 int space = arr1[i];// 取第二个数
13 int left = i-1;//=指向第一个数
14 while(left>=0 && arr1[left]<space) {
15 arr1[left+1] = arr1[left];// 小数向右移
16 left--;// 找回指向空格的索引
17 }
18 arr1[left+1] = space; //填空
19 }
9.Arrays.sort(数组变量); //升序
使用：
int[] a = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5}; Arrays.sort(a);
9.1Arrays.sort区间排序
Arrays.sort(int[] a, int fromIndex, int toIndex)
这种形式是对数组部分排序，也就是对数组a的下标从fromIndex到 toIndex-1的元素排序，注意：下标为toIndex的元素不参与排序。
int[] a = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5};
Arrays.sort(a, 0, 3);
for(int i = 0; i < a.length; i ++) {
System.out.print(a[i] + " ");
方法
1.方法
1.1访问权限修饰符：public/private/protectde/默认
1.2普通修饰符(关键字) : static/final/abstract
1.3返回值类型
有返回值类型 所有数据类型
无返回值 void
1.4方法名（驼峰）：唯一的，不可重复的
1.5（形式参数）：任意数据类型，有返回参数必须return相同类型返回值
1.6 {方法体}
2.调用方法：
静态方法和c一样。
仅适用于数组：有参无返回值调用是直接调用地址，被调用变量的最终结果可能会被其他方法改变。（具体调用是否改变可见源码是否调用地址）
2.1 有多个参数（附卫语句例/登入）：
1 public static void userLogin(String usename,String password){
2 String name = "admin";
3 String pass = "admin";
4
5 //校验username与password
6 if(username==null || password==null){
7 System.out.println("参数不允许为null");
8 return；
9 }
10
11 if(!neme.equals(username) || !pass.equals(password)){
12 System.out.println("用户名或密码不对");
13 }
14
15 System.out.println("登陆成功");
16 System.out.println("执行成功之后的代码。。。。。");
17 }
2.2可变参数：
1 test（）;
2
3 //可变参数->同一种数据类型 例:数据类型...变量名
4 //nums 是可变参数 >=0个实际参数 实际为一个数组
5 public static void test(int...nums){
6 System.out.println(nums[0]);
7 System.out.println(nums[1]);
8 System.out.println("nums:"+Arrays.toString(nums));
9 }
2.3 方法重载 overload
在一个类(java文件)，可以存在多个方法名一样的方法。
-
方法名相同
-
形参的顺序(形参列表不一致)
-
与返回值和修饰符无关
(类与对象)
1.不同方法调用同一个成员变量？
创建成员属性
2.无参&有参构造方法
快捷键：alt+shift+s+c（生产无参构造）
例：调用带参/无参构造方法
成员变量 = 全局变量
1 public class Person {
2
3 public int id;
4 public String name;
5
6 //默认的无参构造方法
7 //构造方法与类名一致
8 //[访问权限修饰符] 类名() {}
9
10 //默认存在
11 //1.帮助创建对象
12 //2.初始化成员变量
13 public Person() {
14 // id = 1001;
15 // name = "jim";
16 }
17 //在创建对象的时候就对成员变量赋值 有参构造
18 //方法重载
19 //方法名相同 形参列表不同
20 //与返回值 修饰符无关
21 //构造方法重载
22 public Persion(int pid,String pname){
23 id = pid;
24 name = pname;
25 }
26 }
27 }
28 public class PersonTest {
29 public static void main(String[] args){
30 Person person = new Person();
31 System.out.println("姓名"+person.name);
32 //使用有参构造进行创建对象
33 Person person2 = new Person(1002,"tom");
34 System.out.println("person2姓名："+person2.name);
35 }
36 }
（封装）
1.默认修饰符只能在本包内访问
修饰符为public时可以访问别的包的成员变量
2.private：只能在本类中被调用
setter&getter中不允许添加其他业务逻辑，会增加维护难度
快捷键生成：alt+shift+s+r
3.lombok
3.1.在使用@Setter能否再另外添加别的set方法？
a：可以，手动写的可以覆盖掉注释里的Setter/Getter
3.2.lombok.jar类库文件
通过注解构建一个全功能的文件：@名称
例：@Sette @Getter（生成set/get方法）
@NoArgsConstructor（生成无参构造）
@AllArgsConstructor（生成有参构造）
@ToString
@cleanup(程序运行之后关闭input，不建议使用)
4.static(作用：修饰成员变量和成员方法)
4.1.静态方法只能访问静态成员
静态成员变量数据是共享的（且只能在本类中调用，使用其他类调用时需要先调用静态成员变量所在方法）
4.2.*静态代码块：static{代码} //有且只走一次
4.3.非静态代码块：｛代码｝
会伴随类执行。
4.3.优先度
静态代码块 > 非静态代码块 > 构造方法
4.4.static修饰成员变量
static修饰成员变量时，该变量数据可以让所有类的对象共用。
5.单例模式/饿汉模式/懒汉模式
userinfo&~test
5.1.单例模式
1.将构造方法改为prevate修饰
2.提供一个静态的成员变量，并初始化成员变量
3.提供静态方法，获得此类的对像
5.2.饿汉模式（开发不推荐）
1 private static ShoopingCar shoppingCar = new ShoppingCar；
2 public static ShoppingCar gatShoppingCar(){
3 return shoppingCar;
4 }
1.不管是否使用变量，都会执行初始化操作，没有体现出懒加载的思想
2.没有线程安全问题
5.3懒汉模式
1 private static ShoppingCar shoppingCar;
2 public static ShoppingCar getShoppincar(){
3 if(shoppingCar==null){
4 shoppingCar = new ShoppingCar;
5 }
6 return shoppingCar;
7 }
1.什么时候使用对象 什么时候执行初始化操作
2.有线程安全问题
5.4枚举（多例/开发常用）
6.this
6.1.在本类里访问无参/有参构造：
使用：this(); //必须在代码第一行
6.2.this可以充当实际参数
（了解）因为他是个对象。