Java 的封装、继承、重写

Java封装

在面向对象程式设计方法中，封装(英文：Encapsulation)是指一种抽象性函数接口的实现细节部分包装、隐藏起来的方法。

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

要访问该类代码和数据，必须通过严格的接口控制。

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

封装的优点

良好的封装能够减少耦合

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

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

隐藏信息，实现细节

实现Java封装的步骤

修改属性的可见性来限制对属性的访问(一般限制为private)

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

代码示例：  

private String name;

private int age;

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

Java继承

继承的概念

基础概念是java面向对象编程技术的一块基石，因为它允许创建分等级层次的类

继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

类的继承格式：class 父类 {}class 子类 extends 父类 {}

继承类型

需要注意的是Java不支持多继承，但支持多重继承

public class Bird {

int weight=0;

//private 成员变量

// private int intPrivate=0;

 

//方法

public void fly(){

System.out.println("I am a bird,I can fly");

}

public void eatting(){

System.out.println("……eat……");

}

}

 

public class Eagle extends Bird{

public static void main(String[] args) {

//实例化 Eagle

Eagle eagle=new Eagle();

//使用成员变量

eagle.weight=3;

System.out.println(eagle.weight);

//调用方法

eagle.fly();

eagle.eatting();

}

}

 

public class Demo {

public static void main(String[] args) {

//实例化Eagle

Eagle eagle=new Eagle();

//使用成员变量

eagle.weight=3;

System.out.println(eagle.weight);

//调用方法

eagle.fly();

eagle.eatting();

 

//Ostrch

Ostrch ostrch=new Ostrch();

ostrch.weight=50;

 

System.out.println(ostrch.weight);

ostrch.fly();

ostrch.eatting();

}

}

 

方法的重写

重写是子类对父类的允许访问的方法的实现过程进行重新编写，返回值和形参都不能改变。

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

重写方法不能抛出新的检查异常或者比重写方法声明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOException，但是在重写这个方法的时候不能抛出Exception异常，因为Exception是IOException的父类，只能抛出IOException的子类异常。

 

方法的重写规则：

参数列表必须完全与被重写方法的相同；

返回雷兴国必须完全与被重写方法付的返回类型相同；

访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为public，那么在子类中重写该方法就不能声明为protected。

父类的成员方法只能被它的子类重写。

声明为final的方法不能被重写。

声明为static的方法不能被重写，但是能够被再次声明。

子类和父类在同一个包中，那么子类可以重写父类所有除了声明为private和final的方法。

子类和父类不在同一个包中，那么子类只能够重写父类的声明为public和protected的非final方法。

 

重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性的异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。

构造方法不能被重写。

如果不能继承一个方法，则不能重写这个方法。

public class Bird {

int weight=0;

//private 成员变量

// private int intPrivate=0;

 

//方法

public void fly(){

System.out.println("I am a bird,I can fly");

}

public void eatting(){

System.out.println("……eat……");

}

}

 

public class Ostrch extends Brid{

 

//方法的重写，范围修饰符范围必须大于或等于父类方法的修饰范围

//一般，一样

//形参列表必须相同

public void fly(){

//如果要调用父类的方法

super.fly();

System.out.println("I am a drid,But I can't fly");

}

public class Demo {

public static void main(String[] args) {

//Ostrch

Ostrch ostrch=new Ostrch();

ostrch.weight=50;

 

System.out.println(ostrch.weight);

ostrch.fly();

ostrch.eatting();

}

}

Super与this关键字

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

This关键字：指向自己的引用。

public class Ostrch extends Brid{

int weight=10;

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

public void fly(){

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

}

//super this 关键字

public void spuerThisDemo(){

//this，调用自身的方法或成员变量

System.out.println(this.weight);

this.fly();

//super，子类中调用父类的方法或成员变量

System.out.println(super.weight);

super.fly();

}

}

重写与重载的之间的区别

区别点	重载方法	重写
参数列表	必须修改	一定不能
返回类型	可以修改	一定不能
异常	可以修改	可以减少或删除一定不能抛出新的或者更广的
访问	可以修改	一定不能做更严格的限制（可以降低限制）

 

方法的重载是一个类中定义了多个方法名相同，而它们的参数的数量不同或数量相同而类型和次序不同，则称为方法的重载（overload）。

方法重写是在子类存在方法与父类的方法的名字相同，而且参数的个数与类型一样，返回值也一样的方法，就称为重写（override）。

方法重载是一个类的多态性表现，而方法重写是子类与父类的一种多态性表现啊。