12.30Java学习总结

运算符（接12.29）
1.1 算数运算符
1.2 关系运算符
1.3 位运算符
1.4 赋值运算符
=：把右边的赋值给左边，a=2，a=b
+=:左右相加，赋值给左边 a+=b 等价a=a+b
-=:左减去右，赋值给左边 a-=b 等价a=a-b
*=
/=
%=
赋值运算符是右结合，从右往左算
初始化还是从左到右
1.5 字符串拼接符
+把多个数据拼成一个字符串
如果+两边是数字则为加运算
如果+两边有一个字符串，则将数字与字符串拼接

public static void main(String[] args) {
		String string = "啊实打实大声道!@#$ int a = 20  阿萨德115" '";
		int a = 100;
		int b = 120;
		System.out.println(a+b);
		// a+b=1012
		System.out.println("a+b="+a+b);
		// a+b=22
		System.out.println("a+b="+(a+b));
		// 100+120=220
		System.out.println(a+"+"+b+"="+(a+b));
	}

1.6 三目运算符（三元运算符）
语法 : 布尔类型表达式 ? 真 : 假 ;
如果布尔型为true 则执行真否则执行假

public class Operator_06 {

	public static void main(String[] args) {
		int i = 2 < 2 ? 1 : 0;
		System.out.println(i);
		System.out.println(false ? 123 : "都是假的");
	}

流程控制
控制程序不同执行分支
2.1 顺序结构
从上到下，从左往右执行
2.2 分支结构
通过指定的判断条件,选择性执行不同分支
2.2.1 if…else…
- 单分支 : 有不执行情况

```
 	if(布尔型表达式){
```
```
 			为真时执行的代码
```
```
 	}
```
双分支 : 一定有一个分支执行
```
 	if(布尔型表达式){
```
```
 			为真时执行的代码
```
```
 	}else{
```
```
 			为假的时候,执行的代码
```
```
 	}
```
多分支 :

 	if(布尔型表达式){}  else if(布尔型表达式){} else if(布尔型表达式){} .....

 	如果多分支最后是以else结尾,则肯定有一个分支执行

 	如果是以else if结尾 那么该多分支 有不执行情况

 	多分支情况下,有一个分支执行则整个多分支结束

每一个分支下如果只有一行代码,则 {} 可以省略

public class If_01 {
	public static void main(String[] args) {
		int a = 110;
		int b = 11;
		if (a > 10) {
			System.out.println("1111");
		} else if (a > 50) {
			System.out.println("2222");
		} else if (a > 100) {
			System.out.println("33333");
		}
		
		// 只有一行代码 大括号可以省略
		if (true) 
			System.out.println("执行完成");
		else
			System.out.println("执行完成");
		
		System.out.println("执行完成");
	}

2.2.2 Switch
* switch : java1.7之前只能传入int值但是从1.7开始可以传入字符串
*

语法 : switch(值){ case 值1: 执行语句; break; case 值2: 执行语句; break; default : 执行语句;
break; }
每一个分支都需要加break来结束分支,否则会出现case穿透现象

public static void main(String[] args) {
		char c = 'B';
		if (c == 'A') {
			System.out.println("优秀");
		} else if (c == 'B') {
			System.out.println("良好");
		} else if (c == 'C') {
			System.out.println("一般");
		} else {
			System.out.println("差");
		}
		// 上下两个程序是一个意思,但是 if可以判断相等,也可以判断范围,而switch只能判断相等,不能判断范围
		switch (c) {
		case 'A':
			System.out.println("优秀");
			break;
		case 'B':
			System.out.println("良好");
			break;
		case 'C':
			System.out.println("一般");
			break;
		default:
			System.out.println("差");
			break;
		}
		// 如果分支没有break 会导致case穿透
		int i = 10;
		switch (i) {
		case 1:
			System.out.println(11111);
		case 2:
			System.out.println(22222);
		case 10:
			// 从符合条件处开始,后面所有的分支全部执行
			System.out.println(101010);
		case 100:
			System.out.println(100100100);
		default:
			System.out.println("默认语句");
		}
	}

public static void main(String[] args) {
		char c = 'C';
		if (c == 'A' || c == 'B') {
			System.out.println("优秀");
		} else if (c == 'C') {
			System.out.println("良好");
		}

		// case合并  利用case穿透 可以完成合并,做到 || 的效果
		switch (c) {
		case 'A':
		case 'B':
			System.out.println("优秀");
			break;
		case 'C':
			System.out.println("良好");
			break;
		}
	}

2.3 循环结构
2.3.1 For
2.3.1.1 单循环

for循环是计数循环,在某个次数范围内重复执行
语法结构 :

