为您找到与java重载重写覆盖的区别相关的共200个结果:
NET是微软的王牌,不能跨平台,运行时,速度和Java基本不相上下,但是.NET的开发速度很快,但是安全性总是.NET开发者的瓶颈,在有就是在.NET中的线程很难控制.
Java是跨平台的,而且Java开发的安全性最高,线程很好控制,运行速度是依据框架而定的,如果用Struts开发Web它的速度会比较平均,但是用JSF它的启动很慢,但是一旦加载完毕后,速度飞快,只要不清楚浏览器记录,它就会永远保持此速度.但是Java也存在许多问题,比如开发速度及其缓慢,搭建框架时需要弄许多配置文件。
比较:
1.在 web 开发方面 java 绝对第一, 因为java 比 .net、 php更加稳定,安全,开发效率高,功能更加强大。java 在web 应用方面 光java服务器就有好多(tomcat,jboss,weblogic,websphere),这些都可以运行java项目,而.net 只可以在微软的IIS服务器上运行局限性很大。
2.在单机软件开发方面,如果开发windows应用那还是 .net 好一些,因为windows 和 .net都是微软的产品所以在开发window应用方面.net更兼容一些。
3.在智能设备软件开发上,java更强,你该知道 android 智能手机 ,它的应用都是用java 开发的,其实在android出来之前,就有J2me 能开发手机上的软件了。
总的说来,java 的前景比.net 好,现在做java 的公司绝对比.net 多。两者在上述三个方面都能做,我在上面三个方面比较了一下哪个更强。 也就是说 java 比 .net更强。这么说吧,一般银行的网上系统都选用 java开发,这就不言而喻了。
浏览量:2
下载量:0
时间:
Java和.Net的区别就像Windows和Linux的区别,正因为Java学习门槛非常高,很多学习者被淘汰了下来,这样能够撑过一个个难关学习下来的开发人员都是水平比较高的人员。因此.Net初级开发人员的工资平均是比Java初级开发人员的工资平均略低的。但是由于.Net中高级人才非常缺乏,因此掌握.Net深入技术的开发人员在企业内部是非常吃香的,招聘人员经常发出这样的感叹“招合适的Java工程师能招来一堆,招合适的.Net工程师一个月都招不来几个”。
.Net秉承了微软技术的入门简单的特点,经过短时间的学习就可以掌握拖拉控件的快速开发方式,很多人被.Net的快速开发方式所满足,认为自己“学成了”,不再深入研究,因此人才市场上充斥着很多只会拖控件、而不懂.Net更深入一步技术的.Net开发人员,比如很多ASP.Net的书上都是讲ASP.Net服务端控件,很多所谓“精通ASP.Net”的人连什么是Http、HTML、JavaScript、Dom等基本概念都稀里糊涂,实际公司项目中很多功能点的实现不是简单的拖一个ASP.Net服务端控件就能搞定的,因此看似学习.Net的人非常多,但是真正满足企业要求的人则比较少;而Java则入门门槛比较高,如果想要配置一个Hello World级别的学习环境就会涉及到很多技术,开发环境也要学习者自行配置,对于初学者来说可能花费一周时间都无法配置一个最简单的环境出来,Java的开发环境也不像.Net开发环境那么可用性强。
浏览量:2
下载量:0
时间:
接触过编程代码的人都知道重载和重写,但是很多人来说,总是不能很好的区别它们,其实区别它们很容易,只要你常常练习编代码,不久就能从本质上将他们区分开。
小编给你举一下代码例子,可以通过代码了解一下
OverrideNew.cs
namespace NET.MST.Third.OverrideNew
{
public class OverrideNew
{
static void Main(string[] args)
{
https://测试重写和隐藏的功能
OverrideBase b = new OverrideBase();
NewBase nb = new NewBase();
Console.WriteLine(ob.ToString() + ":" + ob.GetString());
Console.WriteLine(nb.ToString() + ":" + nb.GetString());
Console.WriteLine("");
https://重写和隐藏的区别
Base bb = ob as Base;
Base nbb = nb as Base;
Console.WriteLine(obb.ToString() + ":" + obb.GetString());
Console.WriteLine(nbb.ToString() + ":" + nbb.GetString());
Console.Read();
}
}
https://基类
class Base
{
public virtual string GetString()
{
return "我是基类";
}
}
https://重写
class OverrideBase : Base
{
public override string GetString()
{
return "我重写了基类";
}
}
https://隐藏
class NewBase : Base
{
public new virtual string GetString()
{
return "我隐藏了基类";
}
}
}
}
https://重写
class OverrideBase : Base
{
public override string GetString()
{
return "我重写了基类";
}
}
https://隐藏
class NewBase : Base
{
public new virtual string GetString()
{
return "我隐藏了基类";
}
}
}
看完了上面的代码,是不是能理解重载和重写了呢,下面小编再给你说明一下重载和重写的定义。
重载
同一个作用域内发生(比如一个类里面),定义一系列同名方法,但是方法的参数列表不同。这样才能通过传递不同的参数来决定到底调用哪一个。而返回值类型不同是不能构成重载的。
重写
继承时发生,在子类中重新定义父类中的方法,子类中的方法和父类的方法是一样的。
浏览量:2
下载量:0
时间:
接触过编程代码的人都知道重载和重写,一些编程高手能很清楚它们之间的区别,但是对于一些刚接触代码的新手来说,总是不能很好的区别它们,下面小编带你了解一下。
重载
同一个作用域内发生(比如一个类里面),定义一系列同名方法,但是方法的参数列表不同。这样才能通过传递不同的参数来决定到底调用哪一个。而返回值类型不同是不能构成重载的。
重写
继承时发生,在子类中重新定义父类中的方法,子类中的方法和父类的方法是一样的。
小编给你举一下代码例子,可以通过代码了解一下
OverrideNew.cs
namespace NET.MST.Third.OverrideNew
{
public class OverrideNew
{
static void Main(string[] args)
{
https://测试重写和隐藏的功能
OverrideBase b = new OverrideBase();
NewBase nb = new NewBase();
Console.WriteLine(ob.ToString() + ":" + ob.GetString());
Console.WriteLine(nb.ToString() + ":" + nb.GetString());
Console.WriteLine("");
https://重写和隐藏的区别
Base bb = ob as Base;
Base nbb = nb as Base;
Console.WriteLine(obb.ToString() + ":" + obb.GetString());
Console.WriteLine(nbb.ToString() + ":" + nbb.GetString());
Console.Read();
}
}
https://基类
class Base
{
public virtual string GetString()
{
return "我是基类";
}
}
https://重写
class OverrideBase : Base
{
public override string GetString()
{
return "我重写了基类";
}
}
https://隐藏
class NewBase : Base
{
public new virtual string GetString()
{
return "我隐藏了基类";
}
}
}
}
https://重写
class OverrideBase : Base
{
public override string GetString()
{
return "我重写了基类";
}
}
https://隐藏
class NewBase : Base
{
public new virtual string GetString()
{
return "我隐藏了基类";
}
}
}
看完了上面的代码,你现在能很好的区别重载与重写吗?希望这段代码对你有所帮助。
浏览量:2
下载量:0
时间:
Java和PHP都是编程语言,大家知道它们最大的区别就是一个是静态语言,一个是动态语言。下面,读文网小编再详细的解释一下这两者的具体区别和比,希望对你有帮助。
1、系统的技术架构比较
分层是将系统进行有效组织的方式,分而治之的思想是计算机领域中非常重要的思想。在好的分层思想引导下,便能实现“高内聚、低耦合”,也能将具体的问题 割裂开来,易于控制、易于延展,更易于分配资源。PHP只能实现简单的分布式两层或三层的架构,而JAVA在这方面就十分强大,可以实现多层的网络架构。运用MVC的设计模式,可使电子商务软件具有更加高效、合理的系统架构。技术架构的落后,使运用PHP编写的电子商务软件先天不足,而后天又无法补足其先天上的劣势。使得系统在可拓展性、需求应变性上与JAVA编写的电子商务软件系统的差距越来越大。架构的差距,注定了PHP做的电子商务充其量是个小家碧玉,始终无法和JAVA这种大家闺秀同台竞技。
2、数据库访问比较
PHP可编译成具有与许多数据库相连接的函数。将自己编写外围的函数去间接存取数据库。通过这样的途径当更换使用的数据库时,可以轻松地修改编码以适应这样的变化。但PHP提供的数据库接口支持彼此不统一,比如对Oracle,MySQL,SQL2000的接口,彼此都不一样。由于PHP对于不同的数据库采用不同的数据库访问接口,所以数据库访问代码的通用性不强。
3、安全性对比
在JAVA的面前,PHP丢掉了很多的优势。在代码的安全性上尤为突出。PHP的开发程序在别人拿到代码后,可以很容易的进行修改。而JAVA开发的程序由于无法看到完整的源代码,只能看到一些编译好的类文件.class,所以安全性较高。加之系统架构的优势,在安全性上PHP和JAVA是相去甚远。如果非要将PHP和JAVA在安全性上做个比较的话,同一个小偷光顾PHP那是随便拿来随便改,想拿什么拿什么,拿的高兴还能大笔一辉某某到此一游。而光顾JAVA的时候,便会发现警察把守,内设自动报警装置,即便突破重重阻扰后进入居室。那值钱的东西都放在加密后的保险柜中,只能望洋兴叹、铩羽而归。
4、前瞻性和拓展性
从整体来说,PHP适用于中小型系统,而JAVA适用于大型系统。PHP能够将单一的事件做好,但却不适合完成集成度较高的多项并发事件。为什么说PHP适合中小型系统而不适合做大系统呢?
首先,PHP缺乏多层结构支持。而对于大型的系统负荷站点,只能采用分布计算。将数据库、应用逻辑层和表示逻辑层彼此分开,并将同层的根据流量分开,组成二维数组。而PHP恰恰缺乏这种支持。
其次,PHP提供的数据库接口不统一,要将多个不同的数据库数据统一需要花费很大的力气。而JAVA则没有这种缺陷,可通过SUN JAVA的JAVA Class和EJB获得规模支持,通过EJB/CORBA以及众多厂商的Application Server获得结构支持。如ProBIZ的Merchant one电子商务软件产品系列。
#p#副标题#e#
浏览量:2
下载量:0
时间:
Java中sleep和wait都是用来进行线程控制的,这两者之间有什么区别呢?下面,读文网小编带你去了解一下sleep与wait的区别。
sleep是Thread类的静态方法。sleep的作用是让线程休眠制定的时间,在时间到达时恢复,也就是说sleep将在接到时间到达事件事恢复线程执行。例如:
try{
System.out.println("I'm going to bed");
Thread.sleep(1000);
System.out.println("I wake up");
}
catch(IntrruptedException e) {
}
wait是Object的方法,也就是说可以对任意一个对象调用wait方法,调用wait方法将会将调用者的线程挂起,直到其他线程调用同一个对象的notify方法才会重新激活调用者。例如:
https://Thread 1
try{
obj.wait();https://suspend thread until obj.notify() is called
}
catch(InterrputedException e) {
}
浏览量:2
下载量:0
时间:
switch和if语句都是Java的选择语句,这两种语句都是允许在程序运行时控制程序的执行过程。那么,switch和if在具体用法上什么具体区别,下面读文网小编给你介绍一下Java中switch和if语句的区别。
首先要看一个问题,if 语句适用范围比较广,只要是 boolean 表达式都可以用 if 判断;而 switch 只能对基本类型进行数值比较。两者的可比性就仅限在两个基本类型比较的范围内。
说到基本类型的数值比较,那当然要有两个数。然后重点来了——
if 语句每一句都是独立的,看下面的语句:
if (a == 1) ...
else if (a == 2) ...
这样 a 要被读入寄存器两次,1 和 2 分别被读入寄存器一次。于是你是否发现其实 a 读两次是有点多余的,在你全部比较完之前只需要一次读入寄存器就行了,其余都是额外开销。但是 if 语句必须每次都把里面的两个数从内存拿出来读到寄存器,它不知道你其实比较的是同一个 a。
于是 switch case 就出来了,把上面的改成 switch case 版本:
switch (a) {
case 0:
break;
case 1:
}
因为特定的规则,他一开始就知道你要比 a,于是 a 一次性读取,相比 if 节约了很多开销。
然后根据大量的实际程序测试(不考虑不同的编译器优化程度差异,假设都是最好的优化),那么Switch语句击中第三个选项的时间跟if/else if语句击中第三个选项的时间相同。
击中第一,第二选项的速度if语句快,击中第四以及第四之后的选项的速度switch语句快。
所以,如果所有选项出现概率相同的话,结论就是:5个选项(包括default)的情况下,switch和if/else if相同。低于5个选项if快,高于5给选项switch快!
浏览量:3
下载量:0
时间:
Java中有throw语句和throws语句,这两种语句都是用来抛出异常的。那么,这两种语句在具体运行的时候又有哪些区别呢?下面小编带你去了解一下。
用户程序自定义的异常和应用程序特定的异常,必须借助于 throws 和 throw 语句来定义抛出异常。
throw是语句抛出一个异常。
语法:
throw (异常对象);
throw e;
throws是方法可能抛出异常的声明。用在声明方法时,表示该方法可能要抛出异常。
语法:
[(修饰符)](返回值类型)(方法名)([参数列表])[throws(异常类)]{......}
public void doA(int a) throws Exception1,Exception3{......}
浏览量:2
下载量:0
时间:
在编程的时候往往会出现系统编译时无法检测到的错误,可是在运行时会出错,如果在可能出错的地方抛出异常,那样便严整了代码的正确性.比如数组越界,分母为0,文件等。 编程中会用try语句和throw语句来对编程运行过程中出现的异常情况进行处理。那么这两种有什么区别呢?下面小编带你去了解一下。
Java通过面向对象的方法进行异常处理,把各种不同的异常进行分类,并提供了良好的接口。在Java中,每个异常都是一个对象,它是Throwable类或其它子类的实例。当一个方法出现异常后便抛出一个异常对象,该对象中包含有异常信息,调用这个对象的方法可以捕获到这个异常并进行处理。
Java的异常处理是通过5个关键词来实现的:try、catch、throw、throws和finally。一般情况下是用try来执行一段程序,如果出现异常,系统会抛出(throws)一个异常,这时候你可以通过它的类型来捕捉(catch)它,或最后(finally)由缺省处理器来处理。
用try来指定一块预防所有“异常”的程序。紧跟在try程序后面,应包含一个catch子句来指定你想要捕捉的“异常”的类型。
throw语句用来明确地抛出一个“异常”。throws用来标明一个成员函数可能抛出的各种“异常”。
Finally为确保一段代码不管发生什么“异常”都被执行一段代码。可以在一个成员函数调用的外面写一个try语句,在这个成员函数内部写另一个try语句保护其他代码。
每当遇到一个try语句,“异常”的框架就放到堆栈上面,直到所有的try语句都完成。如果下一级的try语句没有对某种“异常”进行处理,堆栈就会展开,直到遇到有处理这种“异常”的try语句。
package book.exception;
/**
* 抛出异常和声明异常
* @author joe
*
*/
public class ThrowAndThrows {
/**
* 计算一个数字的平方根
* @param nStr 以字符串的形式提供数字
* @return 返回平方根
* @throws Exception 当用户输入的字符串为空,
* 或者字符串无法转换成数字,或者转换成的数字小于0,都会抛出异常
*/
public static double sqrt(String nStr) throws Exception {
if (nStr == null) {
https://用trow关键字抛出异常,当异常被抛出时,程序会跳出该方法
throw new Exception("输入的字符不能为空!");
}
double n = 0;
try {
n = Double.parseDouble(nStr);
} catch(NumberFormatException e) {
https://将parseDouble方法可能抛出的异常NumberFormatException捕获,
https://然后将捕获的异常重新封装并输出
throw new Exception("输入的字符串必须能够转化成数字!", e);
}
if (n < 0 ){
throw new Exception("输入的字符串转化成的数字必须大于0!");
}
return Math.sqrt(n);
}
public static void main(String[] args) throws Exception {
try{
ThrowAndThrows.sqrt("-124.56");
} catch(Exception e) {
https://将sqrt方法声明的可能抛出的Exception异常捕获
https://打印捕获的异常的堆栈信息,从堆栈信息中可以发现异常发生的位置和原因
System.out.println("Got a Exception:" + e.getMessage());
e.printStackTrace();
throw e; https://不做进一步处理,将异常向外抛出
}
https://将sqrt声明了可能会抛出的异常向外抛出,必须在方法声明中使用throws
ThrowAndThrows.sqrt("-124.56");
}
}
程序输出结果:
Got a Exception:输入的字符串转化成的数字必须大于0!
java.lang.Exception: 输入的字符串转化成的数字必须大于0!
at book.exception.ThrowAndThrows.sqrt(ThrowAndThrows.java:30)
at book.exception.ThrowAndThrows.main(ThrowAndThrows.java:37)
Exception in thread "main" java.lang.Exception: 输入的字符串转化成的数字必须大于0!
at book.exception.ThrowAndThrows.sqrt(ThrowAndThrows.java:30)
at book.exception.ThrowAndThrows.main(ThrowAndThrows.java:37)
源码分析:
在main方法里,由于sqrt方法的声明中有throws关键字,所以,在调用该方法时,必须对throws后面声明的异常进行处置,处置的方法有两种:
(1)main方法处理该异常,使用try.....catch语句,将可能会出现的异常的代码放在try块内,将处理异常的代码放在catch块内,并指明catch能够捕获的异常的类型,当异常被捕获时,执行catch块内的语句。
(2)main方法不处理该异常,将异常向外层程序抛出。在方法声明中使用throws关键字抛出异常,方法体中不需要使用try...catch语句。
异常类Exception的getMessage方法用来获取一场的描述信息,printStackTrace方法用来打印异常的堆栈信息,通过堆栈信息能够查明异常发生的原因和位置,在调试的时候常用。
浏览量:2
下载量:0
时间:
抽象类与接口紧密相关。然而接口又比抽象类更抽象,它们之间明显存在区别。那到底存在哪些方面的区别呢?下面读文网小编给大家讲讲Java中抽象类与接口的区别。
1,抽象类里可以有构造方法,而接口内不能有构造方法。
2,抽象类中可以有普通成员变量,而接口中不能有普通成员变量。
3,抽象类中可以包含非抽象的普通方法,而接口中所有的方法必须是抽象的,不能有非抽象的普通方法。
4,抽象类中的抽象方法的访问类型可以是public ,protected和默认类型,但接口中的抽象方法只能是public类型的,并且默认即为public abstract类型。
5,抽象类中可以包含静态方法,接口内不能包含静态方法。
6,抽象类和接口中都可以包含静态成员变量,抽象类中的静态成员变量的访问类型可以任意,但接口中定义的变量只能是public static类型,并且默认为public static类型。
7,一个类可以实现多个接口,但只能继承一个抽象类。
8.接口更多的是在系统框架设计方法发挥作用,主要定义模块之间的通信,而抽象类在代码实现方面发挥作用,可以实现代码的重用。
浏览量:3
下载量:0
时间:
Java中,我们应该知道最基本的就是定义变量和声明变量了,定义与声明这两者是有区别的,小编在此整理了Java中定义与声明的区别,供大家参阅,希望大家在阅读过程中有所收获!
所谓定义就是(编译器)创建一个对象,为这个对象分配一块内存,并给它取上一个名字,这个名字就是就是我们经常所说的变量名或对象名。
声明有2重含义:
(1) 告诉编译器,这个名字已经匹配到一块内存上,下面的代码用到变量或者对象是在别的地方定义的。声明可以出现多次。
(2) 告诉编译器,这个名字已经被预定了,别的地方再也不能用它来作为变量名或对象名。
浏览量:2
下载量:0
时间:
初学Java的人,可能在在很长一段时间里,对对象和引用的基本概念都是很模糊的,老是分不清楚两者的区别。下面,读文网小编给你整理一些有关对象和引用的区别供有需要的人参考。
相互关联体现在:
1)当对象的引用变量指向对象时,他们两就联系起来,改变引用的属性,就会改变对象的属性;
2)如果同一个对象被多个引用变量引用的话,则这些引用变量将共同影响这个对象本身。
相互独立体现在:
3)一个对象可以被不同的引用变量操纵,同时一个引用变量也可以指向不同的对象,但是同一时刻只能指向一个对象;
4)从存储空间上来说,对象和引用也是独立的,对象一般存储在堆中,而引用存储在堆栈(存储速度更快)中。
浏览量:2
下载量:0
时间:
Java中用final定义的变量可以看做一个常量,那么static与final之间有什么区别呢?下面小编告诉你。
final可修饰类、域(变量和常量)、方法 (而static不修饰类)
1、final修饰类,表示该类不可被继承。
如定义了一个final类:
final class SnowBird{
int i;
String s;
static void fly(){
System.out.println("snowbird is flying");
}
}
https://现在定义一个类,试图继承SnowBird类:
public class Bird extends SnowBird{
public static void main(String[] args){
SnowBird.fly();
}
}
把上面的两个类拷贝到文件中,文件名保存为Bird.java ,现在编译看看会出现什么问题?
出错信息是:cannot inherit from final SnowBird
表明final 类不可被继承。
那么,final修饰变量是怎么样呢?
2、final修饰变量
程序中经常需要定义各种类型的常量,如:3.24268,"201"等等。这时候我们就用final来修饰一个类似于标志符名字。如:
final String connectNumber = "201";
final表明 connectNumber是一个常量,它的取值在整个过程都不会改变。
如果把final 去掉则connectNumber就成为变量了。
有时我们为了节省空间,常量通常声明为 static .因为如上所说的 static 用的是类的内存空间。
3、修饰方法:
final修饰的方法,称为最终方法。最终方法不可被子类重新定义,即不可被覆盖。
如父类定义了public void fly(){ ....}
则子类就不能定义
public void fly(){。。。。。。}
但注意覆盖与重载的区别。不能被覆盖并不是不能被重载,如你还可以定义
public void fly(int i){.....},
举个例子如下:
class FinalValue {
static final int i = 1;
final void fly(){
System.out.println("SnowBird is flying over FinalValue ");
}
}
class TestFinal extends FinalValue {
int i = 2;
void fly(){
System.out.println("SnowBird is flying over TestFinal");
System.out.println("In class FinalValue static Final i = "+ FinalValue.i);
System.out.println("In class TestFinal i = "+ i);
}
void fly(String s){
System.out.println("fly("+ s + ")");
}
}
public class Test {
public static void main(String args[]){
TestFinal tf = new TestFinal();
tf.fly();
tf.fly("ok");
System.out.println(tf.i);
}
}
把上面的程序保存为Test.java编译看看,出现什么错误?
然后,把TestFinal类中的 void fly(){ ... } 注解掉
即 如下
/* void fly(){
System.out.println("SnowBird is flying over TestFinal");
System.out.println("In class FinalValue static Final i = "+ FinalValue.i);
System.out.println("In class TestFinal i = "+ i);
}*/
浏览量:2
下载量:0
时间:
在Java中,重写和重载都是Java多态性的两种不同表现形式,这两者之间的区别是人们好奇的。下面,小编跟大家讲一讲重写和重载的不同之处吧。
重写的规则
1.参数列表必须完全与被重写的方法的相同,否则不能称其为重写而是重载。
2.返回的类型必须一直与被重写的方法的返回类型相同,否则不能称其为重写而是重载。
3.访问修饰符的限制一定要大于被重写方法的访问修饰符(public>protected>default>private)
4.重写方法一定不能抛出新的检查异常或者比被重写方法申明更加宽泛的检查型异常。
例如:父类的一个方法申明了一个检查异常IOException,在重写这个方法是就不能抛出Exception,只能抛出IOException的子类异常,可以抛出非检查异常。
重载的规则
1.必须具有不同的参数列表。
2.可以有不同的返回类型,只要参数列表不同就可以了。
3.可以有不同的访问修饰符。
4.可以抛出不同的异常。
浏览量:2
下载量:0
时间:
对于Java中重载和覆盖的概念,很多人到现在都是搞不清楚,下面小编举例给大家讲讲这两者的区别。
下面是对override和overload的测试程序,其中注释中的内容都是会产生编译错误的代码,我们将注释去掉,看看在编译时会产生什么效果。
https:// 对overload测试的文件:OverloadTest.java
public class OverloadTest {
https:// 下面几个方法用来验证可以通过定义不同的参数类型和参数的数目进行方法重载。
public void fun(){
System.out.println("method fun in OverloadTest, no parameter");
}
public void fun(float f) {
System.out.println("method fun in OverloadTest, parameter type: float");
}
public void fun(int i){
System.out.println("method fun in OverloadTest, parameter type: int");
}
public void fun(int i1, int i2) {
System.out.println("method fun in OverloadTest, parameter type: int, int");
}
https:// 下面的两个方法用来验证可以通过定义不同的参数顺序进行方法重载。
https:// 需要注意:这里的参数肯定不是相同的类型,否则的顺序的先后就毫无意义。
public void fun1(int i, float f) {
System.out.println("method fun1 in OverloadTest, sequence of parameters is: int, float");
}
public void fun1(float f, int i) {
System.out.println("method fun1 in OverloadTest, sequence of parameters is: float, int");
}
https:// 下面的两个方法用来验证方法抛出的异常对于重载的影响.
https:// 无论是异常的类型还是异常的个数都不会对重载造成任何的影响。
public void fun2() throws TestException {
System.out.println("fun2 in OverloadTest, exception: TestException");
}
public void fun2(int i) throws TestException, TestException1 {
System.out.println("fun2 in OverloadTest, exception: TestException, TestException1");
}
public void fun2(float f) throws Exception {
System.out.println("fun2 in OverloadTest, exception: Exception");
}
https:// 不能通过抛出的异常类型来重载fun方法。
https://public void fun(int i) throws Exception {
https:// System.out.println("method fun in OverloadTest, parameter type: int, exception: Exception");
https://}
https:// ? 不能通过返回值重载fun方法。
https://public boolean fun(int i) throws Exception {
https:// System.out.println("method fun in OverloadTest, parameter type: int, exception: Exception, return: boolean");
https:// return true;
https://}
private void fun3() { }
https:// 不能通过不同的访问权限进行重载
public void fun3() { }
public static void main(String[] args) {
https:// 这里只是定义了OverloadTest的实例,所以test不会调用
https:// OverloadTest1中的方法。
OverloadTest test = new OverloadTest1();
https:// 这里定义了OverloadTest1的实例,因为OverloadTest1是OverloadTest
https:// 的子类,所以test1会调用OverloadTest中的方法。
OverloadTest1 test1 = new OverloadTest1();
try {
int i = 1, j = 2, m = 3;
https:// 这里不会调用OverloadTest1的fun方法
https:// test.fun(i, m, j);
test1.fun(i, j, m);
test1.fun();
https:// 这个调用不会执行,因为fun3()在OverloadTest中访问权限是priavte
https://test1.fun3();
test1.fun3(i);
} catch(Exception e) { }
}
}
class OverloadTest1 extends OverloadTest{
https:// 在子类中重载fun
public void fun(int i, int m, int n) {
System.out.println("Overload fun1 in OverloadTest1, parameter type: int, int, int");
}
https:// 这个不是对父类中方法的重载,只是一个新的方法。
public void fun3(int i) {
System.out.println("fun2 in OverloadTest1");
}
}
https:// 对override测试的文件:OverrideTest.java
public class OverrideTest {
public void fun() throws TestException {
System.out.println("method fun in OverrideTest");
}
private void fun1() {
System.out.println("method fun1 in OverrideTest");
}
public static void main(String[] args) {
OverrideTest test = new OverrideTest1();
try {
test.fun();
test.fun1();
} catch(Exception e) { }
}
}
class OverrideTest1 extends OverrideTest{
https:// 以下正常Override
public void fun() throws TestException2 {
System.out.println("fun in OverrideTest1");
}
https:// 不能Override父类中的方法,因为它定义了不同的异常类型和
https:// 返回值。
https://public int fun() throws TestException1 {
https:// System.out.println("method fun in Test");
https:// return 1;
https://}
https:// 不能Override父类中的方法,因为它抛出了比父类中非法范围
https:// 更大的异常。
https://public void fun() throws Exception {
https:// System.out.println("fun in OverrideTest1");
https://}
https:// 这个方法并没有Override父类中的fun1方法,因为这个方法在
https:// 父类是private类型,所以这里只是相当于定义了一个新方法。
public void fun1() {
System.out.println("method fun1 in Test");
}
}
class TestException extends Exception{
public TestException(String msg) {
super(msg);
}
}
class TestException1 extends TestException {
public TestException1(String msg) {
super(msg);
}
}
class TestException2 extends TestException {
public TestException2(String msg) {
super(msg);
}
}
浏览量:2
下载量:0
时间:
重载和覆盖是多态性的两大主要表现,学习代码的朋友对此可能会有所了解,但是可能理解不深,下面是小编带来的关于重载和覆盖的区别的内容,欢迎大家阅读!
public class Base{
int a,b;
public Base(int x,int y){
a = x;
b = y;
}
public int add(){
return (a + b);
}
public void add(int x,int y){
int z;
z = x + y;
}
}
上面这段代码就是重载的三个特征 :
1:方法名必须一样 “add()“。
2:返回类型可以不一样 就象是 ”int “和”void“.
3:参数可以不一样 就是add() 和add(int x,int y)这样的。
public class Base{
int x,y;
public void add(){
int z;
z = x + y;
}
}
public class Child extends Base{
int x,y;
public void add(){
int z;
z = x + y;
}
public static void main(string [] args){
Base b = new Child();
b.add();
}
}
下面这个例子就是重写,他实现了多态。
重写的要求是,方法名必须一样,返回类型必须一样,传入的参数必须一样。
在main函数中定义父类的对象,但是用子类去实例化他,这样就可以通过父类的对象调用到子类的方法。
下面举个例子,例如:
public class Parent {
public int addValue( int a, int b) {
int s;s = a+b;return s;
}
}
class Child extends Parent {
}
Which methods can be added into class Child?
a int addValue( int a, int b ){// do something...}
b public void addValue (){// do something...}
c public int addValue( int a ){// do something...}
d public int addValue( int a, int b )throws MyException {//do something...}
答案为B.C
解释1:
a是覆盖,b ,c是重载。
a的问题出在访问权限上,如果换成public也是可以的。
d是异常的问题。
解释2:
a的访问权限小于父类,所以错误,d是异常错误,b和c中的addValue方法和父类的方法参数不同,所以是重载。
猜你感兴趣:
浏览量:2
下载量:0
时间: