java的方法与运算符

Java浅滩洗脚

方法与运算符

一、运算符（进行特定操作的符号）

被除数/除数=商..余数 //程序除法。
对于一个整数，整数除以整数结果依然是一个整数。
取模（moc）余数的意思：%     //意思是取余数，输出余数
只有整数的除法，取模才有意义，小数运算结果是小数，可以用但是意义不大。 
 注意事项：
 一旦运算当中有不同类型的数据，那么结果将会是数据范围大的那种。

1、加法

  1、对于数值来说，就是加法
  2、对于字符char类型来说，计算之前。会被提升成int在经行运算。
  3、字符串 String ，加号代表字符串连接操作。
  4、任何数据类型和字符串进行连接时，输出都会变成字符串。

 public class Plus{
	     public static void main(String[] args){
		 String str=“hello”；
		 System.out.println(str);//输出hellow
		 System.out.println("Hellow"+"World");//输出HelloWorld
		 String str2="Java";
		 System.out.pritln(str2+20+20);//输出：Java2020
		 }}

自增运算符：++
自减运算符：- -
基本含义：让变量涨一个数字1，或者降一个数字1
使用方式：
1、单独使用：不和其它操作混合，自己独立成为一个步骤。
2、混合使用：和其它操作混合。
使用区别：
A：如果是前++：变量立马加1，然后拿着结果进行使用。
B:如果是后++：那么首先使用变量原本的数值，再让变量+1.

public class Perator{
     public static void main(String[] args){
	 int num1=10;
	 System.out.pritln(num1);//10
	 ++num1;
	 System.out.println(num1);//11
	 num1++;
	 System.out.pritln(num1);//12
	 int num2=5;
	 System.out.println(num2++)//5
	 System.out.println(num2);//6
	 //后++实列
	 int num3=8;
	 System.out.println(++num3);//shuchu 9
	 System.out.println(num3);//输出9
	 }}

2、赋值运算符

赋值运算符：
+= ------ a+=1 ----> a=a+1
-= ------a-=1 ----->a=a-1
= -----a=1 ------->a=a*1
/=
%=
注意事项：
1、只有变量才能使用赋值运算符，常量不能进行赋值。
2、复合赋值运算符其中隐含了一个强制类型转换。

public class Perator{
     public static void main(String[] args){
	 int num1=1;
	 num1+=num1;//  num1=num1+1
	 System.out.println(num1); //  2
	 byte num2=30;
	 num2+=5;
	 //num2=int+int;
	 //num2=(byte)int;编译器功能
	 }
	 }

3、比较运算符

比较运算符：
等于 ==
小于 <
大于 >
小于等于 <=
大于等于 >=
不等于 !=
注意事项：
1、比较运算符的结果一定是一个boolean值，成立就是true，不成立就是false
2、如果进行多次判断不能连着写。列如：1<x<3这种不被程序允许

4、逻辑运算符（logic）

与（并且）：&&   //全部是true结果才是true，不然就是false
或（或者）：||   //有一个是true就是true，全部都是false，才是false
非（取反）：！  //本身是true会变成false
	 注意事项：与，或两种运算符，如果有多个条件，可以连续写
	 例如：条件A	&&	条件B  && 条件C
与“&&” 、或“||" ：具有短路效果，如果根据左边已经可以判断得到最终结果，那么右边的代码将不再执行，从而节省一定的性能。

public class Logic{
     public static void main(String[] args){
	 int a=10;
	 System.out.println(3>4&& ++a<100);
	 System.out.println(a);//左边已经判断出结果，右边将不再被执行}
	 }

5、三元运算符

 一元运算符：只需要一个数据就能进行运算。列如：！、++、--
 二元运算符：需要两个数据才可以进行操作。列如：加法+、=
 三元运算符：需要三个数据才可以进行操作的运算符。列

格式：
数据类型 变量名称 = 条件判断 ？ 表达式A ： 表达式B；
流程：
首相进行条件判断：如果是true，那么将表达式A赋值给左侧的变量。
如果是false，那么将表达式B的值赋值给左侧的变量。

public class perator{
     public static void main(Stirng[] args){
	     int a=5;
		 int b=6;
		 int c;
		 c= a>b ？a : b;//判断a大于b是否成立，成立把a给c，不成立把b给c
		 System.out.println(c=a>b?a:b);//也是正确使用方法
	 }}

注意事项：
1、必须同时保证表达式A和B都符合左侧数据类型的要求。
2、三元运算符的结果必须被使用。

二、方法

方法的定义

