java实验报告2 继承多态 封装

java实验报告2 继承多态 封装
java实验报告2 继承多态 封装

实验报告

学生姓名:学号:专业班级:

实验类型:□验证□综合□设计□创新实验日期:实验成绩:

一、实验项目名称抽象、封装与类(一)

二、实验目的

1.掌握抽象、封装、继承和多态

2.熟练掌握如何自定义一个类。

3.掌握类的访问权限

4.掌握类成员的访问控制

三、实验基本原理

四、主要仪器设备及耗材

Myclipse

五、实验步骤

1、调试程序例3-4

2、编写如下程序。

(1)定义一个表示学生的类Student,包括属性“学号”、“班号”、“姓名”、“性别”、“年龄”;方法“获得学号”、“获得班号”、“获得姓名”、“获得性别”、“获得年龄”、“修改年龄”。

(2)为Student类定义构造函数初始化所有属性,增加一个方法public String toString(),把Student类对象的所有属性信息组合成一个字符串输出。

(3)在main()中创建Student类对象,测试自定义类。

六、实验数据及处理结果

1、package ncu;

— 2

public class Exam3_4 {

static double d;

public static void main(String args[]){

int i;

Exam3_4 pt=new Exam3_4();

i=5;

pt.changeInt(i);

System.out.println("int type value is:"+i);

pt.d=6.25;

pt.changeDouble(pt);

System.out.println("double type value is"+d);

}

public void changeInt(int v)

{v=10;}

public void changeDouble(Exam3_4 ref)

{ref.d=10.5;}

}

— 3

2、package ncu;

