Java程序设计（基础）- 方法

青旅半醒 2022-01-28 10:17 215阅读 0赞

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NjUxMjY3_size_16_color_FFFFFF_t_70]方法：完成特定功能的代码。  
方法的注意事项：

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

修饰符 返回值类型 方法名(参数类型 参数名 1，参数类型 参数名 2…) { 
           函数体;
           return 返回值;
       } 
        
       //注：返回值类型 明确功能结果的数据类型 
       //参数列表 明确有几个参数，以及参数的类型 
       //return 结束方法以及返回方法指定类型的值

# 修饰符 #

修饰符及可见性:

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th>说明</th> 
   <th>当前类</th> 
   <th>当前包</th> 
   <th>子孙类</th> 
   <th>其他包</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>public</td> 
   <td>公共访问控制符</td> 
   <td>√</td> 
   <td>√</td> 
   <td>√</td> 
   <td>√</td> 
  </tr> 
  <tr> 
   <td>protected</td> 
   <td>保护访问控制符</td> 
   <td>√</td> 
   <td>√</td> 
   <td>√</td> 
   <td>×</td> 
  </tr> 
  <tr> 
   <td>default</td> 
   <td>默认的</td> 
   <td>√</td> 
   <td>√</td> 
   <td>×</td> 
   <td>×</td> 
  </tr> 
  <tr> 
   <td>private</td> 
   <td>私有访问控制符</td> 
   <td>√</td> 
   <td>×</td> 
   <td>×</td> 
   <td>×</td> 
  </tr> 
 </tbody> 
</table>

注意：接口中的变量默认是public static final 的，方法默认是public abstract 的

*  类修饰符：

public（访问控制符），将一个类声明为公共类，他可以被任何对象访问，一个程序的主类必须是公共类。  
abstract，将一个类声明为抽象类，没有实现的方法，需要子类提供方法实现。  
final，将一个类生命为最终（即非继承类），表示他不能被其他类继承。  
friendly，默认的修饰符，只有在相同包中的对象才能使用这样的类。

*  成员变量修饰符：

public（公共访问控制符），指定该变量为公共的，他可以被任何对象的方法访问。  
private（私有访问控制符）指定该变量只允许自己的类的方法访问，其他任何类（包括子类）中的方法均不能访问。  
protected（保护访问控制符）指定该变量可以别被自己的类和子类访问。在子类中可以覆盖此变量。  
friendly ，在同一个包中的类可以访问，其他包中的类不能访问。  
final，最终修饰符，指定此变量的值不能变。  
static（静态修饰符）指定变量被所有对象共享，即所有实例都可以使用该变量。变量属于这个类。  
transient（过度修饰符）指定该变量是系统保留，暂无特别作用的临时性变量。  
volatile（易失修饰符）指定该变量可以同时被几个线程控制和修改。

*  方法修饰符：

public（公共控制符）  
private（私有控制符）指定此方法只能有自己类等方法访问，其他的类不能访问（包括子类）  
protected（保护访问控制符）指定该方法可以被它的类和子类进行访问。  
final，指定该方法不能被重载。  
static，指定不需要实例化就可以激活的一个方法。  
synchronize，同步修饰符，在多个线程中，该修饰符用于在运行前，对他所属的方法加锁，以防止其他线程的访问，运行结束后解锁。  
native，本地修饰符。指定此方法的方法体是用其他语言在程序外部编写的。

# 方法的静态与实例 #

*  初始化的顺序：

首先是静态对象（如果他们尚未因为前面的对象创建过程被初始化），然后是非静态对象。无法阻止初始化的进行，他在构造器被调用之前就已经发生了。  
在类的内部，变量定义的顺序决定初始化的顺序，变量定义散布于各个地方，仍然会在任何方法（包括构造方法）调用之前被初始化。  
在子类继承父类的时候，初始化的顺序如下：

在实例化子类的时候：  
1.首先会执行父类的初始化代码块（先静态），实例变量的初始化  
2.执行父类的构造函数  
3.子类的初始化代码块  
4.子类的构造函数。

如果类还没有被加载：那么子类通过类名加点的形式调用对象的时候，首先会执行父类的静态代码块和静态变量，顺序就是他们出现的顺序，然后在执行子类的静态代码块和静态变量。

如果类以及被加载过了，那么静态的变量和静态的代码块就不会被重复执行，再创建对象的时候只会执行与实例相关的变量初始化和构造函数。

*  静态有一些特点：

1.全局唯一，任何一次的修改都是全局性的影响  
2.只加载一次，优先于非静态  
3.使用方式上不依赖于实例对象。  
4.生命周期属于类级别，从JVM 加载开始到JVM卸载结束。

