疯狂Java学习笔记(007)

 

 回 顾

一、方法：

1. 方法的定义：

　　什么是方法？拥有特定功能的一个代码段，称为方法，其他语言中称为Function（函数）.

2. 方法定义的格式：

public static 返回值类型 方法名（形参类型 参数名1，形参类型 参数名2，....）{
　　方法体；
　　return [返回值]；
}

3.定义方法的两个明确：

　　1>返回值类型

　　2>形参列表

4. public static :

　　方法的修饰符，目前的固定格式。以后会又变化。

5. 返回值类型：

　　Java中的数据类型（基本的四类八种，引用的：可以又多种多样：jdk提供的，也可以是我们自己定义的！），表示的是方法执行后需要返回值的类型！

　　如果方法不需要返回任何之，就用void.

6. 方法名：

　　1>可以理解为变量名；

　　　　（就是一段内存空间的标识！方法名就是一段代码的标识！）

　　2>和变量的命名规范是一致的（即小驼峰命名法，从第二个单词开始首字母大写）

　　　　类名和接口名的命名规则是一致的（大驼峰命名法）

　　　　联想一下：包名和final变量名：

　　3>（）里整体称为形参列表；

　　　　每个形参定义包含两方面：形参类型，形参名！形参之间用逗号分隔，如果方法不需要任何参数，什么都不屑，（）必须写！！！

　　4>形参类型：

　　　　任何可用的数据类型：（基本的和引用的都可以）

　　5>形参名：

　　　　就是变量名，这个变量就是在方法体中有效，相当于在方法体中定义的局部变量！！！方法被调用时，形参就被赋值了！按照顺序传值！！！

7. 方法体：

　　0到若干条可以执行的语句，在方法被调用时，这些语句一次执行！

8. return :

　　关键字，表示一个方法的结束，如果方法又明确的返回值类型的话，return后必须有一个值（可以和方法定义时的返回值数据类型一致！或者可以自动类型转换成返回值类型的值：变量；常量；表达式）

　　如果方法的定义中，返回值时void型，return后就不能加任何值！！！

　　即：return；---此时整条语句都可以省略！！！

9. 方法定义的位置：

　　类定义中，和main方法时平级关系：

　　方法中不能再定义其它方法（即：方法不能嵌套定义！！！）

10. 方法的调用：

　　1>方法调用时传值：

　　　　实参：方法调用时，给方法传递的值，就是实参；

　　　　形参：方法定义时，参数列表中出现的参数名

　　2>赋值方向：实参→形参！！！

　　　　方法名（实参）；

　　　　实参的个数一定要和形参的个数对应！

　　　　类型：实参要么和形参类型一致，要么可以隐式类型转换！！！

　　　　实参的种类：变量，常量，表达式

　　3>  如何处理方法的返回值：

　　　　①有返回值的方法：

　　　　　　-不关心返回值：单独调用

　　　　　　-使用返回值：给其他变量赋值，直接参与表达式运算，当成参数传第给其他方法。

　　　　②没有返回值的方法：

　　　　　　-只能单独调用

　　　　　　-不能给其他变量赋值，不能直接参与表达式运算，不能当成参数传第给其他方法。

11. 方法的重载（overload）：

　　两同一不同！！！

　　即同类，同方法名，形参列表不同（个数不同或者类型的不同都成为形参列表不同！！！）

　　方法的访问权限修饰符，以及返回值类型都不是判断方法重载的标志！

 

练习题：

1.定义方法，用于计算一个int数值的阶乘

首先定义：

//返回值类型：int

//形参列表：int value

/*
    1.定义方法,用于计算一个int数值的阶乘
    //返回值类型:int
    //形参列表:int value
*/
public class HomeworkDemo1{
    public static void main(String[] abc){
        //
        int res = getNum(5);
        System.out.println(res);
        
        //
        System.out.println(getNum(5));
    }
    
