面向对象中方法详解

面向过程思想：

步骤清晰简单，第一步做什么，第二步做什么

面对过程适合处理一些较为简单的问题

面向过程和面向对象的理解：

二者都是一种思想，面向对象是相对于面向过程而言的。面向过程，强调的是功能行为，以函数为最小单位，考虑怎么做。

面向对象，将功能封装进对象，强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。

面向过程就是想的怎么去做，是去做功能。而面向对象是将功能封装在对象，然后考虑用哪个对象来实现。

我们示例如下所示：

1.面向过程：强调的是功能行为，以函数为最小单位，考虑怎么做

人把大象装进冰箱

（1）把冰箱门打开

（2)抬起大象，塞进冰箱

（3）把冰箱门关闭

2.面向对象：强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。

（1)人 {

打开（冰箱）

冰箱.开开（ ）

｝

抬起大象｛

大象.进入（冰箱）；

｝

关闭（冰箱）｛

冰箱.闭合（）；

｝

｝

冰箱｛

开开（）｛｝

闭合（）｛｝

｝

大象｛

进入（冰箱）｛

｝

面向对象更加强调运用人类在日常的思维逻辑中采用的思想方法与原则，如抽象、分类、继承、聚合、多态等。

面向对象分析方法分析问题的思路和步骤：

1.根据问题需要，选择问题所针对的现实世界中的实体。

2.从实体中寻找解决问题相关的属性和功能，这些属性和功能就形成了概念世界中的类。

3.把抽象的实体用计算机语言进行描述，形成计算机世界中类的定义。即借助某种程序语言，把类构造成计算机能够识别和处理的数据结构。

4.将类实例化成计算机世界中的对象。对象是计算机世界中解决问题的最终工具。

类和对象的使用（面向对象思想落地的实现）：

1.创建类，实现类的成员

2.创建类的对象

3.通过“对象.属性”或“对象.方法”调用对象的结构

如果创建了一个类的多个对象，则每个对象都独立的拥有一套类的属性（非static的）

意味着：如果我们修改一个对象的属性a,则不影响另外一个对象属性a的值。

但是如果出现如下所示：Person  p3=p1;

即将p1变量保存的对象地址值赋值给p3,导致p1和p3指向了堆空间中的同一个对象实体，从而修改p3也会导致p1值的改变。

 对象的内存解析：

堆：此内存区域的唯一目的就是存放对象实例，几乎所有的对象实例都在这里分配内存。这一点在java虚拟机规范中的描述是：所有的对象实例以及数组都要在堆上分配

通产所说的栈，是指虚拟机栈，虚拟机栈用于存储局部变量等。局部变量表存放了编译期可知长度的各种基本数据类型、对象引用（reference类型，他不等同于对象本身，是对象在堆内存的首地址）。方法执行完，自动释放。

方法区：用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据 

我们设计如下代码：

package com.ypl.System_;




public class Person_ {
    public static void main(String[] args) {
        one one = new one();
        one.name="Tom";
        one.isMale=true;
        one one1 = new one();
        System.out.println(one1.name);
        one one2=one1;
        one2.age=10;
        System.out.println(one1.age);
    }
}

class one {
    int age;
    String name;
    boolean isMale;

    public void re(){
        System.out.println("你是谁");
    }
}

我们运行之后如下所示：

 我们进行分析代码的底层内存解析：

 one one = new one();
        one.name="Tom";
        one.isMale=true;
        one one1 = new one();
        System.out.println(one1.name);
        one one2=one1;
        one2.age=10;
        System.out.println(one1.age);

 我们进行分析如下所示：

 我们对象进行调用类的属性的时候，是保存在堆里面的。

属性（成员变量） VS  局部变量

1.相同点：

     1.1 定义变量的格式：数据类型   变量名 =变量值

     1.2 先声明，后使用

     1.3变量都有其对应的作用域

2.不同点：

    2.1在类中声明的位置的不同

    属性：直接定义在类的一对{ }内

   局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量

   2.2 关于权限修饰符的不同

   属性：可以在声明属性时，指明其权限，使用权限修饰符。

             常用的权限修饰符：private、public、缺省(前面什么也不写）、protected

局部变量：不可以使用权限修饰符。

   2.3默认初始化值的情况：

属性：类的属性，根据其类型，都有默认初始化值。

整型（byte、short、int、long）：0

浮点型（float、double）：0.0

字符型（char):0或'\u0000'

布尔型（boolean):false

