精华内容
下载资源
问答
  • 以下代码我用纯C语言实现面向对象一种方式。C语言实现面向对象从应用级开发来讲,纯粹个鸡肋,所以勿喷!这里只是提供一个思考问题的方向而已! 先来一个父类的头文件 Father.h #ifndef _FATHER_H_ #define...

    从某天开始,我认为面向对象只是一种思想,至于用什么语言实现,怎么实现,其实就看语言的开发者怎么去思考这种问题。以下代码是我用纯C语言实现面向对象的一种方式。C语言实现面向对象从应用级开发来讲,纯粹是个鸡肋,所以勿喷!这里只是提供一个思考问题的方向而已!

    先来一个父类的头文件 Father.h

    #ifndef _FATHER_H_
    #define _FATHER_H_
    
    typedef int(*PrintInfo)();
    
    #define CLASS_BASE()    \
    int nValue;             \
    PrintInfo Fun_Print;
    
    
    #ifdef __cplusplus
    extern "C"
    {
    #endif
    
    	struct S_BASE
    	{
    		CLASS_BASE()
    	};
    
    	int Base_Init(struct S_BASE* pBase);
    	int Base_Print();
    
    #ifdef __cplusplus
    }
    #endif
    
    #endif // !_FATHER_H_
    

    再来一个父类的方法(函数)实现 Father.c

    #include "Father.h"
    #include <stdio.h>
    
    int Base_Init(struct S_BASE* pBase)
    {
    	pBase->nValue = 0;
    	pBase->Fun_Print = &Base_Print;
    	return 0;
    }
    
    int Base_Print()
    {
    	printf("I am Base\n");
    	return 0;
    }

    好啦,来两个子类,Son.h

    #ifndef _SON_H_
    #define _SON_H_
    #include "Father.h"
    #ifdef __cplusplus
    extern "C"
    {
    #endif
    	struct S_SON_A
    	{
    		CLASS_BASE()
    		char chData;
    	};
    
    	struct S_SON_B
    	{
    		CLASS_BASE()
    		float fData;
    	};
    
    	int Init_SON_A(struct S_SON_A* pSon);
    	int Init_SON_B(struct S_SON_B* pSon);
    	int Son_Print();
    
    #ifdef __cplusplus
    }
    #endif
    #endif // !_SON_H_

    子类的实现Son.c

    #include "Son.h"
    #include <stdio.h>
    
    int Init_SON_A(struct S_SON_A* pSon)
    {
    	Base_Init((struct S_BASE*)pSon);
    	pSon->nValue = 1;
    	pSon->chData = 'A';
    	return 0;
    }
    
    int Init_SON_B(struct S_SON_B* pSon)
    {
    	Base_Init((struct S_BASE*)pSon);
    	pSon->Fun_Print = &Son_Print;
    	pSon->fData = 1.0;
    	return 0;
    }
    
    int Son_Print()
    {
    	printf("I am Son!\n");
    	return 0;
    }
    
    

    好啦,最后测试一下main.c

    #include <stdio.h>
    #include "Son.h"
    
    int main()
    {
    	struct S_BASE* pBase;
    	struct S_SON_A Son_A;
    	struct S_SON_B Son_B;
    
    	Init_SON_A(&Son_A);
    	Init_SON_B(&Son_B);
    
    	pBase = &Son_A;
    	pBase->Fun_Print();
    
    	pBase = &Son_B;
    	pBase->Fun_Print();
    	getchar();
    	return 0;
    }

    至于结果,那就不详细说了!

    面向对象的三大特性,封装、继承和多态!个人认为,实现多态才是将面向对象这个思想发挥到一定的高度,上面的代码,实际上就是将多态用C语言实现了一遍!

    展开全文
  • 一、C语言结构体1、结构体是什么(1)用途结构体是一种可以包含一个或者多个不同数据类型的数据结构,是一种可以自己定义的数据类型。与数组不同,结构体的多个数据可以是不同的数据类型。结构体在纯C语言环境中编程常...

    没有万能的编程技术
    没有只产生正确的结果的编程语言
    不是每个项目的编程都是从零开始的
    —-《Object-Oriented Programming With ANSI-C》

    一、C语言结构体

    1、结构体是什么

    (1)用途

    结构体是一种可以包含一个或者多个不同数据类型的数据结构,是一种可以自己定义的数据类型。与数组不同,结构体的多个数据可以是不同的数据类型。

    结构体在纯C语言环境中编程常有两种用途:将多个描述一个对象的数据打包,以体现层次结构,避免大量的垃圾变量名;在利用结构体内存偏移的特性,实现对寄存器的描述。

    本文介绍的主要是其在

    (2)语法

    定义一个结构体


    使用结构体首先需要定义一个结构体

    struct{      //大括号内为结构体的成员
        int a;   //定义成员变量
        int b;
    } my_struct; //结构体名

    这段代码会生成一个结构体my_struct,可以用以下代码测试这个结构体正确运行。

    #include<stdio.h>
    struct{
        int a;
        int b;
    }my_struct;
    int main(void){
        printf("Please input:");
        scanf("%d %d",&(my_struct.a),&(my_struct.b));
        printf("%d %d\n",my_struct.a,my_struct.b);
        return 0;
    }

    正确运行时,将会有以下结果:

    Please input:1 2
    1 2
    请按任意键继续. . .

    这说明定义结构体是成功的。
    使用结构体中变量的语法为结构体名.变量名,结构体复制的时候可以使用=号直接复制。例如:

    #include<stdio.h>
    struct{
        int a;
        int b;
    } my_struct,my_test;
    int main(void){
        printf("Please input:");
        scanf("%d %d",&(my_struct.a),&(my_struct.b));
        my_test = my_struct;
        printf("%d %d\n",my_test.a,my_test.b);
        return 0;
    }

    这段代码将会产生与上面代码一样的结果,这说明可以用等于号直接复制一个结构体。

    定义一个结构体类型


    C语言中有typedef关键字,可以用于自定义数据类型,例如:

    typedef int my_type;

    这时,my_type就可以代替int使用。

    注:这样做看似无意义,但是在不同平台编译代码的时候可以通过只改变几个变量达到控制字段长度的作用。

    这种方法也同样适用于结构体,声明一个结构体类型可以让我们不必每一次使用相同的结构体类型的时候都要重新写结构体的成员,只需要用结构体类型声明就可以了。例如:

    typedef struct{
        int a;
        int b;
    }my_struct_type;

    接下来我们通过以下代码测试这个结构体类型:

    #include<stdio.h>
    typedef struct{
        int a;
        int b;
    }my_struct_type;
    my_struct_type my_struct,my_test;
    int main(void){
        printf("Please input:");
        scanf("%d %d",&(my_struct.a),&(my_struct.b));
        my_test = my_struct;
        printf("%d %d\n",my_test.a,my_test.b);
        return 0;
    }

    当这个程序出现下面的结果的时候,说明定义结构体类型是成功的。

    Please input:1 2
    1 2
    请按任意键继续. . .

    定义一个结构体数组


    与基本类型一样,结构体也可以通过顺序存储来实现对一系列结构体对象的存储。

    顺序存储结构是存储结构类型中的一种,该结构是把逻辑上相邻的节点存储在物理位置上相邻的存储单元中,结点之间的逻辑关系由存储单元的邻接关系来体现。在C语言中,这种存储方法通常用数组实现。

    typedef struct{
        int a;
    }my_struct_type;
    my_struct_type my_struct[10];

    与数组一样,可以通过下标的方式完成遍历:

    #include<stdio.h>
    typedef struct{
        int a;
    }my_struct_type;
    my_struct_type my_struct[10];
    int main(void){
        int i;
        for(i=0;i<10;i++){
            my_struct[i].a=i;
        }
        for(i=0;i<10;i++){
            printf("%d ",my_struct[i].a);
        }
        printf("\n");
        return 0;
    }

    成功执行将会得到以下结果:

    0 1 2 3 4 5 6 7 8 9
    请按任意键继续. . .

    结构体指针


    与基本类型一样,结构体也可以通过指针访问,例如:

    #include<stdio.h>
    typedef struct{
        int a;
    }my_struct_type;
    my_struct_type my_struct;
    my_struct_type* pmy_struct;
    int main(void){
        my_struct.a=2;
        pmy_struct = &my_struct;
        printf("%d ",(*pmy_struct).a);
        printf("\n");
        return 0;
    }

    成功执行后会得到以下结果:

    2
    请按任意键继续. . .

    请注意:在代码中使用了这个方式使用结构体指针(*pmy_struct).a,其是可以被pmy_struct->a替代的。

    使用结构体指针动态的申请空间


    与其他数据类型一样,利用结构体指针也可以通过malloc()这样的函数动态的申请空间,语法如下:

    pmy_struct = (my_struct_type*)malloc(sizeof(my_struct_type));

    通过测试代码检查申请的情况:

    #include<stdio.h>
    #include<stdlib.h>
    typedef struct{
        int a;
    }my_struct_type;
    my_struct_type* pmy_struct;
    int main(void){
        pmy_struct = (my_struct_type*)malloc(sizeof(my_struct_type));
        pmy_struct->a = 2;
        printf("%d ",pmy_struct->a);
        printf("\n");
        return 0;
    }

    如果输出和下面的运行结果一样,说明申请成功:

    2
    请按任意键继续. . .

    注意:这段代码是有缺陷的,通常使用malloc()申请空间后需要检查指针是否为空,否则一旦空间申请失败,将出现严重错误。


    待填坑

    展开全文
  • java入门之面向对象

    2020-12-04 17:11:27
    (1)java语言是一种纯面向对象语言。 (2)历史: C语言是一种面向过程的语言。 C++语言是一种既面向过程,又面向对象的语言。 Java来源于C++,是一种纯面向对象语言。 (3)面向过程和面向对象的区别 他们都是...
    
    
    

    1、面向对象的概念

    (1)java语言是一种纯面向对象的语言。

    (2)历史:

    C语言是一种面向过程的语言。
    C++语言是一种既面向过程,又面向对象的语言。
    Java来源于C++,是一种纯面向对象的语言。

    (3)面向过程和面向对象的区别

    他们都是解决问题的思想。
    面向过程:通过过程来解决问题,没有对象的概念,只是如何解决这个问题的过程。
    面向对象:通过对象来解决问题,需要先构建对象(赋予解决问题的能力),然后指挥对象去解决问题。

    (4)对象

    万事万物皆为对象。
    对象是一个具体存在的能够解决问题的个体。

    如何区别:通过对象的属性和行为。

    属性是记录对象的特征的。
    行为是对象解决问题的能力。

    (5)类

    类是创建对象的模板,有类才有对象。

    在类里面定义对象应该有的属性和行为。

    (6)面向对象

    倒退:
    遇到问题–>通过对象解决问题–>对象–>类

    写程序:
    遇到问题,分析问题;
    通过分析,抽象成类;
    通过类,创建对象;
    通过对象,解决问题。

    2、面向对象实战思路

    (1)问题:小王是一个死胖子,通过努力,减肥成功(由200公斤到148斤)。

    (2)类:

    人类{
    姓名,体重;
    减肥;
    }

    (3)创建对象

    小王=New 人类

    (4)减肥

    小王.减肥

    3、面向对象实战编码

    (1)类的定义

    [修饰符public] class 类名{
    1>属性
    [修饰符public] 数据类型 属性名[=初始值];
    2>方法
    [修饰符public static] 返回值类型void 方法名([参数]){
    //方法体:解决问题的过程
    }
    }
    案例


    public class Person {
    public  String  name;
    public  double  weight;
    public  void   loseWeight() {
    	System.out.println("减肥成功!");
    }
    }
    

    (2)创建对象

    类名 对象名=new 类名();
    案例:
    public static void main(String[] args) {
    Person p=new Person();
    }

    (3)使用对象

    对象名.属性名
    对象名.方法名()
    案例:
    p.name=“小王”;
    p.weight=200;
    p.loseWeight();

    4、创建对象的过程

    调用
    p.name p里面保存了对象在堆里的地址,通过这个地址找这个对象的存储空间,然后找到里面的name属性。
    p.loseWeight() p里面保存了对象在堆里的地址,通过这个地址找这个对象的存储空间,然后找到loseWeight()方法,执行方法体。

    5、OOP案例(长方形)


    public class Rect {
    	public  double  length;
    	public  double  width;
    	public  void  girth() {
    		System.out.println("长方形的周长:"+(length+width)*2);
    	}	
    	public  void  area() {
    		System.out.println("长方形的面积:"+length*width);
    	}
    	public static void main(String[] args) {
    		Rect   r1=new  Rect();
    		r1.length=2;
    		r1.width=3;
    		r1.girth();
    		r1.area();	
    		Rect   r2=new  Rect();
    		r2.length=5;
    		r2.width=5;
    		r2.girth();
    		r2.area();
    	}
    }
    

    6、构造器的定义

    (1)创建对象

    new 类名();
    这里调用的其实是构造器!!

    (2)构造器

    构造对象的过程。

    定义
    【修饰符】 构造器名字([参数]){
    方法体
    }
    注意:构造器名字必须使用类名!!!!

    案例
    构造器:构造方法
    public Circle() {
    构造对象之后,用于初始化这个对象的属性操作
    r=4;
    }

    (3)使用构造器

    new 构造器名();
    执行过程:
    首先,通过类构造一个对象;
    然后,执行方法体完成该对象的属性初始化。

    (4)缺省构造器

    如果类中没有定义构造器,系统会在编译时提供一个缺省的无参构造器。
    缺省构造器:public 类名(){}

    但是,如果你定义了构造器,系统就不会提供缺省构造器了。

    案例


    package day04;
    public class Circle {
    	public  double  r;
    	public  double  PI=3.14;	
    	public  void  grith() {
    		System.out.println(PI*r*2);
    	}
    	public  void  area() {
    		System.out.println(PI*r*r);
    	}
    	//构造器:构造方法
    	public  Circle() {
    		//构造对象之后,用于初始化这个对象的属性操作
    		r=4;
    	}
    }
    

    7、变量

    (1)变量

    分为两种:成员变量和局部变量。

    成员变量:定义在类中,对象的属性。
    局部变量:定义在方法体中的变量。

    (2)成员变量与局部变量的区别

    第一,声明位置不同:成员变量是定义在类中方法体外,局部变量定义在方法体内。
    第二,修饰符不同:成员变量前可以使用各种修饰符修饰,局部变量只能使用final。
    第三,作用范围(作用域)不同:成员变量可以作用所有方法体,局部变量只能作用于当前方法体。
    第四,缺省值不同:成员变量有缺省值,局部变量没有缺省值。

    (3)成员变量缺省值

    整数类型,0
    浮点类型,0.0
    char类型,空白字符
    布尔类型,false
    引用类型,null

    (4)变量重名问题

    变量的作用域:一个变量只能在声明它的最小语句组中使用,超出这个语句组就不能使用。

    重名规则
    一个类中,所有的成员变量之间,不可以重名。
    一个方法中,所有的局部变量之间,不可以重名。
    成员变量可以和局部变量重名,方法内直接使用的是局部变量。

    案例


    package day04;
    public class Student {
    	//成员变量,也叫属性
    	//public final  int     no=10;
    	public  int     no;
    	public  String  name;
    	public  char    sex;
    	public  boolean isGraduate;
    	public   void  test() {
    		//局部变量
    		final int   a;
    		a=10;
    		//a=11;
    		int   b=11;
    		System.out.println(no);
    		System.out.println(name);
    		System.out.println(a);
    		System.out.println(b);
    	}
    	public   void  test2() {
    		System.out.println(no);
    		System.out.println(name);
    	//	System.out.println(a);
    	//	System.out.println(b);	
    		int  a=1;
    		int  b=2;
    		System.out.println(a);
    		System.out.println(b);
    	}
    	public   void  test3() {
    		int  a=1;
    		{
    			int  b=2;
    			System.out.println(a);
    			System.out.println(b);
    		}	
    	/	System.out.println(a);
    	//	System.out.println(b);
    		int  no;
    	//	System.out.println(no);
    	}
    	public Student() {
    		//局部变量
    		int  c;
    		int  d;
    		System.out.println(no);
    		System.out.println(name);
    	//	System.out.println(a);
    	//	System.out.println(b);
    		
    	//	System.out.println(c);
    	//	System.out.println(d);	
    		System.out.println(sex);
    		System.out.println(isGraduate);
    	}
    	public static void main(String[] args) {
    		new  Student();
    	}
    }
    

    8、成员方法-参数

    1)参数

    作用:将数据动态传入方法体内使用

    定义
    定义在方法名或构造器后的小括号里;
    参数的作用域是当前方法体;
    参数类型 参数名,…

    和局部变量比较
    参数和局部变量一样,只能作用于当前方法体;
    局部变量的数据是固定的,而参数的数据是可以变化的。

    赋值
    参数赋值,不是用等号,而是调用方法或构造器时通过小括号传入的。
    调用方法或构造器时,如果定义了参数,那么需要传入数据,数据的顺序、类型、数量必须和定义时一致。

    名称解释
    形参,定义方法时小括号里面的参数。
    实参,调用方法时传入的数据,使用实参给形参赋值。

    重名问题:参数可以成员变量重名,不可以和局部变量重名。

    案例


    public class SumDemo {
    	public  void   sum(int  a,int  b) {
    		//int  a=10,b=20;
    		System.out.println(a+b);
    	}
    	public static void main(String[] args) {
    		SumDemo  sd=new SumDemo();
    		sd.sum(1,2);
    		sd.sum(3,4);
    		sd.sum(10,20);
    	}
    }
    

    (2)方法的重载

    在同一类中,出现多个方法的方法名相同但是参数列表必须不同。

    参数不同:
    数量不同;
    数量相同,但是对应顺序的参数类型至少有一个不同。
    参数名在调用时,不能作为参数不同的依据。


    public class SumDemo {
    	public  void   sum() {		
    		System.out.println(10+20);
    	}
    	public  void   sum(int  a,int  b) {	
    		System.out.println(a+b);		
    	}
    	public  void   sum(int  a,int  b,int  c) {	
    		System.out.println(a+b+c);
    	}	
    	public  void   sum(int  a,double  b) {		
    		System.out.println("我们不一样:"+a+b);
    	}	
    	public  void   sum(double  a,int  b) {	
    		System.out.println("我们不一样:"+a+b);
    	}	
    	public  void sum(double  c,double  d) {
    		System.out.println("double 2:"+(c+d));
    	}
    	public static void main(String[] args) {
    		SumDemo  sd=new SumDemo();
    		sd.sum(1,2);
    		sd.sum(3,4);
    		sd.sum(10,20);		
    		sd.sum();
    		sd.sum(1, 2, 3);
    		sd.sum(12.1, 12.2);
    		sd.sum(1,2.0);
    		sd.sum(2.0,1);
    	}
    }
    ***
    

    (3)构造器的重载

    在同一个类中允许定义多个构造器,但是参数必须不同,这种现象我们叫构造器重载。

    主要目的:完成创建对象后的不同初始化需求。
    //构造器:构造方法


    public  Circle() {
    	//构造对象之后,用于初始化这个对象的属性操作
    	//r=4;
    }
    public  Circle(double  rr) {
    	//构造对象之后,用于初始化这个对象的属性操作
    	r=rr;
    }
    public  Circle(double  rr,double  tt) {
    	//构造对象之后,用于初始化这个对象的属性操作
    	r=rr;
    	t=tt;
    }
        Circle  c1=new  Circle();
    	System.out.println(c1.r);
    	System.out.println(c1.t);
    	System.out.println(c1.PI);
    	Circle  c2=new  Circle(3);
    	System.out.println(c2.r);
    	System.out.println(c2.t);
    	System.out.println(c2.PI);
    	Circle  c3=new  Circle(3,4);
    	System.out.println(c3.r);
    	System.out.println(c3.t);
    	System.out.println(c3.PI);
    

    展开全文
  • Java面向对象基础

    2017-09-26 19:06:09
    面向对象编程的基本概念1、什么对象? 玩物节对象。2、什么面向对象? 面向对象就是指以特征(属性)和行为的观点去分析现实世界中事物的一种方式。...Java语言是一门纯面向对象的编程语言。4、为什

    面向对象编程的基本概念

    1、什么是对象?
    玩物节对象。

    2、什么是面向对象?
    面向对象就是指以特征(属性)和行为的观点去分析现实世界中事物的一种方式。

    3、什么是面向对象编程?
    面向对象编程就是指先使用面向对象的方式进行分析,再使用面向对象的编程语言编写的面向对象程序。
    C语言是一门面向过程的编程语言。C++语言是一门既面向过程又面向对象的编程语言。Java语言是一门纯面向对象的编程语言。

    4、为什么需要面向对象编程?
    面向对象编程是软件产业化发展的需求。

    5、如何学好面向对象编程?
    理解好面向对象的三大特性:封装继承以及多态

    类、对象以及引用

    如:
    String name1 = “李雷”; int age1 = 20; … …
    String name2 = “韩梅梅”; int age2 = 22; … …
    String name3 = “WangYong”; int age3 = 18; … …
    … …
    人类:

    • 特征:姓名、体重
    • 行为:学习、吃饭
      就是”分类”的概念,是一种抽象的表示,是对多个对象共性的提取和描述
      对象就是客观存在的实体,在Java语言中代表内存中的一块区域,类是对象创建的模板
      是一种引用数据类型,里面包含了用于描述特征的成员变量,以及用于描述行为的成员方法。

    1、类的语法格式

       class 类名{ 
          类体;
       }
       //如
       class Car{
       } 

    注意:
    当类名由多个单词组成时,要求每个单词的首字母都要大写。

    2、成员变量的语法格式(其中=初始值可以省略,分号不可以省略)

       class 类名{
          数据类型 成员变量名 = 初始值;
       } 
       //如:
       class Car{
           String name;
           int price;
       }

    注意:
    当成员变量名由多个单词组成时,要求从第二个单词起每个单词的首字母大写。

    局部变量 - 主要指声明在方法体内的变量,作用域从声明开始一直到方法体结束。
    成员变量 - 主要指声明在方法体外类体内部的变量,作用域从声明开始到类体结束。

    对象的创建

    1、对象的语法格式

       new 类名();
    //如:
       new Person();   //匿名对象

    2、使用方式
    对象创建的形式叫做类的实例化,而创建对象的本质是在内存空间的堆区申请一块空间,用于记录该对象所拥有的成员变量信息。

    引用的使用

    1、使用引用数据类型声明的变量叫做引用类型变量,简称为 引用。

    2、引用的语法格式

       类名 引用名称;
    //如:
       Person p;

    3、引用的使用方式
    引用变量通常用于记录创建对象在堆区中的内存地址信息,从而可以方便地使用该对象以及该对象中的成员变量信息,使用方式为:

    引用名.成员变量名;
    //如:
       Car p = new Car();    
       p.name = "ford";
       p.price  = 300000;

    成员方法

       class 类名{
           返回值类型 成员方法名(形参列表){
               成员方法体;
           }
       }
    //如:
       class Car{
           String name;
           int price;
           //自定义成员方法来打印一句话
           void show(){
               System.out.println("这里打印一句话");
           }
       }

    注意:
    当成员方法名由多个单词组成时,要求从第二个单词起首字母大写。

    成员方法的详解

    1、返回值类型
    返回值主要指从方法体中向方法体外返回的数据内容。
    返回值类型主要指返回值的数据类型。

    • 当需要返回数据内容66时,则返回值类型写int类型即可;
    • 当需要返回数据内容3.14时,则返回值类型写double类型即可;
    • 当需要返回数据内容”hello”时,则返回值类型写String类型即可;
      在方法体中使用return关键字来返回数据并结束方法,如:return 20;
      return关键字后面可以跟 直接量、变量、表达式以及方法的调用等。
      当方法体中不需要返回任何数据时,则返回值类型写void即可。

    2、形参列表
    形式参数主要指从方法体外向方法体内传入的数据内容,通常使用变量的声明来传入。
    形式参数的语法格式

    数据类型 形参变量名。
    • 当需要传入数据内容66时,则形式参数写为:int i;
    • 当需要传入数据内容3.14时,则形式参数写为:double d;
    • 当需要传入数据内容”hello”时,则形式参数写为:String s;
      形式参数列表的语法格式:
    数据类型 形参名1, 数据类型 形参名2, ...
    • 当需要传入数据内容为66和3.14时,则形式参数写为:int i, double d;
    • 当需要传入数据内容为66和”hello”时,则形式参数写为:int i, String s;

    当不需要传入任何数据时,则形参列表位置啥也不写即可。

    3、成员方法体
    成员方法体通常用于编写描述该方法功能的语句块,也就是对多条语句的打包/包装。
    当该方法的功能是用于计算3+5的和并返回时,则方法体中写:return 3+5;即可

    成员方法的调用

    1、语法格式

       引用/对象.成员方法名(实际参数列表);
    //如:
       p.show();

    2、使用方法
    实际参数列表主要用于给形式参数列表进行初始化工作,因此参数的个数、类型、顺序等都必须保持一致。
    实际参数可以传递 直接量、变量、表达式以及方法的调用等。

    展开全文
  • 1.面向过程和面向对象初步认识 C语言是面向过程的,关注的是...扩展:java是一门纯面向对象语言 面向过程和面向对象不是一门编程语言,而是一种解决问题的思路 例如:洗衣服 父母辈: 1.取脏衣服 2.拿一个水盆 3.拿洗
  • 前者Procedure Oriented是一种以过程为中心的编程思想,Object Oriented,简称OO,而是以事物为中心的编程思想POP是早期软件工程里的一种编程方法,其代表语言就是C语言(但并不是说C语言就是过程式语言,C也可以以...
  • 面向对象编程(Object Oriented Programming,OOP)是...Java是一种纯面向对象语言,与C语言不一样他是面向过程的语言。通俗说Java程序主要是由类组成的,而C是由函数组成的。 面向对象非常重要,恰当的使用面向对...
  • 背景“面向对象”,每个程序员,在入行的时候,...Java是面向对象语言没错,但我们只能说:Java支持面向对象编程。个脑子里只有面向过程的程序员照样可以用Java写出面向过程的代码。理论看的太累让我们举个栗子
  • 面向对象与C++试题.doc

    2013-12-16 20:49:17
    是一种用户自定义的数据类型 B.只有类中的成员函数或类的友元函数才能存取类中的私有成员 C.在类中,如果不做特别说明,所有成员的访问权限均为私有的 D.在类中,如果不做特别说明,所有成员的访问权限均为公用...
  • C语言虽然面向过程的语言,但是在linux的内核中到处都可以看到其采用面向对象的思想,最典型的就是文件系统,llinux把各种文件系统都可以转换成一标准的文件系统,提供统一的接口给用户。  另个例子就是...
  • 如何创建对象和使用

    2020-12-08 14:46:21
    c语言是一种*面向过程*的语言。 c++语言是一种既*面向对象*,又*面向过程*的语言。 Java(来源于c++)语言是一种*纯面向对象*的语言。 他们都是解决问题的思想: **面向过程**:通过过程来解决问题,...
  • Java:类与对象

    2019-01-07 08:36:28
    (注释:C语言为面向过程语言,C++基于面向对象的语言,但又包含了部分的C,所以不算纯面向对象语言,Java是纯面向对象语言)下面就以Java为例 一.面向对象 一种程序设计的方式,将现实生活的世界以对象为基本...
  • 编程语言简介

    2018-02-23 14:44:00
    C = 各个操作系统的开发语言 1973 ... C++进一步扩充和完善了C语言是一种面向对象的程序设计语言。java = 1995 由sun 公司开发出来,java 虚拟机 支持跨平台 php = 1994, web开发语言, 1994...
  • 用c语言实现面向对象,其实是蛮难的,毕竟c语言是纯面向过程的语言,而面向过程和面向对象是两完全不同的思想,虽不能说格格不入,但至少共同点甚少。不过,c语言天生具有的两大特性成就了其实现面向对象的...
  • 类&对象

    2018-03-21 22:47:46
      C++不是纯面向对象语言,而是基于面向对象的语言(c语言面向过程) 面向对象三大特性   封装、继承、多态 封装: 将数据和方法封装到个类中 类中有访问限定符 三访问限定符 public成员可从...
  • 4、编程语言的分类

    2019-05-23 20:38:00
    600多种编程语言 C = 各个操作系统的开发语言 1973 ... C++进一步扩充和完善了C语言是一种面向对象的程序设计语言。 java = 1995 由sun 公司开发出来,java 虚拟机 支持跨平台 php = 1994, web开发语...
  • 面向对象程序设计 ...C++不是纯面向对象语言,而是基于面向对象语言,因为包含c语言访问限定符 1:public成员可从类外部直接访问,private/protected成员不能从外部直接访问。 2:每个限定符在类...
  • 而Java语言不同,Java语言是一种纯面向对象语言。举个例子:对于车子发动,车子刹车这两个操作。面向过程语言:这是两个事件,车子发动,是一个事件,车子刹车是一个事件。对于这两个事件,需要创建两个函数,按照...
  •  本书编程语言先驱者Ivor Horton的经典之作,是C语言方面最畅销的图书品种之,在世界范围内广受欢迎,口碑极佳。  本书的目标使你在C语言程序设计方面由位初学者成为位称职的程序员。 内容简介  本书...
  • vxworks源码剖析-对象篇(转)

    千次阅读 2011-10-23 22:06:14
    用c语言实现面向对象,其实是蛮难的,毕竟c语言是纯面向过程的语言,而面向过程和面向对象是两完全不同的思想,虽不能说格格不入,但至少共同点甚少。不过,c语言天生具有的两大特性成就了其实现面向对象
  • 他们是纯面向对象的、严格非函数式的语言。 同时,纯函数语言也无法使用面向对象编程,比如Scheme、Haskell以及Lisp。 然而有些语言模式都支持。Python个著名的例子,不过还有别的:Ruby,Jul
  • 第二部分高级主题,包括面向对象语言和函数语言、垃圾收集、循环优化、SSA(静态单赋值)形式、循环调度、存储结构优化等,适合于后续课程或研究生教学。书中专门为学生提供了个用C语言编写的实习项目,包括前端和...
  • OC语言之Objective-C简介

    千次阅读 2016-02-06 15:46:56
    # Objective-C简介 !...##1.Objective-C简介 - Objective-C是一种面向对象的计算机...- 1986年,Brad Cox(布莱德·考克斯)在第一个纯面向对象语言Smalltalk基础上写成了Objective-C语言。 - 1985年,被赶出苹果公司的S
  • C++的重要性质!

    2012-11-20 19:19:02
    C++是一种扭转程序员思维模式的语言,一个人思维模式的扭转,不可能...(所谓纯面向对象语言,是指不管什么东西,都应该存在于对象之中,java就是纯面向对象语言)。C++语言范围何其广大,这部分主题的挑选完全是以MF
  • Objective-C简介

    2016-02-10 15:31:14
    1.Objective-C 是一种面向对象的计算机语言(是什么) 2.OC不是一种全新的语言,它是在C语言的基础上增加了面向对象的语法,所以OC兼容C语言,可以再OC中混入C语言代码,...1986年,BradCox在纯面向对象语言SmallTalk的
  • 什么 C++

    2009-08-07 13:01:00
    同时从市场角度来看, 它又不是纯面向对象, 其实那些纯粹的面向对象语言的阵地只是在实验室. 比较C语言. C++ 的几个显著变化或者解决的问题就是1. 名字空间的问题, 原始的C语言使用公共的名字空
  • 什么C++

    2008-01-08 22:03:00
    同时从市场角度来看, 它又不是纯面向对象, 其实那些纯粹的面向对象语言的阵地只是在实验室. 比较C语言. C++ 的几个显著变化或者解决的问题就是1. 名字空间的问题, 原始的C语言使用公共的名字空间, 这样无论

空空如也

空空如也

1 2 3 4
收藏数 62
精华内容 24
关键字:

c语言是一种纯面向对象语言

c语言 订阅