精华内容
下载资源
问答
  • 方法的组成与调用(必备) 方法也叫函数,我们把一些常用的功能代码写在一个方法里,通过调用重复使用。调用方法是我们只需要考虑方法的功能,参数,和返回值。调用时可以忽略功能实现的具体步骤。这也是简单的面向...

    方法的组成与调用(必备)

    方法也叫函数,我们把一些常用的功能代码写在一个方法里,通过调用重复使用。调用方法是我们只需要考虑方法的功能,参数,和返回值。调用时可以忽略功能实现的具体步骤。这也是简单的面向对象的表现
    定义一个方法首先要知道方法的组成部分
    修饰符 :可以有 访问修饰符 public private protected default static final abstract
    返回值类型:可以是java中的基本数据类型和引用数据类型,表示方法调用后可以返回的数据类型。没有返回值的方法 返回值类型是 void
    方法名:必须是一个合法的修饰符,一般遵守驼峰命名法。
    参数列表:方法名后的() 里是参数的列表 ,里边可以放一个或多个形式参数,代表调用方法的时候需要传递的参数。可以没有也可以有多个中间用 逗号,分割。
    方法体:代表方法具体实现功能的过程。
    方法的定义 一般在类体内 主方法外,方法体内是不可以定义方法的。
    方法内可以调用方法,方法定义后需要在主函数内调用才能执行。
    方法的重载,符合以下三个条件方法的关系便是重载。
    发生在同一个类中。
    方法名相同,参数列表不同,包括参数的个数,类型,和类型的顺序不同。
    与返回值和修饰符无关。
    方法的重载属于java中多态的一种表现。
    方法重载后根据不同的参数选择执行的方法。

    展开全文
  • Java方法的定义与调用

    2019-11-28 22:02:29
    2.方法的组成:[访问控制符] [修饰符] 返回值类型 方法名(参数类型 形式参数,参数类型 形式参数,…) { 方法体 } 修饰符: public 、static 被称为修饰符(后续会详细讲解它们); 返回值类型: 用来说明该方法运算...

    1.方法的定义:方法是完成某个功能的一组语句,通常将常用的功能写成一个方法。
    2.方法的组成:[访问控制符] [修饰符] 返回值类型 方法名(参数类型 形式参数,参数类型 形式参数,…)
    {
    方法体
    }
    修饰符: public 、static 被称为修饰符(后续会详细讲解它们);
    返回值类型: 用来说明该方法运算结果的类型。如果返回其他类型,编译就可能出错;
    方法名: 它作为调用时引用方法的标识;
    参数列表: 方法的参数个数可以是0个到多个,每个参数前面要声明参数的数据类型;每个参数要用逗号分开。也可以一个参数都没有。
    方法体: 它是一个语句块,执行特定的功能操作。对于有返回值类型的方法,方法体当中最后一个语句是return关键字,它的作用是把方法的执行(运算)结果返回到方法外部。
    return 表达式: 这里,进一步分析,return后面的表达式就是方法的返回值。需要注意表达式的类型,必须与方法头中声明的“返回类型”相匹配。
    形式参数:在方法被调用时用于接受外部传入的变量
    参数类型:就是该形式参数的数据类型
    返回值:方法在执行完毕后返回给调用它的程序的数据
    返回值类型:方法要返回的结果的数据类型
    3.方法的分类
    根据参数个数:
    无参方法
    有参方法
    根据返回值类型:
    有返回值的方法:
    基本数据类型
    引用数据类型
    无返回值的方法
    void
    对于无返回值类型的方法,它不向本方法外部返回任何值。定义这样的方法时,声明方法返回类型的位置不能省略不写,而应该用关键字void来代替,即 “空”的意思。
    方法的返回类型可以是java中的任何数据类型:基本数据类型(4种整型、2种浮点型、字符型、布尔型共8种) 和引用数据类型(数组、类、接口)。
    4.方法的调用方法
    有在被调用后才生效
    方法的调用方法:
    无参方法的调用
    有参方法的调用
    无参方法的调用
    定义方法就是编写一段有特定功能的代码,在程序中使用同样功能的地方,没有必要重复编写同样的代码,只要调用定义好的方法就可以。可以实现代码的重用。简化了程序的编写和维护工作。
    所谓调用方法,其实就是给方法的入口传入一些值(参数),然后在出口得到方法执行的结果(返回值)。给方法传入参数的过程,称为“传参”。
    理解“实参”、“形参”。
    实际上,方法传参的过程就是把实参赋值给对应的形参的过程,并且实参和形参的数量、类型必须匹配。

    使用方法时的注意问题

    形参必须注明数据类型
    实参直接写,不需要类型声明
    return只能返回一次
    遇到return语句,方法结束执行,后续语句不执行
    方法的返回值,必须与方法声明中的返回值类型匹配
    方法定义,不能写在main()中
    方法是不能嵌套的

    5.的重载(overload)
    方法的重载就是在同一个类中允许同时存在一个以上同名的方法
    方法重载的规则
    方法名称相同
    方法的参数必须不同
    参数个数不同 或参数类型不同
    方法的返回值类型可以相同,也可以不同

    展开全文
  • 方法的五部分缺一不可 修饰符 比较多,后面会详细介绍。目前public static 返回值类型 用于限定返回值的数据类型 方法名 一个名称,为了方便我们调用方法 参数列表 参数类型 限定调用方法时传入参数的数据类型 参数...

    方法

    简单的说:方法就是完成特定功能的代码块

    在很多语言里面都有函数的定义

    函数在Java中被称为方法

    格式:

    修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2…) {

    ​ 函数体;

    ​ return 返回值;

    }

    方法的五部分缺一不可

    修饰符

    比较多,后面会详细介绍。目前public static

    返回值类型

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

    方法名

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

    参数列表

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

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

    方法体

    完成功能的代码

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

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

    注意:方法没有返回值相应位置使用void关键字替代,返回值类型与返回的实际值类型必须匹配,若方法返回数据类型为void 那么可以省略return

    修饰符使用 public static

    返回值使用 数据类型 / void(有无返回值)

    方法名使用 一般就是当前方法实现的功能名

    参数列表使用 可以写0到无穷个参数(有无参数)

    方法体使用 根据实际实现的功能书写代码(使用参数)

    方法的分类:

    1、无返回值无参数列表

    2、有返回值无参数列表

    3、无返回值有参数列表

    4、有返回值有参数列表

    任意一个方法大致都可以使用这四种中的一种完成

    方法的使用

    由于使用了public static 修饰 所以可以直接使用通过方法名(参数)的形式进行调用

    方法名(参数列表)

    实参与形参

    形参:形式参数

    在方法声明时,有时为了提升代码功能与代码的灵活性,需要声明参数列表,这个参数列表中的声明的变量就称之为形参(在声明方法时,书写在参数列表中,由数据类型与标识符组成的参数 称之为形参)

    实参:实际参数

    在方法调用时,根据方法的形参对应填入的数据,称之为实参。方法执行的过程,实际就是将实参存入形参后执行相应代码体。(方法调用时,形参输入的顺序与数据格式与形参一一对应)

    方法的实际调用过程

    在这里插入图片描述

    方法定义与使用注意事项

    方法不调用不执行

    方法与方法是平级关系,不能嵌套定义

    方法定义的时候参数之间用逗号隔开

    方法调用的时候不用在传递数据类型

    如果方法有明确的返回值,一定要有return带回一个值

    方法重载概述

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

    在同一个类中。两个方法方法名相同参数列表不同,我们称之为发生了方法的重载,或两个方法互为重载

    方法重载特点

    与返回值类型无关,只看方法名和参数列表

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

    参数列表的不同分为三种情况:

    1、个数不同

    2、数据类型不同

    3、顺序不同(个数相同两个以上 数据类型相同两个以上)

    面向对象思想概述

    将是事物的描述变为对对象的描述,通过代码进行一类事物(类)的描述,可以通过具体的描述值来确定是这一类事物中的具体对象,在使用其定义好的方法进行功能开发。

    万物皆对象

    面向对象思想的优点

    是一种更符合我们思想习惯的思想

    可以将复杂的事情简单化

    将我们从执行者变成了指挥者

    角色发生了转换

    类与对象的关系

    对象是类的具体表现形式

    类是创建对象的模版

    类是大量对象共性的抽象

    类的组成

    类名:class后的标识符

    类体:{

    属性:用于描述对象具体的特征

    行为:对象具体拥有的功能

    方法的调用(总)

    方法的使用大致分为三种

    1. 调用本类中的方法

    (1)被static修饰的方法

    直接使用 方法名(参数) 的形式调用

    (2)未被static修饰的方法

    如果当前方法被static修饰,那么他只能调用被static修饰的方法 方法名(参数)

    1. 调用其他类中未被static修饰的方法

    必须先创建指定类的对象,之后通过 对象名.方法名(参数) 的形式调用

    1. 调用其他类中被static修饰的方法

    即可以创建指定类的对象,之后通过 对象名.方法名(参数) 的形式调用

    但是正常使用语法应为 类名.方法名(参数) 的形式

    作业:

    1.熟悉猜拳游戏流程

    2.自己将猜拳游戏方法化

    3.添加数字转换方法 输入选择的数字返回选择相应的字符串

    例如 输入0返回剪刀 1返回石头 =》返回值类型为String

    使用这个方法 在每次游戏结束后输出结果

    例:电脑出的是剪刀 你出的是石头 你赢了

    当前对局次数5次 你赢了3次 输了1次 平局1次

    4.熟悉对象与类的概念,完成手机、汽车类的书写

    展开全文
  • 1. 方法的组成 2. 方法的参数 3. 返回值 4. 静态和实例 5. 同一个类中静态和实例之间的相互调用 6. 不同的类中静态和实例之间的相互调用 7. 构造方法 8. 方法的重载 9.对象数组 10.成员变量和局部变量 一.方法的理解...

    方法

    掌握

    1. 方法的组成
    2. 方法的参数
    3. 返回值
    4. 静态和实例
    5. 同一个类中静态和实例之间的相互调用
    6. 不同的类中静态和实例之间的相互调用
    7. 构造方法
    8. 方法的重载
    9.对象数组
    10.成员变量和局部变量

    一.方法的理解和语法格式
    1.解决某一件事的功能实现。方法,是一段代码块的封装,方法中的代码应围绕某一功能的实现来写,目标明确,逻辑清晰。方法的语法格式
    2.格式:在Java中,声明一个方法的具体语法格式如下:

       /*
       方法的组成:
       修饰符:1.访问(调用)权限修饰符 public private 2.静态修饰符 static
       返回值类型:1.void无返回值  2.有返回值:返回一个基本类型的数据 或 引用类型数据
       方法名: 第一个单词小写,第二个以及后续单词首字母大写,字母,数字,下划线组成
       参数:可以没有,也可以有 ,参数的声明同变量的声明,仅仅只是定义类型,取名字,不赋值
       方法体: 1.定义变量 2.选择,循环结构 3.方法的调用 4.返回语句return
        */
    
    修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2,......){ 
    	执行语句
    	1.方法的调用
    	2.变量的操作:声明 赋值  修改
    	3.程序结构:选择结构 循环结构……… 
    	return 返回值;
    }
    

    对于上面的语法格式中具体说明如下:
    1.修饰符:方法的修饰符比较多,有对访问权限进行限定的,有静态修饰符static,还有最终修饰符final 等,这些修饰符在后面的学习过程中会逐步介绍
    2.返回值类型:用于限定方法返回值的数据类型
    3. 有返回值:基本数据类型 类和接口 没有返回值:void
    4.参数类型:用于限定调用方法时传入参数的数据类型
    5.参数名:是一个变量,用于接收调用方法时传入的数据
    6.return关键字:用于结束方法以及返回方法指定类型的值
    7.返回值:被return语句返回的值,该值会返回给调用者
    需要特别注意的是,方法中的“参数类型 参数名1,参数类型 参数名2”被称作参数列表,它用于描述方法在被调用时需要接收的参数,如果方法不需要接收任何参数,则参数列表为空,即()内不写任何内容。方法的返回值必须为方法声明的返回值类型,如果方法中没有返回值,返回值类型要声明为void,此时,方法中return语句可以省略。

    二.为什么有的方法有参数,有的没有
    1.榨汁机榨苹果汁需要苹果。吃饭需要食物。
    以上描述的都是一个动作,都可以用程序的方法表示,实现这个动作所需 消耗的物资,就对应方法的参数。一般情况下,参数都会在方法体中被使用 和改变。
    当然,不是所有的方法都需要参数,例如:跑步,说话,睡觉,玩手机,看 书。
    2.参数分形参和实参(参数的分类)
    形参:形式参数,在声明一个方法时,方法名后面的小括号中,就是形参,
    格式:(参数数据类型 参数名)
    实参:实际参数,在调用一个方法时,方法名后面的小括号中,就是实参。
    格式:(参数值或一个同类型的变量)
    补充:方法的状态:方法编写完成后,没有调用的状态叫作方法的声明,被其它方法调用时,叫调用状态。
    案例:
    榨苹果汁,吃饭,跑步,说话(背诗歌),睡觉,玩手机,看书。

      /*
       * 1.参数的分类:形参  实参
       * 2.形参和实参的关系:实参给形参赋值的
       * 3.形参和实参 保持 个数一致,类型一致
       * 4.形参的使用范围:相当于方法体中声明的局部变量
       *
       * 扩展:可变形参--相当于数组
       * 1.声明方式 类型 ... 参数名
       * 2.如果还需要其他参数,将可变形参放在最后
       * 3.可以用length属性获取可变参数个数
       *
       * */
        private String name;
    
        public static void main(String[] args) {
            String name1="貂蝉";
            //方法的调用--实参
            fun1(18,"貂蝉","吕布");
            //形参和实参的关系 -- 实参给形参赋值的
        }
    
        //方法的定义--形参
        public static void fun1(int  age,String ... name) {
            System.out.println(name[0]);
        }
    
    }
    
    public class Hello2 {
        /*
        * 1.可变形参可以不传值
        * */
        public static void main(String[] args) {
            int[] a1=new int[]{1,2,3};
            int[] a2=new int[]{1,2,3};
            fun1(a1,a2);
            int [][]aa=new int [1][];
            fun2(aa);
        }
    
        private static void fun1(int [] a,int [] a2) {
            System.out.println(a);
            System.out.println(a.length);
        }
    
        private static void fun2(int [][] ... a) {
            System.out.println(a);
            System.out.println(a.length);
        }
    }
    

    三.方法的返回值
    1.返回值指的是:根据实际的业务需求,对某一功能用程序实现后,需要有一定的产出。
    比如:榨一杯苹果汁,最后会产出一杯苹果汁。这个时候就有人会问:参数和返回值之间好像有着某种联系?
    其实,这两者之间没有任何必然的联系。也就是说,一个方法,可以有参数,也可以没有参数,可以有参数,没有返回值,也可以有参数,也有返回值…
    打个比方:盖房子需要木头,水泥,砖块。这些都是“盖房子”这个方法的参数,但是产出只有一个——房子。再打个比方,“种水稻”这个方法需要的参数有:种子,化肥,除草剂,产出的是大米。可天有不测风云,万一闹灾荒,可能颗粒无收,这个时候,没有产出。当然,我们希望的是每年风调雨顺,国泰民安。再比如,“学习”这个方法,需要的参数是:时间,精力,和思考。可最终是否学业有成,还得看个人在这个过程中是否用心了,有可能学业有成,知识高产出,也有可能中途放弃,或误入歪门邪道,最终没有产出。我们还是祝愿所有的学员能够学员有成!
    2.返回值类型定义在方法名的前面,分两种:
    有返回值:基本数据类型,和引用数据类型(也就是类和接口)
    无返回值:void
    3.返回值用关键字return 表示。

    // 返回值 : void    返回一个对象  返回一个对象数组
    public class Hello3 {
        int a=2;
        Hello3 hello3=new Hello3();
        public static void main(String[] args) {
            fun1();
        }
        public static Hello3[]  fun1() {
            Hello3[] h = new Hello3[2];
            //返回一个对象数组
            return  h;
        }
    }
    

    四.理解静态和实例

    /*
    静态:类
    实例:对象
    * static 属于类的,所有对象公共的,共有的一份。
    * 实例的,每个对象单独拥有一份
    *  调用:
    *       static 静态的,属于类的,通过类名调用
    *       实例的,属于对象的,通过对象名来调用。
    *  注意:
    *       类名只能调用静态的,对象 即可以调用实例的,也可以调用静态的。
    * */
    public class Person {
              int a=0;
       static int b=0;
    
        public static void main(String[] args) {
            System.out.println(Person.b);
            //System.out.println(Person.a);
            Person p1 = new Person();
    
            p1.b=6;
            p1.a=6;
            Person p2 = new Person();
            System.out.println(p2.b);//6
            System.out.println(p2.a);//0
    
        }
    }
    

    五.同一个类中静态和实例之间的相互调用
    1.调用:方法分静态和非静态,同一个类中,静态方法直接调用静态方法,
    静态方法调用非静态,要先创建对象,然后再调用。因为静态方法是属于类的,非静态属于对象的。
    不同的类中:调用静态方法,直接是类名.方法名();调用非静态:创建对象,再调用。同一个类中:
    主调方\被调方 &nbsp 静态方法 &nbsp &nbsp 实例方法
    静态 &nbsp &nbsp 直接写方法名调 &nbsp 创建对象,再调
    实例 &nbsp &nbsp 直接写方法名调 &nbsp 直接写方法名调(省略this)
    不同的类中:
    主调方\被调方 &nbsp静态方法 &nbsp 实例方法
    静态 &nbsp 直接写类名.方法名()来调 创建对象,再调
    实例 &nbsp 直接写类名.方法名()来调 创建对象,再调

    2.传参,调用有多个参数的方法时,传参的顺序一致,数据类型保持一致。

     /* 同一个类中:
        1.静态方法 中 调用 静态方法  类名.静态方法() ,可以省略类名
        2.静态方法 中 调用 实例方法  对象名.实例方法()
        3.实例方法 中 调用 实例方法   3.1 新对象.实例方法()  3.2 当前对象this.实例方法()  可以省略this
        4.实例方法 中 调用 静态方法  类名.静态方法() ,可以省略类名
         */
    public class Hello4 {
        //实例方法
        public void fun1(){
            System.out.println("实例方法1");
            //情况3.1 新创建一个对象
            Hello4 h4_1 = new Hello4();
            h4_1.fun1_1();
    
            //情况3.2 当前对象--谁调用我所在的实例方法,谁就是当前
            this.fun1_1();
            fun1_1();
            System.out.println("方法1中的h4_1:"+h4_1);
            System.out.println("方法1中的this:"+this);
            System.out.println(h4_1==this);
    
            //情况4
            Hello4.fun2();
            fun2();
        }
        public void fun1_1(){
            System.out.println("实例方法1_1");
        }
    
    
        //静态方法
        public static void fun2(){
            System.out.println("静态方法");
        }
    
        public static void main(String[] args) {
            //情况1
            Hello4.fun2();
            fun2();
            //情况2
            Hello4 h4 = new Hello4();
            h4.fun1();
            Hello4 h5 = new Hello4();
            h5.fun1();
            System.out.println("主方法中的h4:"+h4);
            System.out.println("主方法中的h5:"+h5);
        }
    
    }
    

    六. 不同的类中静态和实例之间的相互调用

    /*  不同类中:
       1.静态方法 中 调用 另一个类的静态方法  类名.静态方法()
       2.静态方法 中 调用 另一个类的实例方法  对象名.实例方法()
       3.实例方法 中 调用 另一个类的实例方法  对象名.实例方法()
       4.实例方法 中 调用 另一个类的静态方法  类名.静态方法()
        */
    public class Hello5 {
        public void fun1(){
            //情况3
            Hello5_1 h5_1 = new Hello5_1();
            h5_1.fun1();
            //情况4
            Hello5_1.fun2();
    
            System.out.println("Hello5的实例方法1");
        }
        public static void fun2(){
            //情况1
            Hello5_1.fun2();
            //情况2
            Hello5_1 h5_1 = new Hello5_1();
            h5_1.fun1();
    
            System.out.println("Hello5的静态方法2");
        }
    
    
    }
    
    public class Hello5_1 {
        public void fun1(){
            System.out.println("Hello5_1的实例方法1");
        }
        public static void fun2(){
            System.out.println("Hello5_1的静态方法2");
        }
    }
    

    七.构造方法
    1.构造方法的作用:开辟内存空间,生成对象,俗称类创建对象的过程叫实例化
    特点:方法名和类名相同,没有返回值一说,连void也没有。

    2.构造方法分为有参构造和无参构造
    无参构造:jvm虚拟机在加载类时会自动创建,每个类都默认有一个无参构造
    有参构造:需要开发人员自己去编写,它的作用是:实例化对象的同时,为对象的成员
    属性赋值。有参构造=无参构造+set方法

    注意:如果开发人员编写了有参构造,那么虚拟机就不会默认生成无参构造。如果仍要使用无参构造,需要手动编写。

    /*
    * 构造方法
    * 1.每一个类 都自带一个无参构造方法
    * 2.构造方法返回值和方法名重复的,因此省略了
    * 3.有参构造:参数就是用来给成员属性赋值的
    * 4.无参构造
    * */
    public class Dog {
        String name;
        int age;
    
       /* public Dog(String name1,int age1){
            name=name1;
            age=age1;
        }*/
    
        public Dog(String name,int age){
            this.name=name;
            this.age=age;
        }
        public Dog(String name){
            this.name=name;
        }
        public Dog(int age){
            this.age=age;
        }
    
        public Dog(){
    
        }
    
        public static void main(String[] args) {
            Dog h = new Dog();
        }
    }
    
    //引用数据类型的成员属性 默认值是null
    public class TestPerson {
        public static void main(String[] args) {
            //无参构造创建的对象,属性都是没有赋值的,只有默认值
            Person p1 = new Person();
            System.out.println(p1.name);
            //有参构造创建对象,同时也会给属性赋值
            Person p2 = new Person("貂蝉");
            System.out.println(p2.name);
            Person p3 = new Person("貂蝉", 18);
            System.out.println(p3.name);
            System.out.println(p3.age);
        }
    }
    
    public class Person {
        String name;
        int age;
    
        public Person(String name,int age){
            this.name=name;
            this.age=age;
        }
        public Person(int age){
            this.age=age;
        }
    
        public Person(String name){
            this.name=name;
        }
    
        public Person(){
    
        }
    }
    

    八.方法的重载
    1.一个类中,同名不同参数的两个或以上的方法叫做方法的重载。
    有参构造和无参构造就是典型的方法重载

    2.如果类中只有有参构造,忘记了写无参构造 ,类中的有参构造会覆盖无参构造
    3.如果类中有参构造和无参构造都忘记了写 虚拟机在加载该类的时候会默认帮你生成一个无参构造

    有参构造会覆盖默认的无参构造。

    3.有参构造中的this指的是,调用该构造方法得到的那个对象。

    Public User(String name){
    This.name=name;
    }
    Public User(String name1){
    This.name=name1;
    }
    
    New User(“张三”);
    

    3.判断是否是重载只看两个因素:1.方法名相同,2.参数不同。
    其它的返回值 修饰符什么的都不用看。
    例如:println()

    public class User {
        //每个类都自带一个无参构造,如果写了有参构造,就会覆盖自带的无参构造
        String name;
        String psw;
        int age;
    
        public User(String name, String psw, int age) {
            this.name = name;
            this.psw = psw;
            this.age = age;
        }
    
        public User(String name) {
            this.name = name;
        }
    
        public User() {
        }
    
        /*
        * 同一个类,方法同名不同参
        * 不同参:参数个数不同 类型不同,顺序不同
        * */
       /* public User(String name,String psw,int age){
            this.age=age;
            this.psw=psw;
            this.name=name;
        }
    
        public User(int age,String psw){
            this.age=age;
            this.psw=psw;
        }
        public User(String name,int age){
            System.out.println("构造1");
            this.name=name;
            this.age=age;
        }
        public User(String psw,String name){
            this.name=name;
            this.psw=psw;
        }
        public User(String psw){
            this.psw=psw;
        }
       *//* public User(String name){
            this.name=name;
        }*//*
        public User(int age){
            this.age=age;
    
        }
        public User(){
    
        }*/
        /*public User(int age,String name){
            System.out.println("构造2");
            this.age=age;
            this.name=name;
        }*/
    
    
    
    
    }
    

    九.对象数组

    public class TestUser {
    
        public static void main(String[] args) {
            //有3个人
            User u1 = new User("貂蝉", "111", 18);
            User u2 = new User("貂蝉2", "111", 18);
            User u3 = new User("貂蝉3", "111", 18);
            //对象数组
            User[] users = {u1,u2,u3};
            //遍历输出
            for (int i = 0; i < users.length; i++) {
                System.out.println(users[i].name+"--"+users[i].age);
            }
    
            //对象数组作为方法的参数
            addAge(users);
            //增强for输出
            for(User u:users){
                System.out.println(u.name+"--"+u.age);
            }
        }
        //给每个人的年龄加1
        public static void addAge(User [] users){
            for (int i = 0; i < users.length; i++) {
                users[i].age+=1;
            }
        }
    }
    

    十.成员变量和局部变量
    成员变量:类的成员,也叫全局变量。全局和局部,哪个作用域大呢?
    作用域又是什么呢?变量的有效使用范围
    Java里面的作用域的范围是什么呢?代码块{} 类代码块,方法代码块,循环代码块,无名代码块, try-catch代码块
    思考:成员变量和属性又是什么关系呢?同一个东西的不同称呼。从作用域的范围看,叫成员变量,从类的剖析角度来看,叫属性。
    方法的参数属于的局部变量,形参相当于变量的声明,实参相当于初始化(赋值)。

    展开全文
  • java方法重载递归调用 简介: 一个java方法由一下几部分组成 修饰符: 修饰符是可选的,告诉编译器如何调用该方法。这定义了该方法的访问类型。 返回类型: 方法可以返回一个值。returnValueType的值...
  • 方法简介:可以用于定义可重用的代码以及组织和简化...在max 方法的方法体中使用一个if语句来判断哪个 数较大,然后返回该数的值。为使带返回值的方法能返回一个结果,必须要使用带关键字 return 的返回语句。执行 r...
  • 在PHP语言中,定义函数基本语法格式如下:function函数名([参数1,参数2,…]){函数体…}从上述语法格式可以看出,函数定义由关键字function、函数名、参数和函数体4部分组成,关于这4部分相关说明具体如下。...
  • 在后一种情况中,委托不仅存储对方法入口点的引用,还存储对调用方法的对象的引用。 C 函数指针不同,委托是完全面对对象的;指向成员函数的 C 指针不同,委托同时封装对象实例和方法。委托声明定义从类 ...
  • 本文讨论范围是Cmd命令与PowerShell命令之间组合与调用。  毋庸置疑,Cmd命令与PowerShell命令之间调用有两个方向。即在Cmd命令中调用PowerShell命令,以及在PowerShell脚本中调用Cmd命令。需要说明是,...
  • 编程语言原理---方法重载的实现设计调用方法的原理 1.重载包括:普通方法的重载和构造方法的重载 1 1.1.横向重载”和“纵向重载”1 1.2.方法签名通过方法名称,参数数量,参数类型+返回类型参数顺序(命名...
  • 执行引擎是Java虚拟机最核心的组成部分之一。虚拟机物理机都具有执行代码的能力。区别在去物理机的执行引擎是直接建立在处理器、硬件、指令集和操作系统层面上的,而虚拟机的执行引擎则是自己实现的,可以自行定制...
  • Java中方法的定义使用 在程序书写过程中,以指定方法名书写并提供用于完成指定功能的数据、参数的代码块称之为方法 按照特定语法定义书写的包含一条或多条执行语句的代码块 在其他语言中也称之为函数、过程 方法由...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,104
精华内容 841
关键字:

方法的组成与调用