第三周总结 2022.10.31-2022.11.04

    方法

概述：方法就是将一个功能抽取出来，把代码单独定义在一个大括号内，形成一个单独的功能。 当我 们需要这个功能的时候，就可以去调用。这样即实现了代码的复用性，也解决了代码冗余的现象。 (方法就是完成特定功能的代码块。

格式：修饰符 返回值类型 方法名 （参数列表）｛

             代码（方法体）...

                        return ;

                 ｝

定义格式解释：

修饰符：目前固定写法 public

static 返回值类型 用于限定返回值的数据类型

方法名 一个名称，为了方便我们调用方法

参数类型 限定调用方法时传入参数的数据类型

参数名 是一个变量，接收调用方法时传入的参数

方法体 完成功能的代码

return 结束方法以及返回方法指定类型的值

返回值 程序被return带回的结果，返回给调用者

方法书写前要有两个明确：

1.明确返回值类型；

2.明确参数数量及类型；

有明确返回值的方法调用：

1.单独调用，没有意

2. 输出调用，有意义，但是不够好，因为我不一定非要把结果输出

3.赋值调用，推荐方式

方法定义注意事项

方法不调用不执行 方法与方法是平级关系，不能嵌套定义 方法定义的时候参数之间用逗号隔开 方法调用的时候不用在传递数据类型 如果方法有明确的返回值，一定要有return带回一个值

没有明确返回值的函数调用

其实就是void类型方法的调用 只能单独调用

方法重载：

在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

方法重载的特点：

1.返回值类型无关，只看方法名和参数列表

2.在调用时，虚拟机通过参数列表的不同来区分同名方法

Java中的内存分配

Java 程序在运行时，需要在内存中的分配空间。为了提高运算效率，就对空间进行了不同区域的划分， 因为每一片区域都有特定的处理数据方式和内存管理方式。

栈 存储局部变量

堆 存储new出来的东西

方法区

本地方法区（和系统相关）

寄存器（给CPU使用）

当运行出现一些错误：

jdk提供了类 java.lang.Throwable-->Exception/error (后期讲常用类的去讲) Exception类 子类 RuntimeException:运行时期异常 (程序在运行时发生的问题--->代码写的逻辑不严谨或者一些漏洞) * 不是RuntimeException里面的类:都是编译时期异常(在idea或者eclipse开发工具中,编译通过不了,语法错误!) error:严重问题(错误) ---内存溢出

数组中常见的两个小问题

数组索引越界 ArrayIndexOutOfBoundsException 访问到了数组中的不存在的索引时发生。

空指针异常 NullPointerException 数组引用没有指向实体，却在操作实体中的元素时

方法示例

1.键盘录入比大小

public class FunctionTest {
    public static void main(String[] args) {

        //1)键盘录入两个数据,比较两个数中最大值,使用方法来完成
        //创建键盘录入对象
        Scanner sc = new Scanner(System.in) ;

        //提示并录入数据
        System.out.println("请输入第一个数据:") ;
        int a = sc.nextInt() ;

        System.out.println("请输入第二个数据:") ;
        int b = sc.nextInt();

        //调用:赋值调用
        int reuslt = getMax(a,b) ;
        System.out.println("最大值是:"+reuslt);

    }
    /*
    *   定义一个方法,比较数据中中的最大值
    *   两个明确
    *       1)明确返回值类型 int
    *       2)明确参数类型 以及参数个数
    *           int  2个
    *
    * */
    public static int getMax(int a,int b){ //自己的方法只是完成方法里面的逻辑操作(业务,实际数据是从调用者传进来)
       //要么三元
        //要么流程语句if...else...
        int max ;
        if(a>b) {
            max = a;
        }else if(a==b){
            max = a;//赋值
        }else{
            max = b ;
        }
        return  max ;//记录最大值
    }
}

2.录入n打印nn乘法表

public class FunctionTest3 {
    public static void main(String[] args) {
        //1)键盘录入一个数据N,打印NN乘法表,使用方法完成
        Scanner sc = new Scanner(System.in) ;

        //提示并录入数据
        System.out.println("请您输入数据n(1-9):");
        int n = sc.nextInt() ;
        //调用方法
        printNN(n);
    }
    /*
    * 定义一个方法:打印NN乘法表的
    * 两个明确
    *       1)明确返回值类型:void
    *       2)明确参数类型以及参数个数
    *           int ,1个参数
    * */
    public  static void printNN(int n){
        for(int x=1 ;x<=n;x++){
            for(int y =1 ; y <=x ; y++){
                System.out.print(x+"*"+y+"="+(y*x)+"\t");
            }
            System.out.println();
        }
    }
}

3.猜数字游戏

1)通过jdk提供的Math的random方法 1-100之间的随机数
 * 2)不断的键盘录入数据,和随机数进行比较
 * 3)大了,提示大了
 * 小了,提示下了
 * 否则,猜中了,您是第多少次猜中的
 */
