2019-03-20 面向对象

1.面向对象的封装:

    1)封装的概念

            封装就是打包,把东西包装在一个容器里,当需要的时候就从容器里取

            在java中则是添加一个访问权限,来控制这部分数据可以被哪些权限访问

    2)在Java 中的体现及步骤

        (1)把类中的字段私有化;

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

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

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

                1>那么如果把set和get方法写成一个方法呢?

                这个时候我们需要考虑:

                    a.如果我们只是要取值或者只是要赋值的时候呢

                    b.传入的值和传出的值要怎么办  

                2>如果把一个类中的多个字段的赋值方法 写成一个方法 

                    a.同理,如果我们只是要传入一个字段的值呢

                 总结:我们应该让功能单一且最小化,防止冲突

    3)给对象的字段赋值 一共有哪些方式:

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

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

                new Student(“小李”);

                new Student(“小李飞刀”);

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

        (3)通过(set+字段名)方法赋值  更灵活;

            set方法虽然非常方便,但是它和有参数的构造方法之间并不冲突,创建对象时赋值后面还是可以修改,例如:

                Student s = new Student(“小李飞刀”);

                s.setName(“小李他妈的飞刀”);

    4)JavaBean (一个标准的Java类)

        (1)字段必须私有化

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

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

    5)权限修饰符:public   private   protected   默认不写

        (1)(共同)可以修饰哪些东西:

                a.内部类

                b.类中的字段

                c.类中的方法

                补充:public和  默认不写  可以修饰外部类

        (2)各个修饰符代表的权限

                             同一个类中的成员                        同一个包中的成员                        不同包但存在继承的子类                        全局

private(私有)                    √   

默认不写                          √                                                    √  

protected(受保护)           √                                                    √                                                                √ 

public(公共)                     √                                                    √                                                                √                                                √

2.继承

    1)概念:

    (1)专业解释:

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

        b.特化:在一个父类的基础上拓展子类特有的属性和行为,生成一个新的子类

        c.原则:父类存放共性,子类存放特性

   (2)代码理解:

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

            a.上面的类我们叫做  父类(超类,基类,根类)

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

           a. 下面的类我们叫做 子类(派生类,拓展类)

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

    2)基本语法:

        格式:

        class Animal{

            private int year;

            String name;

            int age;

            void eat(){

                System.out.println("版本......");

            }

        }

        class Pig extends Animal{

        }

    3)什么可以被继承

    (1)语法:

           class A{}

            class B extends A{}

            B这个类继承了A这个类

    (2)可以继承哪些东西:

            ①类

            ②字段

            ③ 普通方法

            ④ 构造方法 (X)

            当父类有字段是私有化的时(private),只有自己能访问

    4)继承的特点

    (1)java中的继承只能是单继承

            一个类只能继承一个类,但是一个类可以被多个类继承

    (2)可以支持多重继承

            一个类可以有子类也可以有父类,它的父类也可以有父类

    (3)每个类都有一个直接父类,如果不写出来,就隐式继承Object类

3.多态

     1)概念的理解:一种事物的多种形态,就像是“一千个人心中有一千个哈姆雷特”这句话一样,每个人心中都有对哈姆雷特的认知,对于这句话,每个人的理解也不同

        (1)在java中,一个大的数据类型可以兼容一个小的数据类型,比如:某一个类的父类(动物类)如果作为一种数据类型,那么用它声明的变量可以存入这个类的子类(鸟类)创建的对象(一只鸟是动物)

    2)官方概念:编译时跟运行时类型不一致就产生了多态

    3)编译和运行时的区别

        有两个类:Animal和Bird

        class Animal{

            public void action(){

                System.out.println("动物");

            }

        }

        class Bird extends Animal{

            public void action(){

                System.out.println("鸟");

            }

        }

        在主方法中我们写入

        Animal animal = new Bird();

        animal.action();

        此时如果进行编译,不会报错,但如果把父类中的方法给去掉,则编译报错

        原因:编译时先看父类类型,在父类类型中找字段或者方法,如果没有则会向上找父类的父类,如果一直没有那么就会报错

        但是如果编译不报错,那么运行时一定不报错(在没有其他问题的情况下)

    4)作用:

        (1)调用方法传递参数时:大的数据类型兼容小的数据类型,那么如果我要传入一种鸟的具体对象,可以用动物类这个类型接收

        (2)调用方法后返回值时:同理,返回一个鸟的具体对象,可以用动物类接收

            好处:屏蔽了不同子类之间实现的差异

你可能感兴趣的:(2019-03-20 面向对象)