文章目录
1.类的数据成员
2.类的成员函数
3.成员函数重载及默认参数
4.成员函数的存储方式
5.类的声明

1.类的数据成员
（1）在类中声明数据成员

正如我们所见， 类的数据成员的声明类似于普通变量的声明。 如果一个类具有多个同一类型的数据成员， 则这些成员可以在一个成员声明中指定。
class Cube  //Cube类表示立方体
{
	… //其他成员
	long color; //数据成员
	double x,y,z,side; //数据成员
};


类的数据成员可以是基本类型、 数组、 指针、 引用、 共用体、 枚举类型、 void指针、 const限定等数据类型。 例如：

class ADT  //类成员数据类型
{
	… //成员函数
	long color;
	double x,y,z,side; //基本类型
	int a[10]; //数组
	char *s; //指针
	char &r; //引用
	void *p; //void指针
};


类的数据成员还可以是成员对象（member object） ， 即类类型或结构体类型的对象。 若类A中嵌入了类B的对象， 称这个对象为子对象（subobject） 。 例如： 类Line嵌入了类Point的子对象start、 end。

class Point  //Point类表示点
{
	public:
		void set(int a,int b);
		int x,y;
};
class Line  //Line类表示线
{
	public:
		void set(Point a,Point b);
		Point start, end; //成员对象
};

（2）在类中定义或声明数据类型

除了定义数据成员和成员函数之外， 类还可以定义自己的局部类型，并且使用类型别名来简化。
在类中定义或声明的数据类型的作用域是类内部， 因此， 它们不能在类外部使用。
在类定义中， 可以定义结构体和共用体类型、 嵌套的类定义， 声明枚举类型

eg：

class ADT  //类定义
{
	struct Point  //定义结构体
	{ 
		int x,y; 
	};
	union UData  //定义共用体
	{
		Point p; 
		long color; 
	};
	enum COLORS {RED,GREEN,BLUE,BLACK,WHITE }; //定义枚举类型
	class Nested  //嵌套类定义
	{
		… //成员函数
		Point start; //数据成员
		UData end; //数据成员
		COLORS color; //数据成员
	};
	typedef Point* LPPOINT; //声明类型别名
	… //成员函数
	… //数据成员
}; //类定义结束

2.类的成员函数
（1） 在类的外部定义成员函数

如果成员函数仅有声明在类定义中， 则在类外部必须有它的实现，其一般形式为：

返回类型 类名::函数名(形式参数列表)
{
	函数体
}

eg：
class Data//Data类定义
{
	public:
		void set(int d);//成员函数原型声明
		int get()//成员函数定义
		{	
			return data;
		}//get函数定义结束
	private:
		int data;//数据成员
};//Data类定义结束

void Data::set(int d)//set函数所属于类Data，//成员函数的外部定义， 使用 Data:: 限定
{
	data=d;//访问类的数据成员
}
void set(int d)//全局普通函数
{
	,,,//函数体
}

说明：
（1） （::） 是作用域限定符（field qualifed，常称之为域作用符）。 如果在作用域限定
符的前面没有类名， 或者函数前面既无类名又无作用域限定符， 例如：
::set(10) 或 set(10)
则表示set函数不属于任何类， 这个函数不是成员函数， 而是全局的普通函数。 
此时的（::） 不是类作用域限定符的含义， 而是命名空间域限定符的含义。

（2） 在成员函数中可以访问这个类的任何成员， 无论它是公有的或是私有的， 
是类内部声明的还是类外部定义的。

（3） 虽然成员函数在类的外部定义， 但在调用成员函数时会根据在类中声明的函数原型找到函数
的定义（即函数代码） ， 从而执行该函数。 因此类的成员函数原型声明必须出现在成员函数定义之前，
否则编译时会出错。

重点：（4） 在类的内部声明成员函数， 而在类的外部定义成员函数， 这是一个良好的编程习惯。 因为不
仅可以减少类体的长度， 使类体结构清晰， 便于阅读， 而且有助于类的接口和实现分离。
►（5） 如果一个成员函数， 其函数体不太复杂， 只有4～5行时， 一般可在类体中定义