public class FunctionTest4 {
    public static void main(String[] args) {

        //main方法中 代码,越少越好
        //调用我们写的方法
        playGuessNumberGame();

    }

    /**
     * 定义一个方法,里面是猜数字游戏
     *  两个明确
     *          明确返回值类型:没有具体返回结果,直接输出
     *          明确参数类型以及参数个数
     *                  空参
     */
    public static void playGuessNumberGame(){
        //产生随机数 1-100之间随机数
        int number = (int) (Math.random()*100+1) ;

        //定义统计变量
        int count = 0 ;
        //不断的键盘录入数据
        while(true){
            count ++ ;
            //创建键盘录入对象
            Scanner sc = new Scanner(System.in) ;

            System.out.println("请您要输入要猜的数字(1-100):");
            int guessNumber = sc.nextInt() ;

            if(guessNumber <0 || guessNumber>100){
                System.out.println("录入数据不合法!");
                break ;
            }else if(guessNumber > number){
                System.out.println("您要猜的数字"+guessNumber+"大了");
            }else if(guessNumber<number){
                System.out.println("您要猜的数字"+guessNumber+"小了");
            }else{
                System.out.println("恭喜您,您是第"+count+"次,猜中了!");
                break;
            }
        }
    }

}

为了标记同一种方法里面可以完成不同参数的使用,为了提高代码的扩展!
 *              java提供overload方法重载
 *
 *                     多个方法的方法名可以相同,参数列表不同,与返回值无关!
 *                                  参数列表不同:可以有下面几种
 *                                         1) 参数类型不同
 *                                         2)参数个数不同
 *                                         3)考虑参数的先后顺序不同

数组

数组是存储同一种数据类型多个元素的集合。也可以看成是一个容器。

数组既可以存储基本数据类型，也可以存储引用数据类型。

数组定义的格式：

格式1：数据类型[] 数组名;（推荐使用）

格式2：数据类型 数组名[];

数组的初始化：

概述：Java中的数组必须先初始化,然后才能使用。 所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。

两种初始化方式：

动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。

格式：数据类型[] 数组名=new 数据类型[数组长度]；

静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长

格式：数据类型[] 数组名=new 数据类型[]{元素一，元素二，元素三……};

数组应用：

1.数组排序之冒泡排序

两两比较,将较大的值往后放,第一次比较完毕,最大值就出现在最大索引处 * 依次这样比较,可以得到一个排好序的数组;

代码实现：