    //返回值类型:int
    //形参列表:int value
    public static int getNum(int value){
        //求阶乘思想:
        int res = 1;
        for(int i = 1;i<=value;i++){
            res *= i;
        }
        return res;
    }
}

2.定义方法，用于获取指定范围内的一个随机值（int）

首先定义：

//返回值类型：int

//形参列表：int start ,int end

/*

定义方法,用于获取指定范围内的一个随机值(int)
//返回值类型:int
//形参列表:int start,int end

*/
public class HomeworkDemo2{
    public static void main(String[] args){
        int start = 10;
        int end = 20;
        System.out.println("随机值是: " + getRandom(start,end));       
    }   
    //返回值类型:int
    //形参列表:int start,int end
    public static int getRandom(int start,int end){
        return (int)(Math.random() * (end - start + 1) + start);
    }   
}

/*

定义方法,用于获取指定范围内的一个随机值(int)
//返回值类型:int
//形参列表:int start,int end

练习:
    改造: 从键盘录入起始和结束值:
*/
import java.util.Scanner;
public class HomeworkDemo2{
    public static void main(String[] args){
        Scanner s = new Scanner(System.in);
        System.out.print("请输入起始值：");
        int start = s.nextInt();
        System.out.println("请输入最终值：");        
        int end = s.nextInt();
        System.out.print("随机值是: " + getRandom(start,end));
        
    }
    
    //返回值类型:int
    //形参列表:int start,int end
    public static int getRandom(int start,int end){
        return (int)(Math.random() * (end - start + 1) + start);
    }
    
    
}

 做练习题

第七天  数组

一、数组

      

　　　数组的特点

　　

　　  数组定义格式

      

　　数组的初始化形式：

/*
    数组:array
        同一种数据类型的 〇到多个 数据的组合.
    
    数组的数据类型:就是元素的数据类型
    　　数组的长度(length):就是数组中数值的个数:
    　　元素(element):数组的各个数值称为元素
    　　索引(index):数组中各个元素的编号:从0开始,最大值是:数组的长度-1
    
    数组类型是引用数据类型:
        数组名保存的是一段内存空间的地址!
        真正的元素保存在那段内存空间中!!!
           
    为什么使用数组:
        减少定义变量名
        方便对一组数据进行操作
    
    定义数组的格式:(即:初始化数组的方式:)
        两种:
        > 定义时不指定初始值:只指定数组的长度,(动态初始化)
            数据类型 变量名 = 初始值;
            
            元素类型[] 数组名 = new 元素类型[数组长度];
            例如:
                定义一个数组,可以存放5个int型数据.
                int[] arrInt = new int[5];
            
        > 定义时就指定初始值:(静态初始化)
            元素类型[] 数组名 = new 元素类型[]{元素1,元素2,...};
            例如:
                int[] arr = new int[]{1,2,3,5};
*/
public class ArrayDemo1{
    public static void main(String[] args){
        //定义数组
        //动态初始化:定义数组时只指定长度,不指定具体的元素值!!
        int[] arr1 = new int[5];
        //arr1保存的是一段内存地址值!
        System.out.println(arr1);//[I@15db9742
        
        //打印引用数据类型的结构:
        //[I : 表示的是数据类型:[ 表示的就是数组,I表示的是元素的类型!
        //@ : 固定的分隔符
        //15db9742 : 一个十六进制的字符串:真实的内存地址值计算出来的!!!
        
        //定义byte类型数组
        byte[] arr2 = new byte[2];
        System.out.println(arr2);
        
        boolean[] arr4 = new boolean[3];
        System.out.println(arr4);
        
        
        //初始化数组的第二种方式:定义数组时指定元素值!此时不能指定数组的长度!
        int[] arr3 = new int[]{1,2,3,4,5,6};
        System.out.println(arr3);
        
        //静态初始化的简化写法:
        int[] arr5 = {1,2,3,45};
    }
}

练习:
考察一下,基本数据类型的数组的变量 ,直接打印时,其中的类型是什么字符?

