Java语言基础

int a = 5;
long b = a; //自动/隐式类型转换
int c = (int)b; //强制类型转换

long d = 5;   //自动类型转换
double e = 5; //自动类型转换

long f = 10000000000L;
int g = (int)f;
System.out.println(g); //1410065408，强转有可能发生溢出
double h = 25.987;
int i = (int)h;
System.out.println(i); //25，强转有可能丢失精度

两点规则：

整数直接量可以直接赋值给byte,short,char,但不能超范围

byte,short,char型数据参与运算时，系统会将其一律先转换为int在运算

byte b1 = 5;
byte b2 = 6;
//byte b3 = b1+b2; //b1+b2时,系统自动将它俩转换为int了,int结果赋给byte,需强转
byte b4 = (byte)(b1+b2);

引用数据类型：

类(class)String：

接口(interface)：

数组：

枚举：

4.运算符

**算术：+、-、*、/、%、++、--**

%：取模/取余，余数为0即为整除

System.out.println(5%2); //1，商2余1
System.out.println(8%2); //0，商4余0----整除
System.out.println(2%8); //2，商0余2

++/--：自增1/自减1，可在变量前也可在变量后

单独使用时，在前在后都一样

被使用时，在前在后不一样

a++的值为a---------(a--的值为a)

++a的值为a+1------(--a的值为a-1)

//演示++单独使用
int a=5,b=5;
a++; //相当于a=a+1
++b; //相当于b=b+1
System.out.println(a); //6
System.out.println(b); //6

//演示++被使用
int a=5,b=5;
int c = a++; //简便记法:a++的值为5，所以c就为5
int d = ++b; //简便记法:++b的值为6，所以d就为6
System.out.println(a); //6
System.out.println(b); //6
System.out.println(c); //5
System.out.println(d); //6

//演示--单独使用:
int a=5,b=5;
a--; //相当于a=a-1
--b; //相当于b=b-1
System.out.println(a); //4
System.out.println(b); //4

//演示--被使用:
int a=5,b=5;
int c = a--; //a--的值为5，所以c为5
int d = --b; //--b的值为4，所以d为4
System.out.println(a); //4
System.out.println(b); //4
System.out.println(c); //5
System.out.println(d); //4

关系：>、<、>=、<=、==、!=

1)>(大于)、<(小于)
>=(大于或等于)、<=(小于或等于)
==(等于)、!=(不等于)
2)关系运算的结果为boolean型，
关系成立则为true，关系不成立则为false

逻辑：&&、||、！

逻辑运算的结果是boolean型

&&：短路与，两边都为真则为真，见false则false

第1个条件为false时，则发生短路（后面的不执行）

//演示短路:
boolean b3 = a>b && c++>2;
System.out.println(b3); //false
System.out.println(c);  //5，发生短路了

||：短路或，有真则为真，见ture则ture

第一个条件为true时，则发生短路（后面的不执行）

//演示短路:
boolean b4 = a<b || c++>2;
System.out.println(b4); //true
System.out.println(c);  //5，发生短路了

!：逻辑非(取反)，非真则假，非假则真

**赋值：=、+=、-=、*=、/=、%=**

简单运算符：=

扩展运算符：+=、-=、*=、/=、%= 注：扩展运算符自带强转功能

int a = 5;
a += 10; //相当于a=(int)(a+10)
System.out.println(a); //15
a *= 2; //相当于a=(int)(a*2)
System.out.println(a); //30
a /= 6; //相当于a=(int)(a/6)
System.out.println(a); //5

//小面试题:
short s = 5;
//s = s+10; //编译错误，需强转，改为s=(short)(s+10);
s += 10; //相当于s=(short)(s+10);

字符串连接：+

若两边为数字，则做加法运算

若两边出现了字符串，则做字符串连接

任何类型与字符串连接，结果都会变为字符串型

System.out.println(10+20+""+30); //3030---------String
System.out.println(""+10+20+30); //102030-------String
System.out.println(10+20+30+""); //60-----------String

条件/三目：?:

语法：boolean?数1:数2

若boolean为true，则整个表达式的值为?后面的数1

若boolean为false，则整个表达式的值为?后面的数2

int a=8,b=5;
int max = a>b?a:b;
System.out.println("max="+max); //max=8

优先级记忆方法：单目乘除为关系，逻辑三目后赋值

单目：+，-，++，--，！，~（按位取反）

乘除：*，/，%，+，-

为（位）：<<（左移），>>（右移）

关系：> ，<， >=， <=， ==， !=

逻辑：&& ，||， &， |， ^

三目：A > B ? X : Y

赋值：= ，+=， -=， *=， /=， %=， |=， &=， ^=

5.三种结构（顺序、分支、循环）

顺序结构：从上往下逐行执行，每句必走

分支结构：有条件的执行某语句一次，并非每句必走

if结构：1条路

if...else结构：2条路

if...else if结构：多条路

1)if语法:
   if(boolean){
      语句块--------------基于条件执行的语句
   }
2)执行过程:
    判断boolean的值:
       若为true，则执行语句块(整个结束)
       若为false，则直接结束
-------------------------------------------------
1)if...else语法:
   if(boolean){
      语句块1
   }else{
      语句块2
   }
2)执行过程:
    判断boolean的值:
      若为true，则执行语句块1(整个结束)
      若为false，则执行语句块2(整个结束)