public static void bubbleSort(int[] arr){

for(int x = 0 ; x < arr.length-1;x++){//控制比较的次数

// arr.length-1-x:为了减少比较的次数

for(int y = 0 ; y < arr.length-1-x; y++){

//如果前面的元素比后面元素大

if(arr[y]> arr[y+1]){

int temp = arr[y] ;

arr[y] = arr[y+1] ;

arr[y+1] = temp;

}

2.遍历数组

public static void printArray(int[] arr){

System.out.print("[");

//遍历数组

for(int x = 0 ; x < arr.length ; x++){

//判断:如果是最大索引值,取到最后一个元素

if(x== arr.length-1){

System.out.println(arr[x]+"]");

}else{

//中间的元素

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

}

面向对象

面向对象的设计理念: 不断的创建对象,使用对象,指挥对象做事情!(面对对象的宗旨)

面向对象的三大特征:封装,继承,多态(面向对象重点)

类：

类:是Java语言中最基本的单元;能够描述现实世界事物的一组事物的属性和行为的集合! 类和现实世界事物是一一对应的关系;

现实世界的事物-------------                     class 类名{
    属性                                              成员变量:类中,方法外
    行为                                            成员方法:非静态(去掉static)
    学生事物                                        class Student{
        属性:姓名,年龄,性别,身高            String name ;  
                                                                int age 
                                                        String gender ;
                                        
        行为:学习                               public void study(){
                                            ...

                                                                }
                                                        }        

对象:

描述现实世界的具体事物!(具体事物的具体的属性和行为

                            类名 对象名  = new 类名();
                                
        姓名:张三                      对象名.成员变量 = 赋值;
        年龄:20
        性别:男            
                                    
        正在学习JavaEE                  对象名.成员方法名() ; 调用方法(单独调用/赋值调用(有返回值类型的方法调用))    
```

 

局部变量和成员变量有什么区别?

 1)书写位置的区别

局部变量:在方法定义中或者方法声明上的变量

 成员变量:类中方法外!

实际开发中:根据具体的情况具体使用,范围越小越好,因为范围小,使用完,释放内存了!

 2)内存位置不同 

局部变量:在栈内存中---跟方法有关(方法进栈)

成员变量:在堆内存中---跟对象有关 (类名 对象名 = new 类名();)

 3)生命周期不同:

局部变量:随着方法调用而存在,随着方法调用结束而消失

 成员变量:随着对象的创建而存在,随着对象的创建完毕后,使用完毕(访问成员变量/访问成员方法)之后等待 垃圾回收器空闲时候回收而消失!(不会立即释放)

 4)初始化值不同

局部变量:在使用之前必须初始化,否则报错

 成员变量:跟对象有关系,存在系统默认初始化,然后可以显示初始化 对象名.成员变量名=赋值

匿名对象(没有名字的对象) (重点)

```
描述具体事物---java代码 体现  
类名 对象名 = new 类名() ;
new 类名().成员变量=赋值;
new 类名().成员方法 ;
```

private :私有的 ,修饰的成员变量或者成员方法只能本类中访问  (为了保证数据安全)

示例：

//定义一个人类
class Person{
    //人都需要工作
    public void work(){
        System.out.println("爱生活,爱Java,爱高圆圆");
    }
}
//定义一个PersonDemo
class PersonDemo{
    //成员方法
    public void function(Person p){//形式参数引用类型,调用这个方法的时候,需要创建Person类对象
        p.work();
    }
}

//测试类
public class NoNameDemo {
    public static void main(String[] args) {
        //使用有名字的对象访问:
        //访问PersonDemo类中 function()方法
        PersonDemo pd = new PersonDemo() ; //创建PersonDemo类对象
        //创建Person类对象
        Person p = new Person() ;
        pd.function(p);//创建Person类对象进行实际参数传递
        System.out.println("------------------------------------------------------");
        //匿名对象的格式 :new 类名();  --可以作为参数传递
        //访问PersonDemo类中 function()方法
        PersonDemo pd2 = new PersonDemo() ;
        pd2.function(new Person());

        System.out.println("------------------------------------------------------");
        //链式编程 (实际开发中:不推荐这种,自己去使用可以用这种格式)
        //访问PersonDemo类中 function()方法
        new PersonDemo().function(new Person());
    }
}
 

this关键字 (重点)

this的含义: 代表当前类对象的地址值引用 
加入this---->标准类的写法    (描述学生事物/描述手机事物) 

JavaBean规范:
    1)类是具体类  class 类名{}
    2)类的属性必须私有化
    3)类中必须提供setXXX()/getXXX()  对成员变量的公共的访问方法(赋值/获取值)