精华内容
下载资源
问答
  • Java封装性就是把对象属性对属性操作结合成一个独立单位,并尽可能隐藏内部细节。 它包含两个含义: 1)把对象全部属性对属性操作结合在起,形成一个不可分割独立单位(即对象)。 Java是一种纯粹...

    封装性

    Java的封装性就是把对象的属性和对属性的操作结合成一个独立的单位,并尽可能的隐藏内部的细节。 它包含两个含义:

    1)把对象的全部属性和对属性的操作结合在起,形成一个不可分割的独立单位(即对象)。
    Java是一种纯粹的面向对象程序设计语言,除了基本数据类型(如整型、浮点型等),Javn中的数据都以对象的形式存在,将属性和操作封装在对象中,它没有游离于类之外的属性和方法,可以有效实现细节隐藏。

    2)信息隐蔽,即尽可能隐蔽对象的内部细节,对外形成一个边界,只保留有限的对外公开接口使之与外部发生联系,这一点通过Java包Java类及其成员的访问权限实现。 可以理解为黑盒子,日常用品之类的商业用品。只给你可以应用的部分。

    1类与对象

    类是Java面向对象程序设计中最基本的程序单元。 编写Java程序时,首先创建类,然后通过类创建不同的对象。 当程序运行时,对象有对应的内存空间存储其具体的属性值,通过对象激活相应的方法(方法访问内存),实现一定的功能。

    1.1类的定义

    Java文件中中能有一个同名类,且只有它能被public修饰

    java中通过class关键字进行定义:类声明和类体

    1. )类声明:创建一个新的对象类型
    public class muchu{  //关键字class前可以有访问权限public也可以没有
          //类体
                  }
    
    1. )类体:定义一个类,就可以在类体中定义;两个类形成员:属性和方法

    1、属性的定义
    属性的定义分为两种:
    基本数据类型
    对象类型:通过class关键字定义的对象类型

    c语言基本数据类型 /位 Java基本数据类型 /位
    char 1 char16
    short 2 $short16
    int 4 int32
    long 4 long64
    longlong 8
    float 4 float8
    double 8 double64
    longdouble 8
    boolean1
    byte8
    	public class Muchu{
    		private float x;
    		private float y;
    }
    
    	public class Shankong{
    		private Muchu mu1;
    		private Muchu mu2;
    }
    

    ·类Muchu两个访问权限为“private”属性,x,y的基本数据类型为float(基本数据类型)。
    ·类Shankong的两个访问权限位private属性,其为对象类型。其中private表示的属性是私有的,只有该类的内部可以访问。

    2、方法的定义

    方法的定义格式包括方法的访问权限、方法名字、方法的参数列表、返回类型和方法体。
    ·参数类型和方法的返回类型对象类型基本数据类型

    3、构造方法的定义
    实质就是 初始化参数
    1.)它具有与类名相同的名称
    2.)它没有返回值(如果有,则不是构造方法,而是和构造方法同名的成员方法)

    3).构造方法的调用时机与一般的方法不同。一般的方法是在需要时才调用,而构造方法则是创建对象时自动调用,并执行构造方法的内容。因此,构造方法无需在程序中直接调用,而是在对象产生时自动执行。
    4).基于上述构造方法的特性,可利用它来对对象的数据成员做初始化的赋值;

    5).在类中没有声明任何的构造方法,系统会自动为类加入一个无参的且什么都不做的构造方法,类似于下面的代码:
    public Person(){}

    6).一但用户自定义了构造方法则系统不再提供无参构造方法。用户手动添加一个(是不是一定要添加?)

    7).构造方法虽然可以被私有了,但并不一定说此类不能产生实例化对象,只是产生这个实例化对象的位置有所变化,即只能在本类中产生实例化对象。

    例子:Java编译器为其提供的缺省构造方法

    public Muchu(){
    }
    
    数据类型 缺省值
    基本数据类型 0
    boolean false
    char \0
    对象类型变量 null

    函数构造方法的定义部分转载于:https://blog.csdn.net/ClinEvol/article/details/82870454

    1.2对象的创建和使用

    1、对象的声明
    Java中的对象类似于c语言的指针,对象变量声明后,系统将分配32位地址空间(4个字节),并且空间为null。

    例子:声明类Muchu 的对象变量mu
    Muchu mu;

    2、对象的创建

    new一个对象,只有在对象变量声明后,通过new关键字调用类的的构造函数创建对象,然后后才可以使用对象变量。

    Muchu mu = new Muchu(x,y);
    

    每次new一个对象都会创建一个类的新的对象,并且分配内存空间。
    对象变量的存储地址不可修改,仅仅可以通过访问他的指向的对象的地址。

    3、对象的使用
    如果要访问对象里的某个成员变量或方法,可以通过下面的语法来实现:

    对象名称.属性名     //访问属性
    对象名称.方法名()     //访问方法
    

    例如,想访问Person类中的name和age属性,可用如下方法来访问:

    p1.name;   //访问Person类中的name属性
    p1.age;    //访问Person类中的age属性
    

    因此若想将Person类的对象p中的属性name赋值为“张三”,年龄赋值为25,则可采用下面的写法:

    p1.name = "张三" ;
    p1.age = 25 ;
    

    如果想调用Person中的talk()方法,可以采用下面的写法:

    p1.talk();   //调用Person类中的talk()方
    

    1.3方法的形式参数和实际参数的传递方式

    Java形参和实参的结合方式为值传递。 与形参的数据类型无关。

    假设 通过Muchu muchu1 = new Muchu(100,200);创建了一个对象m1,定义两个方法changeOne()和changeTwo(),并将muchu1作为实参传递给两个方法。

    public static void changeOne (Muchu m1){
    	m1 = new Muchu(78,156);
    }
    
    public static void changeTwo(Muchu m1){
    	m1.setX(15);
    }
    

    m1作为形参,由于是值传递,实际参数muchu1会把其存储的地址拷贝到形参m1中,此时形参和实参是不同内存同一地址。

    方法changeOne()的调用不会影响实参的和实参指向的对象。(只修改了形参的值,没修改指向的对象的值)
    方法changeTwo()的调用不会影响实参,单会影响实参指向的对象。(方法修改了形参指向的对象的属性值)

    1.4方法重载

    在Java中,同一个类中的多个方法可以有相同的方法名称,但是有不同的参数列表,这就称为方法重载(method overloading)。

    参数列表又叫参数签名,包括参数的类型、参数的个数、参数的顺序(有顺序),只要有一个不同就叫做参数列表不同。

    重载是面向对象的一个基本特性。

    public class Demo {
     
    	//一个普通得方法,不带参数,无返回值
    	public void add(){
    		//method body
    	}
    	
    	//重载上面的方法,并且带了一个整形参数,无返回值
    	public void add(int a){
    		//method body
    	}
    	
            //重载上面的方法,并且带了两个整型参数,返回值为int型
    	public int add(int a,int b){
    		//method body
    		return 0;
    	}
     
    }
    

    通过上面的例子,不难看出,重载就是在一个类中,有相同的函数名称,但形参不同的函。重载的结果,可以让一个程序段尽量减少代码和方法的种类。

    说明:

    ·参数列表不同包括:个数不同、顺序不同、类型不同。
    ·仅仅参数变量名称不同是不可以的。
    ·跟成员方法一样,构造方法也可以重载。
    ·声明为final的方法不能被重载。
    ·声明为static的方法不能被重载,但是能够被在此声明。

    方法的重载的规则:

    方法名称必须相同。
    参数列表必须不同。
    方法的返回类型可以相同也可以不相同。
    仅仅返回类型不同不足以称为方法的重载。
    方法重载的实现:
    方法名称相同时,编译器会根据调用方法的参数个数、参数类型等去逐个匹配,以选择对应的方法,如果匹配失败,则编译器报错,这叫做重载分辨

    方法重载转于:https://blog.csdn.net/xkfanhua/article/details/80561673

    展开全文
  • 文章已移至 C++ 形参和实参在三中传递方式区别
    展开全文
  • 传递和地址传递传递的都是实参的一个拷贝 C语言中实参和形参之间的数据传递是单向的“值传递”,单向传递,只能由实参传给形参,反之不行 输出格式并没有选择%p而是选择了%d,因为十进制的数看起来更直观 1 ...
  • c语言的形参和实参传递的区别

    千次阅读 多人点赞 2019-02-28 10:52:49
    参数传递,是在程序运行过程中,实际参数就会将参数值传递给相应形式参数,然后在函数中实现对数据处理返回过程。参数传递有3种方式: 值传递 地址传递 引用传递 tips: 被调用函数的形参只有函数被调用时...

    转载自 https://blog.csdn.net/u013097971/article/details/77983810


    参数传递,是在程序运行过程中,实际参数就会将参数值传递给相应的形式参数,然后在函数中实现对数据处理和返回的过程。参数传递有3种方式:

    1. 值传递
    2. 地址传递
    3. 引用传递

    tips:

    1. 被调用函数的形参只有函数被调用时才会临时分配存储单元,一旦调用结束占用的内存便会被释放
    2. 值传递和地址传递,传递的都是实参的一个拷贝
    3. C语言中实参和形参之间的数据传递是单向的“值传递”,单向传递,只能由实参传给形参,反之不行
    4. 输出格式并没有选择%p而是选择了%d,因为十进制的数看起来更直观


    1 值传递


    如果只是传递值的话:

    #include <stdio.h>
    
    //值传递:传值
    void swap( int x, int y);
    
    int main()
    {
        int a=2,b=3;
        printf("before:实参为a,b\na=%d,地址为%d\nb=%d,地址为%d\n\n",a,&a,b,&b);
        swap(a,b);
        printf("after:实参为a,b\na=%d,地址为%d\nb=%d,地址为%d\n\n",a,&a,b,&b);
        return 0;
    }
    
    void swap(int x,int y)
    {
        int tmp;
        tmp=x;
        x=y;
        y=tmp;
        printf("inside:形参为x,y\nx=%d,地址为%d\ny=%d,地址为%d\n\n",x,&x,y,&y);
    }

    执行结果:从形参x和y的地址来看,传递的是实参a和b的拷贝。对拷贝的修改不会改变实参的值。。

     


    如果值传递,传递的是地址呢?

    #include <stdio.h>
    
    //值传递:传地址
    void swap( int *x, int *y);
    
    int main()
    {
        int a=2,b=3;
        printf("before:实参为&a,&b\na=%d,地址为%d\nb=%d,地址为%d\n\n",a,&a,b,&b);
        swap(&a,&b);
        printf("after:实参为&a,&b\na=%d,地址为%d\nb=%d,地址为%d\n\n",a,&a,b,&b);
        return 0;
    }
    
    void swap(int *x,int *y)
    {
        int *tmp= NULL;
        tmp=x;
        x=y;
        y=tmp;
            printf("inside:形参为*x,*y\n*x=%d,x=%d,地址为%d\n*y=%d,y=%d,地址为%d\n\n",*x,x,&x,*y,y,&y);
    }

    执行结果:形参是a和b的地址,但通过a和b的地址(即x和y)访问到的是a和b的拷贝。直接交换a和b的地址失败。

     

     

     

    2地址传递

    #include <stdio.h>
        
    //地址传递
    void swap( int *x, int *y);
    
    int main()
    {
        int a=2,b=3;
        printf("before:实参为&a,&b\na=%d,地址为%d\nb=%d,地址为%d\n\n",a,&a,b,&b);
        swap(&a,&b);
        printf("after:实参为&a,&b\na=%d,地址为%d\nb=%d,地址为%d\n\n",a,&a,b,&b);
        return 0;
    }
    
    void swap(int *x,int *y)
    {
        int tmp;
        tmp=*x;
        *x=*y;
        *y=tmp;
            printf("inside:形参为*x,*y\n*x=%d,x=%d,地址为%d\n*y=%d,y=%d,地址为%d\n\n",*x,x,&x,*y,y,&y);
    }

    执行结果为: 形参是a和b的地址,但通过a和b的地址(即x和y)访问到的是a和b的拷贝。虽然不能直接交换a和b的地址,但是可以修改a和b的地址(即x和y)指向的值。也就是说,不能直接修改指针,但是可以修改指针指向的值。所以这一次a和b的值交换了。

     

     

    3 引用传递

    #include <stdio.h>
        
    //引用传递
    void swap( int &x, int &y);
    
    int main()
    {
        int a=2,b=3;
        printf("before:实参为a,b\na=%d,地址为%d\nb=%d,地址为%d\n\n",a,&a,b,&b);
        swap(a,b);
        printf("after:实参为a,b\na=%d,地址为%d\nb=%d,地址为%d\n\n",a,&a,b,&b);
        return 0;
    }
    
    void swap(int &x,int &y)
    {
        int tmp;
        tmp=x;
        x=y;
        y=tmp;
            printf("inside:形参为&x,&y\nx=%d,地址为%d\ny=%d,地址为%d\n\n",x,&x,y,&y);
    }

    void swap( int &x, int &y); //表示传递进去的是实参,而不是拷贝。

    执行结果为: 传递的是实参,而不是实参的拷贝。对实参的修改,将会成功的改变其中的值。

     

    补充

    int x=1;
    int *y=&x; //用于指针传递,y有自己独立的内存地址,存储的内容是x的地址,*y是x的值
    int &z=x; //用于引用传递,可以理解为z就是x,x就是z,只不过名字不一样

    展开全文
  • 形参和实参之间三种传递方式

    千次阅读 2011-11-28 19:39:42
    //形参和实参之间三种传递方式 void fun(int i) { i++;} void fun(int &i) { i++;} void fun(int *i) { *i=*i+1;} 若指针指向是数组首地址,则数组元素访问方式 1.数组名[i] 指针名[i] 2.*...
     
    

    //形参和实参之间的三种传递方式
    void fun(int i)
    {  i++;}
    void fun(int &i)
    {  i++;}
    void fun(int *i)
    {  *i=*i+1;}
    若指针指向的是数组的首地址,则数组元素的访问方式
    1.数组名[i]  指针名[i]
    2.*(数组名+i)  *(指针名+i)
    字符型数组的指针:
    char *p,name[10];
    p=name; 
    p="smith"; //可以等于字符串常量的地址。
    name="smith";//错误的,因为数组名是指针(地址)的常量,定义后不能改变其值。
    cout<<整型数组名;输出的就是数组的首地址。
    cout<<字符型数组名;输出的是该数组中的所有字符,直到空字符结束。

    //形参是数组,实参是数组
    void fun(char name[])    // 或者写为char name[]
    {  cin>>name;}
    void main()
    {char n[10]; fun(n); cout<<n<<endl;}

    //形参是指针,实参是数组
    void fun(char *p)    // 或者写为char name[]
    {  cin>>p;}
    void main()
    {char n[10]; fun(n); cout<<n<<endl;}

    //形参是数组,实参是指针
    void fun(char name[])    // 或者写为char name[]
    {  cin>>name;}
    void main()
    {char n[10]; char *p=n;
     fun(p); cout<<n<<endl;}

    #include<iostream.h>
    #include<string.h>
    void fun(char name[])    // 或者写为char name[]
    {
      strcpy(name,"smith");
    }
    void main()
    {
     char n[10];
     char *p=n;
     fun(p);

    展开全文
  • 2.当传值调用时,改变的是形参的值,并没有改变实参的值,实参的值可以传递形参,但是,这个传递是单向的,形参不能传递回实参。 3.当引用调用时,如果参数是对象,无论对对象做了何种操作,都不会改变实参对象的...
  • 在主函数实现了解传递的本质。 提示:以下是本篇文章正文内容,下面案例可供参考 一、值传递 在主函数中 #include <iostream> using namespace std; void main() { int i=10; int j=i; j=20; cout<&...
  • 良好动态内存申请释放 程序内存分配 一个由C/C++编译程序占用内存分为以下几个部分 1、栈区(stack)— 由编译器自动分配释放 ,存放函数参数值,局部变量值等。其 操作方式类似于数据结构中栈...
  • 形参和实参的传递过程中,牵涉到大的类类型对象、容器类型对象或者不支持拷贝操作的对象时,不适合采用值传递,应使用引用传递的方式。另外,实参形参传递的过程中,系统会忽略形参的顶层引用(可用变量赋值给常量...
  • 形参实参之间传递

    千次阅读 2013-10-09 11:45:20
    C语言中,参数的传递方式是“单向值传递”,形参和实参变量各自有不同的存储单元,被调用函数中的形参变量值的变化不会影响实参变量值。 举个例子  #include  void swap(int x,int y)  {  int z...
  • JavaScript形参和实参

    2016-03-30 20:21:00
    本节要说明的有两点,一个是参数的传递方式,一个是形参和实参的数目。 参数的传递方式 上节已经讲到,在JavaScript中,有两种传值方式,按值传递和引用传递,函数参数的传递也可分为按值传递和引用传递。【例4-4...
  • 指针数组和数组指针,二维数组和二级指针作为形参和实参 C语言学习笔记——指针、数组作为函数参数传递的方式 在一维数组中,数组名表示是数组第一个元素地址。 C语言调用函数时采用“值传递方式,当用变量...
  • Python3 函数的形参和实参

    千次阅读 2019-03-04 22:53:35
    实参的对应关系与形参的对应关系是按位置来依次对应的 说明: 实际参数形式参数通过位置进行传递的匹配 实参个数必须与形参个数相同2、序列传参: 序列传参是只指函数调用过程中,用*将序列拆解后按照为序列...
  • 2.形参的类型决定了形参和实参交互的方式。 (引用->绑定,非引用->拷贝) 3.实参分为:被引用传递(引用形参是实参的别名),被值传递(实参形参是两个相互独立的对象)。 4.传值参数:函数对形参做的所有...
  • 一、区别: 1、函数定义方式不同 形参出现在函数定义中,在整个函数体内都可以使用, 离开该函数则不能使用。...传值调用引用调用指是用于参数传递过程中一种机制。传值调用中,只使用了实参
  • 形参实参

    千次阅读 2012-11-19 23:58:03
    直白的讲,形参是形式上的参数,实参是实际的参数;形参只是对实参的一种抽象类型描述,只是声明一个函数(方法)能...到这里,就又出现程序设计语言中的另一通用概念参数传递方式,传值传址; 1.传值方式,只是将实参的
  • python形参实参

    千次阅读 2019-03-12 21:31:46
    形参---函数完成其工作所需的一项信息,在定义函数时出现的参数 ... 调用函数时,必须使得实参和形参一一对应,最简单的关联方式就是基于实参的顺序,即形参的顺序是power(x,y),实参的power(a,b)就要依次将a,...
  • 传地址值(传引用):是真正以地址的方式在传参数,这是形参和实参是同一个对象,才能真正操作实参! 主调函数中可以直接改变变量值,用函数后只是传值要传地址值操作! 主函数中传值理解: int *p1,*p2...

空空如也

空空如也

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

形参和实参的传递方式