	格式：	public static void 方法名称（）{
         		方法体
	  }
	  修饰符  返回值类型  方法名称（参数类型 参数名称，参数名称2，。。。）
	  {
                       方法体；
							 return 返回值；}

方法名称的命名规则和变量一样，使用小驼峰式。

方法体：大括号中可以包含任意条语句。

 修饰符：列如权限修饰符 public、private.....
返回值类型：也就是方法最终产生数据结果是什么类型
方法名称：方法的名字，小驼峰命名
参数类型：进入方法的数据是什么类型
参数名称：进入方法数据对应的变量名称。
ps：参数有多个的话用逗号隔开
方法体：方法需要做的事情，若干行代码
return：1、停止当前方法2、将后面的返回值还给调用处
返回值：也就是方法执行后最终产生的数据结果
注意：return后面的返回值必须和方法名称前面的返回值类型保持对应

方法三种调用格式：
1、单独调用：方法名称（参数）
2、打印调用：System.out.println（方法名称（参数））
3、赋值调用：数据类型 变量名称=方法名称（参数）

public calss Method{
      public static void main(String[] args){
	  //调用方法
	    method1（）；
		method2（）；
		
	  }
	  public static void method1(){
	  
	 }
	 public static void method2(){
	 
	 }
	  }

 注意事项：
 1、方法定义的向后顺序无所谓。
 2、方法的定义不能产生嵌套包含关系。（方法不能包含方法）
 3、方法定义后，想要执行一定要进行方法的调用
如何调用方法：
格式   方法名称（）；


  编译器优点：对于bytre/short/char三种类型来说，如果没用超过范围
  那么javac编译器会自动隐含的为我们补上一个（byte）\(char)\(short)
  1、如果没超过左侧数据类型范围编译器会自动补上。
  2、超过左侧数据类型范围，编译器会报错。

 编译器的常量优化：
 右侧表达式全部都是常量时候，javac将会直接将若干个常量计算得到结果
比如：short result=4+3；编译得到的.class文件中直接就是short result=7;

方法调用流程：
1、找到调用的方法
2、传递参数
3、执行方法体
4、带着返回值，回到方法的调用处。

方法参数：
有参数：小括号里面有内容，当一个方法需要一些数据条件才能完成任务的时候，就是有参数。
无参数：小括号当中留空，一个方法不需要任何数据条件，自己就能独立完成任务，就是无参数。

public class Demo1 {
    public static void main(String[] args){
        int sum =method1(3,4);
        method2(6,6);//无返回值，结果不告诉main
        System.out.println(sum);
        System.out.println(method1(5,5));
    }
    public static int method1(int a ,int b){/*有返回值的方法*/
        int result=a+b;
        return result;
    }
    public static void method2(int a,int b){
	//对于void没有返回值的方法只能单独调用不能打印和赋值。
        int result=a+b;
        System.out.println(result+"没有返回值");
    }
}

注意事项：
1、对于有返回值的方法，可以使用单独调用（可以不使用返回值）、打印调用或者赋值调用
2、没有返回值的方法只能进行单独调用。

使用方法时候的注意事项：
1、方法应该定义在类中，但是不能在方法当中再定义方法，不能嵌套。
2、方法定义的前后顺序无所谓。
3、方法定义之后不会执行，如果希望执行，一定要调用。
4、如果方法有返回值，那么一定要写上return+返回值，不能没有
5、return后面的数据必须和返回值类型对应。
6、对于一个void没有返回值的方法，不能写return后面的返回值，只能写return自己。这里return只是结束方法而已。
7、对于void类型方法当中最后一行的return可以省略不写。
8、对于一个方法当中可以有多个return语句，但是必须保证同时只有一个会被执行到。

方法重载的基本使用

对于功能类似的方法来说，应为参数列表不一样，却需要记住那么多不同的方法名称，太麻烦。

列如重载前：

public class Demo3 {
    public static void main(String[] args) {
        System.out.println(method1(1, 1));
        System.out.println(method2(1, 1, 1));
    }

    public static int method1(int a, int b) {
        int sum = a + b;
        return sum;
    }

    public static int method2(int a, int b, int c) {
        int sum = a + b + c;
        return sum;
    }

重载之后
方法overload（重载）：多个方法的名称一样但是参数列表不同

public class Demo3 {
    public static void main(String[] args) {
        System.out.println(method1(1, 1));
        System.out.println(method1(1, 1, 1));
    }
     public static int method1(int a, int b) {
        int sum = a + b;
        return sum;
    }

