方法，数组，面向对象思想

一：java中方法的介绍
1.1 函数：Java就是方法。

方法：
    就是完成特定功能的代码块

格式：
    修饰符 返回值类型 方法名(参数类型 参数名1，参数类型 参数名2…) {
        方法体;
        return 返回值;
    }

解释：
    修饰符：目前就写
        public static

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

    方法名：
        方便我们调用方法

    参数类型：
        形式参数    就是接收实际参数的变量(定义时候的)
        实际参数    就是实际参与运算的变量(调用时候的)

    方法体：
        就是完成功能的代码。

    返回值：
        就是功能的返回结果。

    return 返回值：
        结束方法，把返回值带给调用者


1.2 有明确返回值的方法调用（画图讲解方法的调用流程，写一个加法运算演示各种调用区别）：
    A:单独调用
        没有意义
    B:输出调用
        不是特别好,因为我们可能需要对结果进行进一步的操作。
    C:赋值调用
        推荐方案

1.3 书写方法注意的事项：
做到两个明确：
    返回值
        结果的数据类型
    参数
        参数的个数，以及类型

1.4 需求：
    求两个数据和的功能。

    如果数据我没有说类型，默认int类型。

    返回值:
        int
    参数:
        int a,int b 

1.5 方法的注意事项（依然用定义的加法的方法进行演示）：
    A:方法不调用不执行
    B:方法与方法是平级关系，不能嵌套定义
    C:方法定义的时候参数之间用逗号隔开
    D:方法调用的时候不用在传递数据类型
    E:如果方法有明确的返回值，一定要有return带回一个值           


    做到两个明确：
    返回值
        结果的数据类型
    参数
        参数的个数，以及类型



    做到两个明确：
    返回值
        结果的数据类型
    参数
        参数的个数，以及类型


1.8 需求1：请在控制台输出4行5列的星形。
    需求2：请在控制台输出6行7列的星形。
    需求3：请在控制台输出8行9列的星形。 
    （最终封装成方法进行调用）

package com.edu_01;

public class FunctionDemo6 {
public static void main(String[] args) {
//需求1：请在控制台输出4行5列的星形。
/**
* 这里是for循环的嵌套，
* 外层for循环控制行，
* 内层for循环控制列，
* 外层走一次，内层走一轮
* *
* *
* *
* *
*
*/
/*for (int i = 0; i < 4; i++) {
for(int j = 0;j<5;j++){
System.out.print(“*”);
}
//添加一个换行符
System.out.println();
}*/

    //需求2：请在控制台输出6行7列的星形。
    /*for (int i = 0; i < 6; i++) {
        for (int j = 0; j < 7; j++) {
            System.out.print("*");
        }
        System.out.println();
    }*/


    //需求3：请在控制台输出8行9列的星形。
    /*for (int i = 0; i < 8; i++) {
        for (int j = 0; j < 9; j++) {
            System.out.print("*");
        }
        System.out.println();
    }*/

    //printXing(10, 8);
    printXing(5, 6);
}


/**
 * 封装打印成星星的方法
 * 分析：
 * 参数列表：2，int
 * 返回值：无
 */

public static void printXing(int row,int col){
    for (int i = 0; i < row; i++) {
        for (int j = 0; j < col; j++) {
            System.out.print("*");
        }
        System.out.println();
    }
}

}

1.9 作业：需求：键盘录入三个数据，返回三个数中的最大值（写成一个方法可以直接调用并且返回值）        
        package com.edu_01;

public class FunctionDemo7 {
public static void main(String[] args) {
System.out.println(getMax(10, 5, 8));
}

    public static int getMax(int a,int b,int c){
    int max ;
    if (a>b) {
        //a大
        if (a>c) {
            //a最大
            max = a;
        }else {
            //c最大
            max = c;
        }
    }else {
        //b大
        if (b>c) {
            //b
            max = b;
        }else {
            //c
            max = c;
        }
    }
    return max;

}

}

二：方法重载
2.1 需求1：求两个数据和
需求2：求三个数据和
需求3：求四个数据和

    我们曾说：
        见名知意。

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

    方法重载特点
        与返回值类型无关，只看方法名和参数列表
        在调用时，虚拟机通过参数列表的不同来区分同名方法            

2.2 需求：
    比较两个数据是否相等。参数类型分别为两个byte类型，两个short类型，两个int类型，两个long类型，
    并在main方法中进行测试       
        package com.edu_02;

