6.1实验目的和要求
1．熟悉面向对象的基本概念。
2．进一步掌握类的各种成员的使用方法。
3．掌握对象之间通信的基本方法。
6.2实验内容与步骤
题目1 点和直线类
（1）创建C#控制台应用程序L6_1。
（2）在程序中新建一个点类CzPoint，为其定义两个double类型的私有字段成员x和y，分别表示点的横坐标和纵坐标。
（3）为CzPoint定义两个公有属性X、Y，分别用于封装对字段x 和y的读写访问。
（4）定义CzPoint的带参构造函数，在其中对字段x和y进行初始化。参考源代码如下：
public CzPoint(double x, double y)
{
this.x = x;
this.y = y;
}
（5）为CzPoint定义公有方法Move，用于按指定的水平距离和垂直距离移动坐标点。参考源代码如下：
public void Move(double dx, double dy)
{
x += dx;
y += dy;
}
（6）对CzPoint类进行相等和不相等操作符重载。两个坐标点相等，是指它们的横坐标和纵坐标都相等。
（7）在程序主方法中创建坐标为（1,2）和（3,3）的两个坐标点对象，判断它们是否相等；而后将第一个坐标点移动到第二个坐标点上，再判断它们是否相等。
（8）在程序中再新建一个直线类CzLine，为其定义两个double类型的字段成员a和b，分别表示直线的斜率和截距；再定义字段的封装属性A和B，但它们都是只读的。
（9）为CzLine定义两个构造函数，一个根据斜率和截距来创建直线对象，另一个则根据两个CzPoint对象来构造直线对象（直线穿过这两个点）。后一个的参考源代码如下：
public CzLine(CzPoint p1, CzPoint p2)
{
if (p1 == p2)
throw new ArgumentException("两点不能相同");
this.a = (p2.Y - p1.Y) / (p2.X - p1.X);
this.b = p1.Y - this.a * p1.X;
}
（10）为CzLine定义公有方法Move,但它只用于平移直线，而不改变直线的斜率。再为其定义公有方法Contains,用于判断某点是否在该直线上。
（11）类似的，为CzLine重载相等和不等操作符。
（12）最后在程序主方法中采用不同的方式创建直线对象，并编译运行程序，测试它们的使用效果。
程序的整体结构如下：
个人编程：
源代码：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace L6_1
{
class Program
{
static void Main(string[] args)
{
CzPoint a = new CzPoint(1, 2);
CzPoint b = new CzPoint(3, 3);
if (a == b)
Console.WriteLine("点(1,2)与点(3,3)相等.");
else
Console.WriteLine("点(1,2)与点(3,3)不等.");
Console.WriteLine("将点(1,2)移动到点(3,3)");
a.Move(3, 3);
if (a == b)
Console.WriteLine("点(1,2)移动后与点(3,3)相等.");
else
Console.WriteLine("点(1,2)移动后与点(3,3)不等.");
CzLine L1 = new CzLine(2, 0);
CzLine L2 = new CzLine(a, b);
L1.Move(1);
if (L1 == L2)
Console.WriteLine("2条直线相等.");
else
Console.WriteLine("2条直线不等.");
L1.Contains(a);
Console.Read();
}
}
public class CzPoint
{
private double x;
private double y;
public double X
{
get { return x; }
set { x = value; }
}
public double Y
{
get { return y; }
set { y = value; }
}
public CzPoint(double x, double y)
{
this.x = x;
this.y = y;
}
public void Move(double dx, double dy)
{
x += dx;
y += dy;
}
public static bool operator ==(CzPoint a, CzPoint b) {
if (a.X == b.Y && a.Y == b.Y)
return true;
else
return false;
}
public static bool operator !=(CzPoint a, CzPoint b) {
if (a.X != b.Y || a.Y != b.Y)
return true;
else
return false;
}
}
public class CzLine
{
private double a;
private double b;
public double A
{
set { a = value; }
}
public double B
{
set { b = value; }
}
public CzLine(double a, double b)
{
this.a = a;
this.b = b;
}
public CzLine(CzPoint p1, CzPoint p2)
{
if (p1 == p2)
throw new ArgumentException("两点不能相同");
this.a = (p2.Y - p1.Y) / (p2.X - p1.X);
this.b = p1.Y - this.a * p1.X;
}
public void Move(double db)
{
this.b -= this.a * db;
}
public void Contains(CzPoint p)
{
if (p.Y == p.X * this.a + this.b)
Console.WriteLine("点({0},{1})在这条直线上.", p.X, p.Y);
else
Console.WriteLine("点({0},{1})不在这条直线上.", p.X, p.Y);
}
public static bool operator ==(CzLine L1, CzLine L2)
{
if (L1.a == L2.a && L1.b == L2.b)
return true;
else
return false;
}
public static bool operator !=(CzLine L1, CzLine L2)
{
if (L1.a != L2.a || L1.b != L2.b)
return true;
else
return false;
}
}
}
运行结果：
题目2 向量类
（1）创建C#控制台应用程序L6_2。
（2）在程序中新建一个向量类CzVector，在其中定义一个double[]类型的私有字段_values，用于维护向量的各个元素值。
（3）为CzVector定义三个公有属性Length、Sum和Prod，分别用于返回向量的长度、向量所有元素的和以及向量所有元素的积。
（4）在CzVector中定义一个索引函数，用于获取或设置向量各个元素的值。
（5）为CzVector定义两个构造函数，一个根据指定长度来对向量进行初始
化（向量各元素取默认值0），另一个由指定的数组来构造向量并设置各元素的值。参考源代码如下：
public CzVector(int length)
{
_values = new double[length];
}
public CzVector(params double[] dArray)
{
_values = dArray;
}
（6）利用操作符重载来实现向量加法、减法和乘法。这三种运算均要求两个向量的长度相等。设向量α=(a1, a2, …, a n), β=(b1, b2, …, b n)，那么α+β=（a1+ b1, a2+ b2, …, a n+ b n），减法与之类似，而α*β= a1*b1+ a2* b2+ …+ a n* b n，λ*α=(λ*a1, λ*a2, …, λ*a n)。以加法操作符重载为例，参考源代码如下：
public static CzVector operator +(CzVector v1, CzVector v2)
{
if (v1.Length != v2.Length)
return null;
CzVector result = new CzVector(v1.Length);
for (int i = 0; i < v1.Length; i++)
result[i] = v1[i] + v2[i];
return result;
}
（7）类似的，利用操作符重载来判断两个向量是否相等。向量相等的条件是：两个向量的长度相等，且各个位置上的对应元素值也相等。
（8）为CzVector定义一个ConsoleOutput方法，用于在控制台一行输出向量的所有元素，其之间以空格分割。
（9）在程序主方法中随机定义几个向量对象，并测试其运算结果。参考源代码如下：
static void Main()
{
CzVector v1 = new CzVector(1, -5, 9, 6);
CzVector v2 = new CzVector(0, 1, 2, 3);
Console.Write("v1 = ");
v1.ConsoleOutput();
Console.Write("v2 = ");
v2.ConsoleOutput();
CzVector v3 = v1 + v2;
Console.Write("v1 + v2 = ");
v3.ConsoleOutput();
Console.Write("3 * (v1 + v2) = ");
(v3 * 3).ConsoleOutput();
Console.WriteLine("v1 * v2 = {0}", v1 * v2); }
源代码：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace L6_2
{
class Program
{
static void Main(string[] args)
{
CzVector v1 = new CzVector(1, -5, 9, 6);
CzVector v2 = new CzVector(0, 1, 2, 3);
Console.Write("v1 = ");
v1.ConsoleOutput();
Console.Write("v2 = ");
v2.ConsoleOutput();
CzVector v3 = v1 + v2;
Console.Write("v1 + v2 = ");
v3.ConsoleOutput();
Console.Write("3 * (v1 + v2) = ");
(v3 * 3).ConsoleOutput();
Console.WriteLine("v1 * v2 = {0}", v1 * v2);
Console.Read();
}
}
public class CzVector
{
protected double[] _values;
public double this[int index]
{
get
{
if (index < 0 || index >= Length)
throw new ArgumentException("超出索引范围！");
else
return this._values[index];
}
set
{
if (index < 0 || index >= Length)
throw new ArgumentException("超出索引范围！");
else
this._values[index] = value;
}
}
public int Length
{
get { return _values.Length; }
}
public double Sum
{
get
{
double result = _values[0];
for (int i = 0; i < _values.Length; i++)
result += _values[i];
return result;
}
}
public double Prod
{
get
{
double result = _values[0];
for (int i = 0; i < _values.Length; i++)
result *= _values[i];
return result;
}
}
public CzVector(int length)
{
_values = new double[length];
}
public CzVector(params double[] dArray)
{
_values = dArray;
}
public static CzVector operator +(CzVector v1, CzVector v2) {
if (v1.Length != v2.Length)
return null;
CzVector result = new CzVector(v1.Length);
for (int i = 0; i < v1.Length; i++)
result[i] = v1[i] + v2[i];
return result;
}
public static CzVector operator -(CzVector v1, CzVector v2) {
if (v1.Length != v2.Length)
return null;
CzVector result = new CzVector(v1.Length);
for (int i = 0; i < v1.Length; i++)
result[i] = v1[i] - v2[i];
return result;
}
public static double operator *(CzVector v1, CzVector v2) {
if (v1.Length != v2.Length)
return 0;
double result = 0;
for (int i = 0; i < v1.Length; i++)
result += v1[i] * v2[i];
return result;
}
public static CzVector operator *(CzVector v1, double v2)
{
CzVector result = new CzVector(v1.Length);
for (int i = 0; i < v1.Length; i++)
result[i] = v1[i] * v2;
return result;
}
public static bool operator ==(CzVector v1, CzVector v2)
{
if (v1.Length == v2.Length)
{
for (int i = 0; i < v1.Length; i++)
if (v1[i] != v2[i])
return false;
return true;
}
else
return false;
}
public static bool operator !=(CzVector v1, CzVector v2)
{
if (v1.Length == v2.Length)
{
for (int i = 0; i < v1.Length; i++)
{
if (v1[i] != v2[i])
return true;
}
return false;
}
else
return true;
}
public void ConsoleOutput()
{
for (int i = 0; i < _values.Length; i++)
Console.Write("{0} ",this._values[i]);
Console.WriteLine();
}
}
}
运行结果：
C语言的类和对象 【类实现了C++面向对象程序设计的基础，我们使用类来定义对象的属性，类是 C++封装的基本单元。】 一、----- 类 使用关键字class创建类，一个类声明定义了一个连接代码和一个数据的新类型，这个新的类型又可以用来声明该类的对象。因此，类又是逻辑逻辑抽象概念，儿对象是物理存在的，也就是说对象是类的实例。 类的声明语法上和结构相似。 [一下是完整的类的形式] class class_name { private data and functions access_specifier: data and functions access_specifiter: data and functions //…….. access_specifier:是 data and functions }object_list; 其中，object_list是任选项，如过存在，他声明类的对象。access_specifier为下面的三个关键字之一： Public private protected 默认时，在类声明的函数和数据属于该类私有，只能被该类的成员访问。如果使用，pubilc访问限定符号，函数和程序就可以被其他部分访问。Protected访问限定符，仅在涉及继承的时候才需要（十五章了解）。访问限定符已经使用，其作用就保持到遇到别的访问限定符或者达到类声明的结束处。 在类声明内可以任意改变访问说明符号，对于某些声明，可以转换位public，然后再转换成private。 [如下所述] /******************************* ··构造函数和析构函数学习··· *******************************/ //Using a constructor and destructor. /******************************* 声明C++ 程序头文件 *******************************/ #include
实验二类的定义和对象的创建 实验目的 1、学习定义类和使用类 2、学习创建的对象和使用对象 实验内容 1、定义一个Student类。其中定义有“学号”“姓名”“班级”“性别”“年龄”等属性，定 义一个无参数的构造器和至少一个有参数的构造器，定义“获得学号”“获得姓名”“获得班级”“获得性别”“获得年龄”“修改年龄”等方法。另外定义一个方法： public String toString( ) 把Student类的对象的所有属性信息组合成一个字符串，并检验这个功能的程序体现。 public class Student { private int 学号; private String 姓名; private String 班级; private char 性别; private int 年龄; public Student(int a, String b, String c, char d, int e) { 学号= a; 姓名= b; 班级= c; 性别= d; 年龄= e; } public Strudent() { this(0, "张三" ,"软件0901" ,'男', 19); } public int get学号() { return 学号; } public String get姓名() { return 姓名; } public String get班级() { return 班级; } public char get性别() { return 性别; } public int get年龄()
{ return 年龄; } public void set学号(int a) { 学号=a; } public void set姓名(String a ) { 姓名=a; } public void set班级(String a) { 班级= a; } public void set性别( char a) { 性别= a ; } public void set年龄(int a) { 年龄= a; } public String toString() { return "该学生的学号为"+ 学号+ " 姓名为"+姓名+" 班级为"+班级+ " 性别为" +性别+ " 年龄为" +年龄"; } } 2、编程实现圆类，其中包括计算圆周长和面积的方法，并测试方法的正确性。 public class Yuan { private double X, Y, R; public Yuan(double a, double b, double c) { X=a; Y=b; R=c; } public double MianJi() { return 3.1416*R*R; } public double ZhouChang() { return 2*3.1416*R; } public static void main(String[] args) { Yuan s=new Yuan(2,3,4); System.out.println("该圆的面积是"+ s.MianJi()); System.out.println("该圆的周长是"+ s.ZhouChang()); } }
类和对象 一、选择题 1、下面对方法的作用描述不正确的是：（ d ） A、使程序结构清晰 B、功能复用 C、代码简洁 D、重复代码 2、方法定义的变量：（ b ） A 、一定在方法所有位置可见B、可能在方法的局部位置可见 C、在方法外可以使用 D、在方法外可见 3、方法的形参：（a） A、可以没有 B、至少有一个 C、必须定义多个形参 D、只能是简单变量 4、方法的调用：（c） A、必须是一条完整的语句 B、只能是一个表达式 C、可能是语句，也可能是表达式 D、必须提供实际参数 5、return 语句：( d) A、不能用来返回对象 B、只可以返回数值 C、方法都必须含有 D、一个方法中可以有多个return 语句 6、void 的含义：（d） A、方法体为空 B、方法体没有意义 C、定义方法时必须使用 D、方法没有返回值 7、main()方法的返回类型是：（ c ） A 、boolean B、int C、void D、static 8、方法重载所涉及的方法：（ a ） A、有相同的名字 B、参数个数必须不同 C、参数类型必须不同 D、返回类型必须不同 9、下面关于类和对象之间关系的描述，正确的是（ c ） A、联接关系Ｂ、包含关系Ｃ、具体与抽象的关系Ｄ、类是对象的具体化 10、下面关于java中类的说法哪个是不正确的（ c ） A、类体中只能有变量定义和成员方法的定义，不能有其他语句。 B、构造方法是类中的特殊方法。 C、类一定要声明为public的，才可以执行。
D、一个java文件中可以有多个class定义。 11、下列哪个类声明是正确的( d) A、public void H1｛…｝ B 、public class Move()｛…｝ C、public class void number{} D、public class Car｛…｝ 12、下面的方法声明中，哪个是正确的（c） A、public class methodName(){} B、public void int methodName(){} C、public void methodName(){} D、public void methodName{} 13、下述哪些说法是不正确的？（ b ） A、实例变量是类的成员变量 B、实例变量是用static关键字声明的 C、方法变量在方法执行时创建 D、方法变量在使用之前必须初始化 14、下面对构造方法的描述不正确是( b)。 A、系统提供默认的构造方法 B、构造方法可以有参数，所以也可以有返回值 C、构造方法可以重载 D、构造方法可以设置参数 15、定义类头时，不可能用到的关键字是( b)。 A、class B、private C、extends D、public 16、下列类头定义中，错误的是( )。 A、public x extends y {...} B、public class x extends y {...} C、class x extends y implements y1 {...} D、class x {...} 17、设A为已定义的类名，下列声明A类的对象a的语句中正确的是( ) 。 A、float A a; B、public A a=A( ); C、A a=new int( ); D、static A a=new A( ); 18、设i , j为类X中定义的int型变量名，下列X类的构造方法中不正确的是( a )。 A、void X(int k ){ i=k; } B、X(int k ){ i=k; } C、X(int m, int n ){ i=m; j=n; } D、X( ){i=0;j=0; } 19、有一个类A，以下为其构造方法的声明，其中正确的是
类的构建和对象的使用 判断题 1、一个类可以生成多个对象，并且这些对象都具有相同的属性。（） 2、当运行javac命令对一个java源程序进行编译时，必须写出该源程序文件的完整文件名，包括扩展名.java。（） 3、 java语言中不用区分字母的大写小写。（） 4、数组允许存放不同类型的定长元素。（） 程序分析题 阅读下列程序，然后回答问题。 class Car { int carNumber; Car(){} Car(int no){ this.carNumber=no; } void setNumber(int carNum) { carNumber = carNum; } void showNumber() { System.out.println(“My car No. is :” + carNumber); } } ①写出这里定义了什么类？有哪些成员变量？有哪些成员方法？ ②有哪些构造方法？ ④ void表示什么？ 下列程序中，main()方法中使用了上面定义的类，产生了多少个对象？对象名字分别是什么？写出执行后的输出结果。 public class CarDemo { public static void main(String args[]){ Car demoCar1= new Car(); demoCar1.setNumber(168168); demoCar1.showNumber(); } } 编程题 1. 做一个学生管理系统的登陆界面，并判断用户名和密码是否正确。
2.做一个学生管理系统的子界面，来实现对10个学生的成绩的输入，并输出总成绩、平均成绩、最大成绩、最小成绩。再加上了对学生成绩的输入功能，如果输入的成绩部队不对就重新输入。
JAV A类和对象及数组习题 一、选择题 （1）下列构造方法的调用方式中，正确的是（D ）--原因：在通过new实例化一个类对象时系统会自动调用该类相应的构造方法。 A．按照一般方法调用B．由用户直接调用 C．只能通过new自动调用D．被系统调用 （2）在Java中，能实现多重继承效果的方式是（C ）--原因：一个类可以同时实现多个接口。Java接口反映了对象较高层次的抽象，还弥补了Java只支持单继承的不足，可用它来完成多继承的一些功能。 A．内部类B．适配器C．接口D．同步 （3）int型public成员变量MAX_LENGTH，该值保持为常数100，则定义这个变量的语句是( D )—原因：java中定义常量用关键字final来定义。 A．public int MAX_LENGTH=100 B．final int MAX_LENGTH=100 C．public const int MAX_LENGTH=100 D．public final int MAX_LENGTH=100 （4）下列叙述中，正确的是( A )—原因：Java严格区分大小写，所以变量number 与Number不相同；Java 中的注释方式除了“//”行注释之外还有段注释“/*-------*/”和文档注释/**-------*/。Java源文件中的public类只能有一个。 A. 声明变量时必须指定一个类型 B. Java认为变量number与Number相同 C. Java中唯一的注释方式是"//" D. 源文件中public类可以有0或多个 （5）下列叙述中，错误的是( D )—原因：子类继承父类，并且可以有自己的成员变量和成员方法。所以可以认为子类是父类的扩展。
计算机科学与技术实验报告 实验二类和对象(1) 姓名：易XX 班级：计科二班学号：2015110121 实验目的：深入理解类和对象，学会定义类，申明私有、公有变量，学会定义对象，并调用成员函数，解决实际问题。 实验内容： （一）、题目要求： 定义一个描述角度的类CAngle，包含的内容如下： (1)私有成员变量value，表示角度，类型为double； (2)公有成员变量SetValue，实现功能是使用形参为value赋值。 声明为：viod SetValue（double）； (3)公有成员函数GetCos，实现功能计算余弦值，并作为返回值返回。 声明为 double GetCos（）； 编程实现如下功能：定义一个Cangle类的对象deg，调用成员函数设置deg的角度为30度，调用成员函数计算并输出deg的余弦值。 代码： #include 试验四 类和对象的创建 一.类的定义 类是组成Java程序的基本要素。类封装了一类对象的状态和方法。类用来定义对象的模板。 类的实现包括两部分：类声明和类体。基本格式为： 修饰符class类名[extends父类名]{ /*类体的内容*/ } 1.类声明 以下是一个类声明的例子。 class People成为类声明，People是类名。习惯上，类名的第一个字母大写，但这不是必须的。类的名字不能是Java中的关键字，要符合标识符规定，即类的名字可以由字母、下划线、数字或美元符号组成，并且第一个字母不能是数字。但给类命名时，最好遵守下列规则： (1)如果类名使用拉丁字母，那么名字的首写字母使用大写字母，如Hello、Time、People等。 (2)类名最好容易识别，当类名由几个“单词”复合而成时，每个单词的首写字母使用大写，如BeijingTi me、AmericanGame、HelloChina等。 2.类体 编写类的目的是为了描述一类事物共有的属性和功能，描述过程由类体来实现。类声明之后的一对大括号“{”、“}”以及它们之间的内容称为类体，大括号之间的内容称为类体的内容。 类体的内容由两部分构成：一部分是变量的定义，用来刻画属性；另一部分是方法的定义，用来刻画功能。 下面是一个类名为“Trapezia”的类，类体内容的变量定义部分定义了4个float类型变量：top、bottom、h igh和laderArea，方法定义部分定义了两个方法：“getArea”和“setHigh”。 二.对象 1.对象的创建 创建一个对象包括对象的声明和为对象分配内存两个步骤。 (1)对象的声明。 一般格式为： 类的名字对象名字; 如： 这里People是类的名字，zhubajie是我们声明的对象的名字。 (2)为声明的对象分配内存。 使用new运算符和类的构造方法为声明的对象分配内存，如果类中没有构造方法，系统会调用默认的构造方法（你一定还记得构造方法的名字必须和类名相同这一规定），如： 例1： 「注」如果类里定义了一个或多个构造方法，那么Java不提供默认的构造方法。 2.对象的使用 对象不仅可以改变自己变量的状态，而且还拥有了使用创建它的那个类中的方法的能力，对象通过使用这些方法可以产生一定的行为。 通过使用运算符“.”，对象可以实现对自己的变量访问和方法的调用。 例2： 实验二类和对象的使用 班级：学号：姓名：成绩： 一．实验目的 1．掌握类和对象的概念、定义和使用方法。 2．掌握不同特性对象成员的访问方法。 二．使用的设备和仪器 计算机+Windows XP +Visual C++6.0 三．实验内容及要求 1．定义一个Book类，在该类定义中包括以下数据成员和成员函数： 数据成员：bookname（书名）、price（价格）、number（存书数量） 成员函数：set（）输入图书信息；display（）显示图书的情况；borrow（）将存书数量减1，并显示当前存书数量；restore（）将存书数量加1，并显示当前存书数量。 在主函数中，要求创建某一图书对象，并对该图书进行简单的显示、借阅和归还等管理。 2．定义一个中国好声音歌手类。其中，包括每个歌手的名字、年龄、来自哪个省份、所唱的曲目等。可以实现报名、显示、修改等功能。 3．定义一个时间类，实现课堂中第五节中的例2.2。 数据成员：时、分、秒 成员函数：输入时间、设置时间、按12小时制显示时间、按24小时制显示时间、增加1小时、减少1小时等功能。 4．定义一个学生类Student，要求如下： （1）数据成员包括学号、姓名、数学成绩、英语成绩和C++成绩；要求对所输入的成绩的合法性进行判断。 成员函数包括：设置学生的信息函数；输入学生的信息函数；输出学生的信息函数； 计算学生平均成绩的函数。 （2）添加新的数据成员：出生年月日；实现多个学生信息的添加、成绩的修改（一次只能修改一科成绩）等功能。要求单独定义一个日期类，并对所输入的出生年月日的合法性进行判断。 （3）设计一个菜单函数。 ****************************************************************** * * * 1.添加 2.设置 3.显示 4.修改成绩 5.计算平均分0.退出* * * Java编程面向对象——类与对象的关系 面向对象是一种组件化的设计思想，OOA、OOD、OOP 类与对象是整个面向对象之中最为基础的组成单元，如果需要给划出定义：类就是共性的集合，而对象是某一个性的产物；所有类实际上是用来描述一个对象的结构。 类是通过对象来使用的，而对象是通过类来创建的。 类与对象的基本定义： 在程序中，定义类，可以使用“class 类名称{}”的语法结构完成。 而类之中的组成主要有两点： * Field （属性、成员、变量），就是一推变量的集合 * Method （方法、行为），此时的方法是由对象调用的。 这个类中定义了两个属性和一个方法（可以定义更多属性和方法） *类虽然存在，但是类的使用，必须有对象； 对象的定义格式： 声明并实例化对象： 类名称对象名称 = new 类名称(); 分步完成： 声明对象：类名称对象名称 = null； 实例化对象：对象名称 = new 类名称(); 引用数据类型： 引用数据类型最大的不同在于需要内存的开辟及使用，所以关键字new 的主要功能就是开辟内存空间； 即：只要引用数据类型想使用，就必须使用关键字new 来开辟空间。 当一个对象实例化之后就可以使用以下方式利用对象来操作类的结构： 对象.属性：表示要操作类中属性内容 对象.方法()：表示要调用类中的方法内容 内存概念： 堆内存：保存每一个对象的属性内容，堆内存需要用关键字 new 才可以开辟； 栈内存：保存的是一块堆内存的地址。简单的理解，栈内存保存的是对象的名字； 编程中的栈内存和堆内存的操作过程： 引用数据的初步分析： 引用是整个 Java 开发中的核心精髓所在，即：只有掌握了“引用”这一概念之后，才能加入下一步学习，类似C/C++ 中的指针概念。 在所有的引用分析里面，最关键的还是在于关键字 “new ”，每一次使用关键字new ，都会开辟新的堆内存空间，如果你的代码里面声明两个对象，并且使用了关键字new 为两个对象分别实例化操作，那么一定是各自占有各自(独立)的堆内存空间 1.实现简易计算器，分别实现两个整数、三个浮点数的加法运算.（用JAVA中的类和对象） 源码如下： package days;//包名自己修改 import java.util.Scanner;//注意别忘记导入这个包名了public class NumSum { public int add(int num1,int num2){ return num1+num2; } public double add(double num1,double num2,double num3){ return num1+num2+num3; } public static void main(String[] args) { // TODO Auto-generated method stub NumSum nc=new NumSum(); NumSum nc1=new NumSum(); //调用2个整数相加的方法 //Scanner是用键盘手动输入数字。 System.out.println("请用键盘手动输入两个整数："); System.out.println(nc.add(new Scanner(System.in) .nextInt(),new Scanner(System.in).nextInt())); //调用3个浮点数相加的方法 System.out.println("请用键盘手动输入三个浮点数："); System.out.println(nc1.add(new Scanner(System .in).nextDouble(), new Scanner(System.in).nextDouble( ), new Scanner(System.in).nextDouble())); } } 从C到O b j e c t i v e C类 和对象续 集团文件发布号：（9816-UATWW-MWUB-WUNN-INNUL-DQQTY- 从 C++ 到 Objective-C（4）：类和对象（续） 作者:日期: 2011 年 03 月 19 日(9) 方法 Objective-C 中的方法与 C++ 的函数在语法方面风格迥异。下面，我们就来讲述 Objective-C 的方法。 原型、调用、实例方法和类方法 以–开头的是实例方法（多数情况下都应该是实例方法）； 以 + 开头的是类方法（相当于 C++ 里面的 static 函数）。 Objective-C 的方法都是 public 的； 返回值和参数的类型都需要用小括号括起来； 参数之间使用冒号：分隔； 参数可以与一个标签 label 关联起来，所谓标签，就是在 : 之前的一个名字。标签被认为是方法名字的一部分。这使得方法 比函数更易读。事实上，我们应该始终使用标签。注意，第一个 参数没有标签，通常它的标签就是指的方法名； 方法名可以与属性名相同，这使 getter 方法变得很简单。 C++ // 原型 void Array::insertObject(void*anObject, unsigned int atIndex); // shelf 是 Array 类的一个实例，book 是一个对象 shelf.insertObject(book, 2); Objective-C（不带 label，即直接从 C++ 翻译来） // 方法原型 // 方法名字是“insertObject::” // 这里的冒号:用来分隔参数，成为方法名的一部分（注意，这不同于C++ 的域指示符::） -(void) insertObject:(id)anObject:(unsigned int)index // shelf 是 Array 类的一个实例，book 是一个对象 [shelf insertObject:book:2]; Objective-C（带有 label） // 方法原型。“index” 有一个标签“atIndex” // 方法名为“insertObject:atIndex:” // 这样的话，调用语句就很容易阅读了 -(void) insertObject:(id)anObject atIndex:(unsigned int)index // shelf 是 Array 类的一个实例，book 是一个对象 [shelf insertObject:book:2]; // 错误！ [shelf insertObject:book atIndex:2]; // 正确 注意，方括号语法不应该读作“调用 shelf 对象的 insertObject 方法”，而应该是“向 shelf 对象发送一个 insertObject 消息”。这是Objective-C 的实现方式。你可以向任何对象发送任何消息。如果目标对象不能处理这个消息，它就会将消息忽略（这会引发一个异常，但不 一选择题 1.下面方法定义中，正确的是： A)int x(int a,b){return a-b;} B)double x(int a,int b){int w;w=a-b;} C)double x(a,b){return b;} D)int x(int a,int b){return a-b;} 2.下面方法定义中，不正确的是： A)float x(int a,int b){return a-b;} B)int x(int a,int b){return a-b;} C)int x(int a,int b){return a*b;} D)int x(int a,int b){return 1.2*(a-b);} 3下面方法定义中，正确的是： A)int x(){char ch='a';return (int)ch;} B)void x(){return true;} C)int x(){return true;} D)int x(int a,b){return a-b;} 4设X 、Y 均为已定义的类名，下列声明类X的对象x1的语句中正确的是? X x1=new X(); B)X x1= X ( ); C)X x1=new Y( ); D)int X x1; 5设A为已定义的类名，下列声明并创建A 类的对象a的语句中正确的是? A)A a=new A( ); B)public A a=A( ); B)C)A a=new class( ); D)a A; 6下面类的定义中结构正确的是？ A)class A B)class 2A C)int class A D)public class A （） 7下面关于类的结构的说法正确的是？ A)类只能包含一个构造方法 B)类可以没有属性 C)类只能包含方法 D)类只能包含属性 8下面哪个关键字在定义类头时用不到？ A)class B)public C)extends D)int33 9 this在程序中代表的是？ A)类的对象 B)属性 C)方法 D)父类 10下列对构造方法的调用方式的描述中正确的是? A)使用new调用 B)使用类名调用 C)使用对象名调用 c类和对象练习题 Standardization of sany group #QS8QHH-HHGX8Q8-GNHHJ8-HHMHGN# 第8章类与对象 8．1知识要点 1．掌握类与对象的概念和定义方法，掌握类成员的访问属性。 2．掌握构造函数的概念、定义方法和使用方法。 3．掌握析构函数的概念、定义方法和使用方法。 4．掌握拷贝构造函数的概念、定义方法和使用方法。 5．掌握包含对象成员的类构造函数的定义方法。 6．掌握静态成员的概念、定义方法、作用和特点。 7．掌握友元的概念、定义方法、作用和特点。 8．掌握类模板的定义格式与使用方法。 8．2典型例题分析与解答 例题1：下列有关类的说法不正确的是（）。 A．对象是类的一个实例 B．任何一个对象只能属于一个具体的类 C．一个类只能有一个对象 D．类与对象的关系和数据类型与变量的关系相似 答案：C 分析：对象是类的一个实例，类与对象的关系和数据与变量的关系相似，所以一个类可以有多个对象。 例题2：下面（）项是对构造函数和析构函数的正确定义。 A．void X::X(), void X::~X() B．X::X(参数),X::~X() C．X::X(参数),X::~X(参数) D．void X::X(参数),void X::~X(参数) 答案：B 分析构造函数无返回类型、可带参数、可重载；析构函数无返回类型、不可带参数、不可重载。 例题3：（）的功能是对象进行初始化。 A．析构函数B. 数据成员 C.构造函数 D.静态成员函数 答案：C 分析：当一个对象定义时，C++编译系统自动调用构造函数建立该对象并进行初始化；当一个对象的生命周期结束时，C++编译系统自动调用析构函数注销该对象并进行善后工作； 例题4：下列表达方式正确的是（）。 A．class P{B．class P{ public： public： int x=15； int x； voidshow(){cout< 类与对象 知识要点 1．掌握类与对象的概念和定义方法，掌握类成员的访问属性。 2．掌握构造函数的概念、定义方法和使用方法。 3．掌握析构函数的概念、定义方法和使用方法。 4．掌握拷贝构造函数的概念、定义方法和使用方法。 5．掌握包含对象成员的类构造函数的定义方法。 6．掌握静态成员的概念、定义方法、作用和特点。 7．掌握友元的概念、定义方法、作用和特点。 8．掌握类模板的定义格式与使用方法。 典型例题分析与解答 例题1：下列有关类的说法不正确的是（）。 A．对象是类的一个实例 B．任何一个对象只能属于一个具体的类 C．一个类只能有一个对象 D．类与对象的关系和数据类型与变量的关系相似 答案：C 分析：对象是类的一个实例，类与对象的关系和数据与变量的关系相似，所以一个类可以有多个对象。 例题2：下面（）项是对构造函数和析构函数的正确定义。 A．void X::X(), void X::~X() B．X::X(参数), X::~X() C．X::X(参数), X::~X(参数) D．void X::X(参数), void X::~X(参数) 答案：B 分析构造函数无返回类型、可带参数、可重载；析构函数无返回类型、不可带参数、不可重载。 例题3：（）的功能是对象进行初始化。 A．析构函数 B. 数据成员 C.构造函数 D.静态成员函数 答案：C 分析：当一个对象定义时，C++编译系统自动调用构造函数建立该对象并进行初始化；当一个对象的生命周期结束时，C++编译系统自动调用析构函数注销该对象并进行善后工作； 例题4：下列表达方式正确的是（）。 A．class P{ B． class P{ public： public： int x=15； int x； void show(){cout< 实验二类与对象 一、实验目的 1、学习类与对象的定义，掌握类与对象的使用方法。 2、学习数据成员与成员函数的访问方式，理解构造函数和析构函数的定义与执行过程，学会构造函数的重载方法。 3、掌握数组与指针的定义与使用方法，理解数组与指针的存储分配与表示。 4、掌握用指针和引用向函数传递参数。 5、掌握静态数据成员和静态成员函数的使用。 6、理解友元与友元函数的作用与使用方法。 二、实验内容 1、下面是一个计算器类的定义，请完成该类成员函数的实现。 class Counter { public: Counter(int number); void increment(); //给原值加1 void decrement(); //给原值减1 int getValue(); //取得计数器值 int print(); //显示计数 private: int value; }; #include private: int value; }; void count::increment() { int a=value+1; } void count::decrement() { int b=value-1; } int count::getvalue(int s) { value=s; return 0; } int count::print() { cout< 6.1实验目的和要求 1．熟悉面向对象的基本概念。 2．进一步掌握类的各种成员的使用方法。 3．掌握对象之间通信的基本方法。 6.2实验内容与步骤 题目1 点和直线类 （1）创建C#控制台应用程序L6_1。 （2）在程序中新建一个点类CzPoint，为其定义两个double类型的私有字段成员x和y，分别表示点的横坐标和纵坐标。 （3）为CzPoint定义两个公有属性X、Y，分别用于封装对字段x 和y的读写访问。 （4）定义CzPoint的带参构造函数，在其中对字段x和y进行初始化。参考源代码如下： public CzPoint(double x, double y) { this.x = x; this.y = y; } （5）为CzPoint定义公有方法Move，用于按指定的水平距离和垂直距离移动坐标点。参考源代码如下： public void Move(double dx, double dy) { x += dx; y += dy; } （6）对CzPoint类进行相等和不相等操作符重载。两个坐标点相等，是指它们的横坐标和纵坐标都相等。 （7）在程序主方法中创建坐标为（1,2）和（3,3）的两个坐标点对象，判断它们是否相等；而后将第一个坐标点移动到第二个坐标点上，再判断它们是否相等。 （8）在程序中再新建一个直线类CzLine，为其定义两个double类型的字段成员a和b，分别表示直线的斜率和截距；再定义字段的封装属性A和B，但它们都是只读的。 （9）为CzLine定义两个构造函数，一个根据斜率和截距来创建直线对象，另一个则根据两个CzPoint对象来构造直线对象（直线穿过这两个点）。后一个的参考源代码如下： public CzLine(CzPoint p1, CzPoint p2) { if (p1 == p2) throw new ArgumentException("两点不能相同"); this.a = (p2.Y - p1.Y) / (p2.X - p1.X); this.b = p1.Y - this.a * p1.X; } （10）为CzLine定义公有方法Move,但它只用于平移直线，而不改变直线的斜率。再为其定义公有方法Contains,用于判断某点是否在该直线上。 （11）类似的，为CzLine重载相等和不等操作符。 （12）最后在程序主方法中采用不同的方式创建直线对象，并编译运行程序，测试它们的使用效果。 程序的整体结构如下： 类和对象的概念 类(Class) 面向对象思想来源于对现实世界的认知。现实世界缤纷复杂、种类繁多，难于认识和理解。但是聪明的人们学会了把这些错综复杂的事物进行分类，从而使世界变得井井有条。比如我们由各式各样的汽车抽象出汽车的概念，由形形色色的猫抽象出猫的概念，由五彩斑斓的鲜花抽象出花的概念等。汽车、猫、鲜花都代表着一类事物。每一类事物都有特定的状态，比如汽车的品牌、时速、马力、耗油量、座椅数，小猫的年龄、体重、毛色，鲜花的颜色、花瓣形状、花瓣数目，都是在描述事物的状态。每类事物也都有一定的行为，比如汽车启动、行驶、加速、减速、刹车、停车，猫捉老鼠，鲜花盛开。这些不同的状态和行为将各类事物区分开来。 面向对象编程也采用了类的概念，把事物编写成一个个“类”。在类中，用数据表示事物的状态，用函数实现事物的行为，这样就使编程方式和人的思维方式保持一致，极大的降低了思维难度。 封装(Encapsulation) 制造汽车的过程中什么人最牛？当然不是焊钢板的，也不是装轮胎的，更不是拧螺丝的，而是设计汽车的工程师，因为他知道汽车的运行原理。但是我们开车时，需要知道汽车的运行原理吗？答案显然不需要。汽车的运行原理已经被伟大的工程师封装在汽车内部，提供给司机的只是一个简单的使用接口，司机操纵方向盘和各种按钮就可以灵活自如的开动汽车了。 与制造汽车相似，面向对象技术把事物的状态和行为的实现细节封装在类中，形成一个可以重复使用的“零件”。类一旦被设计好，就可以像工业零件一样，被成千上万的对其内部原理毫不知情的程序员使用。类的设计者相当于汽车工程师，类的使用者相当于司机。这样程序员就可以充份利用他人已经编写好的“零件”，而将主要精力集中在自己的专署领域。 接口(Interface) 今天你买了一台等离子电视机，你拿出遥控器，操纵按钮，开始欣赏精彩的电视节目。人们通过遥控器这个接口使用电视机，同样，人们通过类的接口使用类。程序员在编写类时精心地为它设计接口，而设计良好的接口不但方便其他程序员使用，还有利于类的升级改造。 假设你是一个环保人士，最近你用节能的荧光灯代替了普通的白炽灯。白炽灯通过加热电阻丝照亮整个屋子；荧光灯则是激活空气中的某些分子的电子能而发光。虽然它们的原理不同，但是它们的功能却是一样的——照明。因为两种灯具有相同的接口，所以你只需拧下白炽灯，然后再拧上荧光灯即可，轻易的实现“零件”的更新换代。同样，在面向对象编程中，只要保持接口不变，你可以任意更改类的实现细节，用一个设计更好的类替换原来的类，实现类的升级换代。 现在软件维护和修改的成本已经占到了整个软件开发的80%，类的这一编成思想极大的方便了程序的维护和修改，降低了软件成本。 实验报告 一、实验项目：类与对象 二、实验目的： 1. 学会使用类来封装对象的属性和功能 2. 掌握类变量与实例变量，以及类方法与实例方法的区别 3. 掌握使用package和import语 三、实验器材：计算机、Java编程软件JCreator 四、实验原理（或仪器装置图）： 1. 类与对象 类是组成Java程序的基本要素。类封装了一类对象的状态和方法。类是用来定义对象的模板。 类声明 class 类名{ 类体 } 对象的声明 一般格式为： 类的名字对象名字; 定义对象引用后，用new运算符完成对象的创建工作，分配存储空间，并对其初始化。 变量名=new 类名([构造方法实参表]); 对象的使用 访问成员的基本语法形式如下： 对象名.变量成员名 对象名.方法成员名([实际参数表]) 2.成员变量和局部变量 成员变量格式：[修饰符] 变量类型变量名[=初值]; 成员方法： 格式:[修饰符] 返回值的数据类型方法名（参数1，参数2，…） { 语句序列； return[表达式]; } 类中定义的变量是成员变量，而方法中定义的变量是局部变量。 3. 构造方法 构造方法是一种特殊的方法，创建对象时被自动调用。与一般的方法不同，它没有返回值类型的说明，方法体中也不可以用return语句带回返回值。构造方法的方法名与类名相同 在构造方法中可以通过this关键字调用该类中其他的构造方法。 4.包 包是Java语言中有效地管理类的一个机制。 ①通过关键字package声明包语句。package 语句作为Java源文件的第一条语句，指明该 源文件定义的类所在的包。package语句的一般格式为：package 包名; ②import 语句：使用import 语句可以引入包中的类。 五、实验步骤及数据记录：JAVA类与对象的创建
实验二 类和对象的使用_参考答案
Java实例对象概念图解
java类和对象的例子
从C到ObjectiveC类和对象续修订稿
类与对象的复习与练习
c类和对象练习题
类与对象答案
实验二 类与对象
类和对象
类和对象的概念
Java类与对象实验报告
相关主题
文本预览