    public static int method1(int a, int b, int c) {
        int sum = a + b + c;
        return sum;
    }
}

重载（overload）好处：只有记住唯一一个方法名称，就能实现多个功能。
方法重载（overload）与下列因素相关：
1、参数个数不同可以。
2、参数类型不同也是可以的。
3、参数的多类型顺序不同。public static int method(int a,double b){ return (int) (a+b);}
public static int method(int b,double a){ return (int) (a+b);}
4、参数的名称不同，但是类型和个数相同，则会报错
5、返回值样式不同其它相同，也会报错

三、 判断语句

1、 if

格式： if（）{ 语句体； }

 public class DemoIf{
     public static void main(String[] args){
	     int age = 16;
		 if(age>=18){
		     System.out.println("可以浏览网站")；
		     }
		 }}

2、if…else

格式 :
if（）{ 语句体； }
else{ 语句体；} 二者执行其一

public class IfElseDemo{
     public static void main(String[] args){
	 int num=3;
	 if(num%2=0){
	     System.out.println("num偶数")；}
		 else{System.out.println("num是奇");}
	 }}

格式:
  if（判断条件1）{语句体；}
		else if（判断条件2）{语句体二；}
			else{  都不满足收尾；}

可以有多个判断体。

四、选择结构

switch语句格式：
	switch(表达式){
		case 常量值1：
						语句体1；
						break；
	case2 常量值2：
						语句体2；
					break；
	........
	default：
					语句体n+1；
					break；
	}

public class DemoSwitch{
     public static void main(String[] args){
	     int num = 1;
		 switch(num){
		     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;
			 default:
			 System.out.println("今天是周末")；
			 break；
			 }
		 }
	 }

注意事项：
1、多个case后面的数值不可以重复。
2、switch后面的小括号只能放下列数据类型：基本数据类型：byte/short/char/int
引用数据类型：string字符串、enum枚举
3、switch语句格式可以很灵活：前后顺序可以颠倒，而且break语句还可以省略（没用必要不要省略）。
”匹配哪一个case就从哪一个位置向下执行，直到遇到了break或者整体结束为止“

五、循环语句

for循环

格式  for（初始化表达式；布尔判断；步进表达式）{
	循环体；}
	
初始化语句：开始最初执行，而且只做唯一一次。
布尔判断：成立继续循环，不成立则跳出循环。
循环体：重复要做的事情，若干语句。
步进语句：每次循环结束之后进行的扫尾工作，每次循环结束后都要执行一次。

public class DemoFor{
     public static void main(String[] args){
	     for(int a=1;a<=10;a++){
		 System.out.println(a)；}
		 }
	 }

while循环

格式 ：
标准格式：while（条件判断）{循环体；}
扩展格式： 初始化语句； while（条件判断）{循环体；步进语句；}

public class DemoWhile{
     public static void main(String[] args){
	 int a=5;
	/*   while(a<10){
	      System.out.println("死循环")；
		  }
		  */
		  while（a<10）{
		      System.out.println(a);
			  a++;//步进语句
			  }
	 }
	 }

do…while循环

标准格式：
	do{
		循环体
		}
  while(条件判断);
  
do：无条件执行一次循环体，不需要经行条件判断。
扩展格式：
do{
循环体；
部进语句；}
while（）；

public class DemoDoWhile{
     public static void main(String[] args){
	     int a=0;
		 int sum=0;
		 do{
		     sum+=a;
			 a++;
			 }
			 while(a<=100);
		System.out.println(sum);
		 }
		 
	 }

三种循环的区别：
1、如果条件判断从来没有满足过，那么for和while循环不会执行，但是do while循环将会执行一次。
2、for循环的变量在小括号内，只有循环内部才可以使用。while和do while循环的初始化语句本来就在循环外，所以循环之后任然可以使用变量。

关键字：break、continue

1、可以用在switch语句当中，一旦执行，整个switch语句立刻结束。
2、还可以用在循环语句当中，一旦执行，循环结束，打断循环。

关于循环的选择：
凡是次数确定的场景多用for循环，否则多用while循环

打断循环：

public Demo{
     public static void main(String[] args){
	     for(int a=0;a<10;a++){
		 if(a==4){break;}//如果a=4则打断循环
		 }
		 }
	 }

条件控制语句（关键字：continue）：
一旦执行，立即跳过当前次循环剩余的内容，马上开始下一次循环。
列：

public Demo{
      public static void main(String[] args){
	      for(int i=1;i<=10;i++){
		     if(i==4){
			     continue;//如果当前i=4，那么跳过4马上开始i=5的循环。
				 }
		      System.out.println(i);//输出没有4
			  
			  }
		  }
	  }