面向对象：封装 继承 多态

封装 

一.理解什么是封装

    a.大家想一想生活中封装是什么？包装  ：快递  ：打包

    b.例如： 浩浩去网上买了个充气娃娃{ 需要打包 }安全，隐式 ，保密 扎两针

    c.例如： 买了一条狗狗活的：{打包} 准备吃狗肉...打包就需要透气，外界交流

    d.必须是你打开：只要有一定权限的人就可以打开

    e.台式机电脑：机箱[ 主板 显卡  内存  电源  硬盘。。。]

2.如上示例的共同点总结：

    通过封装的操作，可以达到从物理层面控制访问（外面不能轻易访问到里面内容--》这个就是物理层面）

3.那Java程序是如何进行封装呢？ 怎么封装上面的机箱呀？

 

二.Java中的封装如何实现的

1. 程序中一切都是虚幻的：电脑类：伪代码：
2. 如何控制程序中的访问 ？

            通过给类中的成员（字段，方法，构造方法）添加访问权限来实现访问控制

    3.什么是访问权限：

            例子：比如做一个系统，不同人登录进去，的访问权限不一样；

    4.访问权限修饰符： private < 默认不写（注意不要添加default修饰）<  protected < public

           private ：私有的 最小权限，被它修饰的成员只能够在本类中可以访问到；

            public  ：公共的 最大权限，任何地方和任何人都能访问；

    5.测试：变量 age是private修饰的（私有的）只能够在Student本类中可以被访问

    6.为什么需要将字段私有化起来： 安全

三.封装的步骤

1.私有化字段，提供private的权限
 2.标准的提供getset方法！而且本质就是普通方法而已...
 3.提供一个无参数的构造方法

 4.注意：如果字段类型是boolean sex;
            方法名字规范：
             setSex
             getSex---变成---->isSex

  5.未来：工具根据字段，自动生成getSet方法

四.封装小结

1. 封装的意识
2. 在Java 中的体现及步骤

            1）把类中的字段私有化；

            2）给每一个字段都提供一组getter  setter方法  (方法的规范写法)；setXxx

                    在测试类中尝试创建对象,并通过调用getter setter方法完成 对字段的赋值和取值；

            3）提供一个无参数的构造方法

      3.思考:

            1）能否把一个字段的get 和set方法写成一个方法   

                    a.不可取（比如 当我只是取值的时候，还需要传入参数，这不好）

            2）一个类中的多个字段的赋值方法 写成一个方法

                    a.不可取  耦合度太高(万一我们只想给某一个字段赋值)

             3)单一职能原则:功能最小化,不要想着一个方法写完所有的功能

    4.给对象的字段赋值 一共有哪些方式：

            1)直接访问字段赋值   标准java类 X 字段一般都会给私有化（私有化访问不到）；

            2)通过构造方法赋值    只能够创建对象的时候赋初始值；

                       new Student("小李");

                        new Student("小李飞刀");

                    上面的代码 不是把“小李”修改成“小李飞刀”，而是重新创建对象；

            3)通过setXxx方法赋值  更灵活；

                        setXxx 这么好是否就可以不要构造方法了呢？

                        两者不冲突，一般可以在创建的时候赋值，也可以后面进行修改

                          Student s = new Student("小李飞刀");

                            s.setName("小李飞刀");

    5.JavaBean (就是一个标准的Java类):-->(就业班才讲)

            1）字段必须私有化

            2）给每一个字段提供合理的getter setter方法

            3）必须有一个公共的无参数的构造方法;  

 

        继承

一。什么是继承

1. 专业解释：

            1)泛华：在多个子类的基础上面抽取共有属性的行为到一个父类中去

            2)特化：在一个父类的基础上拓展子类特有的属性和行为，生成一个新的子类

            3)原则：父类存放共性，子类存放特性

    2.代码理解：

            1)三个类都有重复的代码，可以把这部分内容 抽出去，抽出去放到另外一个类里面；

                a.上面的类我们叫做  父类（超类，基类，根类）

            2)下面的3个类和上面的类需要发生一点关系【继承】

                 a.下面的类我们叫做 子类（派生类，拓展类）

    3.提取好处 : 提高了代码的复用性

二。java中继承的基本语法

1. Java类中的继承的语法格式:

                    class Animal{}

                    class Person extends Animal{} //目标就是为了继承到Animal,这个类型

                    A 就是B的父类; B是A的子类