/*

    考察基本数据类型的数组变量,直接打印的结果:
*/
public class ArrayDemo2{
    public static void main(String[] args){
        byte[] a1 = new byte[2];
        short[] a2 = new short[2];
        char[] a3 = new char[]{'a','b','c'};
        int[] a4 = new int[]{1,2,4};
        boolean[] a5 = new boolean[3];
        float[] a6 = new float[2];
        double[] a7 = new double[2];
        long[] a8 = new long[2];
        
        //
        System.out.println(a1);
        System.out.println(a2);
        System.out.println(a3);
        //println这个方法对字符型的数组有特殊的处理方式:重载这个方法的结果是打印数组里的所有字符!
        System.out.println(a4);
        System.out.println(a5);
        System.out.println(a6);
        System.out.println(a7);
        System.out.println(a8);
    }
}

/*
    考察基本数据类型的数组变量,直接打印的结果，是内存地址的映射，不是真的内存地址，以十六进制表示:
    
*/
public class PractiseDemo{
    public static void main(String[] args){
        System.out.print("int ：");
        int[] arr1 = new int[5];
        System.out.println(arr1);
        
        System.out.print("byte ：");
        byte[] arr2 = new byte[5];
        System.out.println(arr2);
        
        System.out.print("short ：");
        short[] arr3 = new short[5];
        System.out.println(arr3);
        
        System.out.print("long ：");
        long[] arr4 = new long[5];
        System.out.println(arr4);
        
        System.out.print("char ：");
        char[] arr5 = new char[5];
        System.out.println(arr5);
        
        System.out.print("float ：");
        float[] arr6 = new float[5];
        System.out.println(arr6);
        
        System.out.print("double ：");
        double[] arr7 = new double[5];
        System.out.println(arr7);
        
        System.out.print("boolean ：");
        boolean[] arr8 = new boolean[5];
        System.out.println(arr8);
    
    }
}

打印结果：注意long型开始时J,boolean型区别于byte是Z,而char类型字符型的数组有特殊的处理方式:重载这个方法的结果是打印数组里的所有字符!

　　jvm

1.描述：　　1>.jvm:实际上也是一种软件.

　　2>.jvm实际上只是一种标准,任何组织都可以自己开发jvm虚拟机:
　　　如，淘宝自主开发的  Tao JVM

2. jvm如何对内存进行区域的划分:
　　对内存的划分就是方便对数据的管理:

3. 通常会划分5大区域:
　　栈区:stack
　　堆区:heap
　　方法区:method area
　　本地方法栈:native method stack(基本不用)
　　程序计数器:program counter(基本不用)

4. 不同的jvm虚拟机对内存空间的划分是不一样的.

　　1> 栈区:stack
　　　　方法中定义的局部变量(和形参)都是在栈区:
　　　　栈区中的变量没有初始值,使用之前必须手动赋值!!
　　2> 堆区:heap
　　　　凡是new出来的对象都是在堆区!
　　　　　　Scanner s = new ...
　　　　　　int[] arr = new ...
　　　　ps:堆区中的变量都有初始值!!!

　　3> 方法区:method area
　　　　用来存放.class字节码文件和方法定义的!

4. .java -> .class -> 方法区!!

　

5. 数组的内存结构

5.代码学习

　　1>定义基本数据类型的数组，查看每种数据类型的默认值，其实有点消极。

　　　　整数:0
    　　　浮点数:0.0
    　　   布尔型:false
              引用数据类型:null

/*
    验证:
        1.数组的默认值:
        2.数组元素的访问方式:
            数组名[索引值]
    练习:定义基本数据类型的数组,有2个元素.考察他们的默认值:
        
*/
public class ArrayDemo3{
    public static void main(String[] args){
        //定义一个数组
        int[] arr = new int[3];  
        //在堆空间中开辟3个空间,每个空间可以存放一个int型元素.初始值为0.
        //然后把首元素的地址(也就是整个数组的地址)赋值给栈空间中的变量arr
        
        //验证默认值:
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        
        //如何对数组元素赋值:
        arr[2] = 10;
        System.out.println(arr[2]);
        
        arr[2] = 20;
        System.out.println(arr[2]);
        
    }
}

