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

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© jkdong 高级黑马   /  2015-6-28 12:22  /  1253 人查看  /  11 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

day05回顾
        函数(方法)
                定义格式以及调用方法
                        权限修饰符 返回值类型 方法名(参数列表)
                        {
                                //方法体(执行语句)
                                //return语句
                        }
                                权限修饰符:public共用属性,private私有属性
                                返回值:赋值调用,输出调用
                                                可以单独调用但一般没意义
                                                没有返回值只能单独调用               
                                参数列表可以不写
                                               
        数组
                定义:存储多个同一类型的元素的集合(容器)
                特点:
                        长度固定
                        可以存储基本数据类型也可以存储引用数据类型
                        只能存储同一种数据类型
                格式
                        int[] arr = new int[10];
                        int[] arr = new int[]{1,2,3};
                        int[] arr = {1,2,3,4,5,6};
                功能
                        遍历
                                int[] arr = {5,26,15,47,13,39}
                                for (int x = 0;x<arr.length;x++)
                                {
                                        int everyElement = arr[x];
                                        System.out.println("");
                                }
                        找最值
                                思路
                                        定义变量,记录一个最值,默认选取第一个
                                        然后遍历数组,拿数组中的每一个元素与记录值比较,记录较大值即可
                                       
                                        注意:
                                                能确定下面两个问题:
                                                        数组不是空数组?
                                                        方法传递进来的实参不是null?
                                               
                                                所以为了程序的健壮性要先判断
                                               
                                        解决方案:
                                                我们不找最值,找最值的索引
                                                public static int getMaxIndex(int[] arr)
                                                        if(arr == null || arr.length == 0)
                                                        {
                                                                return -1;
                                                        }
                                                        else
                                                        {
                                                                //再正常的找最值的代码
                                                        }
                                       
                        找指定值的索引
                                遍历数组,依次拿遍历到的元素与指定值进行比较  一旦匹配  返回指定值索引
                               