 for( 表达式1 ; 表达式2 ; 表达式3 ){

 	循环体,就是需要重复执行的代码

```
 }
```
循环三要素 : 起始值,终止条件,步长
表达式1 : 最先执行,并且只执行一次,所以适合做初始化操作
表达式2 : 必须是布尔型,并且决定循环是否结束,所以是终止条件
表达式3 : 也是每次循环都执行,所以可以做为步长
执行过程 :

 先执行表达式1并且只执行一次,然后执行表达式2 , 如果表达式2为true(表达式2必须是布尔型) 则执行循环体

 然后执行表达式3 , 然后再次执行表达式2 ,如果是true 则执行循环体 ,

 然后执行表达式3 ,再次执行表达式2  一直到 表达式2 为false 循环终止

// for ( ; ; ) {
		//
		// }
		// 循环中的变量i  只可以再循环中使用
		for (int i = 0; i < 5; i++) {
			System.out.println(i);
		}
		// System.out.println(i);
		int i;
		for ( i =0 ; i < args.length; i++) {
			System.out.println(i);
		}
		System.out.println(i);

2.3.1.2 嵌套循环

嵌套循环双层嵌套可以模拟二维表, 三层嵌套可以模拟三维体
可以把外层循环看做行数内层循环看做列数

		for (int i = 0; i < 5; i++) {
			for (int j = 0; j < 5; j++) {
				// println会换行  print 不会换行
				System.out.print(0+"  ");
			}
			// 换行
			System.out.println();
		}

2.3.2 While

while : 真假循环,条件为真就执行,为假就终止
语法 :
```
 while(布尔型){
```
```
 	循环体;
```
```
 }
```

		int i = 1000;
		while (i<100) {
			System.out.println(i);
			i++;
		}

2.3.3 Do…while

dowhile 可以保证循环至少执行一次
for和while的执行次数是 0~N次而 doWhile 是 1~N次

		int i = 1000;
		do {
			System.out.println(i);
			i++;
		} while (i < 100);

2.3.4 Break&continue

break : 打断
1 可以用在switch中,用来结束case分支,防止case穿透
2 也可以用在循环中,用来结束当前循环

		for (int i = 0; i < 10; i++) {
			if (i == 3) {
				// 终止循环
				break;
			}
			System.out.println(i);
		}

		// 对外层循环设置名字
		outerFor: for (int i = 0; i < 5; i++) {
			for (int j = 0; j < 5; j++) {
				if (j == 3) {
					// 发生在嵌套循环的时候,break只能终止内层循环
					// break;
					// 终止指定循环,这种方式可以做到在内层循环中,终止外层循环
					break outerFor;
				}
				System.out.print(j + "  ");
			}
			System.out.println();
		}

continue : 跳过当前次循环,继续下次

		for (int i = 0; i < 10; i++) {
			if (i == 3) {
				// break;
				continue;
			}
			System.out.println(i);
		}

方法
3.1 概述

方法就是很多条语句的集合,把这些代码放到方法中,然后就可以多次使用这个方法
方法目的 : 代码复用 , 使程序更加简短清晰,提高开发效率
3.2 方法声明
声明 :

 修饰符列表  返回值类型  方法名  (参数列表){ 方法体 }

 修饰符列表 :  可以有,可以没有,可以有多个

 		权限修饰 : public  protected private  不写  四选一

 		其他修饰 : static , synchronized 
 				abstract , final 二选一 .....
 				
 返回值类型 : 11种数据类型中的任意一种 , 如果不需要返回值,则写 void
 
 方法名 : 方法的名字,望文知义,驼峰命名法
 
 参数列表 : 要做一件事,需要的必备条件,可以作为入参
 		可以有多个,用 , 逗号隔开 比如 int a , int b , int c....
 		
 		形参 : 在方法声明的时候,定义的参数列表
 		实参 : 方法调用时,实际传入的数据
 		
 方法体 : 需要执行的代码
 	注意 : return 终止方法运行并返回
 		如果有返回值类型的方法中,方法体必须有return语句
 				比如 public static int m1(){
 					return 1;// 这里的1 只要是int值即可,因为返回值为int类型
 				}
 		如果 没有返回值 那么可以写return 也可以不写 ,就算写return 也不能返回数据,只能终止运行
 			public static void m1(){
 				return; // 只有终止方法运行的功能
 			}

3.3 方法分类

方法分类

 1 静态方法 : 使用static修饰的方法,是静态方法

 2 成员方法 : 没有static修饰的方法是成员方法

 3 构造方法 : 创建对象使用,先不管

调用 :

 静态方法 : 类名.静态方法名(参数) , 同类中 类名可以省略

 成员方法 : 对象引用.成员方法名(参数)

方法不调用不执行,调用才执行,并把结果返回到调用处
编写方法只考虑功能的实现,最终这个方法被用来做什么,与声明无关

public class Method_01 {
	public static void main(String[] args) {
		int result = Method_01.m1(123,5312);
		System.out.println(result);
	}
	public static int m1(int a , int b){
		return a+b;
	}
	public static void m2(){
		return ;
	}

12.30Java学习总结

Java相关栏目本月热门文章