（2）内联成员函数

类的成员函数可以指定为inline， 即内联函数。
默认情况下， 在类体中定义的成员函数若不包括循环等控制结构，符合内联函数要求时， C++会自动将它们作为内联函数处理（隐式inline） 。
也可以显式地将成员函数声明为inline。 例如


class Data//Data类定义
{
	int getx()//内联成员函数
	{
		return x;
	}
	inline int gety()//显式指定内联成员函数
	{
		return y;
	}
	inline void setxy(int _x, int _y);//显式指定内联成员函数
	void display();
	int x,y;
}；
inline void Data::setxy(int _x,int _y)//内联成员函数
{
{
	x=_x;
	y=_y;
}
void Data::display()//非内联成员函数
{
	...//函数体
}


判断成员函数是否是内联的， 有以下几条：

① 符合内联函数要求；

② 符合①的条件， 并且在类体中定义， 自动成为内联的；

③ 符合①的条件， 在类体显式指明inline， 或在外部定义时显式指明inline， 或者同时显式指明， 则函数是内联的；

④ 在类外部定义， 并且既没有在类体， 也没有在外部定义时显式指明inline， 则函数不是内联的。

3.成员函数重载及默认参数

可以对成员函数重载或使用默认参数。 例如：

class MAX
{
	int Max(int x, int y)//函数名一样，类一样，就是函数重载
	{
	}
		return x>y?x:y;
	int Max()//重载Max
		return Max(Max(a,b),Max(c,d));
	int Set(int i=1,int j=1,int k=3.int l=4)//默认参数
	{
		a=i,b=i,c=k,d=l;
	} 
	int a,b,c,d;
}

需要注意， 声明成员函数的多个重载版本或指定成员函数的默认参数， 只能在类内部中进行。

因为类定义中的声明先于成员函数的外部实现， 根据重载或默认参数函数的要求， 必须在第
1次出现函数声明或定义时就明确函数是否重载或有默认参数。先声明，再定义

4.成员函数的存储方式


用类实例化一个对象时， 系统会为每一个对象分配存储空问。 如果一个类包括了数据成员和成员函数， 则要分别为数据和函数的代码分配存储空间。


通常， C++会为每个对象的数据成员分配各自独立的存储空间， 像结构体成员那样


那么在类中的成员函数是否会如图所示那样也分配各自独立的存储空间呢？




由于不论调用哪一个对象的函数代码， 实际调用的都是同样内容的代码。 因此， 若像上图那样存放相同代码的多份副本， 既浪费空间又无必要。


实际上， 成员函数代码只有公用的一段存储空间， 调用不同对象的成员函数时都是执行同一段函数代码。




类的数据成员与类的成员函数的关系：

成员函数从属于类；

从存储空间来说，成员函数与类是不依赖的，即：类的数据成员和成员函数是分开来存储的；


例如定义了一个类



class Time//Time类
{
	int h,m,s;//数据成员
	void settime(int a,int b,int c)//成员函数
	{
		h=a.m=b,s=c;
	}
};

sizeof(Time)的值是12。 显然， Time类的存储空间长度只取决于数据成员h、 m、 s所占的空间， 
而与成员函数settime无关。 C++把成员函数的代码存储在对象空间之外的地方。

5.类的声明

一旦遇到类体后面的右大括号， 类的定义就结束了。
在一个给定的源文件中， 一个类只能被定义一次。
通常将类的定义放在头文件中， 这样可以保证在每个使用该类的文件都以同样的方式定义类
可以只声明一个类而不定义它：

class Point; //Point类声明， 非Point类定义， 因为没有类体



这个声明， 称为前向声明（forward declaration） ， 表示在程序中引入了Point类类型。


在声明之后、 定义之前， 类Point是一个不完全类型， 即已知Point是一个类， 但不知道它包含哪些成员。 因此不能定义该类型的对象，只能用于定义指向该类型的指针及引用， 或者用于声明（而不是定义） 使用该类型作为形参类型或返回类型的函数。


在创建类的对象之前， 必须完整地定义该类。 这样， 编译器就会给类的对象准备相应的存储空间。


同样地， 在使用引用或指针访问类的成员之前， 必须己经定义类。


类不能具有自身类型的数据成员。 然而， 只要类名一经出现就可以认为该类己声明。 因此， 类的数据成员可以是指向自身类型的指针或引用

eg:


class Point; //Point类声明， 非Point类定义， 因为没有类体
class Line {
	Point a; //错误， 不能使用仅有类声明而没有类定义的类定义数据对象
	
	Point *pp, &rp; //正确， 只有类声明， 即可用它定义该类的指针或引用
	
	Line b; //错误， 类不能具有自身类型的数据成员
	
	Line *pl, &rl; //正确， 类可以有指向自身类型的指针或引用的数据成员
};

1.Java语言的基本元素
类实际上在现实当中是不存在的，是一个抽象的概念，是一个模板。类的本质上现实世界当中某些事物具有共同特征，将这些共同特征提取出来形成的概念就是一个“类”。在Java的世界中，“万物皆为对象”。
对象是实际存在的个体（真实存在的个体），是类的实例化。
2.类的成员
1. 属性(field)

用来描述具体某个对象的特征。描述的是对象的状态信息，通常以变量的形式进行定义。

语法格式：

　　权限修饰符 [特征修饰符] 数据类型 属性名字[ = 值]；

例如：
public class Person {
    public String name;//成员变量
    public int age;
    public String sex;
}

变量通常分为成员变量和局部变量。

在类体中，方法体之外定义的变量称为“成员变量”

成员变量定义在类体中，在整个类中都可以被访问。
成员变量分为类变量和实例变量，实例变量存在于对象所在的堆内存中

成员变量有默认初始化值
成员变量的权限修饰符可根据需要，选择任意一个
创建对象后才能访问的变量称为实例变量

定义在方法内，代码块内的变量称为局部变量

局部变量定义在局部范围内
局部变量存在于栈内存中
作用范围结束，变量空间自动释放
局部变量无默认值，每次必须显示初始化
局部变量声明时一般不指定权限修饰符





2. 方法(method)

描述的是对象的动作信息，为定义在类中的具特定功能的一段独立的程序。

语法格式：

权限修饰符 [特征修饰符] 返回值类型 方法名字 (参数)[抛出的异常]{

　　方法体

}

方法是类或对象行为特征的抽象，用来完成某个功能操作。在某些语言中也称为函数或过程。
将功能封装为方法的目的是，可以实现代码重用，简化代码
Java里的方法不能独立存在，所有的方法必须定义在类里。

public class Person {
    //属性和方法--静态描述特点
    //必要的组成部分
    //  修饰符   数据类型   属性姓名[=值]
    //权限修饰符 [特征修饰符] 数据类型 属性名字
    public String name;//全局变量
    public int age;
    public String sex;

    //方法--描述可以做什么事情(动作)
    //权限修饰符 [特征修饰符] 返回值类型 ([参数列表]){方法体}
    //1、无参数无返回值
    //2、无参数有返回值
    //3、有参数无返回值
    //4、有参数有返回值

    //无参数无返回值
    //设计一个方法  用来描述人类可以做吃饭这件事
    public void eat(){
        System.out.println("吃了一碗大米饭");
    }
    //无参数有返回值
    //设计一个方法  用来告诉别人我的名字
    public String tellName(){
        System.out.println("你们问我叫什么名字呀？勉强告诉你们一下");
        return "张三";
    }
    //有参数无返回值
    //设计一个新的吃饭方法
    public void chiFan(int count,String something){
        System.out.println("吃了"+count+"碗"+something);
    }
    //有参数有返回值
    //设计一个方法 买饮料  1.需不需要提供条件   2.需不需要给别人留下什么结果
    //需要提供条件   钱     需要返回值   饮料
    public String buyDrink(int money){
        if(money>5){
            return "红牛";
        }
        else{
            return "矿泉水";
        }
    }
}

方法的重载(overload)

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

重载的特点：

与返回值类型无关，只看参数列表，且参数列表必须不同。(参数个数或参数类型)。调用时，根据方法参数列表的不同来区别。
参数列表的不同体现在哪里？

参数的个数
参数的leixing
参数的顺序

public class TestOverload {

    //方法重载
    public void test(){
        System.out.println("执行了test方法中没有带参数");
    }
    public void test(boolean b){
        System.out.println("执行了test方法中带boolean参数"+b);
    }
    public void test(int i){
        System.out.println("执行了test方法中带int参数"+i);
    }
    public void test(char c){
        System.out.println("执行了test方法中带char参数"+c);
    }
    public void test(String s){
        System.out.println("执行了test方法中带String参数"+s);
    }

    public static void main(String[] args){
        //创建对象
        TestOverload to = new TestOverload();
        
        //通过对象.方法名字  调用方法  可以直接通过方法名字定位方法
        //如果方法名字一直  通过方法的参数列表类型来定位
        //通过对象调用方法 方法执行一遍
        to.test('a');//方法参数传递  类型之间的转换问题
        //当没有char类型的方法时，会找一个参数类型可以自动转换的int类型方法

        System.out.println(to);//TestOverload@34e45f-->hashCode码
    }
}

可变个数的参数
public class Test {
    //JDK1.5版本之后 出现的一个新的写法-->动态参数列表
    //不能与数组类型的方法构成重载，因为本质上是一样的
    public void test(int... x){//本质上是数组
        System.out.println("执行了test方法携带的动态列表");
        for(int i=0;i<x.length;i++){
            System.out.println(x[i]);
        }
    }
    public void test(int[]...x){
        System.out.println();
    }


    public static void main(String[] args){
        //创建对象
        Test t = new Test();
        t.test(1,2,3,4,5);
        
    }
}

方法参数返回值问题

Java的实参值如何传入方法呢？

Java里方法的参数传递方式只有一种：值传递。 即将实际参数值的副本（传入方法内，而参数本身不受影响。

形参是基本数据类型：将实参基本数据类型变量的“数据值”传递给形参
形参是引用数据类型：将实参引用数据类型变量的“地址值”传递给形参

public class Test {
    public int changeNum(int x){//将void变为int类型的
        System.out.println("方法执行开始："+x);//1
        x = 10;
        System.out.println("方法执行最终："+x);//10
        return x;//返回值  将x临时的变量空间内的值（值或引用）返回出来
    }

    public void changeArray(int[] x){
        System.out.println("方法执行开始："+x[0]);//1
        x[0] = 10;
        System.out.println("方法执行最终："+x[0]);//10
    }
    //每一个类中不是必须包含主方法的
    //主方法不属于任何一个类，主方法主语虚拟机
    public static void main(String[] args){
        //创建一个对象--前提 有一个类模型
        //加载类模板的过程
        Test t = new Test();//堆内存中开辟空间
        int a = 1;
        a = t.changeNum(1);//需要一个int的条件  int x = a;
        //调用方法  让方法执行一遍
        //1.方法存在哪里？ 堆内存的对象空间内
        //2.方法在哪里执行？  栈内存中开辟一块临时的方法执行空间
        System.out.println("方法执行完毕，main方法中a的值："+a);//1
        // 临时开辟的执行changeNum方法的空间就没了   a的值没有改变只是被用了

        System.out.println("++++++++++++++++++++++++++++++++++++++");
        //加载类模板的过程
        int[] b = new int[]{1,2,3};
        t.changeArray(b);
        //方法存在堆内存的对象空间里 方法执行在栈内存中的临时空间里
        //调用方法值将b的值传递给了x  int[] x = b; 传递过来的就是一个引用
        System.out.println("方法执行完毕，main方法中b数组的第一个值："+b[0]);//10

        /**形参和实参
         * 形参可以理解为是方法执行时的临时变量空间 x
         * 实参可以理解为是方法调用时传递进去的参数 a
         *方法调用时会将实参的内容传递给形参
         * 如果内容是基本类型  传递的是值           形参改变  实参不变
         * 如果内容是引用类型  传递的是引用(地址)   形参改变  实参跟着改变
         */
    }
}

方法参数及返回值传递（基本类型）



方法参数及返回值传递（引用类型）


3. 构造方法(构造器)

构造方法的作用：构建(构造)当前类的对象;给对象进行初始化

语法格式：

权限修饰符 与类名一致的方法名 (参数列表) [抛出异常]{

　　语句；

}
public class Animal {
	private int legs;
	// 构造器
	public Animal() {
		legs = 4;
	} 
	public void setLegs(int i) {
		legs = i; 
	}
	public int getLegs() {
		return legs; 
	}
}


创建Animal类的实例：Animal a = new Animal();调用构造方法，将legs初始化为4。

根据参数不同，构造器可以分为如下两类：

隐式无参数的构造方法（系统默认提供）
显式定义一个或多个构造方法（无参、有参）

注意

一旦显式定义了构造方法，则系统不再提供默认构造方法
一个类可以创建多个重载的构造方法

构造方法的重载
public class Person{
public Person(String name, int age, Date d) {this(name,age);…}
public Person(String name, int age) {…}
public Person(String name, Date d) {…}
public Person(){…}
}


4. 块

作用：跟普通方法一样 做事情

语法格式：

{

　　java语句；

}

可以认为块是一个没有修饰符，没有参数，没有返回值，没有名字的特殊方法。

用法：

块需要调用才能执行，但是不需要我们自己调用
每一次调用构造方法之前，会自动调用块

3.this关键字
this是什么？

在方法内部使用，即这个方法所属对象的引用；
在构造器内部使用，表示该构造器正在初始化的对象。

this 可以调用类的属性、方法和构造器
什么时候使用this关键字呢？

当在方法内需要用到调用该方法的对象时，就用this。

具体的：我们可以用this来区分属性和局部变量。比如：this.name = name;

public class Person(){
	String name;
	int age;
	
	public Person(){}
	public Person(String name, int age){
		this.name = name;
		this,age = age;
	}
	public void talk(){
		System.out.println("Person类中的说话方法");
		this.study();
	}
	public void study(){
		System.out.println("Person类中的学习方法");
	}
	public void display(){
		System.out.println(this.name + "今年" + this.age + "岁");
	}
}


在任意方法或构造器内，如果使用当前类的成员变量或成员方法可以在其前面添加this，增强程序的阅读性。不过，通常我们都习惯省略this。
当形参与成员变量同名时，如果在方法内或构造器内需要使用成员变量，必须添加this来表明该变量是类的成员变量。
使用this访问属性和方法时，如果在本类中未找到，会从父类中查找。
his可以作为一个类中构造器相互调用的特殊格式。

枚举类型较传统定义常量的方式，除了具有参数类型检测的优势之外，还具有其他方面的优势。

用户可以将一个枚举类型看作是枚举类型的一个实例，它继承于java.lang.Enum类，当定义一个枚举类型时，每一个枚举类型成员都可以看作是枚举类型的一个实例，这些枚举类型成员都默认被final、public、static修饰，所以当使用枚举类型成员时直接使用枚举类型名称调用枚举类型成员即可。

由于枚举类型对象继承于java.lang.Enum类，所以该类中一些操作枚举类型的方法都可以应用到枚举类型中。下面将列举了枚举类型中的常用方法。

方法名称			具体含义								使用方法

values() 该方法可以将枚举类型成员以数组的形式返回 枚举类型名称.values()

valueOf() 该方法可以实现将普通字符串转换为枚举实例 枚举类型名称.valueOf(“a”)

compareTo() 该方法用于比较两个枚举对象在定义时的顺序 枚举对象.compareTo()

ordinal() 该方法用于得到枚举成员的位置索引 			枚举对象.ordinal()
(1)、values()

枚举类型实例包含一个values()方法，该方法将枚举类型的成员变量实例以数组的形式返回，也可以通过该方法获取枚举类型的成员。

例：在项目中创建ShowEnum类，在该类中使用枚举类型中的values()方法获取枚举类型中的成员变量。



使用枚举类型中的values()方法获取枚举类型中的成员变量，运行结果：



例子中，由于values()方法将枚举类型的成员以数组的形式返回，所以根据该数组的长度进行循环操作，然后将该数组中的值返回。

(2)、valueOf()与compareTo()

枚举类型中静态方法valueOf()可以将普通字符串转换为枚举类型，而compareTo()方法用于比较两个枚举类型对象定义时的顺序。

例：在项目中创建EnumMethodTest类，在该类中使用枚举类型中的valueOf()与compareTo()方法。



使用compareTo()方法比较两个枚举类型成员定义的顺序，运行结果：



调用compareTo()方法返回的结果，正值代表方法中参数在调用该方法的枚举对象位置之前；0代表两个互相比较的枚举成员的位置相同；负值代表方法中参数在调用该方法的枚举对象位置之后。

2、实现一个自定义的字符串类String。
i.	定义具有两个私有数据成员，分别表示字符串的存储地址(char*类型)和长度(int类型)。实现字符串类String的构造函数、析构函数、拷贝构造函数、赋值运算。

ii.	实现运算符重载：String + String、String + char *

iii.	重载运算符 << 和 >> ，实现字符串的输入和输出。

iv.	在main函数写一段简单的使用该字符类（包含上述运算）的测试程序
test.cpp
#include"string.h"
#include<iostream>
using namespace std;
int main()
{
	String s1, s2;
	s1 = "chenhaoran";
	s2 = "zhangchao";
	cout << s1<<endl;
	String s3(s2);
	cout << s3<<endl;
	String s4 = s3;
	cout << s4 << endl;
	//cout << s4 + s2 << endl;
	String s6 = s4 + s2;
	s1 = s4 + s2;//这不是调用复制构造函数
	cout << s6 << endl;
	return 0;
}

string.h
#pragma once
#include<ostream>
#include<istream>
using namespace std;
class String {
private:
	char *_str;
	int _size;
public:
	String();
	~String();
	String(const String &s);
	//friend String operator +(const String &temp1, const String &temp2);
	//friend String operator +(const String &temp1, const char * temp2);
	String operator+(const String &temp);
	String operator+(const char *temp);
	//String &operator =(String temp);
	String &operator =(const char *temp);
	friend ostream &operator<< (ostream &out, String &temp);//这里为什么是取地址符
	friend istream &operator>>(istream &in,String &temp);

};


string.cpp
#include"string.h"
#include<string.h>
#include<iostream>
using namespace std;
String::String()
{
	_str = new char[20];
	_size = 0;
}
String::~String()
{
	if (this->_str != NULL)
	{
		delete[] this->_str;	
		this->_str = NULL;
		this->_size = 0;
	}
}
String::String(const String &s)
{
	int len = strlen(s._str);
	_str = new char[len + 20];
	strcpy(_str, s._str);
	_size = s._size;
}
String String::operator+(const String &temp)
{
	String *p=new String();
	p->_str = new char[strlen(this->_str) + strlen(temp._str) + 1];
	strcpy(p->_str, this->_str);
	strcat(p->_str, temp._str);
	return *p;
}
/*
String operator +(const String &temp1,const String &temp2)
{
	//String temp(temp1);
	String temp;
	strcpy(temp._str, temp1._str);
		//strcat(temp._str, temp1._str);
	temp._size += temp1._size;
	strcat(temp._str, temp2._str);
	temp._size += temp2._size;
	return temp;
}
String operator +(const String &temp1,const char *temp2)
{
	String temp(temp1);
	int len = strlen(temp2);
	strcat(temp._str, temp2);
	temp._size += len;
	return temp;

}
*/
//String &String::operator=(String temp)
//{
	
//	strcpy(this->_str, temp._str);
//	this->_size = temp._size;
//	return *this;
//}
String &String::operator=(const char *temp)
{
	memset(this, '\0', this->_size);
	strcpy(this->_str, temp);
	this->_size = strlen(temp);
	return *this;
}
ostream &operator<< (ostream &out,String &temp)
{
	out << temp._str;
	return out;
}
istream &operator>> (istream &in,String &temp)
{
	in >> temp._size;
	return in;
}