public class student {

private int id;

private String name;

private String tel;

private String addr;

private static int total;

public int getid(){

return this.id;

}

public void setid(int id){

— 4

this.id=id;

}

public String getname(){

return name;

}

public void setname(String name){

t https://www.360docs.net/doc/7218425805.html,=name;

}

public String gettel(){

r eturn tel;

}

public void settel(String tel){

t his.tel=tel;

}

public String getaddr(){

r eturn addr;

}

public void setaddr(String addr){

t his.addr=addr;

}

public student(){

t otal++;

i d=total;

}

public student(String name){

t otal++;

i d=total;

t https://www.360docs.net/doc/7218425805.html,=name;

— 5

}

public String toString(){

String s="id:"+id

+" name:"+name

+" tel:"+tel

+" addr:"+addr;

return s;

}

public static void main(String[]args){

student stu1=new student ("zhangsan");

stu1.settel("123456");

stu1.setaddr("nanchang");

System.out.print(stu1.toString());

}

七、思考讨论题或体会或对改进实验的建议

八、参考资料

— 6

实验6 多态性(一)

福建农林大学实验报告 实验6 多态性(一) 一、实验目的和要求 (1)掌握虚函数的定义与使用方法,进一步理解多态性的概念和分类。 (2)了解纯虚函数和抽象类的使用方法。 二、实验内容和原理 1、分析并调试下列程序,回答以下问题:(1)指出抽象类(2)指出虚函数,并说明它的作用(3)每个类的作用是什么?整个程序的作用是什么? 2、使用虚函数编写程序求球体、圆柱体和圆锥的体积,由于球体、圆柱体和圆锥都可以看做由圆继 承而来,所以可以定义圆类作为基类。在圆类中定义数据成员半径和一个求体积的虚函数。由圆类 派生出球体类、圆柱体类和圆锥类,在派生类中对圆类中的虚函数重新定义。编写一个外部函数求 各类形状的总体积。最后在main()函数中构造若干形状,并求它们的体积和。

三、实验环境 1. 硬件:PC机; 2. 软件:Windows操作系统、Visual C++ 6.0 四、算法描述及实验步骤 1、算法描述及步骤如下: (1)根据题目要求编写好程序代码并在VC环境下输入源程序。 (2)检查程序有无错误(包括语法错误和逻辑错误),有则改之。 (3)编译和连接,仔细分析编译信息,如有错误应找出原因并改正之。本题改正后的代码如下: #include const double PI=3.1415; class Shap { public:virtual double Area()=0; }; class Triangle:public Shap { public:Triangle(double h,double w) { H=h; W=w; } double Area() { return 0.5*H*W; } private:double H,W; }; class Circle:public Shap { public:Circle(double r) { R=r; } double Area() { return PI*R*R; } private:double R; }; double Total(Shap*s[],int n) { double sum=0; for(int i=0;i

实验04 类的继承与多态

实验四类的继承与多态 一、实验目的 1.掌握构造方法和成员方法重载的应用。 2.理解类的继承性的作用 3.领会面向对象编程的多态性。 二、实验内容与要求 基本概念 1.进一步理解继承的含义 新类可从现有的类中产生,并保留现有类的成员变量和方法并可根据需要对它们加以修改。新类还可添加新的变量和方法。这种现象就称为类的继承。 当建立一个新类时,不必写出全部成员变量和成员方法。只要简单地声明这个类是从一个已定义的类继承下来的,就可以引用被继承类的全部成员。被继承的类称为父类或超类(superclass),这个新类称为子类。 Java 提供了一个庞大的类库让开发人员继承和使用。设计这些类是出于公用的目的,因此,很少 有某个类恰恰满足你的需要。你必须设计自己的能处理实际问题的类,如果你设计的这个类仅仅实现了继承,则和父类毫无两样。所以,通常要对子类进行扩展,即添加新的属性和方法。这使得子类要比父类大,但更具特殊性,代表着一组更具体的对象。继承的意义就在于此。 2.了解成员变量的隐藏方式 所谓隐藏是指子类重新定义了父类中的同名变量,在子类L ine 中重新定义了x为x1,y 为y1,隐藏了父类Point 中的两个成员变量x 和y。子类执行自己的方法时,操作的是子类的变量,子类执行父类的方法时,操作的是父类的变量。在子类中要特别注意成员变量的命名,防止无意中隐藏了父类的关键成员变量,这有可能给程序带来麻烦。 3.了解成员方法的覆盖方式 (1)方法覆盖的定义与作用通过继承子类可以继承父类中所有可以被子类访问的成员方法,但如果子类的方法与父类方法同名,则不能继承,此时称子类的方法覆盖了父类的方法,简称为方法覆盖(override)。方法覆盖为子类提供了修改父类成员方法的能力。 4.理解类的多态性类的继承发生在多个类之间,而类的多态只发生在同一个类上。在一个类中,可以定义多个同名的方法,只要确定它们的参数个数和类型不同。这种现象称为类的多态。多态使程序简洁,为程序员带来很大便利。在O OP 中,当程序要实现多个相近的功能时,就给相应的方法起一个共同的名字,用不同的参数代表不同的功能。这样,在使用方法时不论传递什么参数,只要能被程序识别就可以得到确定的结果。 类的多态性体现在方法的重载(overload)上,包括成员方法和构造方法的重载。 实践应用

java实验报告有理数的类封装

华中科技大学文华学院 《Java程序设计》实验报告 实验三:有理数的类封装 专业班级:通信工程2008级1班姓名: 学号: 时间:

实验三:有理数的类封装 1、实验目的: 让学生学习使用类来封装对象的属性和功能。 2、实验要求: 希望程序能对分数(分子分母都是整数)进行四则运算,而且两个分数四则运算的结果仍然是分数。分数也称有理数。本实验要求用类实现对有理数的封装。有理数有两个重要的成员:分子和分母,另外还有重要的四则运算。 编写一个java应用程序,该程序中有一个Rational(有理数)类,具体要求如下: ※Rational类有两个int型的成员变量,名字分别为numberator(分子)和denominator(分母)。 ※提供Rational add(Rational r)方法,即有理数调用该方法与参数指定的有理数做加法运算,并返回一个 Rational对象。 ※提供Rational sub(Rational r)方法,即有理数调用该方法与参数指定的有理数做减法运算,并返回一个 Rational对象。 ※提供Rational muti(Rational r)方法,即有理数调用该方法与参数指定的有理数做乘法运算,并返回一个 Rational对象。 ※提供Rational div(Rational r)方法,即有理数调用该方法

与参数指定的有理数做除法运算,并返回一个Rational 对象。 3、程序效果图 4、程序代码(主要语句有注释!) 5、实验思考问题 6、实验总结及心得 附录:程序摸版 Rational.java public class Rational { int numerator,denominator; Rational(){} Rational(int a,int b){ setNumeratorAndDenominator(a,b); } void setNumeratorAndDenominator(int a,int b){ //设置分子和分母 int c=f(Math.abs(a),Math.abs(b)); //计算最大公约数 numerator=a/c; denominator=b/c; if(numerator<0&&denominator<0){

JAVA继承和多态实验报告

实验项目名称:继承和多态 (所属课程:Java语言程序设计) 院系:专业班级:姓名: 学号:实验地点:指导老师: 本实验项目成绩:教师签字:日期: 1.实验目的 (1)掌握类的继承机制。 (2)熟悉类中成员变量和方法的访问控制。 (3)熟悉方法或构造方法多态性。 2.实验内容 (1)模拟编写程序,理解类的继承、多态、继承和多态规则。 (2)独立编程,实现类的继承和多态。 3.实验作业 设计一个类Shape(图形)包含求面积和周长的area()方法和perimeter()方法以及设置颜色的方法SetColor(),并利用Java多态技术设计其子类Circle(圆形)类、Rectangle (矩形)类和Triangle(三角形)类,并分别实现相应的求面积和求周长的方法。每个类都要覆盖toString方法。 海伦公式:三角形的面积等于s(s-a)(s-b)(s-c)的开方,其中s=(a+b+c)/2 程序代码为: Class包 package Class; public class Shape { private String color = "while"; public Shape(String color){ this.color = color; } public void setColor(String color){ this.color = color; } public String getColor(){ return color;

} public double getArea(){ return 0; } public double getPerimeter(){ return 0; } public String toString(){ return"color:" + color; } } package Class; public class Circle extends Shape { private double radius; public Circle(String color,double radius) { super(color); this.radius = radius; } public void setRadius(double radius){ this.radius = radius; } public double getRadius(){ return radius; } public double getCircleArea(){ return 3.14*radius*radius; } public double getCirclePerimeter(){ return 3.14*2*radius; } public String toString(){

实验六继承性与多态性

湖北工业大学工程技术学院实验报告 课程名称:面向对象程序设计实验内容:实验六继承性与多态性 学院:工程技术学院专业班级: 姓名:学号:指导教师: 实验日期:实验地点: 一、实验目的 1、1、了解多态性的概念。 2、2、了解虚函数的作用及使用方法。 3、3、了解纯虚函数和抽象类的概念和用法。 二、实验步骤 1.设计一个类层次,其中的基类为Date,它拥有一个相关数据成员及一个虚函 数print,从Date类派生ShortE、MediumDate和LongDate类,Date的print 函数使用日期格式:11-26-2015, ShortE的print函数使用日期格式:26-11-2015 MediumDate的print函数使用日期格式:Nov.26,2015 LongDate的print函数使用日期格式:November 26, 2015 编写一个程序来测试各个类的print函数。 #include using namespace std; class Date { protected: int year,month,day; public: Date(int y,int m,int d) { year=y; month=m;

day=d; } virtual void print() { cout<

实验四 多态性

实验四多态性 一、实验目的 1、掌握运算符重载的基本方法。 2、掌握友元运算符函数和成员运算符函数的使用方法及两者之间的不同。 3、学习虚函数的定义与使用方法。 4、了解静态多态性和动态多态性。 5、学习使用虚函数和继承实现动态多态性。 二、试验内容 1、编写一个程序,要求: (1)生明一个类Complex(复数类),定义类Complex的两个对象c1和c2,对象c1通过构造函数直接指定复数的实部和虚部(类私有数据成员为double类型:real和imag)为2.5及3.7,对象c2通过构造函数直接指定复数的实部和虚部为4.2及6.5; (2)定义友元运算符重载函数,它以c1、c2对象为参数,调用该函数时能返回两个复数对象相加操作; (3)定义成员函数print,调用该函数时,以格式“real+imag i”输出当前对象的实部和虚部,例如:对象的实部和虚部分别是4.2和6.5,则调用print函数输出格式为:4.2+6.5 i; (4)编写主程序,计算出复数对象c1和c2相加结果,并将其结果输出。 #include class complex{ private: double real; double imag; public: complex(double r=0.0,double i=0.0); void print(); friend complex operator+(complex &a,complex &b); };

complex::complex(double r,double i) { real=r; imag=i; } complex operator+(complex &a,complex &b) {complex temp; temp.imag=a.imag+b.imag; temp.real=a.real+b.real; return temp; } void complex::print() { cout<

JAVA面向对象基础测试题,继承,封装,多态等测试题

JAVA面向对象基础测试题 提示:本题为第一阶段,JAVA面向对象基础部分练习题,包括对象,类,继承,封装,多态,接口,内部类等等,java核心基础,适合初学者对面向对象基础的知识进行测试,以便查漏补缺。 1. 程序执行的结果是:()。 01 public class Point{ 02 int y = 7; 03 public void step(int y) { 04 y += y; 05 System.out.println(y); 06 } 07 public static void main(String[] args) { 08

Point p = new Point(); 09 p.step(10); 10 } 11 } A.14 B.20 C.10 D.17 正确答案:B解析: 2. 程序的执行结果是:()。 01 public class Question { 02 private int num; 03 public static void main(String [] args){ 04 Question q = new Question();

05 q.num=13; 06 update(q); 07 System.out.println(q.num); 08 } 09 public static void update(Question q){ 10 q.num=9; 11 } 12 } A.13 B.9 C.0 D.4 正确答案:B解析: 3.

程序执行的结果是:()。 01 public class Answer { 02 public static void main(String[] args) { 03 int score = 20; 04 Answer ans= new Answer(); 05 ans.add(score); 06 System.out.println(" main:score = " + score); 07 } 08 void add(int score) { 09 System.out.println(" add:score=" + score++); 10 } 11

Java继承与多态实验报告

西安邮电大学 (计算机学院) 课内实验报告 实验名称:继承与多态 专业名称:计算机科学与技术 班级:计科1405班 学生姓名:高宏伟 学号:04141152 指导教师:刘霞林 实验日期:2016.10.13

一、实验目的 通过编程和上机实验理解Java 语言的继承和多态特性,掌握变量的隐藏、方法的覆盖、重载,掌握抽象类和接口的使用。 二、实验要求 1.编写体现类的继承性(成员变量、成员方法、成员变量隐藏)的程序。 2.编写体现类的多态性(成员方法重载)的程序。 3.编写体现类的多态性(构造方法重载)的程序。 4.编写使用接口的程序。 三、实验内容 (一)类的继承 1.创建公共类Student. (1)编写程序文件Student.java,源代码如下: public class Student { protected String name; //具有保护修饰符的成员变量 protected int number; void setData(String m,int h) //设置数据的方法 { name =m; number= h; } public void print() //输出数据的方法 { System.out.println(name+", "+number); } } (2)编译Student.java,产生类文件Student.class。 2.创建继承的类Undergraduate

(1)程序功能:通过Student 类产生子类undergraduate,其不仅具有父类的成员变量name()、number(学号),还定义了新成员变量academy(学院)、department (系)。在程序中调用父类的print 方法。 (2)编写Undergraduate 程序: class Undergraduate extends Student { 【代码1】//定义成员变量academy 【代码2】//定义成员变量department public static void main(String args[]) { 【代码3】//创建一个学生对象s 【代码4】//用父类的setData方法初始化对象s 【代码5】//对象s调用print方法 【代码6】//创建一个大学生对象u 【代码7】//调用父类的成员方法setData初始化对象u 【代码8】//设置对象u的成员变量academy 【代码9】//设置对象u的成员变量department System.out.print(https://www.360docs.net/doc/7218425805.html,+", "+u.number+", "+u.academy+", "+u.department); } } (3)编译并运行程序 注意:公共类Student 与undergraduate 类要在同一文件夹(路径)。 (二)方法的重载 (1)程序功能:对不同的数进行排序输出。在IntSort 类中定义3 个同名的方法sort。 (2)编写Sort.java 文件,源代码如下。 import java.awt.Graphics; import java.applet.Applet; class IntSort { public String sort(int a, int b) { if (a>b) return a+""+b; else return b+""+a; } public String sort(int a, int b, int c) { int swap; if (a

实验2 类的封装性和继承性设计实验

实验2 类的封装性和继承性设计实验 一、实验目的 理解面向对象封装性、继承性和多态性的基本概念,掌握声明类、封装类、继承类以及运行时多态性的实现方法。 二、实验内容 1.程序理解: 1)设计复数类

2)在构造方法中使用this 3)Static 关键字的使用:

2.编程题: (1) 请按照以下要求设计一个Student类,并进行测试。 要求如下: 1)Student类中包含姓名、成绩两个属性。 2)分别给这两个属性定义两个方法,一个方法用于设置值,另一个方 法用于获取值。 3)Student类中定义一个无参的构造方法和一个接受两个参数的构造 方法,两个参数分别为姓名和成绩属性赋值。 4)在测试类中创建两个Student对象,一个使用无参构造方法,然 后调用方法给姓名和成绩赋值,另一个使用有参的构造方法,在构造 方法中给姓名和成绩赋值。 (提示:注意成员变量和成员方法的访问权限设置,使用this解决成 员变量与局部变量名称冲突的问题) (2) 1) 设计一个类,设计它的一个无参数构造方法,构造方法中打印一条消息。main方法创建这个类的一个对象,观察打印结果。 2) 在练习1)的基础上增加一个重载的构造方法,采用一个String 参数,并在构造方法中把这个String消息打印出来。创建这个类的 对象,观察打印结果。 3) 以练习2)创建的类为基础上,创建属于它的实例对象的一个数组, 但不要实际创建对象并分配到数组里。运行程序时,注意是否打印出 来自构建方法调用的初始化消息?为数组中每个变量创建对象,观察 打印结果? (3) 请按照以下要求设计一个Outer类。 要求如下: 1)定义一个外部类Outer,并在该类中定义一个静态内部类Inner。

