一起学 Java 面向对象(二),java面向对象

【课前思考】
  1. 什么是对象?什么是类?什么是包?什么是接口?什么是内部类?
  2. 面向对象编程的特性有哪三个?它们各自又有哪些特性?
  3. 你知道java语言在面向对象编程方面有何独特的特点吗?

一、方法函数

函数也称为方法,就是定义在类中的具有特定功能的一段独立代码。用于定义功能,提高代码的复用性。

函数的特点 1> 定义函数可以将功能代码进行封装,便于对该功能进行复用;
2> 函数只有被调用才会被执行;
3>
对于函数没有具体返回值的情况,返回值类型用关键字void表示,那么该函数中的return语句如果在最后一行可以省略不写,系统会帮你自动加上;
4> 函数中只能调用函数,不可以在函数内部定义函数。

  修饰符  返回值类型  方法名(参数类型 形式参数1,参数类型 形式参数2,..)
  {  
    方法体;
    return 返回值;
  }

//修饰符: 可选,告诉编译器如何调用该方法。定义了该方法的访问类型。
//返回值类型:函数运行后的结果的数据类型
//参数类型:形式参数的数据类型

 

主函数 main(): 1> 保证该类的独立运行;
2> 程序的入口,自动调用;
3> jvm调用。

 

函数的重载 (overload)

重载的概念:
  在同一个类中,允许存在一个以上的同名函数,只要它们的参数个数或者参数类型不同即可。
重载的特点:
  与返回值类型无关,只看参数列表。
重载的好处:
  方便于阅读,优化了程序设计。Java编译器根据方法签名判断哪个方法应该被调用。

什么时候用重载?

  当定义的功能相同,但参与运算的未知内容不同。

  那么,这时就定义一个函数名称以表示起功能,方便阅读,而通过参数列表的不同来区分多个同名函数。

     
重载的方法必须拥有不同的参数列表。你不能仅仅依据修饰符或者返回类型的不同来重载方法。

重载示例:
  返回两个整数的和
    int add(int x,int y){return x+y;}
  返回三个整数的和
    int add(int x,int y, int z){return x+y+z;}
  返回两个小数的和
    double add(double x,double y){return x+y;}

 

// 重载区分, 重载和返回值类型没关系
void show(int a,char b,double c){}

a. void show(int x,char y,double z){}//没有,因为和原函数一样。
b. int show(int a,double c,char b){} //重载,因为参数类型不同。
c. void show(int a,double c,char b){}//重载,因为参数类型不同。

 

澳门新葡亰游戏网址 1public
class functc { public static void draw(int row, int col){ for (int i=0;
i<row; i++){ for (int n=0; n<col; n++){ System.out.print(‘@’); }
System.out.println(); } } public static void main(String[] args) {
draw(5, 9); } } 打印一个二维数组
澳门新葡亰游戏网址 2public
class funcsj { } public static void main(String[] args) { print99(); }
public static void print99(){ for (int i=1; i<10; i++){ for (int n=1;
n<i+1; n++){ System.out.print(n+”*”+i+”=”+i*n+” “); }
System.out.println(); } } } // 结果 1*1=1 1*2=2 2*2=4 1*3=3 2*3=6
3*3=9 1*4=4 2*4=8 3*4=12 4*4=16 1*5=5 2*5=10 3*5=15 4*5=20
5*5=25 1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36 1*7=7 2*7=14
3*7=21 4*7=28 5*7=35 6*7=42 7*7=49 1*8=8 2*8=16 3*8=24 4*8=32
5*8=40 6*8=48 7*8=56 8*8=64 1*9=9 2*9=18 3*9=27 4*9=36 5*9=45
6*9=54 7*9=63 8*9=72 9*9=81 打印一个99乘法表
澳门新葡亰游戏网址 3public
class funcol { public static void main(String[] args) { int num =
add(5, 8, 9); System.out.print(num); //22 } public static int add(int
x,int y){ return x+y; } public static int add(int x,int y,int z){ return
add(x,y)+z; } } 函数重载

 

