0003-编程基础

一、运算符（6个）

运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。参与运算两边类型相同

Java中有算术运算符、关系运算符、位运算符、逻辑运算符、赋值运算符 和 其他运算符。

1.1算术运算符

a=10，b=20

+	加	a+b=30
-	减	a-b=-10
*	乘	a*b=200
/	除	a/b=1/2
%	取余/取模	b%a=0
++	自加	a++=11 ,++a=11
–	自减	a–=9 , --a=9

自运算符

自增（++）自减（–）运算符是一种特殊的算术运算符，在算术运算符中需要两个操作数来进行运算，而自增自减运算符是一个操作数。

前缀自增自减法(++a,–a): 先进行自增或者自减运算，再进行表达式运算。（先加再算）

后缀自增自减法(a++,a–): 先进行表达式运算，再进行自增或者自减运算 实例：（先算再加）

//自加符
int  i=10;
int  j= i++;//右自增    先赋值在运算 结果：j=10  i=11
int  k= ++i; //左自增   先运算再赋值 结果：k=12  i=12
//i=12
i=i++   当把12赋值给i 时 ,不会两次赋值,运算后则为12
i=++i   i为13
// 自减符--

// +=
int i=0;
i+=3;        //相当于 i=i+3

1.2关系运算符

所有的关系运算符的运算结果都是布尔类型，不是true就是false，不可能是其他值。

操作符	例子
>	大于
>=	大于等于
<	小于
<=	小于等于
==	等于
!=	不等于

1.3位运算符

​ Java定义了位运算符，应用于整数类型(int)，长整型(long)，短整型(short)，字符型(char)，和字节型(byte)等类型。

​ 位运算符作用在所有的位上，并且按位运算。

​ 下表列出了位运算符的基本运算，假设整数变量A的值为60（二进制：0011 1100）和变量B的值为13（0000 1101）：

操作符	描述	例子
＆ 与	如果相对应位都是1，则结果为1，否则为0	（A＆B），得到12，即0000 1100
| 或	如果相对应位都是0，则结果为0，否则为1	（A|B）, 得到61，即 0011 1101
^	如果相对应位相同，则结果为0，否则为1	（A ^ B）得到49，即 0011 0001
〜	按位取反运算符翻转操作数的每一位，即0变成1，1变成0。	（〜A）得到-61，即1100 0011
<<	按位左移运算符。左操作数按位左移左操作数指定的位数。	A << 2得到240，即 1111 0000
>>	按位右移运算符。右操作数按位右移右操作数指定的位数	A >> 2得到15， 即 0000 1111

1.4逻辑运算符

所有的关系运算符的运算结果都是布尔类型，不是true就是false，不可能是其他值。

操作符	描述	例子
&	逻辑与（并且）	两边都是true，结果才是true	有假则为假
│	逻辑或（或者）	有一边是true，结果就是true	有真即为真
!	逻辑非（取反）	!true = false ， !false = true
&&	短路与	两边都是true，结果才是true	只要左边为flate 右边不运算
││	短路或	有一边是true，结果就是true	只要左边为true 右边不运算

1.41.短路与 &&和 逻辑与 &有什么区别？

首先这两个运算符的运算结果没有任何区别，完全相同。
只不过“短路与&&”会发生短路现象。

//测试逻辑与&
int x = 10;
int y = 11;
System.out.println(x > y & x > y++);  //false
//通过这个测试得出：x > y++ 这个表达式执行了。
System.out.println(y); // 12

//测试短路与&&
int m = 10;
int n = 11;
// 使用短路与&&的时候，当左边的表达式为false的时候，右边的表达式不执行
// 这种现象被称为短路。
System.out.println(m > n && m > n++);
System.out.println(n); // 11

1.42什么是短路现象？

右边表达式不执行，这种现象叫做短路现象。

1.43什么时候使用短路与&&，逻辑与& ？

从效率方面来说，&&比&的效率高一些。
因为逻辑与&不管第一个表达式结果是什么，第二个表达式一定会执行。

以后的开发中，短路与&&和逻辑与还是需要同时并存的。
大部分情况下都建议使用短路与&&只有当既需要左边表达式执行，又需要右边表达式执行的时候，才会选择逻辑与&。

1.44 短路或 ||和逻辑或|有什么区别？

首先这两个运算符的运算结果没有任何区别，完全相同。
只不过“短路或 ||”会发生短路现象。

//测试逻辑或|
int x = 10;
int y = 11;
System.out.println(x < y | x > y++); //ture
// 通过这个测试得出：x > y++ 这个表达式执行了。
System.out.println(y); // 12

//测试短路或||
int m = 10;
int n = 11;
// 使用短路或||的时候，当左边的表达式为true的时候，右边的表达式不执行
// 这种现象被称为短路。
System.out.println(m < n || m > n++);
System.out.println(n); // 11

1.45逻辑符运算符例子

//布尔值表达式  逻辑运算符  布尔值表达式
1==1 & 2==2;   t
1!=1&2==2;    f
1!=1|2==2;    true
1!=1&& 2==2;    2==2 不需要判定
1==1 || 2==2;   t  右边不需要判定
    