/* 
    练习:定义基本数据类型的数组,有2个元素.考察他们的默认值: 
    
    考察基本数据类型和引用数据类型的数组的默认值!
    整数:0
    浮点数:0.0
    布尔型:false
    引用数据类型:null

*/

public class PractiseDemo{
    public static void main(String[] args){
        System.out.println("int 默认值为");
        int[] a4 = new int[2];
        System.out.println(a4[0]);
        System.out.println(a4[1]);

        System.out.println("byte 默认值为");
        byte[] a1 = new byte[2];
        System.out.println(a1[0]);
        System.out.println(a1[1]);        
        
        System.out.println("short 默认值为");
        short[] a2 = new short[2];
        System.out.println(a2[0]);
        System.out.println(a2[1]);        
                
        System.out.println("chare 默认值为");
        char[] a3 = new char[]{'a','b','c'};
        System.out.println(a3[0]);
        System.out.println(a3[1]);    
        
        System.out.println("boolean 默认值为");
        boolean[] a5 = new boolean[3];
        System.out.println(a5[0]);
        System.out.println(a5[1]);        
        
        System.out.println("float 默认值为");
        float[] a6 = new float[2];
        System.out.println(a6[0]);
        System.out.println(a6[1]);    
        
        System.out.println("double 默认值为");
        double[] a7 = new double[2];
        System.out.println(a7[0]);
        System.out.println(a7[1]);
        
        System.out.println("long 默认值为");
        long[] a8 = new long[2];
        System.out.println(a8[0]);
        System.out.println(a8[1]);
            
    }
}

结果为：

练习:
1.Java中数组的初始化方式有哪两种?
2.jvm虚拟机的内存划分成几个区域,各个区域都有什么特点?
3.以下每条语句执行时,内存中都发生了什么变化?
int[] arr = new int[2];
arr[1] = 10;
4.定义一个方法,参数是一个int数组.在方法中把所有的元素都打印出来.

 回答：

1. 两种:
        > 定义时不指定初始值:只指定数组的长度,(动态初始化)

　　　　　动态初始化：定义数组时只指定数组的长度，里面的元素都是默认值
            　　数据类型 变量名 = 初始值;
           　　 元素类型[] 数组名 = new 元素类型[数组长度];
            　　例如:
               　　 定义一个数组,可以存放5个int型数据.
                　　int[] arrInt = new int[5];
           
        > 定义时就指定初始值:(静态初始化)

　　　　　静态初始化：定义数组时就指定数组元素的值。
            　　元素类型[] 数组名 = new 元素类型[]{元素1,元素2,...};
           　　 例如:
                　　int[] arr = new int[]{1,2,3,5};

　2.一共有五个区域，分别是：

　　1> 栈区:stack
　　　　方法中定义的局部变量(和形参)都是在栈区:
　　　　栈区中的变量没有初始值,使用之前必须手动赋值!!

　　　　方法调用完毕，方法中定义的变量所占用的空间，就释放了！！

　　2> 堆区:heap
　　　　凡是new出来的对象都是在堆区!
　　　　　　Scanner s = new ...
　　　　　　int[] arr = new ...
　　　　ps:堆区中的变量都有初始值!!!

　　　　　　整型：0

　　　　　　浮点型：0.0

　　　　　　布尔型：false

　　　　　　引用数据类型：null

　　3> 方法区:method area
　　　　用来存放.class字节码文件和方法定义的区域 !

具体的说：

                

3. 以下每条语句执行时,内存中都发生了什么变化?
　　int[] arr = new int[4]; 
　　arr[3] = 10;

 

4.定义一个方法,参数是一个int数组.在方法中把所有的元素都打印出来.