*  抽象类和接口的修饰符  
    1、抽象类中的抽象方法（其前有abstract修饰）不能用private、static、synchronized、native访问修饰符修饰。  
    原因如下：抽象方法没有方法体，是用来被继承的，所以不能用private修饰；static修饰的方法可以通过类名来访问该方法（即该方法的方法体），抽象方法用static修饰没有意义；使用synchronized关键字是为该方法加一个锁。。而如果该关键字修饰的方法是static方法。则使用的锁就是class变量的锁。如果是修饰类方法。则用this变量锁。但是抽象类不能实例化对象，因为该方法不是在该抽象类中实现的。是在其子类实现的。所以。锁应该归其子类所有。所以。抽象方法也就不能用synchronized关键字修饰了；native，这个东西本身就和abstract冲突，他们都是方法的声明，只是一个吧方法实现移交给子类，另一个是移交给本地操作系统。如果同时出现，就相当于即把实现移交给子类，又把实现移交给本地操作系统，那到底谁来实现具体方法呢？  
    2、接口是一种特殊的抽象类，接口中的方法全部是抽象方法（但其前的abstract可以省略），所以抽象类中的抽象方法不能用的访问修饰符这里也不能用。而且protected访问修饰符也不能使用。  
    因为接口可以让所有的类去 实现（非继承） ，不只是其子类，但是要用public去修饰。接口可以去继承一个已有的接口。  
    **接口中的变量默认是public static final 的，方法默认是public abstract 的。**

1.在外部调用静态方法时，可以使用"类名.方法名"的方式，也可以使用"对象名.方法名"的方式。而实例方法只有后面这种方式。也就是说，调用静态方法可以无需创建对象。  
2.静态方法在访问本类的成员时，只允许访问静态成员（即静态成员变量和静态方法），而不允许访问实例成员变量和实例方法；实例方法则无此限制。  
3.静态方法声明必须有static，调用时使用类名 . 静态方法名的方式；非静态方法不能使用static关键字，调用时需初始化该方法所属类。

# 递归 #

说明：递归函数又叫自调用函数，在函数体内直接或间接的调用自己，即函数 的嵌套是函数本身。  
目的：简化程序设计，使程序易读。  
条件：需有完成任务的语句，需满足递归的要求（减小而不是发散）。  
优缺点分析：非递归函数效率高，但较难编程，可读性较 差。递归函数的缺点是增加了系统开销，也就是说，每递归一次，栈内存就多占用一截，容易栈溢出。

public static int JC(int n) { 
        if(n==1){ 
            return 1;
        }else{ 
            return n*JC(n-1);
        }
    }

*  直接递归：在函数中出现调用函数本身。  
    示例 1 ：下面代码求斐波那契数列第 n 项，斐波那契数列第一和第二项是 1 ，后面每一项是前两项之和，即 1 、 1 、 2 、 3 、 5 、 8 、 13 　．．．。

public class Test { 
      public static void main(String args[]) { 
        int x1 = 1;
        int sum = 0;
        int n = 7;
        for (int i = 1; i <= n; i++) { 
          x1 = func(i);
          sum = sum + x1;
        }
        System.out.println("sum=" + sum);
      }
      public static int func(int x) { 
        if (x > 2)
          return (func(x - 1) + func(x - 2));
        else
          return 1;
      }
    }

*  B ：间接递归：指函数中调用了其他函数，而该 其他函数有调用了本函数。  
    示例 2 ：用间接递归来计算上述斐波那契数列。  
    程序代码：

public class Test { 
      public static void main(String args[]) { 
        int x1 = 1;
        int sum = 0;
        int n = 7;
        for (int i = 1; i <= n; i++) { 
          x1 = func1(i);
          sum = sum + x1;
        }
        System.out.println("sum=" + sum);
      }
      public static int func1(int a){ 
          int b;
          b=func2(a);
              return b;
      }
      public static int func2(int b) { 
        if (b> 2)
          return (func1(b - 1) + func1(b - 2));
        else
          return 1;
      }
    }

示例 3 ：下面不用递归函数继续来计算上述斐波那契数列。  
程序代码:

public class Test { 
      public static void main(String args[]) { 
        int n=7;
        int a=1, b=1, temp;
        int sum=2;
        for(int i=3; i<=n; i++){ 
          temp=a+b; a=b; b=temp;
               sum=sum+temp;
        }
        System.out.println("sum=" + sum);   
      }
    } 
    ```
    
    [Java设计基础及面向对象导向](https://blog.csdn.net/qq_37651267/article/details/90550939)

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM3NjUxMjY3_size_16_color_FFFFFF_t_70]: /images/20220128/e1fe3878f50a4bf6b11a183916a7f80f.png