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() 方法用于返回字符串的长度.
- // 例
- public class Test {
- public static void main(String args[]) {
- String Str1 = new String("www.runoob.com");
- String Str2 = new String("runoob" );
- ?
- System.out.print("字符串 Str1 长度 :");
- System.out.println(Str1.length());
- System.out.print("字符串 Str2 长度 :");
- System.out.println(Str2.length());
- }
- }
- // 随机输入一个 100 以内数组
- int[] arr=new int[10];
- for(int i=0;i<arr.length;i++){
- int value= (int)Math.random()*100;
- arr[i]=value;
- }
- 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()// 关闭该变量, 会关闭该程序所有的该变量
>简单登入系统??
- while("n".equals(answer)) {
- System.out.println("输入账号");
- answer = input.nextLine();
- }
- if("y".equals(answer)) {
- System.out.println("********");
- }
卫语句
例:
- if (true){
- if (true){
- if (true){
- for (){
- if (true){
业务代码
- }
- }
- }
- }
- }
在有比较复杂的判断和需要遍历处理业务时候, 经常会出现上面这种情况, 这些代码在执行起来是没问题. 但是这样的代码是一次性代码, 过一段时间, 可能自己都不敢动这里的逻辑了, 更何况下一个接盘侠呢. 这样的代码很难弄明白每个条件的作用和执行的流程, 当你读到最里面一层的时候, 估计你已经记不起来当初是为什么走进这个 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. 冒泡法
- for(int i=1;len = arrlength;i<len;i++){
- for(int j=0;j<len-i;j++){
- // 相邻元素互相比较
- if(arr[j]>arr[j+1]){
- // 交换位置
- int temp = arr[j];
- arr[j] = arr[j+1];
- arr[j+1] = temp;
- }
- }
- }
7. 选择排序
- for(int i=0,len = arr.length;i<;en-1;i++){
- int min = arr[i];
- int minIndex = i;
- for(int j=i+1;j<len;j++){
- if(min>arr[j]){
- min = arr[j];
- minIndex = j;
- }
- }
- }
8. 插入排序 (升 / 降)
- for(int i=1,len = arr.length;i<len;i++){
- int temp = arr[i];
- int leftIndex = i-1;
- while(leftIndex>=0 && arr[leftIndex]>temp){
- arr[leftIndex+1] = arr[leftIndex];// 左边元素要移动, 大数向右
- leftIndex--;
- }
- arr[leftIndex+1] = temp;
- }
倒叙
- for(int i=1;i<arr1.length;i++) {
- int space = arr1[i];// 取第二个数
- int left = i-1;//= 指向第一个数
- while(left>=0 && arr1[left]<space) {
- arr1[left+1] = arr1[left];// 小数向右移
- left--;// 找回指向空格的索引
- }
- arr1[left+1] = space; // 填空
- }
- 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 有多个参数 (附卫语句例 / 登入):
- public static void userLogin(String usename,String password){
- String name = "admin";
- String pass = "admin";
- // 校验 username 与 password
- if(username==null || password==null){
- System.out.println("参数不允许为 null");
- return;
- }
- if(!neme.equals(username) || !pass.equals(password)){
- System.out.println("用户名或密码不对");
- }
- System.out.println("登陆成功");
- System.out.println("执行成功之后的代码.....");
- }
2.2 可变参数:
- test();
- ?
- // 可变参数 -> 同一种数据类型 例: 数据类型... 变量名
- //nums 是可变参数 >=0 个实际参数 实际为一个数组
- public static void test(int...nums){
- System.out.println(nums[0]);
- System.out.println(nums[1]);
- System.out.println("nums:"+Arrays.toString(nums));
- }
2.3 方法重载 overload
在一个类 (java 文件), 可以存在多个方法名一样的方法.
方法名相同
形参的顺序 (形参列表不一致)
与返回值和修饰符无关
(类与对象)
1. 不同方法调用同一个成员变量?
创建成员属性
2. 无参 & 有参构造方法
快捷键: alt+shift+s+c(生产无参构造)
例: 调用带参 / 无参构造方法
成员变量 = 全局变量
- public class Person {
- public int id;
- public String name;
- // 默认的无参构造方法
- // 构造方法与类名一致
- //[访问权限修饰符] 类名 () {}
- // 默认存在
- //1. 帮助创建对象
- //2. 初始化成员变量
- public Person() {
- // id = 1001;
- // name = "jim";
- }
- // 在创建对象的时候就对成员变量赋值 有参构造
- // 方法重载
- // 方法名相同 形参列表不同
- // 与返回值 修饰符无关
- // 构造方法重载
- public Persion(int pid,String pname){
- id = pid;
- name = pname;
- }
- }
- }
- public class PersonTest {
- public static void main(String[] args){
- Person person = new Person();
- System.out.println("姓名"+person.name);
- // 使用有参构造进行创建对象
- Person person2 = new Person(1002,"tom");
- System.out.println("person2 姓名:"+person2.name);
- }
- }
- (封装)
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. 饿汉模式 (开发不推荐)
- private static ShoopingCar shoppingCar = new ShoppingCar;
- public static ShoppingCar gatShoppingCar(){
- return shoppingCar;
- }
1. 不管是否使用变量, 都会执行初始化操作, 没有体现出懒加载的思想
2. 没有线程安全问题
5.3 懒汉模式
- private static ShoppingCar shoppingCar;
- public static ShoppingCar getShoppincar(){
- if(shoppingCar==null){
- shoppingCar = new ShoppingCar;
- }
- return shoppingCar;
- }
1. 什么时候使用对象 什么时候执行初始化操作
2. 有线程安全问题
? 5.4 枚举 (多例 / 开发常用)
6.this
6.1. 在本类里访问无参 / 有参构造:
使用: this(); // 必须在代码第一行
6.2.this 可以充当实际参数
(了解) 因为他是个对象.
快速查看
来源: http://www.bubuko.com/infodetail-3317042.html