难点:
  1. 理解方法重载和方法重写,不要混淆了两者的使用。
  2. 类变量和类方法的使用。
  3. 接口的使用。

构造方法

当一个对象被创建时候,构造方法用来初始化该对象。构造方法和它所在类的名字相同,但构造方法没有返回值。

通常会使用构造方法给一个类的实例变量赋初值,或者执行其它必要的步骤来创建一个完整的对象。

不管你与否自定义构造方法,所有的类都有构造方法,因为Java自动提供了一个默认构造方法,它把所有成员初始化为0。

一旦你定义了自己的构造方法,默认构造方法就会失效。

public class myfunc {
    int x;
    myfunc(int i){
        x = i;
    }
}

澳门新葡亰游戏网址 4//
myfunc.java public class myfunc { int x; myfunc(int i){ x = i;
System.out.println(x); } } // MyDemoTest.java public class MyDemoTest {
public static void main(String args[]) { myfunc t1 = new myfunc(9);
myfunc t2 = new myfunc(5); System.out.println(t1.x + ” ” + t2.x); } } //
输出结果 9 5 9 5 构造方法实例

 

3.1 面向对象技术基础

可变参数

JDK 1.5 开始,Java支持传递同类型的可变参数给一个方法。

在方法声明中,在指定参数类型后加一个省略号(…) 。

一个方法中只能指定一个可变参数,它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。

//typeName... parameterName
public static void My( double... nums){...}

澳门新葡亰游戏网址 5public
class myfunc { public static void printNum( double… numbers) { double
result = numbers[0]; System.out.println(“The value index eq 0: ” +
result); for (int i = 1; i < numbers.length; i++){
System.out.println(“The value is ” + numbers[i]); } } public static
void main(String args[]) { // 调用可变参数的方法 printNum(1, 2, 9, 5,
8); printNum(new double[]{1, 2, 6}); } } // 输出结果 The value index
eq 0: 1.0 The value is 2.0 The value is 9.0 The value is 5.0 The value
is 8.0 The value index eq 0: 1.0 The value is 2.0 The value is 6.0 可变参数实例

 

3.1.1 面向对象的基本概念
  面向对象的基本思想
  面向对象是一种新兴的程序设计方法,或者是一种新的程序设计规范(paradigm),其基本思想是使用对象、类、继承、封装、消息等基本概念来进行程序设计。从现实世界中客观存在的事物(即对象)出发来构造软件系统,并且在系统构造中尽可能运用人类的自然思维方式。开发一个软件是为了解决某些问题,这些问题所涉及的业务范围称作该软件的问题域。其应用领域不仅仅是软件,还有计算机体系结构和人工智能等。

finalize() 方法

Java
允许定义这样的方法,它在对象被垃圾收集器析构(回收)之前调用,这个方法叫做
finalize( ),它用来清除回收对象。

例如,你可以使用 finalize() 来确保一个对象打开的文件被关闭了。

在 finalize() 方法里,你必须指定在对象销毁时候要执行的操作。

finalize() 一般格式是:

protected void finalize()
{
   // 在这里终结代码
}

关键字 protected 是一个限定符,它确保 finalize()
方法不会被该类以外的代码调用。

当然,Java 的内存回收可以由 JVM
来自动完成。如果你手动使用,则可以使用上面的方法。