public class FunctionOverload2 {
public static void main(String[] args) {
//定义两个byte类型的数据，进行比较
int a = 10;
int b = 20;
System.out.println(isEquals(a, b));

}


public static boolean isEquals(byte a,byte b){
    System.out.println("比较两个byte类型的数据是否相等");
    return a==b;
}

public static boolean isEquals(short a,short b){
    System.out.println("比较两个short类型的数据是否相等");
    return a==b;
}


public static boolean isEquals(int a,int b){
    System.out.println("比较两个int类型的数据是否相等");
    return a==b;
}

public static boolean isEquals(long a,long b){
    System.out.println("比较两个long类型的数据是否相等");
    return a==b;
}

}

三：数组(容器，用来存储相同类型数据的容器)
3.1
数组：数组是存储同一种数据类型多个元素的集合
注意：数组既可以存储基本数据类型，也可以存储引用数据类型
3.2
数组的定义格式
A:数据类型[] 数组名;
int[] arr;
B:数据类型 数组名[];
int arr[];

    区别：念法上区别
        int[] arr;
            int类型的数组，arr
        int arr[];
            int类型的，arr[]
3.3
数组初始化概述:
    A:Java中的数组必须先初始化,然后才能使用。
    B:所谓初始化
        就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。
3.4
如何为数组进行初始化呢?
    A:动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。
    B:静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度。
3.5
动态初始化：
    初始化时只指定数组长度，由系统为数组分配初始值。

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

        数组长度其实就是数组中元素的个数。
3.6
为了方便我们获取数组中的元素，数组就为每个元素进行了编号，从0开始。
这个编号，专业叫法：索引。(角标,下标)
有了索引如何获取元素呢?    
    格式：数组名[索引]                  

3.9（简单画内存图）
定义两个数组，分别输出数组名及元素。然后分别给数组中的元素赋值，分别再次输出数组名及元素。   
package com.edu_03;

/**
* 3.4
如何为数组进行初始化呢?
A:动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。
*3.5
动态初始化：
初始化时只指定数组长度，由系统为数组分配初始值。
格式：
数据类型[] 数组名 = new 数据类型[数组长度];
数组长度其实就是数组中元素的个数。
*/
public class ArrayDemo2 {
public static void main(String[] args) {
//创建一个int类型的数组，这个数组的长度为3
//动态的初始化了一个数组
int[] arr = new int[3];
System.out.println(arr);//[I@33abb81e,这是一个地址值
System.out.println(arr[0]);//0
System.out.println(arr[1]);//0
System.out.println(arr[2]);//0

    //再给每一个元素进行赋值
    arr[0] = 10;
    arr[1] = 20;
    arr[2] = 30;
    System.out.println(arr);//[I@33abb81e,这是一个地址值
    System.out.println(arr[0]);//10
    System.out.println(arr[1]);//20
    System.out.println(arr[2]);//30


}

}

3.10
定义两个数组，先定义一个数组，赋值，输出。
然后定义第二个数组的时候把第一个数组的地址赋值给第二个数组。
然后给第二个数组赋值，再次输出两个数组的名及元素。
        (见上面代码)

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

    格式：
        数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};

    简化格式：
        数据类型[] 数组名 = {元素1,元素2,…};

3.12（写一个案例进行演示）
数组操作常见的两个小问题
    A:
        ArrayIndexOutOfBoundsException:数组索引越界异常
        怎么产生的：
            你访问了不存在的索引。
        如何解决：
            修改你的访问索引。
    B:
        NullPointerException:空指针异常
        怎么产生的：
            引用已经不再指向堆内存
        如何解决：
            一般来说，只要是引用类型的变量，我们在使用前，都要先判断是否为null。
            如果不为null，才继续使用。

3.13        
数组遍历:
    依次输出数组中的每一个元素

数组遍历标准格式：
    for(int x=0; x<数组名.length; x++) {
        System.out.println(数组名[x]);
    }

练习：
    自己定义一个数组，并遍历。   
        public class ArrayDemo7 {
public static void main(String[] args) {
    //定义一个数组
    int[] arr = {1,3,5,6};

    //遍历

// System.out.println(arr[0]);
// System.out.println(arr[1]);
// System.out.println(arr[2]);
// System.out.println(arr[3]);

    //使用for循环改进数组遍历的方法
    //数组的长度，怎么获取,通过数组的length属性获取数组的长度
    //System.out.println(arr.length);
    (int i=0;i<arr.length;i++){
        System.out.print(arr[i]+"  ");
    }
}



3.14
我们可能有很多个数组需要遍历，所以我们把遍历写成一个功能。   
    package com.edu_03;

public class ArrayDemo8 {
public static void main(String[] args) {
//定义一个数组
int[] arr = {5,6,7,8};
printArray(arr);
}

 * 分析：
 * 参数列表：1，int[]
 * 返回值：无
 */
public static void printArray(int[] arr){
    //拿到arr作何操作？？？
    for (int i= 0;i<arr.length;i++) {
        //打印数组中的每一个元素
        Systemtxt文档进行讲解）.out.print(arr[i]+",");
    }
}

}

3.15
数组获取最值(获取数组中的最大值最小值)    


***
作业：数组元素查找(查找指定元素第一次在数组中出现的索引)，封装成方法实现       

四：面向对象思想
1:面向过程思想
一步一步的完成某个需求。这些步骤是我们要完成的。侧重于过程。
代表性语言：C语言

2:面向对象思想—指挥对象做事情
面向对象是基于面向过程的。

关注完成功能的类。侧重于结果。
代表性语言：Java语言

3:面向对象思想特点
面向对象是基于面向过程的编程思想

A:是一种更符合我们思想习惯的思想
B:可以将复杂的事情简单化
C:将我们从执行者变成了指挥者

4:举例
做饭(摊个煎饼)：
面向过程：和面–起炉灶–将面摊入锅中–加个鸡蛋加个香肠多点香菜–烧上2分钟–起锅
面向对象：找到摊煎饼的老板–给钱–收货
洗衣：
面向过程：买洗衣粉–泡–搓衣服–漂洗–晾晒
面向对象：找洗衣店–给钱给衣服–收货

5:需求
把大象装进冰箱

面向过程：
    思路：
        A:打开冰箱门
        B:将大象放入冰箱
        C:关冰箱门

    代码体现：
        class Demo {
            public static void main(String[] args) {

            }

            public static void open() {
                System.out.println("打开冰箱门"); //代码有很多，比如说100多行
            }

            public static void in() {
                System.out.println("把大象塞进去");
            }

            public static void close() {
                System.out.println("关闭冰箱门");
            }
        }


面向对象：
    如何让我们的代码更符合面向对象思想呢?
        A:找有哪些类存在?(名词提取法)
        大象，冰箱



        B:类有哪些成员?
        类中所谓的成员包括：成员变量(这个类所具有的一些特点，一般来说是名词)
                            成员方法(这个类所具有的功能，一般来说是动词),成员方法没有static            
        冰箱：关门，开门
        大象：进入



        C:类与类的关系?


    代码实现：
    class Daxiang{
        public void in(){
        syso("我可以自己进入冰箱")
        }
    }

    class   BingXing{

    //开门
    public void open(){
    syso("冰箱可以自己开门");
    }

    //关门
    public void close(){
    syso("冰箱可以自己关门");
    }

    }


    class Test{
    main(){
        //面向对象，是指挥对象做事情，首先要找到能完成这个功能类，
        //接着调用这个类中的方法完成我们想要的功能
        BingXing.open();
        Daxing.in();
        BingXing.close();
    }
    }


学完面向对象：
    以后我们在完成某个功能的时候，一定是先找具有该功能的类。
    然后通过该类的对象调用该功能。

五：类与对象
5.1:我们学习编程语言，就是为了模拟现实世界的事物，实现信息化。

    5.2:我们是如何描述现实世界的事物的呢?
        属性  就是该事物的描述信息（举例，人，汽车）
        行为  就是该事物能够做什么（举例，人，汽车）

    人：（类）
        属性：姓名，性别，年龄
        行为：吃，睡，学习

    张三：（人这个类对应的实例，也叫对象）


    汽车：
        属性：颜色，品牌，价格
        行为：拉人，拉货，跑滴滴

    奇瑞qq:（是汽车类的一个实例，或者叫对象）


    5.3:我们学习的Java语言最基本单位是类，所以，我们就应该把事物用一个类来体现。

    5.4:类与对象
        类：是一组相关的属性和行为的抽象
        对象：是该类事物的具体体现。(实例)

        举例：
            对象：张三
            类：学生

六：类的定义
6.1
类是用来描述现实世界事物的。

        事物：
            属性  特征
            行为  功能

        类：
            成员变量    特征
            成员方法    功能

        类的组成：
            成员变量    类中方法外的变量
            成员方法    没有static修饰的方法

        需求：
            用Java语言体现学生类。

        分析：
            A:得到学生事物
            B:把学生事物转换为学生类
            C:用代码体现学生类

        实现：
            A:得到学生事物
                属性：
                行为：
            B:把学生事物转换为学生类
                成员变量：
                成员方法：
            C:用代码体现学生类
                学生类：

                成员变量：

                成员方法：

    6.2
    练习：
        模仿学生类，写出手机类。
        1.得到手机类事物
        属性：
        行为：
        2.事物转换成手机类
        成员变量：
        成员方法：
            package com.edu_04;

public class Car {

//成员变量，位于类中方法外
/**
 * 品牌，价格
 */
String brand;
int price;

//成员方法，没有static,方法与方法之间是平性关系
/**
 * 拉货，拉人
 */
public void laHuo(){
    System.out.println("汽车可以拉货");   
}

public void laRen(){
    System.out.println("汽车可以拉人");
}

}

        3.用java代码实现
        类：

        成员变量：

        成员方法：

七：
类的使用+内存图解（重要：new关键字的含义）
7.1 一个文件一个类
类的使用（拿学生类过来练习，并画内存图进行讲解）
使用一个类，其实是使用该类的成员。(变量和方法)

    我们要想想用一个类的成员，就必须创建该类的对象。
    如何创建类的对象呢?
        格式：
            类名 对象名 = new 类名();

            就表示创建了该类类型的一个对象。

    如何使用成员呢?
        成员变量：
            对象名.变量;
        成员方法：
            对象名.方法名(...);

7.2 练习：
    写出手机类的测试类

package com.edu_04;
/**
* 得到手机这个事物：
* 属性：品牌，价格，颜色
* 行为：打电话，玩游戏，发短信
*
* 将手机事物转换成手机类：
* 成员变量：品牌，价格，颜色
* 成员方法：打电话，发短信，玩游戏
*
*/
public class Phone {
//成员变量
String brand;
int price;
String color;

//成员方法
public void call(){
    System.out.println("手机可以打电话");
}

public void sendMessage(){
    System.out.println("手机还可以发短信");
}

public void playGame(){
    System.out.println("手机还可以耍游戏");
}

}

八：成员变量和局部变量的区别？
A:在类中的位置不同
成员变量 类中方法外
局部变量 方法内或者方法声明上
B:在内存中的位置不同
成员变量 堆内存（全局变量）
局部变量 栈内存
C:生命周期不同
成员变量 随着对象的存在而存在，随着对象的消失而消失
局部变量 随着方法的调用而存在，随着方法的调用完毕而消失
D:初始化值
成员变量 有默认初始化值
局部变量 没有默认初始化值

九：形式参数问题
数据类型：
基本类型：4类8种。byte,short,int,long,float,double,char,boolean
基本类型实际参数传递的时候传递的是这个基本类型的具体的值
引用类型：类,接口,数组
引用类型进行参数传递的时候，传递的是该引用类型的（实例对象）说白了就是这个对象的地址值

基本类型形式参数案例：
1.创建一个类，里面写一个加法运算，在测试类中new对象，调方法进行使用

形式参数案例：
1.写一个类，类中有一个方法遍历数组，接收的参数为  

个数组对象
2.写一个学生类Student（里面有一个学习方法），创建一个StudenDemo这个类里面有个方法（method(Student s)），还有一个测试类进行测试

十：匿名对象（学生案例代码进行演示）
匿名对象：就是没有名字的对象
是对象一种简写形式。
package com.edu_09;
/**
* 十：匿名对象（学生案例代码进行演示）
匿名对象：就是没有名字的对象
是对象一种简写形式。

应用场景：
    A:调用方法(对象调用方法仅仅一次的时候)
    B:作为实际参数传递

*
*/
class Student{
public void show(){
System.out.println(“student的show方法”);
}
}

class StudentDemo{
public void method(Student s){//需要的实际参数一定是Student类的对象的的地址值
s.show();
}
}

public class StudentTest {
public static void main(String[] args) {
/* //我现在需要调用StudentDemo中的method()方法
StudentDemo sd = new StudentDemo();
//需要的实际参数一定是Student类的对象的的地址值
Student s = new Student();
sd.method(s);*/

    System.out.println("--------------------------");
    //想调用我现在需要调用StudentDemo中的method()方法
    //使用匿名对象调用方法,并传递参数
    new StudentDemo().method(new Student());    
}

}

}

}