小白的20天Java学习打卡day8

太原理工大学机器人团队20天学习打卡day8

今天继续昨天方法基础语法的学习，主要是用通过写代码来理解和记忆，所以今天的代码会比较多

也就没有小结了，多多练习！！

话不多说，直接献上笔记！

实例

//public表示公开的
//class表示定义类
//MethodTest03是一个类名
public class MethodTest03{//表示定义一个公开的类，起名MethodTest03
    //类体
    
    //方法
    //public表示公开的，static表示静态的，void表示方法执行结束之后不返回任何数据，
    //main是方法名：主方法
    //(String[] args)：形式参数列表，其中String[]是一种引用数据类型，args是一个局部变量的变量名
    //所以以下只有args这个局部变量的变量名是随意的
    //主方法就需要这样固定编写，这是程序的入口。
    public static void (String[] args){
	//这里的程序是一定会执行的
        //main方法是JVM负责调用的，是一个入口位置
        //从这里作为起点开始执行程序
        //既然是这样，我们就可以在这里编写java语句来调用其他的方法
        //调用MethodTest03的sum方法,传递两个实参
        MethodTest03.sum(10,20);  
        //(10,20)是实参列表【实际上执行到这里main方法暂停了，进入sum方法执行】
        
        //注意：方法体当中的代码是有顺序的遵循自上而下的顺序依次执行
        
        //一个方法可以被重复调用
        int a = 100;
        MethodTest03.sum(a,500);
    }
    
    //自定义方法，不是程序的入口
    //方法作用：计算两个int类型数据的和，不要求返回结果，但是要求将结果直接输出到控制台
    //修饰符列表：pubilc static
    //返回值类型：void
    //方法名：sum
    //形式参数列表：(int x，int y)
    //方法体：主要的任务是求和之后输出计算结果
    public static void sum(int i,int j){  //(int i,int j)是形参列表
		System.out.println(i + "+" + j "=" + i+j);
    }
}

---

方法的调用不一定在main方法当中，可以在其他方法当中

只要是程序可以执行到的位置，都可以去调用其他方法

public class MethodTest04{

    public static void sum(int i,int j){
		System.out.println(i + "+" + j + "=" + i+j);
        //调用doSome方法
        MethodTest04.doSome();
    }
    
    //主方法
    public static void main (String[] args){
	//调用sum方法
        MethodTest04.sum(1,2);  
        
        System.out.println("Hello World");
    }
    
    public static void doSome(){
        System.out.println("do some");
    }
   
}

---

方法调用的时候实参和形参要求个数对应相同，数据类型对应相同

类型不同的时候要求能够进行相应的自动类型转换

public class MethodTest05{

  	public static void main (String[] args){
		//编译错误，参数数量不同
        //MethodTest05.sum(); 
        
        //编译错误，实参和形参的类型不是对应相同
        //MethodTest05.sum(true,false);
        
        //可以
        MethodTest05.sum(10L,20L);
        //存在自动类型转换：int——>long
        MethodTest05.sum(10,20);
        
        //编译错误，参数类型不是对应相同的
        //MethodTest05.sum(1.0,20);
        
        //可以
        MethodTest05.sum((long)3.0,20);
    }
    
	public static void sum(long a,long b){
		System.out.println(a + "+" + b + "=" + a+b);     
        
    }
}

---

有的时候“类名.“可以省略，什么情况下可以省略

负责调用的方法和被调用的方法在同一个类体当中

public class MethodTest06
{
  	public static void main (String[] args){
		//调用方法
        MethodTest06.m();
        
        //对于方法的修饰符列表当中又static关键字的，类名.可以省略不写吗
        m();//编译通过了
        
        //调用其他类【不是本类】中的方法
        A.doOther();
        
        //省略试试
        //doOther(); 编译报错，“类名.”省略之后默认从当前类中找doOther方法，当前类中该方法不存在
    }
    
	public static void m(){
		System.out.println("m method execute");
        //完整的方式
        MethodTest06.m2();
        //省略的方式
       	m2();
        
        //不想调用当前本类中的m2方法，这个时候就必须添加“类名.”了
        A.m2();
        
    }
    
    public static void m2(){
		System.out.println("m2 execute");     
        
    }
}

class A//建议一个java源文件当中只定义一个class，比较清晰，这里是为了方便说明
{
    public static void doOther(){
        System.out.println("A's doOther method invoke");
    }
    
    public static void m2(){
		System.out.println("m2 execute");     
        
    }
}

---

运行顺序

• 分析以下程序的输出结果：

  main begin

  m1 begin

  m2 begin

  m3 begin

  m3 over

  m2over

  m1 over

  main over

• 对于当前程序来说

  • main方法最先被调用，main方法也是最后一个结束
  • 最后调用的方法是m3方法，该方法最先结束