1.5赋值运算符

运算符	含义	例子
=	赋值，右边的赋值给左边的	C = A + B将把A + B得到的值赋给C
+=	加等，左操作数和右操作数相加赋值给左操作数	C + = A等价于C = C + A
-=	减等，把左操作数和右操作数相减赋值给左操作数	C - = A等价于C = C - A
*=	乘等	C * = A等价于C = C * A
/=	除等	C / = A等价于C = C / A
%=	取模赋值操作符	C％= A等价于C = C％A
<< =	左移位赋值运算符	C << = 2等价于C = C << 2
＆=	按位与赋值运算符	C＆= 2等价于C = C＆2
^ =	按位异或赋值操作符	C ^ = 2等价于C = C ^ 2
|=	按位或赋值操作符	C|= 2等价于C = C|2

除了第一个是赋值运算符，其他都是拓展赋值运算符

使用扩展赋值运算符的时候，永远都不会改变运算结果类型。

1.6条件运算符

1.61三目运算符/三目运算符

语法格式：布尔表达式 ? 表达式1 : 表达式2

只能写值的赋予

赋值表达式,最终一定会返回一个值,可以嵌套使用

1.62执行原理是什么？

布尔表达式的结果为true时，表达式1的执行结果作为整个表达式的结果。
布尔表达式的结果为false时，表达式2的执行结果作为整个表达式的结果。

1.63代码表示

char a = true ? '男' : "女";
string a1 = true ? '男' : "女";
以上两个都报错。

//下面可以
 String  s = "";
 s += true ? '男' : "女";

int i=100;
char c =i>=100? 'A':'B'

char c =i> 100? 'A': i>=90?'B' : 'C';


//对mark判定，大于90则为A，80-90为B,70-80为C，60-70为D，否则为E
int mark=100;
char level=mark>=90? 'A':  mark>=80? 'B':  mark>=70? 'C':  mark>=60? 'D':  'E';

//局部变量在同一个作用域内不能同名
int mark=100;
char c;
if( mark>=90){
   c= 'A';
}else if( mark>=80){
   c='B';
}else if( mark>=70 ){ 
   c= 'C';
}else if(mark>=60){
   c= 'D';
}else{
   c= 'E';
}


//如果if的花括号内只有一行语句 可以忽略{}
if(true) int i=100;


if (true){
    int i =100;
}

1.7运算符题目

int i=10;
int k=10;

i++>10 && i++>k      10>10 false  左边为false,右边不运算    f    i=11 k不变

++i >k || --k>8      11>10 true   左边为真,右边不运算.       t   i=11 k=10

i-->k-- || i++>=k    10>10 false   9>= 9 true              t   i=10 k=9   

i++>--k && i-->k     10>9 true     11>9 true              t   i=10 k=9     

i++>--k || i-->--k   10>9 true                            t   i=11 k=9
    

//按照 参与运算的最大的数据类型输出
10/3    3

10/3.0   3.3333    
    
jshell> char c ='a'+'b'
c ==> '?'

jshell> char d=1+1
d ==> '\002'

1.8类型转换

运算时,byte short char 不会相互转换,直接视为 int

隐式转换 byte short char int long float double

int i='a'         合法     //i=97
short s=100        合法    //s=100
byte b=i           不合法  //变量 ,从int转换到byte可能会有损失
byte b2=100        合法    //b2=100
short s2=b2+b2     不合法  //从int转换到short可能会有损失，大类型转小类型
char c =b2 +b2     不合法  //从int转换到char可能会有损失，大类型转小类型
short s3=100+100   合法   //s3=200

float f =1.0F +(1+1.0)+ (float)1.0  不合法 // 从double转换到float可能会有损失      
float f =1.0F +(float)(1+1.0)+ (float)1.0    合法//f=4.0 

double d=i+i+1.0  合法    
float f2=1.0F     合法    //fa2=1.0
float f2=1.0      不合法  // 从double转换到float可能会有损失
    
f2-0.1 ==0.9   true    //都是double          
f-0.1F==0.9    false   //float转为double  

byte b=99999999999   //过大，超出byte范围

1.9字符串连接运算符(+)

1. +运算符在java语言中有两个作用。
   作用1：求和
   作用2：字符串拼接

2. 什么时候求和？什么时候进行字符串的拼接呢？
   当 + 运算符两边都是数字类型的时候，求和。
   当 + 运算符两边的“任意一边”是字符串类型，那么这个+会进行字符串拼接操作。

3. 一定要记住：字符串拼接完之后的结果还是一个字符串。

   int a = 100;
   int b = 200;
   // 这里的 + 两边都是数字，所以加法运算
   int c = a + b;
   System.out.println(a + "+" + b + " = "  + a + b);//100+200=100200 字符拼接
   System.out.println(a + "+" + b + " = "  + (a + b));//100+200=300 数字计算	
   

遵循“自左向右”的顺序依次执行（除非额外添加了小括号，小括号的优先级高）

二、流程控制

2.1顺序结构