------------------------------------------------------------------------------

        1）没有导包Arrays:

        2）class Tools extends java.util.Arrays{ }

        3）导包了Arrays

        4）class Tools extends Arrays{ }

    2.验证:子类中是否可以继承到父类中的东西(通过创建子类对象来操作从父类继承的东西)

 

三。子类可以从分类继承哪些成员

1. 思考 : 一个父类中可能有哪些?    字段  方法  构造方法
2. 思考 : 可能还和访问权限有关     private  public
3. 验证 :非私有的字段 和方法 可以被继承到（暂时这样记忆-主要是从是否可以访问的层面考虑）
4. 构造方法不能够被继承:java规定

    5.子类可以继承到父类的特性class MyFrame extends java.awt.Frame{}

 

四.继承的特点

1. Java中类的继承只能够是单继承
2. 可以支持多重继承
3. 每一个类都有一个直接父类,如果没有看到显示的继承代码,那么就隐式继承就Object

 

五。继承总结

1. 继承的概念引入
2. 继承的基本语法
3. 继承到父类的那些东西

        （1）非私有的字段及方法

        （2）父类特性

    4.继承的特点

        （1）单继承

        （2）多重继承

        （3）没有显示的继承,那么隐式的继承Object

 

多态

一.多态的引入

1. 简单理解一种事物的多种形态
2. 示例：
   1. 今天晚上请大家吃大餐 : 思想上的大餐 , 凉开水
   2. 同学们准备买一辆车:   宾利 兰博基尼  柯塞尼格
   3. 同学们要上天 :  坐飞机,
3. java代码中的体现

            1）一个动物就是一个蛇  false 

            2）一个动物就是一个猪  false

            3）一个动物就是一个人  false

            4）一个人就是一个动物：Animal aml = new Person();//一个动物变量中，可能存放子类对象的多可能

                    a.一个大的数据类型兼容小的数据类型的

            5）一个猪就是一个动物：Animal aml = new Pig();

            6）一个蛇就是一个动物：Animal aml = new Snak();

            7）一个人就是一个猪Person pson = new Pig();

            8）一个蛇就是一个人

            9）一个猪就是一个蛇

二.什么是多态

1. 一个人就是一个动物：

                a.Animal aml = new Person();//一个动物变量中，可能存放子类对象的多种可能

1. 理解：使用aml：编译是看的是Animal类型，运行时看的是实际存放的对象[真实类型]
2. 官方概念：编译时跟运行时类型不一致就产生了多态
3. 民间理解：父类类型的变量，存放子类类型的对象，可能存放子类类型的对象有多种可能
4. 多态存在的前提：必须有继承关系

三.多态方法调用编译运行过程

1.编译时，看的是父类类型，会现在父类中，看有不有对应的方法，如果没有继续向上找{更高父类}
          如果找到了，编译通过，如果找不到，编译失败报错
 2.运行时：看真实类型，如果在真实类型中找到了，就运行真实类型中的函数，如果没有找到，向上找

          问题：编译通过了，但是运行可不可能找不到？不可能的，因为编译都已经说明了，上面一定有

四.多态体现的集中情况

1. 如上代码多态的体现的本质：都是父类类型的变量存放子类类型的对象
2. Dog dog = new XDog();//核心本质
3. 方法参数传递：方法形参父类类型，允许传子类类型对象

            a.Dog dog = new XDog();

            b.XDog xdog = new XDog();

            c.void feedDog(Dog dog){   }//此方法运行传递上面两个参数dog   或者  xdog   :  本质传递的都是子类对象

    4.方法返回值

            Dog getDog(){//此方法返回值类型为父类类型Dog

                        return new XDog();//允许返回子类类型

            }

            思考：方法内部返回值的类型一定是，方法返回值位置指定的类型么？

     5.多态的好处：屏蔽了不同子类之间实现的差异

     6.加强面向对象编程思想：

            a.此处体现java语言设计是想，希望将现实生活中的对象与对象之间的关系在计算机系统得以体现

五.多态小结

1. 多态的概念
2. 编译时运行时过程
3. 多态的用途【多态的方法参数传递】

            a.结合面向对象编程思想及执行流程分析

    4.多态在代码中如何体现的

    5.多态的好处

    6.加强面向对象编程思想的认识

 

 

 

 

 

 

 

 

 

 

 

转载于:https://my.oschina.net/u/4083647/blog/3027694