• main 方法结束后整个程序就结束了*【这句话只适合于当前所讲的内容】*

不用刻意记忆：

​ 只要记住代码是自上而下依次执行即可。

​ 当前行的代码没有执行的时候，下一行代码是无法执行的

public class MethodTest07{

  	public static void main (String[] args){
		System.out.println("main begin");
        m1();//暂停，进入m1
        System.out.println("main over");	           
    }
    public static void m1(){
        System.out.println("m1 begin");
        m2();//暂停，进入m2
        System.out.println("m1 over");
    }
    
    public static void m2(){
        System.out.println("m2 begin");
        m3();//暂停，进入m3
        System.out.println("m2 over");
    }
    
    public static void m3(){
        System.out.println("m3 begin");
        System.out.println("m3 over");//结束后，m3结束
    }
}

---

方法的返回值类型不是void的时候

• 返回值不是void的时候
  • 要求方法必须百分百的执行return 值;这样的语句，来完成值的返回
  • 没有这个语句编译器会报错
• 一个方法有返回值的时候，当我们调用这个方法时，方法返回了一个值，对于调用者来说，这个返回值可以选择接收，也可以选择不接收。但是大部分情况下我们都是接收的

public class MethodTest08{
  	public static void main (String[] args){
        //调用这个方法
		divide(10,3);	
        
        //这里接收一下方法执行结束之后的返回值
        //采用变量接收
        //变量的数据类型需要和返回值的数据类型相同，或者可以自动类型转换
        
        //赋值运算符的右边先执行，将执行的结果赋值给左边的变量
        int i = divide(10,3);
        System.out.println(i);
        
        System.out.println(divide(10,3));
        
    }
    //需求：定义并实现一个方法，该方法可以计算两个int类型数据的商，要求将最终的计算结果返回给调用者
    
    //编译报错，缺少返回语句
    /*
    public static int divide(int a,int b){	
    }
    */
    
   	//编译报错，缺少返回值
    /*
    public static int divide(int a,int b){
    	return;
    }
    */
    
    //编译报错：方法定义时要求返回int类型，此时返回布尔类型，类型不兼容
    /*
    public static int divide(int a,int b){
    	return true;
    }
    */
    
    //可以：但是具体的方法体中编写的代码无法满足当前的需求
    /*
    public static int divide(int a,int b){
    	return 1;
    }
    */
    
    public static int divide(int a,int b){ 
        System.out.println("Hello");
    	return a/b;
    }
    
}

---

深入return语句

• 带有return关键字的java语句只要执行，所在的方法执行结束。
• 在同一个作用域当中，return语句下面不能编写任何代码，因为这些代码永远都执行不到，编译会报错

public class MethodTest09{
  	public static void main (String[] args){
 		
        System.out.println(m());
    }
    
    //编译报错：缺少返回语句，以下程序编译器认为无法百分百保证“return 1”会执行
    /*
    public static int m(){
		int a = 10;
        if(a > 3){
			return 1;
        }
    }
    */
    
    //以下程序可以保证return 1或者return 0 执行，编译通过
    /*
    public static int m(){
		int a = 10;
        if(a > 3){
			return 1;
        }else{
            return 0;
        }
    }
    */
    
    //可以，和以上方法完全相同
    /*
    public static int m(){
		int a = 10;
        if(a > 3){
			return 1;
        }
        return 0;
    }
    */
    
    /*
    public static int m(){
		int a = 10;
        if(a > 3){
			return 1;
            //这里不能编写代码，编译错误，无法访问的语句
            //System.out.println("Hello");
        }
        //这里的代码可以执行到
        System.out.println("Hello");
        return 0;
        //编译错误，无法访问的语句
        //System.out.println("Hello");
    }
    */
    
     public static int m(){
		return 10>3 ? 1 : 0;
    }
}

---

在返回值是void的方法当中使用 return; 语句

return;语句出现在返回值为void的方法当中主要是为了用来结束该方法

public class MethodTest10{
  	public static void main (String[] args){
 		m();
        
        for(i = 10;i>0;i--){
			if(i==2){
				return;//结束的是main方法
            }
            System.out.println("data-->" + i);
        }
        System.out.println("Execute Here");
    }
    
    //编译错误：对于结果类型为空的方法，无法返回值
    /*
    public static void m(){
		return 10;
	}
	*/
    
    /*可以：
    public static void m(){
		return;
    }
    */
    
    public static void m(){
		for(int i = 0 ; i<10 ; i++){
			if(i==5){
                return;//不是终止for循环，终止的是m方法
                //break; //终止的for循环
            }
            System.out.println("i-->" + i);
        }
        System.out.println("HelloWorld");
    }
    

}