Java的继承、封装和多态

  • 一、封装
  • 1、概念：
  • 2、好处：
  • 3、封装的实现步骤
  • 二、继承
  • 1、概念：
  • 2、继承的好处：
  • 3、语法规则：
  • （1）方法的重写
  • （2）final关键字:
  • （3）super关键字
  • （4）Object类
  • 三、多态
  • 1.引用多态
  • 2.方法多态
  • A.引用类型转换
  • B.抽象类
  • C.接口


一、封装

1、概念：

将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问。

2、好处：

  1. 实现了专业的分工
  2. 良好的封装能够减少耦合
  3. 类内部的结构能够自由修改
  4. 可以对成员进行更精确的控制
  5. 隐藏信息，实现细节

3、封装的实现步骤

1）将属性私有化，设为private类型
2）对所有私有属性创建Getters和Setters方法

public class Circle {
             private double radius; 
             public final double getRadius() { 
                        return radius; 
             } 
             public final void setRadius(double radius) {
                             this.radius = radius; 
                             }
  ｝

二、继承

1、概念：

继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。JAVA不支持多继承，单继承使JAVA的继承关系很简单，一个类只能有一个父类，易于管理程序，父类是子类的一般化，子类是父类的特殊化（具体化)。

2、继承的好处：

子类拥有父类的所有属性和方法（除了private修饰的属性不能拥有）从而实现了实现代码的复用。

3、语法规则：

只要在子类加上extends关键字继承相应的父类就可以了：
子类 extends 父类；

（1）方法的重写

子类如果对继承的父类的方法不满意（不适合），可以自己编写继承的方法，这种方式就称为方法的重写。当调用方法时会优先调用子类的方法。
重写要注意：
　 a、返回值类型
　　b、方法名
　　c、参数类型及个数
　都要与父类继承的方法相同，才叫方法的重写。
重载和重写的区别：
　　方法重载：在同一个类中处理不同数据的多个相同方法名的多态手段。
　　方法重写：相对继承而言，子类中对父类已经存在的方法进行区别化的修改。

（2）final关键字:

使用final关键字做标识有“最终的”含义。
　　a. final 修饰类，则该类不允许被继承。
　　b. final 修饰方法，则该方法不允许被覆盖(重写)。
　　c. final 修饰属性，则该类的该属性不会进行隐式的初始化，所以 该final 属性的初始化属性必须有值，或在构造方法中赋值(但只能选其一，且必须选其一，因为没有默认值！)，且初始化之后就不能改了，只能赋值一次。
　　d. final 修饰变量，则该变量的值只能赋一次值，在声明变量的时候才能赋值，即变为常量。

（3）super关键字

在对象的内部使用，可以代表父类对象。
　　 a、访问父类的属性：super.age
　　 b、访问父类的方法：super.eat()

（4）Object类

Object类是所有类的父类，如果一个类没有使用extends关键字明确标识继承另一个类，那么这个类默认继承Object类。
Object类中的方法（可重写）
1、toString()
　 在Object类里面定义toString()方法的时候返回的对象的哈希code码(对象地址字符串)。
　　2、equals()
　　equals（）----返回值是布尔类型
　　3、getClass（）
　　可以得到类对象，判断类型是否一样
　　4.hashCode()
　　计算对象的存储位置

三、多态

1.引用多态

父类的引用可以指向本类的对象； Animal an = new Animal();
　　父类的引用可以指向子类的对象； Animal an = new Dog();

2.方法多态

创建本类对象时，调用的方法为本类方法；
　　创建子类对象时，调用的方法为子类重写的方法或者继承的方法；
　　使用多态的时候要注意：如果我们在子类中编写一个独有的方法（没有继承父类的方法），此时就不能通过父类的引用创建的子类对象来调用该方法！！！
　　注意： 继承是多态的基础。

A.引用类型转换

  1. 向上类型转换(隐式/自动类型转换)，是小类型转换到大类型
    2).向下类型转换(强制类型转换)，是大类型转换到小类型(有风险,可能出现数据溢出)。
    3)instanceof运算符，来解决引用对象的类型，避免类型转换的安全性问题。
    它的作用是测试它左边的对象是否是它右边的类的实例，返回boolean类型的数据
总结：在写程序的时候，如果要进行类型转换，
 我们最好使用instanceof运算符来判断它左边的对象是否是它右边的类的实例，
 再进行强制转换。

B.抽象类

定义：抽象类前使用abstract关键字修饰，则该类为抽象类。
1）抽象类是约束子类必须有什么方法，而并不关注子类如何实现这些方法
2） 抽象类应用场景：
　　　a. 在某些情况下，某个父类只是知道其子类应该包含怎样的方法，但无法准确知道这些子类如何实现这些方法(可实现动态多态)。
　　　b. 从多个具有相同特征的类中抽象出一个抽象类，以这个抽象类作为子类的模板，从而避免子类设计的随意性。
3） 抽象类定义抽象方法，只有声明，不需要实现。抽象方法没有方法体以分号结束，抽象方法必须用abstract关键字来修饰。
4）包含抽象方法的类是抽象类。抽象类中可以包含普通的方法，也可以没有抽象方法。
5）抽象类不能直接创建，可以定义引用变量来指向子类对象，来实现抽象方法。

C.接口

1、概念
　　接口可以理解为一种特殊的类，由全局常量和公共的抽象方法所组成。也可理解为一个特殊的抽象类，因为它含有抽象方法。　
　　　　　
2、接口定义的基本语法

[修饰符] [abstract] interface 接口名 [extends父接口1,2…]（多继承）{

0…n常量 (public static final)

0…n 抽象方法(public abstract)

}

其中[ ]里的内容表示可选项，可以写也可以不写;接口中的属性都是常量，即使定义时不添加public static final 修饰符，系统也会自动加上；接口中的方法都是抽象方法，即使定义时不添加public abstract修饰符，系统也会自动加上。
　　
3.使用接口
　　一个类可以实现一个或多个接口，实现接口使用implements关键字。java中一个类只能继承一个父类，是不够灵活的，通过实现多个接口可以补充。
　　继承父类实现接口的语法为：
　　　　　[修饰符] class 类名 extends 父类 implements 接口1，接口2…{
　　　　　　　类体部分//如果继承了抽象类，需要实现继承的抽象方法；要实现接口中的抽象方法
　　　　　}
　　　　
　　注意：如果要继承父类，继承父类必须在实现接口之前,即extends关键字必须在implements关键字前
　　
4.接口和匿名内部类配合使用
接口在使用过程中还经常和匿名内部类配合使用。匿名内部类就是没有没名字的内部类，多用于关注实现而不关注实现类的名称。