Java学习lesson 05

Posted 2020-10-10

方法

   *  定义: 实现一个功能的代码片段的封装。

   *  [修饰符...] 返回值类型 方法名称([形参的列表]){

          //方法中实现的逻辑

       }

   *   形参列表: 方法接收外部传入的数据的接收媒介.

   *   返回值: 方法执行结束之后，返回的值可以是基本数据类型（int,float等）也可以是复合数       据类型（如数组、对象等）。

   *   如果方法不需要返回任何的值，那么我们的方法返回类型写作void.

      在方法里返回一个值，需要用到 return. 

   *   形参列表:

       当我们定义了一个方法之后，去调用方法的时候，一定要注意我们传递给方法的入参的类型        和数量，一定要一一对应（参数可以有零个或多个，多个参数要用“，”隔开）。

     关注点:

     * 方法名是否一致

     * 形参列表的所有参数类型和数量是否一致。 对于形参变量的命名，完全是没有关系的.

     * 返回值的类型可以是基本类型，也可以是引用类型。

     * 方法内不能再声明方法，即一个类中的方法都是并列的。

public class BookDemo {
	public static void main(String[] args){
			//用一个变量来保存方法的返回值，如果不保存方法的返回值，则方法的返回值会放到一个临时的空间，并且方法执行结束之后，内存空间就释放。
			String mybookName= choiceBook(1);
			System.out.print("你选择的书是:"+mybookName);
			
			long page = pageCount(1);
			System.out.println("共"+page+"页");
	}
	public static String choiceBook(int num){
		String bookName;
		switch(num){
			case 1:bookName = "《时间简史》";
			break;
			case 2:bookName = "《解忧杂货店》";
			break;
			case 3:bookName = "《围城》";
			break;
			default:bookName = "《我们仨》";
		}
		return bookName;
	}
	public static long pageCount(int num){
		 long page;
			switch(num){
			case 1:page=558;
			break;
			case 2:page=387;
			break;
			case 3:page=465;
			break;
			default:page=307;
		}
			return page;
	}
}

注意:

    * 一旦明确指定了方法的返回类型(非void),那么一定要保证最终方法可以成功的返回我们对应的      返回类型的数据.

    * 关于void返回类型

      如果不主动的添加return语句，在执行的时候，也会自动添加return.在实现void类型的方法       的时候，主动添加一个return也是没有问题。 

java预编译的特点：

    * 方法参数的传递来说，基本类型传递的是值。对于引用类型，传递的是引用.(传递的是地址)

传一个数组类型实现排序

public class ArrayParameterDemo{
    public static void main(String[] args){
         int []arr=new int[]{12,90,67,45,78,23};
         sortDemo(arr);
        
         
    }

   public static void sortDemo(int []arr){
        int temp=0;
        for(int i=0;i<arr.length-1;i++){
           for(int j=(i+1);j<arr.length;j++){
            if(arr[i]<arr[j]){
               temp=arr[i];
               arr[i]=arr[j];
               arr[j]=temp;
             }
            }
         }
          for(int i=0;i<arr.length;i++){

             System.out.print(arr[i]+",");
           }
   }
   
}

类:

     * 类的声明：

            类通过关键字Class来定义，一般格式为：[类的修饰符]class类名[接口名表]{

            类型 成员变量1；

           类型 成员变量2；

            ……

            类型 成员方法1（参数列表）{

              方法体1

            }

            类型 成员方法2（参数列表）{

              方法体2

            }

            ……

            }

用户类： 包含订单类(用户通过订单类中的方法进行下单)

   

商品类 

  电子类商品

  生活用品类商品

  家电类商品

订单类

public class User {
		public static void main(String[] args){
	       int num=2;
	       String productName=null;
			Product myProduct=new Product(num);//调用构造器
			myProduct.getProductName(num);
                        
			Order myOrder=new Order();
	                myOrder.getOrder();
	   }
	}
	class Product{
		int num;
		String productName;
		//构造器
		Product(int numParm){
			num=numParm;
		};
		
		//获取产品名称
		public void getProductName(int num) {  
			switch(num){
	              case 1:productName="电子类商品";
	              break;
	              case 2:productName="生活用品类商品";
	              break;
	              case 3:productName="家电类商品";
	              break;
	          }
                  System.out.println("你选择的是："+productName);
		}

	}
	class Order{	
	    //编译器会添加一个默认的构造器  Order(){  }
	    public void getOrder(){
	    	
			System.out.println("恭喜你，下单成功！！！");

	}

	}

    * 关于变量的作用域:

    * 成员变量:

     类的属性

    * 局部变量:

     方法中定义的变量或者是方法的形式参数。

    * 对于java语言来说，作用域控制是通过块来控制的.

     块的概念: 一对{} 包裹，该代码片段就称为 一块.

     对于某个块内定义的变量：

    * 对于当前的块，不能再定义同名的变量,即使类型不同也不行。

    * 对于当前的块，定义了某个变量，在块外不能够访问到块中定义的变量

    * 如果存在块的嵌套:

    * 那么外层块定义的变量，在内层块中是可以访问到的.

构造方法(构造器)

    *  类中特殊的方法，对于定义来讲，它的方法名必须和类名一模一样，并且不返回任何的值，        主要不能添加void.

    *  在new（创建一个对象的时候），一定会去调用它的构造方法。 但是如果我们没有自己添加        自己定义的构造器的话，编译器会添加一个默认的构造器:

       类名(){

        }

  

   *   如果我们主动添加一个默认的构造器，那么在创建对象的时候，通过new 类名(); 会调用我       们自己添加的默认构造器.

  

   *  当我们主动添加了一个包含参数列表的构造器，并且没有主动添加默认的构造器，则再通过       new 类名(); 就会遇到编译问题.

方法重载 

 

    *  对于同名的方法，具有不相同的参数列表，我们在访问的时候，通过调用方法传入不同的参        数列表，就可以找到我们特定的方法。

    *  当我们定义多个重载的方法的时候，在编译阶段的话，编译器可以根据我们方法形式参数数        量以及类型来区别不同的方法，执行阶段可以

       根据我们调用的时候传入的参数列表， 仅仅拥有不同的返回值类型，是不被视为重载的。

   

   练习:

   

   定义一个类，类中有个1维数组的成员变量(short)。 提供俩个方法，第一个方法接受一个int数    组，第二个方法接受一个long型的数组。

   俩个方法均将各自 形参传入的数组中元素的值进行求和。 并且与本身我们类成员变量数组的和做    一个差。 最终返回这样的结果。

 

public class ArrayOverload {
    short []arrShort;
    int sum;
    public static void main(String[] args){
		ArrayOverload array = new ArrayOverload(5);
                 int sum1=array.getArrPlus(new int[]{1,2,3,4,5});
		long sum2=array.getArrPlus(new long[]{1,2,3,4,5});
		array.ArrayOverload();
		System.out.println("getArrPlus(int[] arr)的结果是"+sum1);
		System.out.println("getArrPlus(int[] arr)的结果是"+sum2);
	}
    ArrayOverload(int a){
    	arrShort = new short[]{1,2,3,4,5};
    	for(int i=0;i<arrShort.length;i++){
    		sum+=arrShort[i];
    	}
    }
    void ArrayOverload(){
	}
    int getArrPlus(int[] arr){
		int sum3=0;
		for(int i=0;i<arr.length;i++){
			sum3+=arr[i];
		}
		
		return sum3 - sum;
	}
	//方法名相同，参数类型，个数不同
	long getArrPlus(long[] arr){
		long sum3= 0;
		for(int i=0;i<arr.length;i++){
			sum3+=arr[i];
		}
		return sum3-sum;
	}
	
}