C 的封装性、继承性和多态性概念

C++的封装性、继承性和多态性概念 封装的目的是增强安全性和简化编程,使用者不必了解具体的实现细节,而只是要通过外部接口,一特定的访问权限来使用类的成员。例如,在抽象的基础上,我们可以将时钟的数据和功能封装起来,构成一个时钟类。按c++的语法,时钟类的声明如下:class Clock { public: //共有成员,外部借口void SetTime(int NewH,int NewM,int NewS); void ShowTime(); private: //私有成员,外部无法访问int Hour,Minute,Second; } 可以看到通过封装使一部分成员充当类与外部的接口,而将其他的成员隐蔽起来,这样就达到了对成员访问权限的合理控制,使不同类之间的相互影响减少到最低限度,进而增强数据的安全性和简化程序的编写工作。什么是多态(Polymorphisn)?按字面的意思就是“多种形状”。引用Charlie Calverts对多态的描述——多态性是允许你将父对象设置成为和一个或更多的他的子对象相等 的技术,赋值之后,>>>父对象就可以根据当前赋值给它的子对象的特性以不同的方式运作<<<(摘自“Delphi4 编程技术内幕”)。简单的说,就是一句话:允许将子类类型的指针赋值给父类类型的指针。多态性在Object Pascal和C++中都是通过虚函数(Virtual Function)实现的。好,接着是“虚函数”(或者是“虚方法”)。虚函数就是允许被其子类重新定

义的成员函数。而子类重新定义父类虚函数的做法,称为“覆盖”(override),或者称为“重写”。“继承”是面向对象软件技术当中的一个概念。如果一个类A继承自另一个类B,就把这个A称为"B的子类",而把B称为"A的父类"。继承可以使得子类具有父类的各种属性和方法,而不需要再次编写相同的代码。在令子类继承父类的同时,可以重新定义某些属性,并重写某些方法,即覆盖父类的原有属性和方法,使其获得与父类不同的功能。 ... 继承是指一个对象直接使用另一对象的属性和方法。事实上,我们遇到的很多实体都有继承的含义。例如,若把汽车看成一个实体,它可以分成多个子实体,如:卡车、公共汽车等。这些子实体都具有汽车的特性,因此,汽车是它们的"父亲",而这些子实体则是汽车的"孩子"。19. 多态的作用?主要是两个:1. 隐藏实现细节,使得代码能够模块化;扩展代码模块,实现代码重用; 2. 接口重用:为了类在继承和派生的时候,保证使用家族中任一类的实例的某一属性时的正确调用。

《java面向对象程序设计-继承和多态》教案

第四章 面向对象的概念和 Java 实现-2 回顾 ?类是具有相同属性和行为的一组对象的集合 , 对象是类的实例 ?封装是隐藏对象实现细节的过程,以便不让用户看到实现的细节 ?类可用Class 来定义,类的变量和方法可被该类的实例访问, 圆点符号用于访问对象的成员,构造函数在创建对象时初始化对象 ?包可用package 来申明,可用import 来导入包 目标 ?理解继承及其特点 ?运用JAVA程序实现继承 ?理解多态及其特点设计 ?运用JAVA程序实现多态 ?掌握访问修饰符和方法修饰符 继承 继承的特点 继承的优点 继承的JAVA实现 子类构造方法 2-1 子类构造方法 2-2 ?调用父类构造方法的语法为: super() 或 super(参数列表) ; ?super () 方法始终指向调用类的父类 调用父类构造方法 演示:示例 3 多态性 2-1 ?多态性是指?°多种形式?± ?它使用不同的实例而执行不同操作 ?多态包括方法重写和方法重载 多态性 2-2 方法重载 2-1 方法重载 2-2 演示:示例 4 方法重写 2-1 方法重写 2-2 访问修饰符 3-1 ?信息隐藏是 OOP 最重要的功能之一,也是使用访问修饰符的原因 ?信息隐藏的原因包括: ?对任何实现细节所作的更改不会影响使用该类的代码 ?防止用户意外删除数据 ?此类易于使用

访问修饰符 3-2访问修饰符 3-3

?访问修饰符可访问性 方法修饰符 static 修饰符 3-1 ?static修饰符修饰的方法叫静态方法 ?目的 ?使该方法独立于类的实例,使用类去访问,而不是类实例,所以也叫类方法 static 修饰符 3-2 ?调用静态方法的语法为: classname.methodname( ); static 修饰符 3-3 演示:示例 6 final 修饰符 abstract 修饰符 3-1 ?由abstract修饰的方法叫抽象方法;由abstract修饰的类叫抽象类 ?抽象方法必须声明在抽象类中 ?抽象方法语法: abstract type method_name(parameter_list); ?声明抽象类语法: abstract class{…… } ?使用:父类中的某些抽象不包含任何逻辑,并需要在子类中重写,子类提供这种抽象方法的实现细节 abstract 修饰符 3-2 ?抽象类可以具有指向子类对象的对象引用 abstract 修饰符 3-3 演示:示例 7 接口 ?接口就是某个事物对外提供的一些功能的申明 ?可以利用接口实现多态,同时接口也弥补了Java单一继承的弱点 ?使用interface关键字定义接口 ?一般使用接口声明方法或常量,接口中的方法只能是声明,不能是具体的实现 创建接口的步骤 2-1 // 定义方法的接口 public interface myinterface { public void add(int x, int y); public void volume(int x,int y, int z); } // 定义程序使用的常量的接口 public interface myconstants { public static final double price = 1450.00; public static final int counter = 5; } 创建接口的步骤 2-2 接口使用示例

Java类与对象实验报告

实验报告 一、实验项目:类与对象 二、实验目的: 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 语句可以引入包中的类。 五、实验步骤及数据记录: 1.定义一个圆柱体类Cylinder,并创建相应的对象,然后计算圆柱体的底面积与体积。

面向对象的三大特性(封装-继承-多态)

一丶封装 1 权限修饰符 可以用来修饰成员变量和成员方法,对于类的权限修饰只可以用public和缺省default。 被public修饰的类可以在任意地方被访问;default类只可以被同一个包内部的类访问。 权限由大到小:public protected default(不写) private 被private修饰的成员只能在本类中访问,外界不能访问 2 set()/get()方法 (1)this关键字 a.可以用来调用变量,方法,构造方法; b.this.xx 理解为调用当前类的xx。 (2)成员变量和局部变量 1)在类中的位置不同 a:成员变量:在类中,方法外 b:局部变量:在方法声明上(形式参数),或者是在方法定义中

