java程序设计基础篇_程序基础设计

java程序设计基础篇_程序基础设计Java程序设计(基础)- 方法

大家好,又见面了,我是你们的朋友全栈君。

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

  • A:方法不调用不执行
  • B:方法与方法是平级关系,不能嵌套定义
  • C:方法定义的时候参数之间用逗号隔开
  • D:方法调用的时候不用在传递数据类型
  • E:如果方法有明确的返回值,一定要有return带回一个值
   修饰符 返回值类型 方法名(参数类型 参数名 1,参数类型 参数名 2) { 
   
       函数体;
       return 返回值;
   } 
    
   //注:返回值类型 明确功能结果的数据类型 
   //参数列表 明确有几个参数,以及参数的类型 
   //return 结束方法以及返回方法指定类型的值
   

修饰符

修饰符及可见性:

说明 当前类 当前包 子孙类 其他包
public 公共访问控制符
protected 保护访问控制符 ×
default 默认的 × ×
private 私有访问控制符 × × ×

注意:接口中的变量默认是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)
版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。

发布者:全栈程序员-用户IM,转载请注明出处:https://javaforall.cn/106699.html原文链接:https://javaforall.cn

【正版授权,激活自己账号】: Jetbrains全家桶Ide使用,1年售后保障,每天仅需1毛

【官方授权 正版激活】: 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...

(0)


相关推荐

发表回复

您的电子邮箱地址不会被公开。

关注全栈程序员社区公众号