day06
            参数传递问题
                        java参数传递问题
                基本类型
                        形参的改变对实参没有影响
                引用类型
                        形参的改变直接影响实参
                        但是字符串特殊
                java只有值传递,引用类型传递的是地址值,基本类型传递的是实际值
               
        面向对象
                面向对象的概念
                        面向过程:面向过程以函数为基础,完成各种操作,强调的过程(分解模块)如c
                        面向对象:面向对象以对象为基础,完成各种操作,强调对象、结果
                        面向对象是相对面向过程而言
                        面向对象和面向过程都是一种思想
                        面向过程强调的是功能行为
                        面向对象将功能封装进对象,强调具备功能的对象
                        面向对象是基于面向过程的
                                具备功能的对象功能的实现是面向过程的
                       
                        举例:孙悟空三打白骨精
                                面向过程:
                                        打()
                                                孙悟空  白骨精
                                面向对象
                                        孙悟空,打(白骨精)
                                        更符合人们的思想                               
                面向对象思想特点        .
                        是一种更符合人们思考习惯的思想
                        可以将复杂的事情简单化
                        将程序员从执行者转换为指挥者
                       
                        举例:
                                买电脑。
                                        面向过程:自己做所有事情
                                        面向对象:找个懂电脑的
                                吃饭
                                        面向过程:买菜洗菜切菜做菜吃菜洗盘
                                        面向对象:找个对象让他做
                                旅游
                                        面向过程:自己查路线,订票,查宾馆。。。
                                        面向对象:找个旅行社。。
                                招人
                                        面向过程:所有工作自己做
                                        面向对象:招人来做                                                                               
                                以后做任何事情:
                                        找对象,让对象做事情
                                        自己造对象然后用,还可给别人用
                来个实例体现面向对象和面向过程的区别:把大象装进冰箱
                        面向过程
                                打开冰箱门
                                装进冰箱
                                关门
                               
                                代码体现
                                        class 测试类
                                        {
                                                public static void main(String[] args)
                                                {
                                                        open();
                                                        in();
                                                        close();
                                                }
                                               
                                                public static void open(String[] args)
                                                {
                                                        System.out.println("开门");
                                                }
                                               
                                                public static void in(String[] args)
                                                {
                                                        System.out.println("进去");
                                                }
                                               
                                                public static void close(String[] args)
                                                {
                                                        System.out.println("关门");
                                                }
                                        }//不利维护扩展
                                       
                                什么是符合面向对象的思想
                                                分析该系统中包含哪些对象:名词提取
                                                明确哪个对象可以做什么:依赖于面向过程
                                                明确对象间的关系
                                               
                                        步骤:
                                                有哪些?大象 冰箱 测试
                                                每个对象有什么?
                                                        大象:in()
                                                        冰箱:open()  close()
                                                        测试:main()
                                                对象的关系
                                                        测试中调用大象和冰箱的功能
                                               
                                                代码:
                                                        class 大象
                                                        {
                                                                public static void in(String[] args)
                                                                {
                                                                        System.out.println("进去");
                                                                }       
                                       
                                                        }
                                                       
                                                        class 冰箱
                                                        {
                                                                public static void open(String[] args)
                                                                {
                                                                        System.out.println("开门");
                                                                }
                                               
                                                                public static void close(String[] args)
                                                                {
                                                                        System.out.println("关门");
                                                                }
                                                        }
                                                       
                                                        class 测试
                                                        {
                                                                public static void main(String[] args)
                                                                {
                                                                        冰箱.open();
                                                                        大象.in();
                                                                        冰箱.close();
                                                                }
                                                        }                               
                        面向对象的开发设计特征
                                开发就是不断创建对象使用对象指挥对象
                                设计过程:管理维护对象之间的关系
                类与对象关系
                        使用计算机语言就是不断描述现实中的事物
                        学习编程语言其实就是把现实世界的事物通过编程语言体现出来               
                        先研究这个事物
                                属性:外在特征
                                动作:能够做什么
                        描述事物通过属性和行为来描述
                        java语言中最基本的单位是类,类就是用来体现事物的
                        类就应该包含属性和行为(变量和函数)
                                属性:成员变量
                                        char默认空字符
                                行为:成员方法(函数)
                       
                        类是什么?
                                java中最基本的单位,是属性和行为的集合,是一个抽象的概念
                        对象
                                类的具体的存在和体现(实例)
                                举例:
                                        学生这样一个事物  --  类(泛指的概念)
                                        张三就是一个具体存在--对象
                                       
                        定义学生类
                                学生事物
                                        属性:
                                                姓名 年龄 性别。。
                                        行为
                                                学习 吃饭 睡觉。。
                                        把事物转换为java中的类
                                学生类
                                        成员变量:定义在类中方法外的变量,有自己的默认值
                                                姓名 年龄 性别
                                        成员方法:就是函数,先把static去掉就是成员方法
                                                学习 吃饭 睡觉
                                代码体现
                                class Student
                                {
                                        String name;
                                        int age;
                                       
                                        public void sleep()
                                        {
                                                System.out.println("睡觉");
                                        }
                                       
                                        public void eat()
                                        {
                                                System.out.println("吃饭");
                                        }
                                }
                               
                                //使用
                                创建对象
                                Student s = new Student();
                                使用成员变量
                                s.name = "林青霞";
                                s.age = 26;
                                //使用成员方法
                                s.sleep();
                                s.eat();
                               
                                注意可以在一个java文件中写多个class
                                这个文件的名字必须和带有main方法的哪个类一致
                               
                        关于敲代码的重要提醒
                                在入门阶段必须养成良好的编码习惯
                                        去看刘意老师代码的格式
                        成员变量的定义               
                                事物的属性是事物的一部分,这个属性对应的变量才能被定义为成员变量。在java中,成员变量其实就是这个类的属性。
                                其他情况,都应该将变量定义成局部变量。
                                当然,你如果不按照这个标准做也没有太大问题,只是不符合面向对象的思想特点。
                               
                                成员变量和局部变量区别
                                定义位置区别:
                                        成员 类中方法外,定义在类中
                                        局部 方法中或方法的形参
                                存储位置区别(生命周期)
                                        成员 堆中,随着对象的存在而存在,对象消失而消失
                                        局部 栈中,随着方法的调用而存在,调用完毕消失
                                初始化值区别
                                        成员  有默认初始化值
                                                引用类型null int0 double0.0 char空字符
                                        局部 没有默认值 定义时必须先赋值才可以用
                                使用范围(就近原则)
                                        首先在局部范围找,有就用
                                        接着在成员范围找,有就用
                                        成员范围没有,就报错
                                       
                        匿名对象
                                没有名字的对象
                                        Student s = new Student();
                                        s.show();
                                        --->匿名
                                        new Student().show();
                                应用场景
                                        当对方法仅进行一次调用时
                                        匿名对象可以作为实际参数进行传递
                                        public void hello(Student s)
                                        {
                                                s.show();
                                        }
重点:                                       
        面向对象的思想理解,思想特点,怎样分析问题符合面向对象
        一个学生类的定义 测试使用 敲出来  能画出内存图
        成员变量和局部变量定义和区别
                               
                封装
                this
                static

评分

参与人数 2黑马币 +42 收起 理由
小鲁哥哥 + 40 赞一个!
温暖的小白 + 2

查看全部评分

11 个回复

倒序浏览
班长加油,锲而不舍
回复 使用道具 举报
思绪刈飘 来自手机 中级黑马 2015-6-28 18:30:58
藤椅
真棒
继续努力              
回复 使用道具 举报
班长不错!顶你
回复 使用道具 举报
有没有练习啊,能不能也粘上?:)
回复 使用道具 举报
618帮顶
回复 使用道具 举报
强大的兵哥 啊  支持班长
回复 使用道具 举报
班长顶义个
回复 使用道具 举报
笔记做的不错,值得一看
回复 使用道具 举报
先收藏了
回复 使用道具 举报
一块的   赞个
回复 使用道具 举报
难怪是班长,全搞的笔记。。。
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马