2)在内存中的位置不同 a:成员变量:在堆内存 b:局部变量:在栈内存 3)生命周期不同 a:成员变量:随着对象的创建而存在,随着对象的消失而消失 b:局部变量:随着方法调用而存在,随着方法的调用结束而消失 4)初始化值不同 a:成员变量:有默认值 b:局部变量:必须初始化值,否则报错!(在使用它之前,没有初始化) (3)set()/get()方法 当成员变量被private修饰时,不在本类中无法直接访问,便需要set()/get()方法来解决这个问题 3 封装性 封装:是面向对象的第一大特性,所谓封装,就是值对外部不可见(一般而言被private修饰),外部只能通过对象提供的接口(如set()/get()方法)来访问。 封装的好处:a.良好的封装能够减少耦合;

b.类内部的结构可以自己修改,对外部影响不大; c.可以对成员进行更精准的控制(防止出现与事实不符的情况); d.影藏实现细节。 注意:在开发中,类的成员变量全部要进行封装,封装之后通过set()/get()方法访问。 二丶继承extends 1 实现:通过 class Zi extends Fu{} 实现类的继承 (1)子类继承父类,父类中声明的属性,方法,子类都可以获取到; 当父类中有私有的属性方法时,子类同样可以获取到,由于封装性的设计,使得子类不能直接调用访问。 (2)子类除了可以继承父类的结构外,还可以定义直接特有的成员变量,成员方法; (3)Java中类的继承只支持单继承,一个类只能继承一个父类,父类可以有多个子类,但是可以多层继承; (4)子类不能继承父类的构造方法,可以间接的通过super关键字去访问父类的构造方法(super();); 在子类的构造方法中如果没有显示的调用父类的构造方法,会默认调用父类的无参构造(所以最好父类都写有无参构造方法)。 子类继承父类的访问特点:首先父类进行初始化,然后子类进行初始化;多层访问! 2 方法的重写(区别重载) 子类继承父类以后,若父类的方法对子类不适用,那么子类可以对父类方法重写(override) 规则:1)要求子类方法的返回值类型方法名(参数列表)与父类方法一致; 2)子类方法的权限修饰符不能小于父类方法的修饰权限; 3)若父类方法抛异常,那么子类方法抛的异常类型不能大于父类; 注意: a.当子类重写了父类的方法以后,可以用 super.方法调用父类被重写的内容; b.子父类的方法必须同为static或同为非static。 class Fu{ private int i; public Fu(){ //无参构造 super();可以省略 super(); } public Fu(int i){ //有参构造

Java为什么要继承、封装和多态

为什么要继承、封装和多态 1,为什么要继承 继承的好处是代码重用.哲学上讲事物都是有共性和特性的.把共性函数代码放入到父类中,把特性函数代码放入到子类中,当然是否共性要以参照点的标准.OO中所谓的抽象我自己理解为哲学中的共性在同一个行业中,他们各业务流程往往有很大的相似性,但往往我们都是到一个项目中就重新写一套流程代码,或者粘贴以前的代码.可能有很多代码都是以前写过的重复代码.造成重复劳动.如果采用继承应该这样,首先在父类中做一个基本上大部分行业项目都必要的简洁的主流程.在子类中针对具体项目的特殊性做主流程充分的完善的补充.这样在每个项目中,只针对项目的特殊性编写代码,大大降低重复劳动.当然根据具体流程的复杂多可以划分多的继承层次,呈现一种继承的树结构,但一定的要保证层次一定要有实际的意义. 2,为什么要封装 高内聚低偶合的思想简单的理解同一模块内的提高内聚,不同模块降低偶合.如果说一个类代表一个模块或是一个业务流,那么A类内部要提高内聚,类的属性可以看成是内的局部变量.提高数据的重用.公共函数尽量能被其他主函数,尽量达到功能内聚.如果说是A类和B类,并且是不同模块(也许是同一个模块下的两个子模块),那么B 是不能使用A的函数和属性的,紧进行数据偶合.封装的作用就体现在这里.

再现实中就项目中经常遇到这种情况,某项业务增加或修改一种类型的业务流,自己本身调试成功了,但是缺影响了此业务下其他的业务流,不得不测试所有得其他原本正常的业务流并不得不针对此做类型判断的补丁,这种补丁很肯能导致程序结构的不合理. 3.为什么要多态 个人认为多态的好处体现在代码的可扩充性,比如一个业务有多个业务流,为了区别不同的类型就的使用判断,那么新添加一个流程就得在过程执行主流程(往往是final,必然是面向过程的)中添加一个”if then”或是重载一个函数 在目前项目中mvc得控制器就是典型的多态.想想如果我们不使用多态那么怎么办?因为对PO对象是新添加的,那么必须针对新的PO 对象在代码中做IF判断,才能用他本身的对象类型指向他.造成过程执行主流程不断的要变更自己的代码. 总结: OO中继承和多态互相依赖又互相矛盾,没有继承就不可能有多态,多态的使用往往又在面向过程的代码中.继承是使子类可以使用父类的功能,而多态使父类能使用子类的功能. OO并非只是在编码阶段来处理,实际上在概要设计,详细设计,数据库设计的时候就应该OO的思想来设计.提高软件可重用性和可扩充性.对于想对一个行业做标准化产品软件而言,很重要.

第7课件 封装、继承和多态(4学时 19-22)

第七讲义面向对象——类 几种设计模式: 1. 当创建一个对象,若不想让对象的内容(私有成员变量)发生变化,则需要满足以下条件 (1) 所有数据域都是私有的;(2)没有修改方法setMethod;(3)没有一个访问器方法会返回一个指向可变数据域的引用。不可变类/对象例如:String类 2. 为了防止用户创建某个类的对象,则应该定义该类的私有构造方法。例如:Math类 3. 当只允许某个类只能创建一个实例时,称为单例模式。 一、类的封装 方法的抽象;类的抽象;(将方法的实现和使用分开| 将类的实现和使用分开) 类的用户&类的开发者 二、类的继承和多态(2个学时) 继承是java在软件重用方面最重要的特征。能有效避免代码冗余,使系统易于理解和维护、子类继承于父类,UML图表示,次类——超类,或继承类—基类。 当子类继承父类的时候,子类可以继承父类的所有成员跟方法,继承下来不代表可以访问,要访问得看访问控制规则。私有属性也可以继承,不过根据访问控制规则,私有属性虽继承下来却不可以访问的,只有通过public的方法访问继承下来的私有属性。 B继承A类,C继承B类。A类中的私有属性,到了C会怎么样,能继承、访问吗?答案是:如果A中的属性有增加setget方法,可以访问的。举例 public class A { private int a; public int getA(){ return a; } public void setA(int a){ this.a=a; } } public class B extends A{ private int b; public int getB() { return b; } public void setB(int b) { this.b = b; } } public class C extends B { private int c; public int getC() { return c; }

20XX级java语言实验3指导(面向对象程序设计(继承、封装、多态))

20XX级java语言实验3指导(面向对象程序设计(继承、封装、多态)) 上机实验三:面向对象程序设计(继承、封装、多态) 类是面向对象程序设计的基础,是Java的核心和本质所在,在Java中,所有的语言元素都封装在类中。编写java 程序的过程就是从现实世界中抽象出java可实现的类,并用合适的语句定义它们的过程,本节将学习类的应用,以及如何创建类的实例,通过类的继承更有效的组织程序结构,明确类之间的关系。掌握本节所讲的内容后,读者就可以使用面向对象技术编写java程序了。 接口是特殊的抽象类,只包含常量和方法的定义,而没有方法的实现,也就是说接口是方法定义和常量值的集合。 包是Java语言中有效管理类的一个机制。通过关键字package声明包语句,package语句作为Java源文件的第一条语句,指明该源文件定义的类所在的包。使用import语句可以引入包中的类。 一、实验目的 1) 2) 3) 4) 5) 6) 7) 掌握类的定义和使用掌握对象的声明和使用 了解构造函数的概念和使用掌握类的继承关系和派生方法掌握多态的概念与使用掌握接口的定义和使用掌握

Java中包的应用 二、实验内容 1) 2) 3) 4) 5) 6) 7) 类的声明 定义类成员变量以及成员方法 实例化类、创建类对象以及类方法的调用类的继承 通过实例理解接口的定义通过实例熟悉接口的应用 正确应用Java中包和import语句 三、实验步骤 1) 类和类的实例化 一个类的实现包括两部分:类声明和类体。、类声明[public][abstract][final] class className [extends superclassName] [implements interfaceNameList] {……} 期中修饰符[public][abstract][final]说明类的属性className为类名 superclassName为父类的名字 interfaceNameList为类实现的接口列表、类体类体定义如下 class className { [public|protected|private] [static] [final] [transient] [volatile] Type variableName; //成员变量

实验六 多态性和虚函数

实验六多态性和虚函数 一、实验目的 1、了解多态性的概念。 2、了解虚函数的作用及其使用方法。 3、了解静态关联和动态关联的概念和用法。 4、了解纯虚函数和抽象类的概念和用法。 二、实验要求 1、分析程序运行结果,掌握虚函数的使用。 程序一: #include class ONE { public: virtual void f(){cout<<"l"<f(); } 程序二: #include class Base { public: virtual void fn() { cout <<"In Base Class\n";} }; class SubClass :public Base { public: virtual void fn(){ cout <<"In Sub Class\n"; } }; void main()

{ Base bc,*p; SubClass sc; p=&bc; p->fn(); p=≻ p->fn(); } 2、实现一个类A,在A中有两个私有的整型变量a和b,定义构造函数对a和b进行初始化,并实现成员函数geta()取得a的值和getb()取b的值。实现类B从A继承,覆盖geta(),使其返回a的2倍。主函数中声明类B对象,调用类B中的geta()并将结果输出。 3、声明抽象基类Shape,由它派生出3个派生类:Cirle(圆形)、Rectangle(矩形)、Triangle (三角形),用一个函数printArea分别输出以上三者的面积,3个图形的数据在定义对象是给定。

类的设计与封装(一)实验报告

浙江大学城市学院实验报告课程名称面向对象程序设计 实验项目名称类的设计与封装实验(一) 学生姓名专业班级学号 一. 实验目的和要求 1.掌握使用类将对象的属性与功能封装在类中的特点 2.掌握实例方法与构造方法 二. 实验内容 1. 分析Time类的设计 2. 分析并设计Product类 3. 分析并设计Fraction类 4. 设计Rectangle类 5. 设计Student类及其测试类School类 三. 实验结果与分析(可将程序运行结果截屏,也可分析运行结果) 1. 阅读以下关于Time类的代码,分析程序并回答相关的问题 import java.text.DecimalFormat; public class Time{ private int hour; private int minute; private int second; Time(){hour=0;minute=0;second=0;} Time(int h){ hour=h;minute=0;second=0;} Time(int h,int m){hour=h;minute=m;second=0;} Time(int h,int m,int s){hour=h;minute=m;second=s;} Time(Time time){ this.hour=time.getHour(); this.minute=time.getMinute(); this.second=time.getSecond(); } public int getHour(){return hour;} public int getMinute(){ return minute;}

相关文档
最新文档