java

自动转换

short a = 1;
short b = 2;
那么 a+b 是什么类型？
1+2会自动转换为int型

表达式的数据类型自动提升
所有的byte型、short型和char的值将被提升到int型。
如果一个操作数是long型，计算结果就是long型；
如果一个操作数是float型，计算结果就是float型；
如果一个操作数是double型，计算结果就是double型。

final

final修饰基本类型变量，表示该变量只有一次赋值机会
final修饰引用，表示该引用只有1次指向对象的机会
当类被修饰成final的时候，表示不能够成为父类
方法被修饰成final,那么该方法，不能够被重写
static final表示常量

自增 自减操作符置前以及置后的区别

i++; 先取值，再运算
++i; 先运算，再取值

        int i = 5;
        System.out.println(i++); //输出5
        System.out.println(i);   //输出6
         
        int j = 5;
        System.out.println(++j); //输出6
        System.out.println(j);   //输出6

逻辑运算符

& 长路与
&& 短路与
| 长路或
|| 短路或
! 取反
^ 异或^

位运算符

Integer.toBinaryString() 一个整数的二进制表达
| 位或
& 位与
^ 异或
~ 取非
<< 左移*2
>> 右移/2

Scanner

Scanner s = new Scanner(System.in);
float a = s.nextFloat();

条件语句

if
else if
else

		  switch(a){
		    case 1:
                System.out.println("星期一");
                break;
            case 2:
                System.out.println("星期二");
                break;
            case 3:
                System.out.println("星期三");
                break;
            case 4:
                System.out.println("星期四");
                break;
            case 5:
                System.out.println("星期五");
                break;
            case 6:
                System.out.println("星期六");
                break;
            case 7:
                System.out.println("星期天");
                break;
            default:
                System.out.println("这个是什么鬼？");
}

循环

continue 跳过本次循环，继续下一次循环
break 结束循环
标签：

      outloop:
      for (int i = 0; i < 10; i++) { 
        for (int j = 0; j < 10; j++) {
            System.out.println(i+":"+j);
            if(0==j%2) 
                break outloop; //如果是双数，结束外部循环
        }
         
    }

数组

创建数组的时候，要指明数组的长度。
new int[5]
//没有赋值，那么就会使用默认值
//作为int类型的数组，默认值是0
.length属性用于访问一个数组的长度
写法一： 分配空间同时赋值
int[] a = new int[]{100,102,444,836,3236};

写法二： 省略了new int[],效果一样
int[] b = {100,102,444,836,3236};

选择法排序

选择法排序的思路：
把第一位和其他所有的进行比较，只要比第一位小的，就换到第一个位置来
比较完后，第一位就是最小的
然后再从第二位和剩余的其他所有进行比较，只要比第二位小，就换到第二个位置来
比较完后，第二位就是第二小的
以此类推

for (int j = 0; j < a.length-1; j++) {
            for (int i = j+1; i < a.length; i++) {
                if(a[i]<a[j]){  
                    int temp = a[j];
                    a[j] = a[i];
                    a[i] = temp;
                }
            }
        }

冒泡法排序

冒泡法排序的思路：
第一步：从第一位开始，把相邻两位进行比较
如果发现前面的比后面的大，就把大的数据交换在后面，循环比较完毕后，最后一位就是最大的
第二步： 再来一次，只不过不用比较最后一位
以此类推

for (int j = 0; j < a.length; j++) {
            for (int i = 0; i < a.length-j-1; i++) {
                if(a[i]>a[i+1]){  
                    int temp = a[i];
                    a[i] = a[i+1];
                    a[i+1] = temp;
                }
            }
        }

复制数组

System.arraycopy(src, srcPos, dest, destPos, length)

src: 要复制的数组
srcPos: 复制数据的起始位置
dest: 目标数组
destPos: 复制到目标数组的起始位置
length: 复制的长度

二维数组

int b[][] = new int[][]{
{1,2,3},
{4,5,6},
{7,8,9}
};

Arrays

是针对数组的工具类，可以进行 排序，查找，复制填充等功能。 大大提高了开发人员的工作效率。
copyOfRange 数组复制
toString() 转换为字符串
sort 小到大正序排序

binarySearch 搜索 需要注意的是，使用binarySearch进行查找之前，必须使用sort进行排序
如果数组中有多个相同的元素，查找结果是不确定的
Arrays.sort(a);
System.out.println(“数字 62出现的位置:”+Arrays.binarySearch(a, 62));

equals 判断是否相同
fill 填充 使用同一个值，填充整个数组

int[] b = Arrays.copyOfRange(a, 0, 3); 从a的0开始复制3个元素
String content = toString(a);
Arrays.sort(a)
Arrays.equals(a, b)
Arrays.fill(a, 5);

this

this代表当前对象

如果要在一个构造方法中，调用另一个构造方法，可以使用this(构造方法参数)

    //带一个参数的构造方法
	    public Hero(String name){
	        System.out.println("一个参数的构造方法");
	        this.name = name;
	    }
      
    //带两个参数的构造方法
    public Hero(String name,float hp){
        this(name);
        System.out.println("两个参数的构造方法");
        this.hp = hp;
    }

JAVA中的传参

基本类型传参
在方法内，无法修改方法外的基本类型参数

static

用来修饰成员变量，将其变为类的成员，从而实现所有对象对于该成员的共享；

static修饰方法最大的作用，就是可以使用"类名.方法名"的方式操作方法，常用于工具类
static方法只能操作类变量
如果一个方法，没有调用任何对象属性，那么就可以考虑设计为类方法

static{} 静态块
在类加载时执行，因为类只会加载一次，所以只会执行一次

普通初始化块：创建对象时隐式调用

静态初始化块：类加载时隐式调用

public class Hero {
    public String name = "some hero"; //先执行
    protected float hp;
    float maxHP;
 
{
    maxHP = 200; //2执行
}  
 
public Hero(){
    hp = 100; //最后
     
}
 
}

饿汉式与懒汉式单例模式

单例模式:构造方法私有化,通过类方法返回实例对象
饿汉式:在定义类属性时 就实例化
懒汉式:在类方法中 如果类属性指向空 就实例化