JAVA方法的重载、封装与重写

在Java中，方法名字相同，参数不同，返回类型可以相同可以不同，这就是JAVA中的重载，它是在一个类里面的。

然而每个重载的方法都是或者构造函数都必须有独一无二的参数类型列表，平时我们最常用的就是构造器的重载。

重载有以下规则，共六点：

1.被重载的方法必须形参列表不一样(参数个数或类型不一样)；

2.被重载的方法可以改变返回类型；

3.被重载的方法可以改变访问修饰符；

4.被重载的方法可以声明新的或更广的检查异常；

5.方法能够在同一个类中或者在一个子类中被重载。

6.返回值类型不能作为重载函数的区分标

下面看下代码：

public void say(String text){

System.out.println(this.age +"岁的"+this.name+"说：\""+text+"\"");

}

public void say(String text,String state){

System.out.println(this.age +"岁的"+this.name+state+"的说：\""+text+"\"");

}

public String say(String text,String state,String location){

return this.age +"岁的"+this.name+"在"+location+""+state+"的说：\""+text+"\""

}

 

//错误写法

public String say(String text){

return  this.age +"岁的"+this.name+"说：\""+text+"\"";

}

 

public String say(String text,String state){

System.out.println(this.age +"岁的"+this.name+state+"的说：\""+text+"\"");

}

其实我们在写上面代码之前需要封装下代码可以调用的：

那么java的封装是一种将抽象性函式接口的实现细节部份包装、隐藏起来的方法。

它可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访

问。

当然了，适当的封装可以让程式码更容易理解与维护，也加强了程式码的安全性。

那么它有什么优点呢：

1.良好的封装能够减少耦合。

2.类内部的结构可以自由修改。

3.可以对成员变量进行更精确的控制。

4.隐藏信息，实现细节

他的封装步骤为：

1. 修改属性的可见性来限制对属性的访问（一般限制为private）

2. 对每个值属性提供对外的公共方法访问，也就是创建getter 和 setter方法（将实例变量的首字母大写，在前面添加get或者set， 变成getter 和 setter方法名）

见下代码：

public class Person {

private String name;

private int age;

//===getter setter方法

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getAge() {

return age;

}

public void setAge(int age) {

if (age<0 || age>120) {

System.out.println("年龄不符合要求");

return;

} else {

this.age = age;

}

}

}

重写：

1. 重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。
2. 重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异

好处：

1.重写的好处在于子类可以根据需要，定义特定于自己的行为。 也就是说子类能够

规则：

1. 参数列表必须完全与被重写方法的相同；
2. 返回类型必须完全与被重写方法的返回类型相
3. 访问权限不能比父类中被重写的方法的访问权限
4. 父类的成员方法只能被它的子类重写。
5. 声明为final的方法不能被重写。
6. 声明为static的方法不能被重写，但是能够被再次声明。
7. 子类和父类在同一个包中，那么子类可以重写父类所有除了声明为private和final的
8. 构造方法不能被重写。
9. 如果不能继承一个方法则不能重写这个
10. 子类和父类不在同一个包中，那么子类只能够重写父类的声明为public和protected的非final方法。
11. 重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常。

代码示例：

先创建方法：

public class Bird {

int weight=0;

//private 成员变量

private int intPrivate=0;

//‐‐方法

public void fly(){

System.out.println("我是xx，我可以飞！");

}

public void eatting(){

System.out.println("....吃.....");

}

// private 方法

private void methodPrivate(){

System.out.println("....test.....");

}

}

重写方法：

public class Ostrch extends Bird{

int weigth=10;

//重写父类的方法 (override)

public void fly(){

System.out.println("我是xx，虽然我是xx但我不能飞！");

}

}

public class Demo2 {

public static void main(String[] args) {

//实例化 Ostrch 类

Ostrch ostrch=new Ostrch();

ostrch.fly();

ostrch.eatting();

}

}

看下运行结果:

重载与重写的区别：

重载（Overload）是一个类以统一的方式，可以处理不同类型数据的一种手段，他的表现就是多个具有不同的参数个数或者类型同名的函数（返回值类型可随意，不能以返回类型作为重载函数的区分标准）存在于同一个类中，是一个类多态性的一种表现形式。

 

重写（Override）是父类与子类之间的多态性，其实就是对父类的函数进行重新定义，要是在子类中定义的方法与父类有相同的名称和参数则该方法被称为重写，不过子类的访问修饰的权限不能低于父类的；要是子类中的方法与父类中的方法具有相同的方法名和返回类型还有参数列表，那么新的方法将覆盖原有的方法，要是想用父类中原有的方法那么使用   super 关键字。

 

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

象的父类