int i=10;
int j=10;
int k=i+j;

2.2分支结构

2.21 if else

//从上到下挨个匹配,直到有个符合条件
if (布尔值表达式) {
    //todo
}else if(布尔表达式){  
    //todo
}else{    
    //以上情况都不符合
}


//{}变量的作用域
int k=100;
if(true){    
    int k=10;
}else{   
    int y=k+100;
}

// 对mark判定
int mark=100;
char level=  mark>=90? 'A':  mark>=80? 'B':  mark>=70? 'C':  mark>=60? 'D' : 'E';

//局部变量在同一个作用域内不能同名
int mark=100;
char c;
if( mark>=90){
   c= 'A';
}else if( mark>=80){
   c='B';
}else if( mark>=70 ){
    
   c= 'C';
}else if(mark>=60){
    c= 'D';
}else{
   c= 'E';
}


//如果if的花括号内只有一行语句 可以忽略{}
if(true) int i=100;

if (true){
    int i =100;
}

2.22 switch …case

对变量进行判定,进行精确判定,不会从上到下匹配,直接进入符合条件的分支,如果没有,进入default分支

break的作用 跳出花括号,防止break 向下执行.

只能针对变量,效率比if高

//变量只能是基本数据类型中的 byte char short int  和引用数据类型String
switch (变量){
	case 值:
	break;
	case 值:
	break;
	...
	default :
	break;
}

//例子
int i=100;
switch(i){
	case 100:
		System.out.println("i的值是100");
		break;
	case 90:
		System.out.println("i的值是90");
		break;
	default:
		System.out.println("i的值是100");
}

println  打印并换行
print    打印
System.out.printf()

2.23字符串String

引用数据类型 ，所有引用类型首字母大写

//在java中单引号表示字符,双引号表示字符串
String s1="a";
String s='a'+'b';   错误  //右边返回int数据类型， int无法转换为java.lang.String

//什么地方出现字符串,什么时候就是字符串的拼接
//字符串的拼接
System.out.println(1+2+3+"我"+"我们"+12); //6我我们12
System.out.println("我"+"我们"+"1"+"2222");   //我我们12222
   
//switch  case用法
String aut="春天";
switch (aut){
        case"春天"  :
        	System.out.println("春天345");
       	 break;
        case"夏天"  :
        	System.out.println("夏天567");
       	 break;
        case"秋天"  :
       	 	System.out.println("秋天8910");
       	 break;
         case "冬天":
        	 System.out.println("冬天1112");
        break;
   		default  :
        	System.out.println("非法");
        break;
} 


//去掉break 尝试 看输出结果   

2.3循环结构

2.31 for循环

for(初始值表达式;布尔值表达式;值改变表达式){
//todo 循环体
}

//1 常规写法
for(int i=1;i<=10;i++){
	System.out.println(i);
}
//2 在外面声明变量
int i=1;
for(;i<=10;i++){
	System.out.println(i);           
}
//3 布尔值表达式放里面
int i=1;
for(;;i++){
   if(i>10)break;  
	System.out.println(i);   
}

//4 值改变表达式放里面
int i=1;    
for(;;){
    if(i>10)break;
    System.out.println(i);
    i++;   
}

for循环例子

//输出1-50的所有偶数 ,用两种方法
//能被2整除的就输出，加判断条件
for(int i=1;i<=50;i++){
if(i%2==0)
    System.out.println(i);
}

//改变初始值表达式和值改变表达式
for(int i=2;i<=50;i+=2){
    System.out.println(i);
}


//continue用法

//continue 跳出本次循环
//break 跳出本层循环
for(int i=1;i<=50;i++){
if(i%2!=0)continue;
    System.out.println(i);
}


//九九乘法表         %d占位符

  for(int i=1;i<10;i++){
        for(int j=1;j<=i;j++){
        System.out.printf("%d*%d=%d  ",j,i,i*j);
    }
		System.out.println();
    }

       
//
 for(int i=1;i<10;i++){
        for(int j=1;j<10;j++){
        System.out.print(j+"x"+i+"="+j*i+"\t");
    };
		System.out.println();
    }


//左下角直角三角	
*
**
***
****
    for(int i=1;i<10;i++){          //i控制行数
        for(int j=1;j<=i;j++){       //j控制列数
        System.out.printf("* ");
    }
 		System.out.println();
    }


//菱形
int hight=9;
int top=hight%2 ==0? hight/2: hight/2+1;
int left=top;
int right=top;
for (int i=1;i<=hight;i++  ){
	String line="";
	for(int j=1;j<=hight;j++){
		line+= j>=left && j<= right? "* ": "  ";
    }
    if(i<top){
        left--;
        right++;
    }else{
    	left++;
        right--;
        
    }
	System.out.println(line);
}

2.32 while do

while(布尔值表达式){

}

//输出1-10
int i=1;
while(i<=10){
System.out.println(i);
i++;
}

2.33 do while

至少执行一次循环

do{

}while(布尔值表达式);

//1-10
int i=1;
do{
	System.out.println(i);
	i++;
} while(i<=10);