澳门新葡亰游戏网址 6public
class myfunc { public static void main(String args[]) { Cake c1 = new
Cake(1); Cake c2 = new Cake(2); Cake c3 = new Cake(3); c2 = c3 = null;
System.gc(); //调用Java垃圾收集器 } } class Cake extends Object {
private int id; public Cake(int id) { this.id = id;
System.out.println(“Cake Object ” + id + “is created”); } protected void
finalize() throws java.lang.Throwable { super.finalize();
System.out.println(“Cake Object ” + id + “is disposed”); } } // 输出结果
Cake Object 1is created Cake Object 2is created Cake Object 3is created
Cake Object 3is disposed Cake Object 2is disposed finalize() 方法实例

 

1. 对象的基本概念
  对象是系统中用来描述客观事物的一个实体,它是构成系统的一个基本单位。一个对象由一组属性和对这组属性进行操作的一组服务组成。

二、修饰符类型

public 类:类属变量及方法,包内及包外的任何类均可以访问;
protected
类:
类属变量及方法,包内的任何类,及包外的那些继承了此类的子类才能访问;
private 类:类属变量及方法,包内包外的任何类均不能访问;
friendly
类:
类属变量及方法不以上这三种修饰符来修饰,那么包内的任何类都可以访问它,而包外的任何类都不能访问它(包括包外继承了此类的子类),因此,这种类、类属变量及方法对包内的其他类是友好的,开放的,而对包外的其他类是关闭的。

主动对象是一组属性和一组服务的封装体,其中至少有一个服务不需要接收消息就能主动执行(称作主动服务)。
2. 类的基本概念
类是具有相同属性和服务的一组对象的集合,它为属于该类的所有对象提供了统一的抽象描述,其内部包括属性和服务两个主要部分。在面向对象的编程语言中,类是一个独立的程序单位,它应该有一个类名并包括属性说明和服务说明两个主要部分。

类:

访问修饰符 修饰符 class 类名称 extends 父类名称 implement 接口名称
(访问修饰符与修饰符的位置可以互换)

访问修饰符

名称

说明

备注

public

可以被所有类访问(使用)

public类必须定义在和类名相同的同名文件中

package

可以被同一个包中的类访问(使用)

默认的访问权限,可以省略此关键字,可以定义在和public类的同一个文件中

修饰符

名称

说明

备注

final

使用此修饰符的类不能够被继承

 

abstract

如果要使用abstract类,之前必须首先建一个继承abstract类的新类,新类中实现abstract类中的抽象方法。

类只要有一个abstract方法,类就必须定义为abstract,但abstract类不一定非要保护abstract方法不可

 

3. 消息

变量:

l         Java中没有全局变量,只有方法变量、实例变量(类中的非静态变量)、类变量(类中的静态变量)。
l         方法中的变量不能够有访问修饰符。所以下面访问修饰符表仅针对于在类中定义的变量。
l         声明实例变量时,如果没有赋初值,将被初始化为null(引用类型)或者0、false(原始类型)。
l         可以通过实例变量初始化器来初始化较复杂的实例变量,实例变量初始化器是一个用{}包含的语句块,在类的构造器被调用时运行,运行于父类构造器之后,构造器之前。
l         类变量(静态变量)也可以通过类变量初始化器来进行初始化,类变量初始化器是一个用static{}包含的语句块,只可能被初始化一次。
 

访问修饰符

名称

说明

备注

public

可以被任何类访问

 

protected

可以被同一包中的所有类访问 可以被所有子类访问

子类没有在同一包中也可以访问

private

只能够被当前类的方法访问

 

缺省 无访问修饰符

可以被同一包中的所有类访问

如果子类没有在同一个包中,也不能访

修饰符

名称

说明

备注

static

静态变量(又称为类变量,其它的称为实例变量)

可以被类的所有实例共享。 并不需要创建类的实例就可以访问静态变量

final

常量,值只能够分配一次,不能更改

注意不要使用const,虽然它和C、C++中的const关键字含义一样
可以同static一起使用,避免对类的每个实例维护一个拷贝

transient

告诉编译器,在类对象序列化的时候,此变量不需要持久保存

主要是因为改变量可以通过其它变量来得到,使用它是为了性能的问题

volatile

指出可能有多个线程修改此变量,要求编译器优化以保证对此变量的修改能够被正确的处理

 

 

消息就是向对象发出的服务请求,它应该包含下述信息:提供服务的对象标识、服务标识、输入信息和回答信息。服务通常被称为方法或函数。

方法:

访问修饰符 修饰符 返回类型 方法名称(参数列表)throws 违例列表

l         类的构造器方法不能够有修饰符、返回类型和throws子句
l         类的构造器方法被调用时,它首先调用父类的构造器方法,然后运行实例变量和静态变量的初始化器,然后才运行构造器本身。
l         如果构造器方法没有显示的调用一个父类的构造器,那么编译器会自动为它加上一个默认的super(),而如果父类又没有默认的无参数构造器,编译器就会报错。super必须是构造器方法的第一个子句。
l         注意理解private构造器方法的使用技巧。

访问修饰符

名称

说明

备注

public

可以从所有类访问

 

protected

可以被同一包中的所有类访问 可以被所有子类访问

子类没有在同一包中也可以访问

private

只能够被当前类的方法访问

 

缺省 无访问修饰符

可以被同一包中的所有类访问

如果子类没有在同一个包中,也不能访问

修饰符

名称

说明

备注

static

静态方法(又称为类方法,其它的称为实例方法)

提供不依赖于类实例的服务 并不需要创建类的实例就可以访问静态方法

final

防止任何子类重载该方法

注意不要使用const,虽然它和C、C++中的const关键字含义一样
可以同static一起使用,避免对类的每个实例维护一个拷贝

abstract

抽象方法,类中已声明而没有实现的方法

不能将static方法、final方法或者类的构造器方法声明为abstract

澳门新葡亰游戏网址,native

用该修饰符定义的方法在类中没有实现,而大多数情况下该方法的实现是用C、C++编写的。

参见Sun的Java
Native接口(JNI),JNI提供了运行时加载一个native方法的实现,并将其于一个Java类关联的功能

synchronized

多线程的支持

当一个此方法被调用时,没有其它线程能够调用该方法,其它的synchronized方法也不能调用该方法,直到该方法返回

 

3.1.2 面向对象的基本特征

接口:

访问修饰符 interface 接口名称 extends 接口列表
l         接口不能够定义其声明的方法的任何实现
l         接口中的变量总是需要定义为“public static
final 接口名称”,但可以不包含这些修饰符,编译器默认就是这样,显示的包含修饰符主要是为了程序清晰

访问修饰符

名称

说明

public

所有 

无访问修饰符(默认)

同一个包内

 

1.封装性
  封装性就是把对象的属性和服务结合成一个独立的相同单位,并尽可能隐蔽对象的内部细节,包含两个含义:
  ◇
把对象的全部属性和全部服务结合在一起,形成一个不可分割的独立单位(即对象)。
  ◇
信息隐蔽,即尽可能隐蔽对象的内部细节,对外形成一个边界〔或者说形成一道屏障〕,只保留有限的对外接口使之与外部发生联系。
  封装的原则在软件上的反映是:要求使对象以外的部分不能随意存取对象的内部数据(属性),从而有效的避免了外部错误对它的”交叉感染”,使软件错误能够局部化,大大减少查错和排错的难度。

三、类的继承

2.继承性
  特殊类的对象拥有其一般类的全部属性与服务,称作特殊类对一般类的继承。

继承的特性:

  • 子类拥有父类非private的属性,方法和构造器。

  • 子类可以拥有自己的属性和方法,即子类可以对父类进行扩展。

  • 子类可以用自己的方式实现父类的方法。

  • Java的继承是单继承,但是可以多重继承,单继承就是一个子类只能继承一个父类,多重继承就是,例如A类继承B类,B类继承C类,所以按照关系就是C类是B类的父类,B类是A类的父类,这是java继承区别于C++继承的一个特性。

  • 提高了类之间的耦合性(继承的缺点,耦合度高就会造成代码之间的联系)。

一个类可以是多个一般类的特殊类,它从多个一般类中继承了属性与服务,这称为多继承。

 

在java语言中,通常我们称一般类为父类(superclass,超类),特殊类为子类(subclass)。

关键字

    继承可以使用 extends 和 implements
这两个关键字来实现继承,而且所有的类都是继承于
java.lang.Object,当一个类没有继承的两个关键字,则默认继承object(这个类在 java.lang 包中,所以不需要 import)祖先类。

extends关键字

   
在Java中,类的继承是单一继承,也就是说,一个子类只能拥有一个父类,所以
extends 只能继承一个类。

implements关键字

    使用 implements
关键字可以变相的使java具有多继承的特性,使用范围为类继承接口的情况,可以同时继承多个接口(接口跟接口之间采用逗号分隔)。

super 与 this 关键字

   
super关键字:我们可以通过super关键字来实现对父类成员的访问,用来引用当前对象的父类。

