Java语言接口与继承本质区别

Java语言接口与继承本质区别
Java语言接口与继承本质区别

Java语言接口与继承本质区别

大多数人认为,接口的意义在于顶替多重继承。众所周知Java没有c++那样多重继承的机制,但是却能够实作多个接口。其实这样做是很牵强的,接口和继承是完全不同的东西,接口没有能力代替多重继承,也没有这个义务。接口的作用,一言以蔽之,就是标志类的类别(type of class)。把不同类型的类归于不同的接口,可以更好的管理他们。OO的精髓,我以为,是对对象的抽象,最能体现这一点的就是接口。为什么我们讨论设计模式都只针对具备了抽象能力的语言(比如c++、java、c#等),就是因为设计模式所研究的,实际上就是如何合理的去抽象。(cowboy的名言是“抽象就是抽去像的部分”,看似调侃,实乃至理)。

设计模式中最基础的是工厂模式(Factory),在我最近的一个很简单的应用中,我想尽量的让我的程序能够在多个数据库间移植,当然,这涉及很多问题,单是如何兼容不同DBMS的SQL就让人头痛。我们不妨先把问题简单化,只考虑如何连接不同的数据库。

假设我有很多个类,分别是Mysql.java、SQLServer.java、Oracle.java、DB2.java,他们分别连接不同的数据库,统一返回一个Connection对象,并且都有一个close方法,用于关闭连接。只需要针对你的DBMS,选择不同的类,就可以用了,但是我的用户他会使

用什么数据库?我不知道,我希望的是尽量少的修改代码,就能满足他的需要。我可以抽象如下接口:

package org.bromon.test;

public interface DB

{

java.sql.Connection openDB(String url,String user,String password);

void close();

}

这个接口只定义两个方法,没有任何有实际意义的代码,具体的代码由实作这个接口的类来给出,比如Mysql.java:

Package org.bromon.test;

import java.sql.*;

public class Mysql implements DB

{

private String url=”jdbc:mysql:localhost:3306/test”;

private String user=”root”;

private String password=””;

private Connection conn;

public Connection openDB(url,user,password)

{

//连接数据库的代码

}

public void close()

{

//关闭数据库

}

}

类似的当然还有Oracle.java等等,接口DB给这些类归了个类,在应用程序中我们这样定义对象:

org.bromon.test.DB myDB;

使用myDB来操作数据库,就可以不用管实际上我所使用的是哪个类,这就是所谓的“开-闭”原则。但是问题在于接口是不能实例化的,myDB=new DB(),这样的代码是绝对错误的,我们只能myDB=new Mysql()或者myDB=new Oracle()。麻烦了,我还是需要指定具体实例化的是哪个类,用了接口跟没用一样。所以我们需要一个工厂:

package org.bromon.test;

public class DBFactory

{

public static DB Connection getConn()

{

Return(new Mysql());

}

}

所以实例化的代码变成:myDB=DBFactory.getConn();

这就是23种模式中最基础的普通工厂(Factory),工厂类负责具体实例化哪个类,而其他的程序逻辑都是针对DB这个接口进行操作,这就是“针对接口编程”。责任都被推卸给工厂类了,当然你也可以继续定义工厂接口,继续把责任上抛,这就演变成抽象工厂(Abstract Factory)。

整个过程中接口不负责任何具体操作,其他的程序要连接数据库的话,只需要构造一个DB对象就OK,而不管工厂类如何变化。这就是接口的意义----抽象。

继承的概念不用多说,很好理解。为什么要继承呢?因为你想重用代码?这绝对不是理由,继承的意义也在于抽象,而不是代码重用。如果对象A有一个run()方法,对象B也想有这个方法,所以有人就Class B extends A。这是不经大脑的做法。如果在B中实例化一个A,调用A的Run()方法,是不是可以达到同样的目的?如下:

Class B

{

A a=new A();

a.run();

}

这就是利用类的聚合来重用代码,是委派模式的雏形,是GoF 一贯倡导的做法。

那么继承的意义何在?其实这是历史原因造成的,最开始的OO 语言只有继承,没有接口,所以只能以继承来实现抽象,请一定注意,继承的本意在于抽象,而非代码重用(虽然继承也有这个作用),这是很多Java烂书最严重的错误之一,它们所造成的阴影,我至今还没有完全摆脱,坏书害人啊,尤其是入门类的,流毒太大。什么时候应该使用继承?只在抽象类中使用,其他情况下尽量不使用。抽象类也是不能实例化的,它仅仅提供一个模版而已,这就很能说明问题。

软件开发的万恶之源,一是重复代码而不是重用代码,二是烂用继承,尤以c++程序员为甚。Java中取缔多重继承,目的就是制止烂用继承,实是非常明智的做法,不过很多人都不理解。Java能够更好的体现设计,这是让我入迷的原因之一。

JAVA类的继承实验报告

《面向对象程序设计》实验报告 实验六、类的继承 课程代码:1H10500学分:6 实验类型:实践型实验学时:4个学时 实验时间:2017.11.23 实验地点:5407 班级:计算机164 专业:计算机科学与技术专业学号:2016011147 姓名:林文辉 一、实验目的 (1)学习JAVA继承的思想 (2)了解JAVA语言继承的实现 二、实验内容及步骤 内容:在圆柱体类Cylinder里,用一个构造方法调用另一个构造方法 步骤:方案的设计与分析(类结构图。。。。。。) (1)找出对象的共同属性和行为 (2)设计代表共同状态与行为的类 (3)决定子类是否需要让某项行为有特定的不同的运行方式 (4)寻找更多抽象化的机会 (5)完成类的继承层次 三、实验过程及结果 实验1代码: abstract class Graphics { abstract void parameter(); abstract void area(); } class Rectangle extends Graphics{ double h,w; Rectangle(double u,double v){h=u;w=v;} void parameter() { S ystem.out.println("矩形高度为:"+h+",矩形宽度为:"+w); } void area() { S ystem.out.println("矩形面积为:"+(h*w)); } }

class Circle extends Graphics{ double r; String c; Circle(double u,String v){r=u;c=v;} void parameter() { System.out.println("圆半径为:"+r+",圆颜色为:"+c); } void area() { System.out.println("圆面积为:"+(Math.PI*r*r)); } } class ExamAbs{ public static void main(String args[]) { Rectangle rec=new Rectangle(2.0, 3.0); Circle cir=new Circle(4.0, "Red"); Graphics[]g= {rec,cir}; for(int i=0;i

java继承与接口实验三

信息与计算科学专业实验报告 课程名称Java课程设计总实验学时: 16 第3 次共6 次 实验项目名称继承与接口本次实验学时数: 3 实验类 型 验证 日期20 12 年 3 月6 日星期二年级 学生姓名学号课任教师 1.实验目的 巩固如下概念:子类的继承性、子类对象的创建过程、成员变量的继承与隐藏、方法的继承与重写;掌握上转型对象的使用;掌握接口回调技术。 2.实验要求 实验前,应事先熟悉相关知识点,拟出相应的实验操作步骤,明确实验目的和要求;实验过程中,服从实验指导教师安排,遵守实验室的各项规章制度,爱护实验仪器设备;实验操作完成后,认真书写实验报告,总结实验经验,分析实验过程中出现的问题。 3.实验内容 1、继承 编写一个Java应用程序,除主类外,该程序中还有4个类:People、ChinaPeople、AmericanPeople和BeijingPeople类。要求如下:People类有访问权限是protected的double 型成员变量:height和weight,以及public void speakHello()、public void averageHeight()、public void averageWeight()方法;ChinaPeople类是People的子类,新增了public void chinaGongfu()方法。要求ChinaPeople重写父类的public void speakHello()、public void averageHeight()、public void averageWeight()方法;AmericanPeople类是People的子类,新增public void americanBoxing()方法。要求AmericanPeople重写父类的public void speakHello()、public void averageHeight()、public void averageWeight()方法;BeijingPeople类是ChinaPeople的子类,新增public void beijingOpera()方法。要求BeijingPeople重写父类的public void speakHello()、public void averageHeight()、public void averageWeight()方法;请按模板要求,将【代码】替换为Java程序代码。 2、上转型对象 编写一个Java应用程序,要求有一个abstract类,类名为Employee。Employee的子类有YearWorker、MonthWorker和WeekWorker。YearWorker对象按年领取薪水,MonthWorker按月领取薪水,WeekWorker按周领取薪水。Employee类有一个abstract方法:public abstract double earnings(); 子类必须重写父类的earnings()方法,给出各自领取报酬的具体方式。有一个

第五章 Java类的继承、包及接口

第5章类的继承、包及接口 在前一章的实验中已经了解了类的基本构成、对象的创建及重载方法的应用等。本章实验的任务主要是了解Java中类的继承、类包、内部类、匿名类及接口的基本构成及应用。 5.1 实验一:类的继承 1. 实验目的 1)正确理解Java中类继承基本概念及思想; 2)基本掌握继承类和被继承类(子类和父类)之间的关系,正确地创建继承类。 2. 实验要求 正确地划分类,根据类之间的关系,确定父类和子类,掌握覆盖方法的应用,完成类程序的编写与调试。 3. 实验内容 在上一章的实验中,建立了公司职员信息类,现在需要处理职员的工资信息,建立职员工资类。 实验示例5.1.1 创建职员工资类Payroll类。 实现该示例的方法步骤如下: ⑴首先分析一下该类的构成 工资信息应包括职工的基本信息,因此可以把Employers类作为Payroll类的父类,Payroll类继承了父类所有的成员变量和方法,因此在Payroll类中需要定义的内容是: ①成员变量 对于工资信息项应该包括basicWage(基本工资)、positionWage(职位工资)、extraWage(附加工资)、other(其他补贴)等等。它们均可声明为int (整数类型)。 ②成员方法 常常需要显示或获得全部或某些项工资的信息,因此需要定义如下一些方法: display() 显示工资的全部信息; display(int value) 显示一项工资额; display(int value1, int value2) 显示两项工资额。 ③构造方法 如前所述,一个类能够有多个构造对象方法,视需要而定。对Payroll类来说可以给出两个构造方法: Payroll () 构造无名对象; Payroll(String ID,String name,String sex,String birthday,String home,String address, String number,int basicWage,int positionWage,int extraWage,int other) 构造一般对象。 ⑵根据上边分析和描述,按照类的构成,给出如下类程序代码: public class Payroll extends Employers { int basicWage; //定义基本工资 int positionWage; //定义职位工资 int extraWage; //定义附加工资

4、c语言和c++和Python-和Java优缺点(B)

C语言 虽说C语言在内存管理方面存在严重的缺陷,不过它还是在某些应用领域里称王称霸。对于那些要求最高的效率,良好的实时性,或者与操作系统内核紧密关联的程序来说,C仍然是很好的选择。 C良好的可移植性也为它加了分。不过现在很多其他的语言可移植性越来越好,C在这方面的优势可能会逐渐丧失。 现有的很多程序可以产生非常棒的C代码,比如语法分析器、GUI Builder等,这时候C语言也是有吸引力的,因为你所需要编写的代码只是整个程序的一小部分。 再有,我们当然应该认识到,C语言对于程序员来说具有无可替代的价值。就我这里讨论的每一种语言而论,只要你发掘的足够深,到最后你会看到它们的内核都是用纯正的、可移植的C写成的。 到了今天这个时候,我们最好把C看成是UNIX虚拟机上的高级汇编语言。 就算是其他的高级语言完全可以满足你的工作需要,抽出时间来学习C语言也仍然有益,它能帮助你在硬件体系的层次上思考问题。 即使到了今天,最好的C语言教程仍然是1988年出版的K&R第二版The C Programming Language. 总结:C最出色的地方在于其高效和贴近机器,最糟糕的地方在它的内存管理存在严重的缺陷。

C++语言 C++最初发布于1980年代中期,当时面向对象语言被认为是解决软件复杂性问题的银弹。C++的面向对象特性看相去使其全面超越了C,支持者认为C++将迅速把上一代语言挤到陈列馆里去。 但是历史并非如此。究其原因,至少有一部分归咎于C++本身。为了与C兼容,C++被迫作出了很多重大的设计妥协,结果导致语言过分华丽,过分复杂。为了与C兼容,C++并没有采用自动内存管理的策略,从而丧失了修正C最严重问题的机会。 另外一部分原因,恐怕要算到面向对象身上。看起来OO(字母)并没有很好的达成人们当年的预期。我就这个问题调研过,我发现使用OO方法导致组件之间出现很厚的粘合层,并且带来了严重的可维护性问题。今天让我们来看看开放源码社区,你会发现C++的应用还是集中在GUI,游戏和多媒体工具包这些方面,在其他地方很少用到。要知道,面向对象也只是在这些领域被证明非常成功,而开放源码社区的选择,很大程度上体现了程序员的自由意志,而不是公司管理层的胡乱指挥。 也许C++实现OO的方法有问题。有证据表明C++程序在整个生命周期的开销高于相应的C,Fortran和Ada程序。不过,究竟这是否应该归咎与C++的OO实现上,还不清楚。

Java 接口与类之间继承例题

1,定义一个接口Assaultable(可攻击的),该接口有一个抽象方法attack()。 2,定义一个接口Mobile(可移动的),该接口有一个抽象方法move()。 3,定义一个抽象类Weapon,实现Assaultable接口和Mobile接口,但并没有给出具体的 实现方法。 4,定义3个类:Tank,Flighter,WarShip都继承自Weapon,分别用不同的方式实现Weapon 类中的抽象方法。 5,写一个类Army,代表一支军队,这个类有一个属性是Weapon数组w(用来存储该军队所拥有的所有武器);该类还提供一个构造方法,在构造方法里通过传一个int类型的参数来限定该类所能拥有的最大武器数量,并用这一大小来初始化数组w。该类还提供一个方法addWeapon(Weapon wa),表示把参数wa所代表的武器加入到数组w中。在这个类中还定义两个方法attackAll()和moveAll(),让w数组中的所有武器攻击和移动。 6,写一个主方法去测试以上程序。 interface Assaultable{//可攻击的 void attack(); } interface Mobile{//可移动的 void move(); } abstractclass Weapon implements Assaultable,Mobile { publicvoid attack(){} publicvoid move(){} } class Tank extends Weapon{ publicvoid attack(){ System.out.println("坦克攻击!!!"); } publicvoid move(){ System.out.println("坦克移动!!!"); } } class Flighter extends Weapon{ publicvoid attack(){ System.out.println("战斗机攻击!!!"); } publicvoid move(){ System.out.println("战斗机移动!!!");

实验15、16:JAVA面向对象编程(继承、接口)

实验15:面向对象基础编程(六)继承 实验目的: 1.理解继承的概念 2.掌握继承的实现 3.理解继承中的覆盖现象 4.理解抽象类的概念,掌握定义抽象类的方法和应用 实验数据记录及分析(或程序及运行结果) 1.首先预测下列程序的运行结果,然后编译、执行以验证你的预测: class Pet{ protected String name; public Pet(String n){ name = n; } public String getName(){ return name; } public String move(){ return "run"; } public String speak(){ return ""; } public String toString(){ return "My pet " + name; } } class Dog extends Pet{ protected int weight; public Dog(String s){ super(s); } } class PetTest{ public static void main(String[] args){ Pet myPet = new Pet("George"); Dog myDog = new Dog("Spot"); System.out.println(myPet.toString() + "\n" + "Speak: " + myPet.speak() +"\n" + myPet.move() + " " + myPet.getName() + "\n"); System.out.println(myDog.toString() + "\n" + "Speak: " + myDog.speak() +"\n" + myDog.move() + " " +myDog.getName() + "\n"); }

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/7111191461.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

C语言词法分析程序java版

附录:核心代码清单 C语言词法分析代码算法实习--------------------------------------------------------By NLLWRQ 功能类: package conversion; import java.io.*; public class Work{ public String filename; public int flage=1; public int error[]={0,0,0,0,0}; public int error1[]={0,0,0,0,0,0}; StringBuffer buffer=new StringBuffer(); private String Keychar[]={"int","char","long","float","double","short","unsigned","struct","union","enum","auto","ext ern", "static","register","typedef","void","if","else","switch","case","default","do","while","for","break", "continue","return","goto","define","include","undef","ifdef","endif","line","sizeof","asm","fortran","ad a","pascal"}; private String Keyfile[]={"stdio","windows","stdlib","ctype","math","time","string"}; public Work(String filename){ this.filename=filename; } boolean isKeyfile(String ch){ for(int i=0;i

java 类的继承 实验报告(含代码)

实验三类的继承 实验目的:掌握类的继承、抽象类的定义和使用、对象的向上转型。实验内容:已知若干图形,求以该图形为底的锥体的体积。 实验要求:用面向抽象的思想实现 实验步骤: 1、程序总体框架 2、在shape包中创建抽象类Shape,代码如下: 3、在centrun包中创建一个类Centrun,代码如下:

Centrun这个类为核心类,在之后的代码编写中可以不做更改,getVolume函数用来求椎体的体积,即利用抽象类getArea进行适应性计算。 4、创建一个包myshape,在其中先创建一个Circle类,代码如下:

Circle是对抽象类shape的继承(记得导入shape包),在Circle类中,利用对getArea 函数代码的重写操作,具体实现了求圆的面积这一操作。【此处的具体实现应该放入该图形的具体面积求法。】 5、创建一个包Test,对以上三个包中的代码进行具体实现,代码如下: 导入myshape包,在main函数中通过向上转型,实例化shape包中的抽象类Shape,然后调用函数输出圆锥的体积。 6、在求出实验结果1,即调试好shape、myshape、centrun这三个包后,不再更改shape、centrun包,而是在myshape包下新建所需的类,如本次实验所需的三角形、矩形; 7、在myshape包下创建一个类Rectangular,代码如下:

8、在myshape包下创建一个类Triangle,需注意的是,求三角形的面积需要判断三角形的三边能否构成三角形(不能构成时返回0),代码如下:

实验结果: 1、Test测试包最终代码:

Java实验报告 继承、多态、接口和异常处理

实验5 继承、多态、接口和异常处理 一、实验目的 1、掌握Java的类和对象的声明和使用方法; 2、掌握Java的类的继承和实现方法; 3、掌握多态性在类的继承中的运用; 4、掌握接口的定义与使用; 5、掌握基本异常的处理机制; 6、熟悉try语句与catch语句的搭配使用; 7、了解有异常处理与没有异常处理的差别; 8、多重catch语句的使用; 9、使用Throws声明异常和Throw抛出异常。 二、实验环境 1、PC微机; 2、DOS操作系统或 Windows 操作系统; 3、Java sdk程序开发环境、eclipse集成环境。 三、实验内容 1. 设计三个类,分别是学生类Student,本科生类UnderGraduate,研究生类 Postjgraduate,其中Student类是一个抽象类,它包含学生的基本信息如姓名、所学课程、课程成绩等,而Undergraduate类和Postgraduate类都是Student类的子类,这两个类计算课程成绩等级的方法有所不同,如下表所示。假设某班级里既有研究生又有本科生,编写程序统计出全班学生 2. 和 Mobilephone具体实现,并设计一个应用程序类来使用这些类。 3.要求设计一个GUI图形窗口程序,该程序让用户输入一个星期中的任意一天的数字1-7,然后输出该数字所对应的是星期几。 四、实验步骤 实验内容一

1.建立package experiment5_1,其最终目录结构如下: 2.建立Student类: package experiment5_1; public abstract class Student { final static int CourseNo = 3; String name; String type; int[] courses; String courseGrade; public Student(String name) { https://www.360docs.net/doc/7111191461.html, = name; courses = new int[CourseNo]; courseGrade = "" ; } public abstract void calculateGrade(); public String getName( ) { return name; } public String getType( ) { return type ; } public String getCourseGrade( ) { return courseGrade; } public int getCourseScore(int courseNumber) { return courses[courseNumber]; } public void setName(String name) { https://www.360docs.net/doc/7111191461.html, = name; } public void setType(String type) { this.type = type; } public void setCourseScore(int courseNumber, int courseScore) { //按课程索引号设置课程成绩 this.courses[courseNumber] = courseScore ; } }

java中继承的相关知识总结

JAVA中继承的总结 一、继承概念: 把多个类中相同的成员给提取出来定义到一个独立的类中。然后让这多个类和该独立的类产生一个关系, 这多个类就具备了这些内容。这个关系叫继承。 二、何时实现继承 A:继承体现的是:is a的关系。 B:采用假设法 三、怎么实现继承 A:用关键字extends表示 B:格式: class 子类名 extends 父类名 {} C:子类 public class 子类 extends 父类 { //增加自己属性 //重写父类的属性 //增加自己的方法 //重写父类的方法 } 四、继承的好处: A:提高了代码的复用性 B:提高了代码的维护性

C:让类与类产生了一个关系,是多态的前提 继承的弊端: A:让类的耦合性增强。这样某个类的改变,就会影响其他和该类相关的类。 原则:低耦合,高内聚。 耦合:类与类的关系 内聚:自己完成某件事情的能力 B:打破了封装性 五、Java中继承的特点 A:Java中类只支持单继承,只能一个直接父类,Object 根类 B:Java中可以多层(重)继承(继承体系) 六、继承的注意事项: A:子类能继承父类的私有成员,但不是都能访问 B:子类不能继承父类的构造方法,但是可以通过super去访问 C:不要为了部分功能而去继承 七、继承中static用法 A:static:子类可以继承父类的静态方法,但不能重写 B:static 的属性和方法都是不能覆盖的,因为static修饰的部分都是与对象无关的,只与类有关 八、Java继承中的成员关系 A:成员变量 a:子类的成员变量名称和父类中的成员变量名称不一样,这个太简单 b:子类的成员变量名称和父类中的成员变量名称一样,这个怎么访问呢?

java继承与接口 实验报告

应用数学学院信息与计算科学专业 2 班学号3111008162 姓名许庆平教师评定_________________ 实验题目继承与接口 一、实验目的与要求 实验目的: 1、掌握类的继承关系。 2、掌握接口的定义与使用。 实验要求: 按下列要求编写Java程序: 1、定义接口Printx,其中包括一个方法printMyWay(),这个方法没有形参,返回值为空。 2、编写矩形类,矩形类要求实现Printx接口,有求面积、求周长的方法,printMyWay()方法要能显示矩形的边长、面积和周长。 3、编写正方形类作为矩形类的子类,正方形类继承了矩形类求面积和周长的方法,新增加求对角线长的方法,重写printMyWay()方法,要求该方法能显示正方形的边长、面积、周长和对角线长。 二、实验方案 先按要求定义接口Printx,再创建一个矩形类Rectangle,有成员变量length 和width,area()求面积,circle()求周长,用PrintMyWay()显示。 然后定义正方形类,继承Rectangle类,定义求对角线长的函数duijiaoxian()。面积和周长用父类中的area()和circle()实现。用PrintMyWay()显示。最后在主类中实现这两个类。 三、代码如下 interface Printx

{ void PrintMyWay();} class Rectangle implements Printx { int length,width; Rectangle(int x,int y){ length=x; width=y; } int area(){ return length*width; } int circle(){ return 2*(length+width); } public void PrintMyWay(){ System.out.println("矩形的长为:"+length); System.out.println("矩形的宽为:"+width); System.out.println("矩形的面积为:"+area()); System.out.println("矩形的周长为:"+circle()); }

C语言,C++语言,C#语言和Java语言有什么区别

C语言,C++语言,C#语言和Java语言有什么区别 简单地说,它们不是一种语言,语法有差别,编程时具体用到的类库或者函数库也不一样。 虽然它们不是一种语言,不过它们却也有所联系。广泛地说,C可以看作其他三种语言的源语言,因为其他三种语言几乎都是从C而来的,无论从数据类型还是控制语句看,其他三种语言都有从C得来的迹象。 其中C++则一般看作是对C语言的扩展。因为C语言没有面向对象的语法结构,而当时业界又迫切需要面向对象的编程特性,所以贝尔实验室的开发者就为C添加了面向对象的结构。现在C++已经不只是C的扩展了,它已经完全可以被看作一种新的编程语言。虽然C的特性以及库函数仍然被C++支持,不过C++拥有自己的独立的类库体系,功能相当强大。 Java语言是一种完全的面向对象语言,虽然它的底层(运行时库)是用C语言开发的,可是并不依赖于C。因为Java的运行是在运行时库的支持下进行的,所以运行效率比起可以更接近底层的C/C++来说效率会有所影响,不过Java的类库采用很好的设计理念设计,非常好用,也非常实用,已经成为业界的一种标准开发语言。它的跨平台的特性尤其让很多开发者欢迎,你只需要开发一次就能在所有安装了Java运行时库的系统上运行。Java发展了十几年了,可以

应用领域非常之广泛,Web开发有JSP,J2EE,桌面领域现在有JavaFX。 C#是微软开发的一种编程语言,语法类似Java,几乎就是从Java的翻版。运行原理和Java也类似,也是通过运行时库的支持运行。不过支持的平台还很有限。JAVA几乎被所有平台支持,而C#目前只被Windows和Linux支持,Windows下的支持当然是由微软自己开发的,而Linux下的支持则有MONO支持。实际上,MONO也是把C#应用转化为JAVA应用而已,所以本质上,C#仍然只是被微软自己的操作系统支持。应用平台受到限制,是它最大的缺点。 C/C++的优点在于与底层比较接近,可以控制的粒度更加精细,是开发系统级应用的最佳选择。关于缺点,我想正是源于其优点,因为它们能控制的编程元素粒度精细,所以编程比较困难,烦琐,容易出错。 Java和C#都比较高级,可以看作高级语言的高级语言,优点是开发容易,但运行效率不如更为底层的C/C++。 具体选择使用的时候,可以根据实际的项目需要选择。运行效率要求高的,底层控制要求高的用C/C++,否则可以选择Java或C#;跨平台的要求高的可以用Java。

在UML中表示Java继承和接口

在UML中表示Java继承和接口 作者:仙人掌工作室本文选自:赛迪网 在上一篇文章中,我们引入了UML类图的概念,比较了在Java编程语言和UML类图中表示类、属性、操作和关联关系的不同之处。下面我们来看看如何在UML中表示两个重要的Java概念——继承,接口。 继承 在Java中,我们可以声明一个类扩展(extends)另一个类,还可以声明一个类实现(implements)一个或者多个接口。下面我们来看看如何在UML中表达这些概念。 下面是三个Java类的基本骨架。第一个类是代表某种支付方式的Payment抽象类,另外两个类分别扩展Payment 类,描述两种不同的支付方式:

图一用UML显示了同样的三个类。在操作和属性声明中,类型和参数之类的细节都没有显示出来,这是为了更

清楚地显示出类的整体结构以及各个类之间的关系。 图一:UML一般化关系 Java中的extends关键词声明了继承关系,相当于UML中的“一般化”(Generalization,也译为“泛化”)关系,在UML图形中用子类向超类的实线空心封闭箭头表示。图一额外增加了一个Sale类,这是为了更清楚地说明UML一般化关系与UML定向关联关系所用箭头的不同。关联关系与一般化关系的另一个不同之处在于,一般化关系的两端不需要说明多重性或角色名称。 显然,UML类图比三个Java源代码文件更清楚直观地显示出了三个类之间的继承关系。如果你要与别人探讨设计思路,绘制UML草图也要比直接使用代码简单快捷得多。 也许有人会说,系统的类结构图就在他们的头脑中,他们只需要直接使用Java代码。实际上,对于规模较大的系统,这种说法显然是不成立的;即使对于规模较小的系统,如果一定的时间之后要由其他程序员修改,没有UML图也会寸步难行——很难保证每一个人都了解你头脑中的类结构图。 在UML中,抽象类的标志是类的名字以斜体显示。在白板或纸张上手工画UML草图时,很难区分字体是否是斜体。为此,一些人建议这些场合可以在类名称的右下角加上{abstract}标记以示区别。 另一些人认为,在白板上写{abstrac t}显得太罗嗦,他们倾向于打破UML常规,在类名称的右下角加上一个0表示零个实例,如果在该位置写上1,则表示该类是一个singleton类(永远只有一个实例的类);如果在该位置写上N,则表示它是一个枚举类(拥有固定实例数量的类,如一星期中的天数,彩虹的颜色,等等)。不过,这一切都不是标准的UML,只能用于手工绘制UML图的场合,看来也不可能得到UML建模工具的支持。 历史知识:UML首先由Rational公司的一个工作组发明,Ration公司是UML建模工具Rose的生产者。UML于1995年的OOPSLA会议上被公诸于世,随后,OMG(对象管理组织)于1997年采用了UML规范。不难理解,继

JAVA语言和C语言的区别

JAVA语言和C语言的区别 12521330张露 在大一刚开始,我们便接触了C语言这门课程,刚开始接触这类语言感觉非常的陌生,后来在学习了一段时间以后才发现语言是一门看眼我们逻辑思维以及对固定关语法应用的一门课程。随着年级的增高,我们有学习了汇编语言、机器语言等,这学期,我们终于接触到了JAVA语言,平时总是听说这类语言,这次终于学习了这门语言感觉和C语没太大区别,主要是在语法上有些许的不同。 首先,JAVA采用面向对象的机制,采用运算符new为每个对象分配内存空间,而且,实际内存还会随程序运行情况而改变.程序运行中,每个,Java系统自动对内存进行扫描,对长期不用的空间作为”垃圾”进行收集,使得系统资源得到更充分地利用.按照这种机制,程序员不必关注内存管理问题,这使Java程序的编写变得简单明了,并且避免了了由于内存管理方面的差错而导致系统出问题.而C语言通过malloc()和free()这两个库函数来分别实现分配内在和释放内存空间的。 C语言中更多是运用子函数的调用,java则是类和类之间的引用,而且很多的是接口。 其次,Java面向对象的特征主要有封装,继承,多态。类的继承关系是单一的、非多重的,一个子类只有一个父类,子类的父类又只有一个父类。C语言支持“运算符的重载”,这是它的一个很重要的多态特征,是数据抽象和泛型编程的利器。它允许直接对对象进行四则运算,正像基本数据类型那样Java不支持这种多态机制,也是为降低复杂性。Jvav可以支持方法重载和重写,所谓重载就是一个类具备多个相同属性行为;重写就是在继承关系中父类的行为在不同的子类上有不同的实现。在Java中比C语言多了一些修饰符,如访问修饰符Public(公共的)、Private(私有的)、Protected(受保护的)、默认。Java有super关键字,指代父类对象,通常被用于调用父类的构造方法或一般方法C 语言则没有super关键字,两者都有this,指代当前对象。在Java中,除了static、final、private是静态绑定以外,所有方法一律按动态绑定处理。Java 中可以将类组织起来用Package打包,而C语言没有。Java程序中,不能在所有类之外定义全局变量,只能通过在一个类中定义公用、静态的变量来实现一个全局变量。 在Java中比C多了一些修饰符,如Public、Private、Protected这些访问修饰符,可以控制变量的使用范围。两者都有this来指代当前对象。在c语言中没有这种修饰符,也就是说在安全性方面不如java,java对变量的保护做得非常好。 Java不再使用指针,指针是C和C++中最灵活,也最容易产生错误的数据类型.由指针所进行的内存地址操作常会造成不可预知的错误,同时通过指针对某个内存地址进行显式类型转换后,可以访问一个C++中的私有成员,从而破坏安全性.而Java对指针进行完全地控制,程序员不能直接进行任何指针操作。可以说指针是c语言的精髓,然而java中更多的是对数据每一位的操作,比如substring等。 从专业的角度来说,Java课程对于软件设计而言是十分必要的,Java的定义是一种可以撰写跨平台应用软件的面向对象的程序设计语言,是由Sun Microsystems公司于1995年5月推出的Java程序设计语言和Java平台。Java

JAVA继承类求几何图形面积周长代码

class shap2D { static double getArea; //面积 static double getPerimeter; //周长 } class circle extends shap2D { double r; double getRadius(){return r=2;} double getArea() {return Math.PI*r*r;} double getPerimeter() {return 2*Math.PI*r;} public String toString() { String s; return s="周长:"+getPerimeter()+"面积:"+getArea(); } } class Triangle extends circle { double a,b,c; Triangle (double x,double y,double z) {a=x; b=y;c=z;} void setA(double x){a=x;} double getA(){return a;} public double getPerimeter() {return a+b+c;} public double getArea() { double s=(a+b+c)/2; return Math.sqrt(s*(s-a)*(s-b)*(s-c)); } public boolean isTriangle() { boolean flag=false; if(a>0&&b>0&&c>0&&a+b>c&&a+c>b&&c+b>a) flag=true; return flag; } } class rectangle extends circle { double a,b;

JAVA继承、抽象类、接口

JA V A继承、抽象类、接口 编辑人:星辰·樱 联系QQ:838826112 一.类的继承 通过继承可以实现代码的复用,被继承的类称为父类或超类(superclass),由继承而得到的类称为子类(subclass)。一个父类可以拥有多个子类,但一个类只能有一个直接父类,这是因为JA V A语言中不支多重继承。 子类继承父类的成员变量和成员方法,同时可以修改父类的成员变量或重写父类的方法,还可以添加新的成员变量或成员方法。 JA V A语言中有一个名为https://www.360docs.net/doc/7111191461.html,ng.Object的特殊类,所有的类都是直接或间接地继承该类而得到的。 1.子类的创建 类的继承是通过extends关键字来实现的,在定义类时若使用ectends关键字指出新定义类的父类,就是在两个类之间建立了继承关系。新定义的类称为子类,它可以从父类那里继承所有非private的成员作为自己的成员。 子类的创建: * 格式:class SubClass extends SuperClass * { * . * . * . * } 2.调用父类中特定的构造方法 在没有明确地指定构造方法时,子类还是会先调用父类中没有参数的构造方法,以便进行初始化的操作。在子类的构造方法中可以通过super()来调用父类特定的构造方法。 例://以Person作为父类,创建学生子类Student,并在子类中调用父类里某指定的构造方法。 class Person2 { private String name; private int age;

public Person2()//定义Person2类的无参构造方法 { System.out.println("调用了Person2类的无参构造方法"); } public Person2(String name,int age)//定义Person2类的有参构造方法 { System.out.println("调用了Person2类的有参构造方法"); https://www.360docs.net/doc/7111191461.html,=name; this.age=age; } public void show() { System.out.println("姓名:"+name+" 年龄:"+age); } } class Student2extends Person2//定义继承自Person2类的子类Student2 { private String department; public Student2()//定义Student2类的无参构造方法 { System.out.println("调用了学生类的无参构造方法Student2()"); } public Student2(String name,int age,String dep)//定义Student2类的有参构造方法 { super(name,age);//调用父类的胡参构造方法 department=dep; System.out.println("我是"+department+"学生"); System.out.println("调用了学生类的有参构造方法Student2(String name,int age,String dep)"); } } public class App8_2 { public static void main(String[] args) { Student2 stu1=new Student2();//创建对象,并调用无参构造方法 Student2 stu2=new Student2("李小四",23,"信息系");//创建对象并调用有参构造方法 stu1.show(); stu2.show(); } } /*在子类中访问你类的构造方法,其格式为super(参数列表)。

相关文档
最新文档