A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© 悟能 中级黑马   /  2015-8-7 21:18  /  394 人查看  /  9 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文


面向对象思想
        概述:基于面向过程. 就是你找一个对象来完成一件事,这个对象包含了完成事情的过程.

类与对象
        类: 对事物的描述  -- 虚
        对象: 该事物的实体,实例  -- 实
        关系:  定义类,使用对象.
                类是对象的描述,对象是类实体.

定义类
        格式:
                class 类名 {
                }
        成员变量: 事物的属性  --天生的     --通常叫属性
        构造方法: 初始化数据  new 类();           --通常叫构造
        成员方法: 事物的行为  --后天的           --通常叫方法


面向对象的三大特征
        封装
                步骤:1.使用private修饰成员(通常修饰属性),隐藏成员
                         2.提供公共的访问方式 (get/set)

                private:
                        作用:隐藏属性,不让外界直接访问
                        特点:只能本类访问
                this: 当局部变量隐藏成员变量时使用this
                        作用:指代当前(本类)对象,通常修饰成员变量
                static:
                        特点:静态.
                        修饰的成员变量,值被所有对象共享.
                        修饰的成员方法,直接类名调用.
                               
        继承
                概述:子类继承父类,
                特点:1.父类成员子类可以直接使用
                         2.类与类形成了关系,从而形成体系
                         3.多态的前提
                注意事项:
                        1.父类私有的子类不能访问
                        2.构造方法不能用
                        3.不能随便继承
                        4.类与类是 "is a" 的关系,可以使用继承

                super:表示父类存储空间的标识(理解为父类引用)
       
                成员关系
                        成员变量(同名):使用子类
                                想要使用父类super.成员变量
                               
                        构造方法:不能继承,但是子类会访问父类构造super()
                                加载顺序:创建子类时,先访问父类的构造
                                注意事项:
                                        1.super(参数),访问父类的有参.
                                        2.位置必须在第一行
                                       
                                       
                        成员方法(同名):使用子类
                                重写概述:父类和子类方法声明一模一样(返回值类型,方法名,参数列表)
                                注意事项:
                                        私有:不能重写
                                        权限:子类的权限不能更低
                        静态方法:必须使用静态重写.

                                       
                        面试题:
                                重写与重载的区别:
                                override: 父类和子类方法声明一模一样(返回值类型,方法名,参数列表)
                                overload: 同一类中,方法名一样,参数列表不同,与返回值类型无关

                final:  最终
                        概述: 修饰类  成员变量,方法
                        特点:被修饰的东西不能被更改
                                类: 不能继承
                                变量: 只能赋值一次
                                方法: 不能重写
               
        多态:
                概述:一种事物多种形态(H2o , 动物 ,水果....)
                前提:
                        1.子类继承父类,或者实现接口 (必须二选一)
                        2.方法重写(非必须)
                        3.父类引用指向子类对象(最必须)

                                Fu f = new Zi();
                               
                成员关系:
                        成员变量:编译看左边,运行看左边
                               
                        构造方法:编译看左边,运行看左边
                               
                        成员方法:编译看左边,运行看右边  *****
                               
                        静态方法:编译看左边,运行看左边
                               
                子类特有的方法:
                        向上转型:从子类转向父类
                                格式: Fu f = new Zi();
                        向下转型:从父类转向子类
                                格式 : Zi z = (Zi)f;

注意: 参数传递为类,抽象类,接口 --案例练习 (钢铁侠,榨汁机,发牌机)               
        -------------------------------------------------------


抽象类
        概述:无法具体描述的类,通常定义父类为抽象类
        特点:
                1.格式:abstract class 类名{
                }
                2.类中可以有抽象方法,和非抽象
                        abstract 返回值类型 show();
                3.有构造方法,但是不能new
                4.想new抽象类,只能ne它的子类
                5.子类: 要么是抽象的
                                要么必须重写抽象方法 ***
               
        成员特点:
                a:成员变量:既可以是变量,也可以是常量。
                b:构造方法:有。
                                        用于子类访问父类数据的初始化。
                c:成员方法:既可以是抽象的,也可以是非抽象的。
        面试题: abstract 不能和哪些关键字共存?
                        private    冲突 -- 对子类隐藏,而 abstract 必须让子类重写
                        final      冲突 -- 不能被重写,矛盾
                        static     无意义-- 类名调用,没有方法体,无意义
接口
        概述:实现类的扩展功能
        本质:定义的规则
        特点:
                1.格式: interface 接口名{
                }
                       
                        使用: class 子类 implements 接口名{  // 可以实现多个接口
                                //重写所有的抽象方法  

                        }
                2.成员变量: 只能是常量
                3.成员方法: 只能是抽象
                4.构造方法: 无
                5.实例化: new 子类();
                6.子类要求:重写所有的抽象方法  
                         
       
        类与类,类与接口,接口与接口关系--看图


内部类
        概述: 类里面的类 (人里面的心脏)
        成员内部类:
                格式:
                        class Outer{
                                class Inner{
                                }
                        }
                       
               
                       
                注意:如果private 修饰 内部类,那么就不能直接创建,提供公共的访问方式.(封装的思想 )
        局部内部类:
                格式:
                        class Outer{
                                show(){
                                        局部变量必须final;
                                        class Inner {

                                        }
                                }
                        }
                问题:只能访问被final修饰的局部变量吗?
                肯定的.局部变量和内部类的生命周期不同,所以使用final把局部变量变成常量.
匿名内部类:
        前提:有一个接口或者类
        本质: *匿名对象*-- 实现了接口,或者继承了类的匿名子类的对象  
        new 接口(){
                抽象方法
        };

代码块:
        静态:执行一次,类加载的时候
        static {
               
        }
        构造:执行多次,调用构造方法
        局部:及时回收变量,提高运行效率
       
权限修饰符:
                                        本类                同包                不同包子类                不同包其他类
        private                         *
        default                         *                        *                         
        protected                 *                        *                                *
        public                         *                        *                                *                                *

常用 public 修饰 类 和方法
和         private 修饰 成员变量


9 个回复

倒序浏览
厉害   !
回复 使用道具 举报
留名  接着看
回复 使用道具 举报
很需要这些东西啊,刚学完,脑子一片糊涂
回复 使用道具 举报
赞一个!
回复 使用道具 举报
学习了 臜
回复 使用道具 举报
多谢分享,收藏了
回复 使用道具 举报
这个必须顶啊   我们刚讲完面向对象
回复 使用道具 举报
不错赞一个
回复 使用道具 举报
只要你细心  黑马会给你你所要的全部   一块加油吧!!!赞赞赞{:2_30:}{:2_32:}
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马