Java 学习记录4——封装、继承、多态

目录

封装：

继承

方法继承中的覆盖（重写）：

多态

---

1

封装：

（1）封装介绍：

• 私有属性不能外部直接访问。

（2）封装作用：

• 对于某事物，封装其复杂性，对外呈现较简单的操作入口。电视机，电冰箱等...
• 封装之后，才形成真正的对象，真正的独立体
• 意味着程序可以重复使用，这个事物的适应性比较强。
• 对于事物本身提高了安全性（安全级别高）

（3）封装的步骤：

• 所有属性私有化，使用private关键字进行修饰，private表示私有的。
• 修饰的所有数据只能在本类中进行访问。
• 对外提供简单的操作入口（对外提供两个公开的方法，分别是set和get方法）：
• 理解为==》通过实例对象的属性而创建的方法
• 想读取所修饰的属性，调用get方法
• 想修改所修饰的属性，调用set方法

（4）定义示范：

//1
public class Student {
    public String getName() {
        return name;
    }

    public void setName(String name) {
    //可以在该处设置是否执行下去的控制条件语句
        this.name = name;
    //this表示当前类，this.name表示下边的String name
    //等号右边的name表示传递进来的形参
    }

    private String name;//封装

}

• get函数和set函数没有static关键字

（5）调用：

• 实例对象名.方法名

• //2
          Student s3=new Student();
          s3.setName("张三");
          System.out.println(s3.getName());

2

继承

（1）继承：

• 基本作用：代码复用。重要作用：为"方法的覆盖"和”多态"做铺垫

（2）语法结构：

• [修饰符列表] class 类名 extends 父类名{类体=属性+方法}

（3）术语：B类继承A类

• A类：父类，基类，superclass
• B类：子类，派生类，subclass

（4）继承数据：

• 私有的不支持
• 构造方法不支持
• 其他数据支持

（5）另：

• Java只支持单继承，java语言支持间接继承
• 假设类没有显示的继承任何类，则默认继承javaSE库中的java.lang.Object类
• java语言中任何一个类都有Object类的特征

（6）简单示例：

//3
public class JianDanJiCen {
    public static void main(String[] args) {
        C c=new C();
        c.DaYin();
    }
}
class A{
    public void DaYin(){
        System.out.println("Hello");
    }
}
class B extends A{}
class C extends B{}

方法继承中的覆盖（重写）：

（1）什么时候方法重写：

• 父类方法无法满足之类需求，可以 重写==》过程为方法覆盖

（2）记： 

• 方法覆盖发生在有继承关系的父子类之间
• 返回值类型相同，方法名相同，参数列表相同
• 访问权限不能更低
• 静态方法不存在覆盖

 （3）示例：

//4
public class Animal {
    public void move(){
        System.out.println("动物在移动");
    }
    //输出：动物在移动
    public static void main(String[] args) {
        Animal a1=new Animal();
        a1.move();
    }
}

//连4
//5
public class Ma extends Animal{//继承
    public void move(){
         System.out.println("马儿在跑");
    }
    //输出：马儿在跑
    public static void main(String[] args) {
        Ma m1=new Ma();
        m1.move();
    }
}

3

多态

（1）理解：

• 动物在动，这个动物可以是马，猫，鸟

（2）多态中转型概念（需要两类具有类型继承关系）：

• 向上转型（upcasting）（自动类型转换）：子类型->父类型
• 向下转型（downcasting）（强制类型转换，需要强制类型转换符）：父类型->子类型

（3）多态语法机制：

（1）由方法重载实现的静态多样性（编译时多态）和方法覆盖实现的动态多样性（运行时多态）

//连4,5
//6
Animal a2 = new Ma();//向上类型转换
a2.move();//马儿在跑

理解：

• 编译时（静态绑定）确定move()在Animal类中是否具有，运行时(动态绑定)使用Ma类中的所具有的move()

（2）扩展

若需要a2使用Animal中没有，而Ma中有的方法（子类特有方法）==》向下类型转换

//连4，5，6
//7
Ma m2 = (Ma)a2;

向下类型转换编译不易判断 “所转类型是否为实例对象类型”，会出现ClassCastException的错误，解决方法：

//连7
//8
if(a2 instanceof Ma){//判断是否是所需要转型的类的对象
Ma m2 = (Ma) a2
}
//else...

（4）示例：

主人养猫，猫吃猫粮

//连10，11，12
//9
public class ZhuRen {
    public void feed(Pet pet){//参数部分多态
        pet.eat();
    }
}

//连9，11，12
//10
public class Pet {
    public void eat(){
        System.out.println("宠物在吃东西");
    }
}

//连9，10，12
//11
public class Cat extends Pet{
    public void eat(){//覆盖
        System.out.println("猫在吃猫粮");
    }
}

//连9，10，11
//12
public class Text {
    public static void main(String[] args) {
        ZhuRen r1=new ZhuRen();
        Cat c1=new Cat();
        r1.feed(c1);//相当于Pet pet = Cat c1
    }
}
//结果：猫在吃猫粮

多态理解：主人类面向的是一个抽象的Pet，不在面向具体的宠物

（5）多态作用：

 降低程序耦合度，提高程序扩展力