精华内容
下载资源
问答
  • 当方法局部变量和成员变量重名时候,根据“就近原则”,优先使用局部变量。 如果需要访问本类当中成员变量,需要使用格式: this.成员变量名 “通过谁(this)调用方法,谁就是this。”这里this是...

    /*
    当方法的局部变量和类的成员变量重名的时候,根据“就近原则”,优先使用局部变量。
    如果需要访问本类当中的成员变量,需要使用格式:
    this.成员变量名

    “通过谁(this)调用的方法,谁就是this。”这里的this是Person与sayHello.
    this 的作用就是解决重名的作用。
    */
    public class Person {

    String name; // 我自己的名字
    
    // 参数name是对方的名字
    // 成员变量name是自己的名字
    public void sayHello(String name) {
        System.out.println(name + ",你好。我是" + this.name);
        System.out.println(this);
    }
    

    }

    public class Demo01Person {

    public static void main(String[] args) {
        Person person = new Person();
        // 设置我自己的名字
        person.name = "王健林";
        person.sayHello("王思聪");
    
        System.out.println(person); // 地址值
    }
    

    }

    展开全文
  • 宏定义函数的区别

    千次阅读 2019-03-04 21:42:56
    在带宏定义中,不会为形式参数分配...这一点函数是不同:在函数中,形参实参是两个不同的变量,都有自己作用域,调用时要把实参值传递给形参;而在带参数宏中,只是符号替换,不存在值传递问题。 ...

    在带参宏定义中,不会为形式参数分配内存,因此不必指明数据类型。而在宏调用中,实参包含了具体的数据,要用它们去代换形参,因此必须指明数据类型。

    这一点和函数是不同的:在函数中,形参和实参是两个不同的变量,都有自己的作用域,调用时要把实参的值传递给形参;而在带参数的宏中,只是符号的替换,不存在值传递的问题。

    展开全文
  • 不同C系统提供库函数数量功能会不一样。 用户自己定义函数。用以解决用户专门需要 从函数形式看 无函数:调用函数时,主调函数不向被调用函数传递参数。无函数一般用来执行指定一组操作 有...

    一、 函数的种类

    从用户的角度看

    1. 标准函数,即库函数。由系统提供的,用户不必自己定义这些函数,可以直接使用它们。如:printf。不同C系统提供的库函数的数量和功能会不一样。
    2. 用户自己定义的函数。用以解决用户的专门需要

    从函数的形式看

    1. 无参函数:调用函数时,主调函数不向被调用函数传递参数。无参函数一般用来执行指定的一组操作
    2. 有参函数:在调用函数时,主调函数在调用被调用函数时,通过参数向被函数调用传递数据,一般情况下,执行被调用函数时会得到一个函数值,供主函数使用。

    二、 函数定义的一般形式

    1. 定义无参函数的一般形式为:

    类型标识符  函数名(){
         声明部分
         语句部分
    }
    

    在定义函数时要用”类型标识符”指定函数值的类型,即函数带回来的值得类型。

    2. 定义有参函数的一般形式为

    类型标识符 函数名(形式参数表列){
        声明部分
        语句部分
    }
    

    3. 定义空函数的一般形式为

    类型标识符 函数名(){
    }
    

    三、 形式参数和实际参数

    • 在有参函数调用种,在定义函数时,函数名括号内的变量名称为形式参数,简称形参
    • 在主函数调用一个函数时,函数名后面括号种的参数,也可以是一个表达式称为实际参数,简称实参。
      例如:
    #include <stdio.h>
    void print(char a) {
    	printf("%c的HelloWord",a);
    }
    int main() {
    	char s = 'a';
    	print(s);
    	return 0;
    }
    

    由以上函数可知,主函数种的print(s)中的s就是实参,调用函数中void print(a)中的a就是形参

    四、 函数参数和函数的值

    • 大部分情况下,主调函数和被调函数之间有数据传递关系
    • return后面的值作为函数带回的值,也称函数的返回值
    • 在不同的函数之间传递参数,可以使用
      • 第一种:通过形参和实参
      • 第二种:使用return返回的值来计算结果
      • 第三种:全局变量即外部变量
    int max(int x, int y) {
    	int z;
    	z = x > y ? x : y;
    	return z;
    }
    
    void main() {
    	int a, b, c;
    	scanf("%d,%d",&a,&b);
    	c = max(a, b);
    	printf("最大值为:%d",c);
    }
    
    • 在定义函数中指定的形参,在未出现函数调用时,他们并不占内存种的存储单元。只有发生函数调用时,函数max种的形参才被分配内存单元。在调用结束后,形参所占的内存单元也被释放。
    • 实参可以时常量、变量或表达式,如:max(3,a+b);但必须有确定的值
    • 在被定义的函数中,必须指定形参的类型
    • 形参与实参的类型必须相对应,必须同时为int 或float等等等

    五、 函数的返回值

    通过函数调用使主调函数能得到一个确定的值,即为函数的返回值。

    • 其使通过函数中的return语句获得

      • return语句将被调用函数中的一个确定值待会主调函数中去
      • 如果需要从被调用函数带一个函数值供调函数使用,被调用函数中必须包含return语句,。如果不需要从被调用函数待会函数值则可以不用return。使用void
    • 其值也是一个表达式,如return x>y?x:y;

      • 函数的返回值应当属于某一个确定的类型,在定义函数时指定函数的返回值的类型。
      • C语言中,凡不加类型说明的函数,自动按整型处理
      • 定义函数时指定的函数类型一般应该和return语句中的表达式类型一致。
      • 对于不带回值得函数,应该用”void”定义函数为无类型或“空类型”

    六、 函数的调用

    一般形式为:函数名(实参表列)

    • 调用无参函数,则实参表列可以没有,但括号不能省略
    • 如果实参表列包含多个实参,则各参数间用逗号隔开,实参与形参的个数相等,类型应该匹配。实参与实参按顺序对应
    • 如果实参表列包括多个实参,对参数值的顺序并非确定,有的自左向右,有的自右向左
    int f(int a, int b) {
    	int c;
    	if (a>b)
    	{
    		c = 1;
    	}
    	else if (a == b)
    	{
    		c = 0;
    	}
    	else
    	{
    		c = -1;
    	}
    	return c;
    }
    
    int main() {
    	int f(int a, int b);
    	int i = 2, p;
    	
    	p = f(i, ++i);
    	printf("%d\n",p);
    	return 0;
    }
    

    该程序可以判定形参是自左向右还是自右向左,如果按自左向右顺序求实参的值,则函数调相当于f(2,3)。如果自右向左则函数f(3,3)

    七、 函数调用的方式

    1. 函数语句
      把函数调用作为一个语句,此时不要求函数带返回值,只要写了函数名就等于调用了
    2. 函数表达式
      要求函数确切的待会一个确定的值以参加表达式的运算。如c=max(a,b);
    3. 函数参数
      函数的本身作为参数。如:m=max(a,max(1,3));printf(“%d”,max(a,b));后面的printf于max也是一种把函数的本身作为参数调用
      九、 对被调用函数的声明和函数原型
    4. 被调用的函数必须是已经存在的函数(库函数或者用户自身定义的函数)
    5. 如果使用库函数,还应该在本文件开头引入#include命令将调用有关库函数时所需用到的信息包含到本文件中来
    6. 如果使用用户自己定义的函数,而该函数的位置在调用它的函数(主调函数)的后面(同一文件中),应该在主调用函数中对被调用的函数作声明

    八、 声明的含义

    声明的作用是是函数名,函数参数的个数和参数类型等信息通知编译系统,以便在遇到函数调用时,编译系统能正确识别函数并检查调用是否合法。

    (例如函数名是否正确,实参与参的类型和个数是否一致)

    九、 递归(函数调用函数)

    在调用一个函数的过程中又出现直接或间接地调用该函数本身,称为函数地递归调用。
    例如:

    int f(int x) {
    		int y, z;
    		z = f(y);
    		return (2 * z);
    }
    

    例:计算5的阶乘

    void main() {
    	long result = recursion(5);
    	printf("%d",result);
    }
    long recursion(int n) {
    	if (n==1 || n==0)
    	{
    		return 1;
    	}
    	else
    	{
    		return recursion(n - 1)*n;
    	}
    }
    

    十、 数组作为函数的参数

    数组可以作为函数的参数使用,进行数据传送。数组用作函数参数有两种形式

    • 一种是把数组元素(下标变量)作为实参使用

    • 一种是把数组名作为函数的形参和实参使用

    1.数组元素作为实际参数使用

    数组元素就是下标变量,它与普通变量并无区别。因为它作为函数实参使用与普通变量是完全相同的,在发生函数调用时,把作为实参的数组元素的值传送给形参,实现单向的值传送

    例题:判别一个数组a[10]中各元素的值,若大于0则输出该值,若小于等于0则输出0

    void test(int a);
    void main() {
    	int a[10] = { 1,2,3,4,5,6,-1,-2,-3,-4 };
    	for (int  i = 0; i < 10; i++)
    	{
    		test(a[i]);
    	}
    	printf("\n");
    }
    
    void test(int a) {
    	if (a>0)
    	{
    		printf("%d", a);
    	}
    	else
    	{
    		printf("0");
    	}
    }
    

    2. 数组名作为函数的形参和实参使用

    • 当数组名做实参时,按照普通变量即可,注意和函数的形参保持一致

    • 当数组名做形参时,编译系统不为其分配地址内存。(实际是实参将地址分配给形参)

    • 由于数组名就是数组的首地址,所以传递过程中实际是把实参数组的首地址赋予形参数组名

    • 形参数组名取得该首地址之后,也就等于有了实在的数组

    void test(int b[]);
    void main() {
    	int a[10] = { 1,2,3,4,5,6,-1,-2,-3,-4 };
    	
    		test(a);
    	
    	printf("\n");
    }
    void test(int b[]) {
    	for (int  i = 0; i < 6; i++)
    	{
    		printf("%d",b[i]);
    	}
    }
    

    十一、局部变量和全局变量

    1. 局部变量

    在一个函数内部定义的变量是内部变量,它只在本函数范围内有效。

    float f1(int a) {
    	int b, c;			//a,b,c有效
    }
    char f2(int x, int y) {
    	int i,j;		//x,y,i,j有效
    }
    void main() {
    	int m, n;		//m,n有效
    }
    
    • 即使内部的变量名称相同也互不影响,若上方的f2的i,j换成a,b也是不同的a,b

    • 形式参数也是局部变量

    2.全局变量

    全局变量:在函数外部定义的变量称为外部变量,也就是全局变量

    全局变量可以为本文件中其他函数所共用。它的有效范围为从定义变量的位置开始到本源文件结束

    int p = 1, q = 5;		//从f1到main
    float f1(int a) {
    	
    	int b, c;			
    
    }
    char c1, c2;			//从f2到main
    char f2(int x, int y) {
    
    	int i,j;		
    }
    void main() {
    	int m, n;		
    }
    
    • 因为编译器是自上往下执行,所以先声明的作用范围最大

    3. 建议

    • 全局变量在程序的全部行过程中都占用存诸单元,而不是在需要时才开辟单元

    • 使用全局变量过多,会降低程序的清晰性、人们往往难以楚地判断出每个瞬时各个外部变量的值。在各个函数行时都可能改变外部变量的值,程序容易出错。因此,要限制用全局变量

    • 它使函数的通用性低了、因为函数在行时要依赖于其所在的列外部变量。如果将一个函数移到另一个文件中,还要将有关的外部变量及其值一起移过去。

    • 但若该外部变量与其他文件的变量同名时,就会出现问题、降低了程序的可靠性通用性

    • 一般要求把 C 程序中的函数成一个封闭体,除了可以通过“实参——形参”的渠道与外界发生联系外,没有其他渠道

    十二、 变量的存储类别(从变量的生存期)

    1. 静态存储方式

    程序运行开始时由系统分配固定的存储空间的方式

    2. 动态存储方式

    程序运行期间根据需要进行动态的分配空间的方式

    用户存储空间可以分为三个部分

    • 程序区
    • 静态存储区(全局变量)
    • 动态存储区(局部变量)

    C语言中每一个变量和函数有两个属性:数据类型(int,char等)和数据的存储类别(内存中的存储方式)存储类别,具体有如下四种

    • 自动的 (auto)
    • 静态的 (static)
    • 寄存器的 (register)
    • 外部的 (extern)

    根据变量的存储类别,知道变量的作用域和生存周期

    3. auto变量

    • 函数中的局部变量,如不专门声明static存储类别,那么都为动态地分配存储空间的栈,数据存储在动态存储区中

    • 函数中的形参和函数中定义的变量都是auto变量,在调用该函数时系统会给他们分配存储空间,在函数调用结束时就自动释放这些存储空间

    4. static变量

    • 函数中调用结束后不消失而是保留原值,其所占用的存储单元不释放,在下一次该函数调用时,该变量已有值,就是上一次函数调用结束时的值

    • 静态局部变量属于静态存储类别,在静态存储区内分配存储单元。在程序整个运行期间都不释放(使用栈空间)

    • 动态局部变量也就是自动变量,属于动态存储类别,占动态存储区空间而不占静态存储区空间,函数调用结束后就会释放

    • 静态局部变量是在编译时赋初值,也就是只赋值一次,在程序运行时已有初值。

    • 静态局部变量不赋予初值的话,编译时自动赋值为0,动态局部变量不赋予初值即没有初值

    5. register变量

    • 一般情况下,变量(静态和动态存储方式)的值时存放在内存中的。当程序中用到哪个变量时,由控制器发出指定将内存中该变量的值送到运算器中。经过运算器进行运算,如果需要存数,再从运算器将数据送到内存存放

    • 有一些变量使用频繁,则为存取变量的值要花费很多时间,C语言允许将局部变量的值放在CPU寄存器中,需要用时直接从寄存器中取出参与运算,不必到内存其中去存取

    • 由于寄存器的存取速度远高于对内存的存储速度,因为这样可以提高效率。这种变量即为寄存器变量

    • 寄存器空间比较小,斟酌使用

    6. extern变量

    • 外部变量就是全局变量,它的作用域时从变量的定义处开始,到本程序文件的末尾

    • 全局变量可以为程序中各个函数所引用。编译时将外部变量分配在静态存储区

    • 有时需要使用extern来声明外部变量,以扩展外部变量的作用域

    7.总结

    对于变量而言,声明有两种情况,

    • 一需要建立存储空间(int a)
    • 另一种是不需要建立存储空间(extern a)
    • 前者称为“定义性说明”——定义性声明
    • 后者称为“引用性说明”——仅为声明
    展开全文
  • 构造方法 构造方法概述作用: 创建对象,给对象中成员...b:如果我们给出了构造方法,系统将不再提供默认构造方法。 注意:这个时候,如果我们还想使用无构造方法,就必须自己给出。建议永远自己给...

    构造方法

    构造方法概述和作用:

    创建对象,给对象中的成员进行初始化
    

    构造方法格式特点:

    a:方法名与类名相同
    b:没有返回值类型,连void都没有
    c:没有具体的返回值
    

    构造方法注意事项:

    a:如果我们没有给出构造方法,系统将自动提供一个无参构造方法。
    b:如果我们给出了构造方法,系统将不再提供默认的无参构造方法。
    

    注意:这个时候,如果我们还想使用无参构造方法,就必须自己给出。建议永远自己给出无参构造方法.

    学习了构造方法后,我们想对私有成员变量进行赋值,就可以采用构造方法进行赋值。

    给成员变量赋值的两种方式:

     a:setXxx()方法
     b:构造方法
    

    通过构造方法进行赋值:

    public class Teacher {
        private String name;
        private int age;
        public Teacher(){
            System.out.println("空参构造调用了");
        }
        //构造方法的重载
        public Teacher(String name) {
            System.out.println("一个参数的构造调用了"+name);
        }
    public Teacher(String name,int age) {
            System.out.println("两个参数的构造调用了" + name+"==="+age);
        }
        public String getName() {
            return name;
        }
         public void setName(String name) {
            this.name = name;
        }
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
    }
    
    
    
    public class MyTest {
        public static void main(String[] args) {
            //借助空参构造,来创建该类对象
            Teacher teacher = new Teacher();
            //使用有参构造来创建对象
            Teacher teacher1 = new Teacher("zhansan");
    	Teacher teacher2 = new Teacher("wangwu", 25);
         }
     }
    创建对象的步骤

    创建一个对象Student s = new Student();
    步骤:

    (1):加载Student.class文件进内存
     (2):在栈内存为s开辟空间
     (3):在堆内存为学生对象开辟空间
     (4):对学生对象的成员变量进行默认初始化
     (5):对学生对象的成员变量进行显示初始化
     (6):通过构造方法对学生对象的成员变量赋值
     (7):学生对象初始化完毕,把对象地址赋值给s变量
    

    需求:
    定义一个长方形(Rectangle)类,定义求周长(length)和面积(area)的方法,
    然后定义一个测试类Test,进行测试。
    分别用两种方法进行赋值

    public class Rectangle {
        //成员属性
        private double width;
        private double height;
        //提供无参,有参构造
        public Rectangle() {
        }
        public Rectangle(double width, double height) {
            this.width = width;
            this.height = height;
        }
        //提供get set 方法
        public double getWidth() {
            return width;
        }
        public void setWidth(double width) {
            this.width = width;
        }
        public double getHeight() {
            return height;
        }
        public void setHeight(double height) {
            this.height = height;
        }
        //提供获取周长的方法
         public double getLength() {
            return (this.width + this.height) * 2;
        }
        //提供获取面积的方法
        public double getArea() {
            return height * width;
        }
    }
    
    
    
    
    
    
    
    public class MyTest {
        public static void main(String[] args) {
            Rectangle rectangle = new Rectangle();
            rectangle.setWidth(20);
            rectangle.setHeight(30);//通过set方法赋值
            double area = rectangle.getArea();
            double length = rectangle.getLength();
            System.out.println("面积是:"+area);
            System.out.println("周长是:"+length);
            System.out.println("--------------------------");
            Rectangle rectangle1 = new Rectangle(60, 30);//通过有参构造赋值
            double area1 = rectangle1.getArea();
            double length1 = rectangle1.getLength();
             System.out.println("面积是:" + area1);
            System.out.println("周长是:" + length1);
           }
    }
    

    static关键字

    static关键字的特点:

    a:随着类的加载而加载
    b:优先于对象存在
    c:被类的所有对象共享
    如果某个成员变量是被所有对象共享的,那么它就应该定义为静态的。
     举例:
      饮水机(用静态修饰)
      水杯(不能用静态修饰)
    d:可以通过类名调用
     其实它本身也可以通过对象名调用。
     推荐使用类名调用。
     静态修饰的内容一般我们称其为:与类相关的,类成员
    

    static的注意事项:

    a:在静态方法中是没有this关键字的
      如何理解呢?
       静态是随着类的加载而加载,this是随着对象的创建而存在。
       静态比对象先存在。
     b:静态方法只能访问静态的成员变量和静态的成员方法
    

    简单记:静态只能访问静态,非静态可以访问静态的也可以访问非静态的

    public class Cat {
        public String name; //实例变量
        public static int num = 20;  //方法区的静态区 被类的所有对象所共享 类变量
        //实例方法:
        public void test() {
            System.out.println("这是一个非静态的test方法");
            //非静态的方法,既能访问静态的,也能访问非静态的
            System.out.println(name);
            System.out.println(num);
        }
         //静态方法:静态只能访问静态的,不能非静态的
        public static void show() {
            System.out.println("这是一个静态的show方法");
            //加载时机的问题 被静态所修饰的成员,随着类的加载而加载加载时机早,实例变量创建对象的时候才存在,是后来才有的
            // 先来的肯定找不到后来的
            // System.out.println(name);
            System.out.println(num);
        }
         public void test2() {
            //方法中有一个隐藏的对象this
            this.test();
        }
          //在静态方法里面,不能出现this this也是代表一个对象,对象是后来才有的
        public static void test3() {
            //方法中有一个隐藏的对象this
            // this.test(); //报错
            Cat.show();
        }
     }

    public class Person {
        public String name;
        //static 静态的:可以修饰成员变量,成员方法,修饰成员变量,此变量就变成了共享变量
        public static  String guoji="中国";
    }
    
    
    public class MyTest {
        public static void main(String[] args) {
            //我想把中国这个 数据,设置成共享数据,让多个对象,去共享这个数据
            Person.guoji="中国";
            //被静态所修饰的成员,属于类的 推荐使用类名直接调用
            //被static所修饰的成员变量,我们称之为类变量
            Person p1 = new Person();
            p1.name = "张三";
            Person p2 = new Person();
            p2.name = "李四";
            Person p3 = new Person();
            p3.name = "王五";
            System.out.println(p1.name);//张三
            System.out.println(p1.guoji);//中国
            System.out.println(p2.name);//李四
            System.out.println(p2.guoji);//中国
            System.out.println(p3.name);//王五
            System.out.println(p3.guoji);//中国
        }
    }

    静态变量和成员变量的区别

    所属不同:
     静态变量属于类,所以也称为类变量
     成员变量属于对象,所以也称为实例变量(对象变量)
    内存中位置不同:
     静态变量存储于方法区的静态区
     成员变量存储于堆内存
    内存出现时间不同:
     静态变量随着类的加载而加载,随着类的消失而消失
     成员变量随着对象的创建而存在,随着对象的消失而消失
    调用不同:
     静态变量可以通过类名调用,也可以通过对象调用,推荐使用类名调用
     成员变量只能通过对象名调用
    

    学习Math类的随机数功能

    Math类概述:
    类包含用于执行基本数学运算的方法
    Math类特点:
    由于Math类在java.lang包下,所以不需要导包。
    没有构造方法,因为它的成员全部是静态的。
    获取随机数的方法:
    public static double random():返回带正号的 double 值,该值大于等于 0.0 且小于 1.0。
    

    需求:猜数字小游戏(数据在1-100之间)

    public class GuessNumber {
        public static void main(String[] args) {
          /*  A:
            案例演示:
            需求:猜数字小游戏(数据在1 - 100之间)*/
            int num = (int) ((Math.random() * 100) + 1);
    	while (true) {
                Scanner scanner = new Scanner(System.in);
                System.out.println("请输入一个整数 1---100");
                int userNum = scanner.nextInt();
                //比对
                if (userNum > num) {
                    System.out.println("你猜大了");
                } else if (userNum < num) {
                    System.out.println("你猜小了");
                } else {
                    System.out.println("恭喜你!猜对了");
                    break;
                }
            }
        }
    }
    

    再见-_-||

    展开全文
  • 构造函数成员函数构造函数也被称为构造器,当创建对象的时候第一个被自动调用的函数,系统默认提供了一个无的构造函数,语法如下:def __ init__(self,arg1,arg2,...):函数体构造函数成员函数的区别成员函数的...
  • 构造函数成员函数的区别 成员函数的函数名可以自定义,但是,构造函数的函数名是固定的__init__ 成员函数需要被手动调用,但是,构造函数在创建对象的过程中是自动被调用的 对于同一个对象而言,成员函数可以被...
  • 例如在main函数中声明的变量并使用它进行运算,此处的变量胃实参;在写函数传入参数中使用,此类参数只在本函数中有效,因此命名为形参。 具体如下: 形参(形式参数) 新在函数定义中出现参数,可以看做是...
  • 自动变量)static变量(静态变量)register变量extern声明外部变量用...变量和字符数组的讨论指向函数的指针返回指针值的函数指针函数和函数指针的区别指针数组和指向指针的指针指针运算小结预处理命令无宏定义带...
  • 一、变量 1.成员变量:定义在类中,在整个自定义类中都可以使用,且不用赋值,成员变量自带...3.变量调用中需要注意问题:基本数据类型引用数据类型有区别。情况如下: 1.基本数据类型: int x=1235; int ...
  • 开发react组件,我们最常用到俩个引起组件渲染可能就是stateprops了,那么他们有什么区别呢? props: props:函数组件props就是函数组件 类组件:this.props包含被该组件调用或者定义props state:...
  • 指针引用作为函数参数的区别

    千次阅读 2018-12-02 10:37:50
    一言以蔽之:如果想改变一般类型的参数的值,可以使用变量的指针做参数;如果想改变指针变量指向的地址就要用引用参数。   先介绍一下问题产生的原因: 在AVL树的函数操作里,需要返回的改变较多,所以无法定义...
  • 想要学好C++的C++堆栈,那么就要了解什么是C++堆栈,所为C++堆栈就是一种数据项按序排列的数据...栈,就是那些由编译器在需要的时候分配,在不需要的时候自动清楚的变量的存储区。里面的变量通常是局部变量、函数...
  • 2.构造函数在类中如果不写会自动添加一个无构造函数,构造体中构造函数不能手写 3.结构体构造函数必须为每个字段都赋值 4.构造体可以直接声明变量(不用new),但是这样构造体是没有初值(因为没有...
  • 最大区别为结构体为值类型存在栈上,类为引用类型存在堆上。 细节区别: 1.结构体不具有多态、继承特性,只有...7.结构体不能在内部申明自己一样结构体变量,而类可以 结构体虽然没有继承特性,但是可以继承接口。
  • c#基础 类与结构体的区别 继承

    千次阅读 2017-08-11 08:22:52
    类是引用类型变量中保存数对象地址,s1s2中保存但是同一个对象地址 结构体是值类型,复制时,是将s3中成员拷贝给s4成员,s3,s4是两个结构体变量。 结构体中不带参的构造函数会一直存在,不会因为...
  • super this 对比 多态 子类可以赋值给父类类型 执行会执行动态绑定 看执行那个类方法 方法调用 参照核心卷 强制类型转化 将一个子类引用赋给一个超类 变量, 编译器是允许。但将一个超类
  • 类和对象基础笔记面向对象的程序设计思想类和对象的不同构造方法无构造方法有构造方法构造块静态构造块实例构造块构造方法与构造块的关系初始化基本数据类型变量和引用类型变量的区别 面向对象的程序设计思想 ...
  • 关于人工智慧思考

    2019-10-05 13:57:13
    在让机器理解语言模型里,随着新语言行为发生,和新语言信息输入,机器需要不断重新确认模型中(因变量,参变量等信息)各个模型组成部分计算结果,结合新输入,不断重新计算。 所以这是一个不断...
  • 一、构造方法给成员变量赋值1.格式 方法名与类名相同(大小也要与类名一致) 没有返回值类型,连void都没有 return; 2.注意事项 如果我们没有给出构造方法,系统将自动提供一个...3.给成员变量赋值的两种方式的区别 setX
  • Shell脚本基本命令

    2020-02-07 19:43:09
    1. 什么是Shell(计算机壳层) 在计算机科学中,Shell俗称壳(用来区别于核),是指“为使用者提供操作界面”软件(命令解析器) 它类似于DOS下command.com和后来cmd....作为程序设计语言,它定义了各种变量和参...
  • 一、结构的区别 1、结构的级别类一致,写在命名空间下面,可以定义字段、属性、方法、构造方法也可以通过关键字new创建对象。 2、结构中的字段不能赋初始值。 3、无参数的构造函数无论如何C#编译器都会自动...
  • shell脚本常用命令

    2019-06-06 20:12:02
    1.shell脚本(计算机壳层) 在计算机科学中,Shell俗称壳(用来区别于核),是指“为使用者提供操作界面”软件(命令解析器)。它类似于DOS下command.com和后来...作为程序设计语言,它定义了各种变量和参...
  • Shell脚本中常用命令(一)

    千次阅读 2020-02-13 22:05:10
    1. 什么是Shell(计算机壳层) 在计算机科学中,Shell俗称壳(用来区别于核),是指“为使用者提供操作界面”软件(命令解析器) 它类似于DOS下command.com和后来cmd....作为程序设计语言,它定义了各种变量和参...
  • 1.什么是shell(计算机壳层)? 在计算机科学中,Shell俗称壳(用来区别于核),是指“为使用者提供操作界面”软件(命令解析器) 它类似于DOS下command.com和后来...作为程序设计语言,它定义了各种变量和参...
  • 对象的使用包括引用对象的成员变量和方法,通过运算符·可以实现对变量的访问和方法的调 用,变量和方法可以通过设定一定的访问权限(见下面的例子)来允许或禁止其它对象对它的 访问。 我们先定义一个类 Point。 例子...

空空如也

空空如也

1 2 3 4 5
收藏数 89
精华内容 35
关键字:

参变量和自变量的区别