    this关键字:指向自己的引用

final关键字

    final
关键字声明类可以把类定义为不能继承的,即最终类;或者用于修饰方法,该方法不能被子类重写:

声明类:
    final class 类名 {//类体}
声明方法:
    修饰符(public,private,void,protected等) final 返回值类型 方法名(){//方法体}

实例变量也可以被定义为final,被定义为final的变量不能被修改。被声明为final的内的方法自动地声明为final,但是实例变量并不是final。

 

3.多态性
  对象的多态性是指在一般类中定义的属性或服务被特殊类继承之后,可以具有不同的数据类型或表现出不同的行为。这使得同一个属性或服务在一般类及其各个特殊类中具有不同的语义。例如:”几何图形”的”绘图”方法,”椭圆”和”多边形”都是”几何图”的子类,其”绘图”方法功能不同。
3.1.3 面向对象程序设计方法
  OOA-Object Oriented Analysis     面向对象的分析
  OOD-Object Oriented Design      面向对象的设计
  OOI-Object Oriented Implementation  面向对象的实现
3.2 Java语言的面向对象特性

构造器

   
子类不能继承父类的构造器(构造方法或者构造函数),但是父类的构造器带有参数的,则必须在子类的构造器中显式地通过super关键字调用父类的构造器并配以适当的当属列表。

   
如果父类有无参构造器,则在子类的构造器中用super调用父类构造器不是必须的,如果没有使用super关键字,系统会自动调用父类的无参构造器。

 

澳门新葡亰游戏网址 7class
Animal { private String name; private int id; public Animal(String
myName, int myid) { name = myName; id = myid; } public void eat(){
System.out.println(name+”正在吃”); } public void sleep(){
System.out.println(name+”正在睡”); } public void introduction() {
System.out.println(“Hello everyone, my cardid is “+ id + “, and my name
is ” + name + “.”); } } class Bird extends Animal { public Bird(String
myName, int myid) { super(myName, myid); } } class Dog extends Animal {
public Dog(String myName, int myid) { super(myName, myid); } } class
SuperClass { private int n; SuperClass(){
System.out.println(“SuperClass()”); } SuperClass(int n) {
System.out.println(“SuperClass(int n)”); this.n = n;
System.out.println(“SuperClass(int n):”+this.n); } } class SubClass
extends SuperClass{ private int n; SubClass(){ super(300);
System.out.println(“SuperClass”); } public SubClass(int n){ super(500);
System.out.println(“SubClass(int n):”+n); this.n = n;
System.out.println(“n:”+n+”, this.n:”+this.n); } } public class
AnimalMain { public static void main(String[] args){ Animal
Mouseobjone = new Dog(“小虎”, 9); Mouseobjone.eat(); //小虎正在吃
Mouseobjone.introduction(); //Hello everyone, my cardid is 9, and my
name is 小虎. Animal Mouseobjtwo = new Dog(“贝贝”, 5);
Mouseobjtwo.eat(); //贝贝正在吃 Mouseobjtwo.introduction(); //Hello
everyone, my cardid is 5, and my name is 贝贝. SubClass sc = new
SubClass(); //输出 //SuperClass(int n) //SuperClass(int n):300
//SuperClass SubClass sc2 = new SubClass(200); //输出 //SuperClass(int
n):500 //SubClass(int n):200 //n:200, this.n:200 } } practice

 

3.2.1 类
  类是java中的一种重要的复合数据类型,是组成java程序的基本要素。它封装了一类对象的状态和方法,是这一类对象的原形。一个类的实现包括两个部分:类声明和类体

四、重写(Override)与重载(Overload)

方法的重写(Overriding)和重载(Overloading)是java多态性的不同表现,重写是父类与子类之间多态性的一种表现,重载是一类中多态性的一种表现。

1.类声明:
  [public][abstract|final] class className [extends
superclassName] [implements interfaceNameList]
  {……}
  其中,修饰符public,abstract,final
说明了类的属性,className为类名,superclassName为类的父类的名字,interfaceNameList为类所实现的接口列表。
 2.类体
  类体定义如下:
  class className
  {[public | protected | private ] [static]
  [final] [transient] [volatile] type
  variableName;                 //成员变量
  [public | protected | private ] [static]
  [final | abstract] [native] [synchronized]
  returnType methodName([paramList]) [throws exceptionList]
   {statements}                 //成员方法
  }
 3.成员变量
  成员变量的声明方式如下:
  [public | protected | private ] [static]
  [final] [transient] [volatile] type
  variableName;                 //成员变量
  其中,
  static: 静态变量(类变量);相对于实例变量
  final: 常量
  transient:
暂时性变量,用于对象存档,用于对象的串行化,见对象的串行化一节
  volatile: 贡献变量,用于并发线程的共享
 4.成员方法
  方法的实现包括两部分内容:方法声明和方法体。
  [public | protected | private ] [static]
  [final | abstract] [native] [synchronized]
  returnType methodName([paramList])
  [throws exceptionList]            //方法声明
   {statements}                //方法体
  方法声明中的限定词的含义:
  static: 类方法,可通过类名直接调用
  abstract: 抽象方法,没有方法体
  final: 方法不能被重写
  native: 集成其它语言的代码
  synchronized: 控制多个并发线程的访问
  ◇ 方法声明
  方法声明包括方法名、返回类型和外部参数。其中参数的类型可以是简单数据类型,也可以是复合数据类型(又称引用数据类型)。
  对于简单数据类型来说,java实现的是值传递,方法接收参数的值,但不能改变这些参数的值。如果要改变参数的值,则用引用数据类型,因为引用数据类型传递给方法的是数据在内存中的地址,方法中对数据的操作可以改变数据的值。
  例3-1说明了简单数据类型与引用数据的区别。
【例3-1】
  import java.io.*;
  public class PassTest{
  float ptValue;
  public static void main(String args[]) {
  int val;
  PassTest pt=new PassTest();
  val=11;
  System.out.println(“Original Int Value is:”+val);
  pt.changeInt(val);                   //值参数
  System.out.println(“Int Value after Change is:” +val); /*值参数
                    值的修改,没有影响值参数的值*/
  pt.ptValue=101f;
  System.out.println(“Original ptValue is:”+pt.ptValue);
  pt.changeObjValue(pt); //引用类型的参数
  System.out.println(“ptValue after Change is:”+pt.ptValue);/*
引用参数值的修改,改变了引用参数的值*/
  }
  public void changeInt(int value){
  value=55;            //在方法内部对值参数进行了修改
  }
  public void changeObjValue(PassTest ref){
  ref.ptValue=99f;        //在方法内部对引用参数进行了修改
    }
  }

重写规则:

  • 参数列表必须完全与被重写方法的相同;
  • 返回类型必须完全与被重写方法的返回类型相同;
  • 访问权限不能比父类中被重写的方法的访问权限更低。例如:如果父类的一个方法被声明为public,那么在子类中重写该方法就不能声明为protected。
  • 父类的成员方法只能被它的子类重写。
  • 声明为final的方法不能被重写。
  • 声明为static的方法不能被重写,但是能够被再次声明。
  • 子类和父类在同一个包中,那么子类可以重写父类所有方法,除了声明为private和final的方法。
  • 子类和父类不在同一个包中,那么子类只能够重写父类的声明为public和protected的非final方法。
  • 重写的方法能够抛出任何非强制异常,无论被重写的方法是否抛出异常。但是,重写的方法不能抛出新的强制性异常,或者比被重写方法声明的更广泛的强制性异常,反之则可以。
  • 构造方法不能被重写。
  • 如果不能继承一个方法,则不能重写这个方法。
  • 当需要在子类中调用父类的被重写方法时,要使用super关键字。

澳门新葡亰游戏网址 8class
Animal{ public void move(){ System.out.println(“动物可以行走”); } }
class Dog extends Animal{ public void move(){ super.move();
System.out.println(“狗会跳”); } public void bark(){
System.out.println(“狗会叫”); } } public class Override { public static
void main(String args[]){ Animal animalobj = new Animal(); Dog dogobj
= new Dog(); animalobj.move(); dogobj.move(); //dogobj.bark();
//会报错!!!抛出一个编译错误,因为dogobj的引用类型Animal没有bark方法。
} } practice

 

◇ 方法体
  方法体是对方法的实现,它包括局部变量的声明以及所有合法的Java指令。方法体中声明的局部变量的作用域在该方法内部。若局部变量与类的成员变量同名,则类的成员变量被隐藏。
为了区别参数和类的成员变量,我们必须使用this。this—–用在一个方法中引用当前对象,它的值是调用该方法的对象。返回值须与返回类型一致,或者完全相同,或是其子类。当返回类型是接口时,返回值必须实现该接口。
5.方法重载
 方法重载是指多个方法享有相同的名字,但是这些方法的参数必须不同,或者是参数的个数不同,或者是参数类型不同。返回类型不能用来区分重载的方法。
  参数类型的区分度一定要足够,例如不能是同一简单类型的参数,如int与long。编译器会根据参数的个数和类型来决定当前所使用的方法。

重载(overloading)

是在一个类里面,方法名字相同,而参数不同。返回类型可以相同也可以不同。

每个重载的方法(或者构造函数)都必须有一个独一无二的参数类型列表。

只能重载构造函数

重载规则:

  • 被重载的方法必须改变参数列表(参数个数或类型或顺序不一样);
  • 被重载的方法可以改变返回类型;
  • 被重载的方法可以改变访问修饰符;
  • 被重载的方法可以声明新的或更广的检查异常;
  • 方法能够在同一个类中或者在一个子类中被重载。
  • 无法以返回值类型作为重载函数的区分标准。

澳门新葡亰游戏网址 9public
class Overloading { public int test(){ System.out.println(“This is
one.”); return 1; } public void test(int a){ System.out.println(“This is
two.”); } public String test(int a,String s) { System.out.println(“This
is three.”); return “3”; } public static void main(String args[]) {
Overloading olobj = new Overloading(); System.out.println(olobj.test());
//This is one.、1 olobj.test(1); //This is two.
System.out.println(olobj.test(1, “test3”)); //This is three.、3 } }
practice

 

6. 构造方法
  ◇ 构造方法是一个特殊的方法。Java
中的每个类都有构造方法,用来初始化该类的一个对象。
  ◇ 构造方法具有和类名相同的名称,而且不返回任何数据类型。
  ◇ 重载经常用于构造方法。
  ◇ 构造方法只能由new运算符调用

五、多态

网站地图xml地图