引用数据类型(类、数组、接口）：null.

局部变量：没有默认初始化值。

意味着，我们在调用局部变量之前，一定要显式赋值。

特别地，形参在调用时，我们赋值即可。

2.4 在内存中加载的位置是不一样的

属性：加载到堆空间中

局部变量：加载到栈空间中

1.方法的声明：权限修饰符  返回值类型  方法名（形参列表）{

方法体

}

static、final、abstract 来修饰的方法

2.说明：2.1关于权限修饰符：默认方法的权限修饰符先都使用public

         java规定的4种权限修饰符：private、public、缺省、protected

             2.2 返回值类型：有返回值  vs 没有返回值

           2.2.1   如果方法有返回值，则必须在方法声明时，指定返回值的类型。同时，方法中，需要使用return关键字来返回指定类型的变量或常量。

            如果方法没有返回值，则方法声明时，使用void来表示。通常，没有返回值的方法中，就不需要使用return.但是，如果使用的话，只能“return;"表示结束此方法的意思。

          2.2.2 我们定义方法该不该有返回值？

                （1）题目要求

                （2）凭经验：具体问题具体分析

              2.3方法名：属于标识符，遵循标识符的规则和规范，"见名知意"

             2.4形参列表：方法可以声明0个，1个，或多个形参。

                        2.4.1格式：数据类型1   形参1，数据类型2  形参2，·····

                        2.4.2我们定义方法时，该不该定义形参？

                  （1）题目要求

                  （2）凭经验：具体问题具体分析

        2.5方法体：方法功能的体现

3.return关键字的使用：

      3.1.使用范围：使用在方法中

       3.2.作用：（1）结束方法

              （2）针对于有返回值类型的方法，使用“return  数据”方法返回所要的数据

      3.3.注意点：return关键字后面不可以声明执行语句。

4.方法的使用中，可以调用当前类的属性或方法

       特殊的：方法A中又调用了方法A：递归方法（但不是每时每刻都可以用的，有时会导致栈溢出 ）

      方法中，不可以定义方法

面向对象思想：

物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单纯思考，最后，才对某个分类下的细节进行面向过程的思索。

面向对象适合处理复杂的问题，适合处理需要多人协作的问题。

属性+方法会变成一个类

对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理。

面向对象编程的本质就是：以类的方式组织代码，以对象的组织（封装）数据。

抽象

三大特性：

封装，继承，多态。

从认识论角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象。

从代码运行角度考虑是先有类后有对象。类是对象的模板。

静态方法的体现：

package com.rgf.oop;

public class B {
    public static void main(String[] args) {
        //如果是静态方法，调用Student类里面的say方法，采用类名.方法，即Student.say();。
        Student.say();
    }
}

package com.rgf.oop;
//学生类
public class Student {
    //静态方法
    public static void say() {
        System.out.println("学生不说话了");
    }

    }

采用静态方法去调用另一个类中的方法的时候，我们采用类名.方法。

非静态方法的体现：

package com.rgf.oop;

public class B {
    public static void main(String[] args) {
        //如果是调用非静态方法，则先实例化这个类，即new一个对象,然后利用对象名调用此方法。
        //对象类型  对象名 =对象值;
        Student student = new Student();
        student.say();
    }
}

package com.rgf.oop;
//学生类
public class Student {
    //非静态方法，没有static.
    public  void say() {
        System.out.println("学生不说话了");
    }

    }

采用非静态方法去调用另一个类中的方法的时候，我们采用先把所调用的那个类new一个对象，然后利用该对象的对象名进行调用此方法，即实例对象名.方法(),即student.say()。

方法调用的体现：

package com.rgf.oop;

public class C {
    //当a和b都是静态方法的时候，a可以调用b，b也可以调用a.
    public static void a()  {
        b();
    }
    public static void b(){
        a();
    }
}

package com.rgf.oop;

public class C {
    //当a和b都是非静态方法的时候，a可以调用b，b也可以调用a.
    public  void a()  {
        b();
    }
    public  void b(){
        a();
    }
}

package com.rgf.oop;

public class C {
    //当a是静态方法，而b不是非静态方法的时候，a不可以调用b，但b可以调用a.
    //这是因为static是和类一起加载的，存在时间比较早。
    // 而b方法是和对象有关的，是在类实例化之后才存在的,即是在对象创建之后才存在的。
    public  static void a()  {//已经存在的东西去调用不存在的东西，所以会报错。
    //    b();
    }
    public  void b(){
        a();
    }
}

综上所述，方法调用的两种方法：

1.直接将此方法转变为静态方法，然后利用类名.方法直接进行调用。

2.面对非静态方法，可以先实例化一个对象，即new该类，并调用该类的方法。

实际参数和形式参数的体现：

package com.rgf.oop;

public class D {
    public static void main(String[] args) {
        //第一种非静态方法：我们采用new,实例化一个对象进行调用。
        new D().add(1,5);
        System.out.println( new D().add(1,5));
    }
    public  int add(int a,int b){//形式参数
        return a+b;
    }
}

package com.rgf.oop;

public class D {
    public static void main(String[] args) {
        //第二种静态方法：类名.方法，点击alt+enter可以自动获得一个返回值。
        //实际参数要和形式参数的类型对应。
        int add = D.add(1, 5);
        System.out.println(add);

    }
    public static  int add(int a,int b){//形式参数
        return a+b;
    }
}

值传递和引用传递：

值传递：

package com.rgf.oop;
//值传递
public class E {
    public static void main(String[] args) {
        int a=1;
        System.out.println(a);
        E.change(a);
        System.out.println(a);
    }
    //返回值为空。
    public static void change(int a){
        a=10;
    }
}

通过结果可知，我们并没有获得返回值，由于在change方法中并没有返回值类型，而是返回为空，所以相当于走完这个方法了，但并没有改变值，具体的运行过程，可以通过debug进行了解。

值传递，只是把值传递过去了，在函数里修改变量的值，原变量的值不变。

引用传递是把地址传递过去了 ，修改变量的值，原变量的值也会变。

引用传递：

package com.rgf.oop;
//引用传递：对象，本质还是值传递
//对象，内存。
public class F {
    public static void main(String[] args) {
        //用下面的Person类，需要new一个对象。
        //我们new一个对象的时候，需要alt+enter,进行获得对象名。
        //同类方法可以直接调用，非同类非静态用对象调，静态用类名调用。
        Person person = new Person();
        System.out.println(person.name); //第一次打印出来为null
        F.change(person);
        System.out.println(person.name);
    }

    public static void change(Person person) {
        //person是一个对象，指向的是一个具体的人Person person = new Person();
        //这是一个具体的人，即Person类里面的name属性。可以改变属性。
        person.name="rgf";
    }
    //定义了一个Person类，有一个属性：name;
   static class Person{
        String name; //默认值为null
    }
}

递归方法的使用：