3)说明:
    语句块1和语句块2，必走其中之一-------------2选1
--------------------------------------------------
1)if...else if语法:
  if(boolean-1){
    语句块1
  }else if(boolean-2){
    语句块2
  }else if(boolean-3){
    语句块3
  }else{
    语句块4
  }
2)执行过程:
    判断boolean-1，若为true则执行语句块1(结束)，若为false则
    再判断boolean-2，若为true则执行语句块2(结束)，若为false则
    再判断boolean-3，若为true则执行语句块3(结束)，若为false则执行语句块4(结束)
3)说明:
    语句块1/2/3/4，必走其中之一--------多选1

switch...case结构：多条路

优点：效率高、结构清晰

缺点：只能对整数判断相等

break：跳出switch

注：switch可以作用于的数据类型有byte , short , char , int , String , 枚举

循环结构：有条件的执行某语句多次，并非每句必走

循环：反复多次执行一段相同或相似的代码

循环三要素：循环变量的初始化

循环变量的条件（以循环变量为基础）

循环变量的改变（向着循环的结束变）

循环变量：在整个循环过程中反复改变的那个数

while结构：先判断后执行，有可能一次都不执行

1)语法:
  while(boolean){
    语句块/循环体------------反复执行的代码
  }
2)执行过程:
    先判断boolean的值，若为true则执行语句块，
    再判断boolean的值，若为true则再执行语句块，
    再判断boolean的值，若为true则再执行语句块，
    如此反复，直到boolean的值为false时，while循环结束

do...while结构：先执行后判断，至少执行一次

建议：当第1要素与第3要素的代码相同时，首选do...while

1)语法:
  do{
    语句块
  }while(boolean);
2)执行过程:
    先执行语句块，再判断boolean的值，若为true则
    再执行语句块，再判断boolean的值，若为true则
    再执行语句块，再判断boolean的值，若为true则
    再执行语句块，如此反复，直到boolean的值为false时，do...while结束

for结构：应用率高，与次数相关

1)语法:
  //    1      2       3
  for(要素1 ; 要素2 ; 要素3){
    语句块/循环体---------------反复执行的代码   4
  }
2)执行过程:
    1243243243243243...2

三种循环结构如何选择：

先看循环是否与次数有关：

若有关----------------------直接上for

若无关，再看要素1与要素3的代码是否相同

若相同------------------直接上do...while

若不同------------------直接上while

break:跳出循环

for(int num=1;num<=9;num++){
    if(num==4){ //在某种特定条件下，提前结束循环
        break; //跳出循环
    }
    System.out.println(num+"*9="+num*9);
}

/*  执行过程:
    num=1  1*9=9
    num=2  2*9=18
    num=3  3*9=27
    num=4
*/

continue:跳出循环体中剩余语句而进入下一次循环

//输出9的乘法表，只要不能被3整除的
for(int num=1;num<=9;num++){
    if(num%3!=0){
        System.out.println(num+"*9="+num*9);
    }
}

//输出9的乘法表，跳过能被3整除的
for(int num=1;num<=9;num++){
    if(num%3==0){
        continue; //跳过循环体中剩余语句而进入下一次循环
    }
    System.out.println(num+"*9="+num*9);
}
  
/*  执行过程:
    num=1  1*9=9
    num=2  2*9=18
    num=3
    num=4  4*9=36
    num=5  5*9=45
    num=6
    num=7  7*9=63
    num=8  8*9=72
    num=9
    num=10 false
*/

嵌套循环：循环中套循环，常常多行多列时使用，一般外层控制行，内层控制列

执行规则：外层循环走一次，内存循环走所有次

建议：嵌套的层数越少越好，能用一层就不用两层，能用两层就不用三层

break只跳出当前一层循环

补充：生成随机数：Math.random()----------0.0到0.9999999

Random rand=new Random();

rand.nextInt();----------0.0到0.9999999

默认值规则：byte , short , int , long , char ,------------------0

float , double-----------------------------------------0.0

boolean------------------------------------------------false

6.数组

是一种数据类型（引用类型）

相同数据类型元素的集合

初始化：初始化数组中的元素

访问：访问的是数组中的元素

通过（数组名.length）可以获取数组的长度（元素的个数）

通过下标/索引来访问数组的元素，下标从0开始，最大到（数组的长度-1）

遍历/迭代：从头到尾挨个走一圈

数组复制：

System.arraycopy(a,1,b,0,4);
int[] b = Arrays.copyOf(a,6);
  a = Arrays.copyOf(a,a.length+1);

数组排序：

Arrays.sort(arr); //从小到大的排序

7.方法：函数、过程

作用：用于封装一段特定的业务逻辑功能

建议：方法尽可能独立，一个方法只干一件事

方法可以被反复调用多次

可以减少代码重复，有利于代码的维护

何时用：只要是一个独立的的业务功能，就得封装到一个方法中

方法的定义：五要素

修饰词返回值类型方法名(参数列表){
方法体----具体的业务逻辑功能实现
}

方法的调用：

return 值; 1)结束方法的执行 2）返回结果给调用方--------用在有返回值的方法中

return; 1）结束方法的执行----------用在无返回值的方法中

补充：break，continue,return的区别：

break：跳出当前循环

continue：结束当次循环，进入下次循环

return：结束方法

-------------------------------------------------------------------------------------------------------------------------(自用)