黑马程序员技术交流社区

标题: 封装 [打印本页]

---

作者: 任有智双元    时间: 2015-8-3 23:23
标题: 封装
1. 回顾
        面向对象
       
        面向过程:
       
        面向对象的思想:       
       
        分析问题:
               
        class Demo
        {
                // 求和
               
               
                // 99乘法表
                public void print99(){
                        for (int x = 1; x <= 9; x++)
                        {
                                for (int y = 1; y <= x; y++)
                                {
                                        System.out.print(y + "*" + x + "=" + y*x + "\t");
                                }
                                System.out.println();
                        }
                }
               
                // 比较是否相等
        }
       
        class DemoTest
        {
                public static void main(String[] args)
                {
                        Demo d = new Demo();
                        d.print99();
                }
       
        }
       
       
        局部变量:
       
        成员变量:
       
        匿名对象:
       
2. 封装
        隐藏对象的属性和具体的实现细节,仅对外提供公共的访问方式.
       
        访问权限修饰符: private
                修饰成员变量和成员方法(还可以修饰内部类)
                被修饰的成员特点:不能被其他类直接访问. 向外界提供公共的方法进行访问.
       
        关于非法数据:
                像咱们的课上案例 Student类  Teacher类 Car类 Phone类 等等,其实是简单的描述某种事物的类.
                以后校验的逻辑并不在这些类里面完成.这些类有个名字:
                javaBean -- 简单的描述类
       
        class Student
        {
                private String name;
                private int age;
                private String userName;
                ...
               
                public Student(){}
               
                public String getName()
                {
                        // this  -- s
                        return s.name;
                }
               
                public void setName(String name)
                {
                        // this  -- s
                        this.name = name;
                }
               
        }
       
        思考: getters 和 setters 必须要成对出现吗?
                不一定.
                如果仅允许别人对属性进行赋值,就只提供setter方法,
                同理,如果仅允许别人对属性进行获取,就只提供getter方法.
                但一般都是成对出现.
       
        要求: 带private封装的标准学生类,必须能敲熟练.

3. 类的组成
        成员变量:
        构造方法(构造器):
                1) 方法名与类名一致.
                2) 没有返回值类型.
               
                作用:
                        初始化对象(还可以为成员赋值)
               
        成员方法:
                权限修饰符 public  private
       
        注意:
                如果没有显示的给出任何构造方法,系统将提供一个默认的无参构造.
                一旦显示的给出了构造方法, 系统将不再提供默认无参构造.
               
4. this
        代表方法所属对象的引用. (当前运行类的对象的引用)
        谁调用的方法,this就代表谁.
        应用:
                解决局部变量隐藏成员变量的问题.
                用于构造方法中.
               
class Student {
       
        private String name; // 姓名
       
        private int age; // 年龄
       
        // 无参构造
        public Student() {
        }

        // 带参构造
        public Student(String name, int age) {
                this.name = name;
                this.age = age;
        }

        public String getName() {
                return name;
        }
        public void setName(String name) {
                this.name = name;
        }
        public int getAge() {
                return age;
        }
        public void setAge(int age) {
                this.age = age;
        }

}

class StudentTest
{
        main(String[] args)
        {
                Student s = new Student();// 先使用无参构造
                s.setName("李四"); // 为属性赋值
                s.setAge(19);
               
                Student s1 = new Student("张三", 20);
                // s1 的属性name, age 就初始化好了
        }

}

5. 代码块
        就是一对{} 括起来的代码.
       
        局部代码块: 方法中的一对{}
                控制变量的生命周期.
       
        构造代码块:
                类中方法外的一对{}
                将构造方法中的共性内容提取出来,减少代码的重复率.
                执行特点: 每次创建对象都执行,而且是优先于构造方法.
       
        (静态代码块)
       
6. 对象初始化过程
        成员变量默认初始化 -- 显示值替代默认值 -- 构造代码块 -- 构造方法执行
       
7. static 关键字
        修饰成员变量和成员方法.(还可以修饰内部类)

        特点:
                1) 随着类的加载而加载, 优先对象于对象而存在.
                2) 被类的所有对象共享.
                3) 可以使用类名直接调用.
               
                class Demo{
                        public static void main(String[] args)
                        {
                                show();
                        }
                       
                        public static void show(){
                                //
                        }
                }
               
                class DemoTest
                {
                        public static void main(String[] args)
                        {
                                Demo.show();
                               
                                Demo d = new Demo();
                                d.show();
                               
                                d = null;
                                d.show();// 但是这还能运行.
                        }
                }
               
        类变量:
                被static修饰的成员变量.
        实例变量:
                没有static修饰的成员变量.
               
        注意事项:
                1) 静态方法中没有this关键.
                2) 静态方法只能访问静态成员变量和静态成员方法.
                3) 静态成员强烈建议使用类名调用.
       
8. 不同java文件中方法的调用
        目前大家就把多个java文件放到一个文件夹中. 然后编译带main的就可以了,因为其他的类,如果用到了,会自动编译.       
       
        帮助文档的生成:
                javadoc -d 存放路径 -author -version 类名.java
       
        关于怎样生成CHM文档,参照百度经验.
       
9. Math类的功能
        Math 类的所有方法都是静态的,所以类名.方法名() 直接调用.
                int abs(int i)
                        获取绝对值
                double ceil(double d)
                        向上取整
                double floor(double d)
                        向下取整
                long round(double d)
                        四舍五入
                int round(float f)
                        四舍五入
                double random()
                        返回[0.0, 1.0)之间的一个随机小数
               
                        补充: 左闭右开原则在java中的方法设计上有通用性.
               
                int max(int i, int j)
                        获取最大值
       
        作业:
                完成课堂案例: 猜数字小游戏.
                并且改进, 如果猜3次猜不对, 不让猜了,结束循环.
                如果能实现, 请自学Random类. 使用Random类的nextInt(int i)方法完成猜数字游戏.
               
                提示:
                        Random类 采用无参构造创建对象.
                       
                        功能:
                                nextInt(int i) -- 返回0 - i 之间的一个随机int值,包括0但不包括i.
       
       
       
       
       
       
       
       
       
       
       
       
       
       
       
       

---

欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2