import java.util.Scanner;
public class PractiseDemo{
    public static void main(String[] args){
        Scanner s = new Scanner(System.in);
        System.out.print("请输入一个数字: ");
        int x = s.nextInt();
        list(x);
    }
    public static void list(int value){
        int[] arr = new int[value];
            for(int i =0;i<=(value-1);i++ ){
            System.out.println(arr[i]);
            }
    }
}

/*
    数组的遍历:traversal
        依次访问数组中每个元素的机制:
    
    如果程序中出现大量重复的代码,考虑优化:
        目前优化有两种方式:
            1.循环
            2.封装成方法
    
    
*/
public class ArrayDemo5{
    public static void main(String[] args){
        int[] arr = {1,2,3,4,5,6,7,8,9,10};
        
        /*
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        System.out.println(arr[3]);
        System.out.println(arr[4]);
        */
        
        //使用循环改进打印数组的元素
        /*
        for(int i = 0;i<5;i++){
            System.out.println(arr[i]);
        }
        */
        
        //数组的长度是我们查出来的,有可能数组是通过方法传递进来的.
        //必须让程序自己计算数组的长度.
        //数组有一个属性:length,代表的就是数组的长度(数组的元素的个数)
        for(int i = 0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
        
    }
}

/*
    数组操作容易见到的两个问题:
        1.数组索引越界异常:java.lang.ArrayIndexOutOfBoundsException:
            0 length-1
                -1 length+1
        2.空指针异常:java.lang.NullPointerException
            数组类型的变量,不再指向内存中的数组.而是指向null值.
            此时用数组名[索引值] 就会出现空指针异常.
            
            
*/
public class ArrayDemo7{
    public static void main(String[] args){
        int[] arr = {1,2,3,5};
        
        // java.lang.ArrayIndexOutOfBoundsException:
        //运行时异常,在编译阶段不检查越界异常!!!报错信息中会提示错误的索引值!
        // System.out.println(arr[40]);
        
        //空指针异常:
        // arr = null;
        // System.out.println(arr[0]);//java.lang.NullPointerException:空指针异常!运行时异常:
        
    }
    
}

/*
定义一个方法,参数是一个int数组.在方法中把所有的元素都打印出来
*/
public class ArrayDemo6{
    public static void main(String[] args){
        //调用方法
        int[] arr = {1,2,3,5,6};
        
        printArray(arr);
        printArray2(arr);
    }
    //返回值类型:void
    //形参列表:int[] arr
    public static void printArray(int[] arr){
        //
        for(int i = 0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
    }
    
    //
    public static void printArray2(int[] arr){
        //
        for(int i = 0;i<arr.length;i++){
            System.out.print(arr[i]);
            //判断是否是最后一个元素:(索引值是长度值-1就说名是最后一个元素)
            if(i != arr.length - 1){
                System.out.print(",");
            }
        }
    }
    
    
}

/*
    求最值的思路:
    求最大值:
        先定义一个变量,初始值是数组的第一个元素!!
        然后从第二个元素开始遍历数组,
            判断:
                如果遇到了比变量大的值,让元素的值赋值给变量.
        遍历完成后,整个数组的最大值就保存在变量中!!
        
    求最小值:
        先定义一个变量,初始值是数组的第一个元素!!
        然后从第二个元素开始遍历数组,
            判断:
                如果遇到了比变量小的值,让元素的值赋值给变量.
        遍历完成后,整个数组的最小值就保存在变量中!!
        
*/
public class ArrayDemo8{
    public static void main(String[] args){
        int[] arr = {9,5,2,70};
        System.out.println("最大值是: " + getMax(arr));
    }
    //获取最大值:
    //返回值类型:int
    //形参列表:int[] arr
    public static int getMax(int[] arr){
        //遍历数组,获取最大值
        int max = arr[0];
        
        //从第二个元素开始遍历数组
        for(int i = 1;i<arr.length;i++){
            //判断
            if(arr[i] > max){
                max = arr[i];
            }
        }
        //
        return max;
    }
}