面向对象之封装

类和对象的关系

  • 类就是：对现实生活中事物的描述。
  • 对象：就是这类事物，实实在在存在的个体。

比如：

现实生活中的对象：张三，李四。

想要描述：提取对象中共性内容。对具体对象的抽象。

描述时，这些对象的共性有：姓名，年龄，性别，学习java的功能。映射到java中，描述就是class定义的类。具体对象就是对应java在堆内存中用new建立的实体。

（其实定义类）描述事物，其实就是在描述事物的属性和行为。属性对应类中变量，行为对应类中的函数（方法）。属性和行为共同成为类中的成员（成员变量和成员函数）。

成员变量和局部变量的区别：

　　1、作用域

　　　　成员变量作用于整个类中。

　　　　局部变量作用于函数中，或者语句中。

　　2、在内存中的位置

　　　　成员变量：在堆内存中，因为对象的存在，才在内存中存在。

　　　　局部变量：存在栈内存中。

匿名对象

匿名对象使用方式：

  1. 当对对象的方法只调用一次时，可以用匿名对象来完成，这样写比较简化。如果对一个对象进行多个成员调用，必须给这个对象起个名字。
  2. 可以将匿名对象作为实际参数进行传递。

示例代码如下：

class Car {
    //描述颜色
    String color = "红色";
    //描述轮胎数
    int num = 4;

    //运行行为
    void run() {
        System.out.println(color+".."+num);
    }

    public static void main(String[] args) {
        Car c = new Car();
        c.num = 10;
        //run();
    }
}
class CarDemo {
    public static void main(String[] args) {
        //生产汽车，在java中通过new操作符来完成
        //其实就是在堆内存产生一个实体
        Car c = new Car();//c就是一个类类型变量。记住：类类型变量指向对象。

        c.color = "蓝色";
        c.run();
//      Car c1 = new Car();
//      c1.run();

//      Car c = new Car();
//      c.num = 5;
//      new Car().num = 5;
//      new Car().color = "blue";
//      new Car().run();
        //匿名对象使用方式一：当对对象的方法只调用一次时，可以用匿名对象来完成，这样写比较简化
        //如果对一个对象进行多个成员调用，必须给这个对象起个名字

        //匿名对象使用方式二：可以将匿名对象作为实际参数进行传递
//      Car q = new Car();
//      show(q);
        show(new Car());
    }
    public static void show(Car c) {
        c.num = 3;
        c.color = "black";
        c.run();
    }
}

封装

private:私有，权限修饰符，用于修饰类中的成员（成员变量、成员函数）。私有只在本类中有效。

注意：私有仅仅是封装的一种表现形式。

 构造代码块

构造代码块——定义的是不同对象共性的初始化内容。

作用：给对象进行初始化，对象一建立就运行，而且优先于构造函数执行。

和构造函数的区别：构造代码块是给所有对象进行统一初始化，而构造函数是给对应的对象初始化。

对象一建立就会调用与之对应的构造函数。构造函数和一般函数在写法上有不同，在运行上也有不同。构造函数是在对象一建立就运行，给对象初始化。而一般函数是对象调用才执行，是给对象添加对象具备的功能。一个对象建立，构造函数只运行一次，而一般函数可以被该对象调用多次。

示例代码：

class Person {
    private String name;
    private int age;

    /*
     * 构造代码块——定义的是不同对象共性的初始化内容
     * 作用：给对象进行初始化，对象一建立就运行，而且优先于构造函数执行
     * 和构造函数的区别：构造代码块是给所有对象进行统一初始化，而构造函数是给对应的对象初始化
     */
    {
        //System.out.println("person code run");
        cry();
    }

    Person() {
        System.out.println("A: name="+name+", age="+age);
        //cry();
    }

    Person(String n) {
        name = n;
        System.out.println("B: name="+name+", age="+age);
        //cry();
    }

    public void setName(String n) {
        name = n;
    }

    public String getName() {
        return name;
    }

    Person(String n, int a) {
        name = n;
        age = a;
        System.out.println("C: name="+name+", age="+age);
        //cry();
    }

    public void cry() {
        System.out.println("cry....");
    }

    public void setAge(int a) {
        if(a > 0 && a < 130) {
            age = a;
            speak();
        }
        else
            System.out.println("非法年龄");
    }

    public int getAge() {
        return age;
    }

    void speak() {
        System.out.println("age="+age);
    }

}
public class PersonDemo {
    public static void main(String[] args) {
        Person p1 = new Person();//对象一建立就会调用与之对应的构造函数
//      p1.cry();//构造函数和一般函数在写法上有不同，在运行上也有不同。构造函数是在对象一建立就运行，给对象初始化
                 //而一般函数是对象调用才执行，是给对象添加对象具备的功能
                 //一个对象建立，构造函数只运行一次，而一般函数可以被该对象调用多次
        Person p2 = new Person("lisi");
//      p2.setName("libusi");
//      p2.setName("LIBUHSI");
//      System.out.println(p2.getName());
//      Person p2 = new Person("LISI");
//      Person p3 = new Person("WNAGWU", 10);
    }
}

 this

this:看上去，是用于区分局部变量和成员变量同名情况。

this：代表本类的对象，this代表它所在函数所属对象的引用，简单说：哪个对象在调用this所在的函数，this就代表哪个对象。

示例代码：

class Person {
    private String name;
    private int age;
    /*
     * this:看上去，是用于区分局部变量和成员变量同名情况
     * this：代表本类的对象，this代表它所在函数所属对象的引用，简单说：哪个对象在调用this所在的函数，this就代表哪个对象
     */
    Person() {

    }

    Person(String name) {
        this();
        this.name = name;
    }

    Person(int age) {
        this.age = age;
    }

    public Person(String name, int age) {
//      this.name = name;
        this(name);  //p(name);用于构造语句之间互相调用
        this.age = age;
    }

    public void setName(String n) {
        name = n;
    }

    public String getName() {
        return name;
    }

    public void setAge(int a) {
        age = a;
    }

    public int getAge() {
        return age;
    }

    public boolean compare(Person per) {
        if(this == per) {
            return true;
        }
        if(this.getName().equals(per.getName()) &&
                this.getAge() == per.getAge()) {
            return true;
        } else {
            return false;
        }
    }

    public void speak() {
        System.out.println("name="+name+"...age="+age);
        show();
    }

    public void show() {
        System.out.println(this.name);
    }

    /*
     * this的应用
     * 比较年龄是否相同的？
     */
    public boolean compareAge(Person per) {
        return this.age == per.age;
    }
}
public class ThisDemo {

    public static void main(String[] args) {
//      Person p1 = new Person(20);
//      Person p2 = new Person(25);
//      boolean b = p1.compareAge(p2);
//      System.out.println(b);
        Person p = new Person("lisi", 30);
//      Person p1 = new Person("zhangsan");
//      p.speak();
//      p1.speak();
    }

}

static

static:用法：是一个修饰符，用于修饰成员（成员变量、成员函数）。

特点：

  1. 随着类的加载而加载，类的消失而消失，说明它的生命周期最长。
  2. 优先于对象存在，明确一点：静态是先存在的，对象是后存在的。
  3. 被所有对象所共享。
  4. 可以直接被类名所调用。

静态的成员变量，也叫类变量。成员变量，也叫实例变量。

实例变量和类变量的区别：

　　1、存在位置

　　　　类变量随着类的加载而存在于方法区中。

　　　　实例变量随着对象的建立而存在于堆内存中。

　　2、生命周期

　　　　类变量生命周期最长，随着类的消失而消失。

　　　　实例变量生命周期随着对象的消失而消失。

静态使用注意事项：

  1. 静态方法只能访问静态成员，非静态方法既可以静态也可以访问非静态。
  2. 静态方法中不可以定义this、super关键字。因为静态优先于对象存在，所以静态方法中不可以出现this。
  3. 主函数是静态的。

静态有利有弊：

  • 利处：对对象的共享数据进行单独空间的存储，节省空间，没有必要每一个对象中都存储一份；可以直接类名调用。
  • 弊端：生命周期过长，访问出现局限性（静态虽好，只能访问静态）。

示例代码：

class S_Person {
    String name;//成员变量，也叫实例变量
    int age;
    /*
     * static:用法：是一个修饰符，用于修饰成员（成员变量、成员函数）
     * 特点：
     * 1、随着类的加载而加载，类的消失而消失，说明它的生命周期最长
     * 2、优先于对象存在，明确一点：静态是先存在的，对象是后存在的
     * 3、被所有对象所共享
     * 4、可以直接被类名所调用
     */
    static String country = "CN";//静态的成员变量，也叫类变量
    /*
     * 实例变量和类变量的区别：
     * 1、存在位置——类变量随着类的加载而存在于方法区中
     *          实例变量随着对象的建立而存在于堆内存中
     * 2、生命周期——类变量生命周期最长，随着类的消失而消失
     *          实例变量生命周期随着对象的消失而消失
     */
    /*
     * 静态使用注意事项：
     * 1、静态方法只能访问静态成员
     *   非静态方法既可以静态也可以访问非静态
     * 2、静态方法中不可以定义this、super关键字
     *   因为静态优先于对象存在，所以静态方法中不可以出现this
     * 3、主函数是静态的
     *
     * 静态有利有弊
     * 利处：对对象的共享数据进行单独空间的存储，节省空间，没有必要每一个对象中都存储一份
     *    可以直接类名调用
     * 弊端：生命周期过长，访问出现局限性（静态虽好，只能访问静态）
     */
    /*static public void setCountry(String country) {
        //this.country = country; //Cannot use this in a static context
        S_Person.country = country;
    }*/

    public S_Person() {

    }

    public S_Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public static void show() {
        System.out.println("::"+country);
    }
    public void info() {
        System.out.println("姓名："+this.name+"，年龄："+this.age+"，城市："+this.country);
    }
}
public class StaticDemo {

    public static void main(String[] args) {
        S_Person.show();
//      System.out.println(S_Person.country);
//      S_Person p = new S_Person();
//      System.out.println(p.country);

    }

}

主函数(main)

主函数：是一个特殊的函数，作为程序的入口，可以被JVM调用。

主函数的定义：

  1. public：代表着该函数访问权限是最大的。
  2. static：代表主函数随着类的加载就已经存在了。
  3. void：主函数没有具体的返回值。
  4. main：不是关键字，但是是一个特殊的单词，可以被JVM设别。
  5. String[] args：函数的参数，参数类型是一个数组，该数组中的元素是字符串，字符串类型的数组。

主函数是固定格式的：JVM设别。JVM在调用主函数时，传入的是new String[0];。

示例代码：

public class StaticDemo1 {

    public static void main(String[] args) {
        System.out.println(args[0]);//会出现ArrayIndexOutOfBoundsException异常
    }

}

 静态代码块

格式：

static {
    静态代码块中的执行语句
}

特点：随着类的加载而执行，只执行一次，并优先于主函数。用于给类进行初始化。

示例代码如下：

class StaticCode {
    int num = 9;
    StaticCode() {
        System.out.println("b");
    }
    static {
        System.out.println("a");
    }
    /*
     * 构造代码块
     */
    {
        System.out.println("c"+this.num);
    }
    StaticCode(int x) {
        System.out.println("d");
    }
    public static void show() {
        System.out.println("show run");
    }
}
public class StaticCodeDemo {

    static {
        //System.out.println("b");
    }
    public static void main(String[] args) {
        //new StaticCode();//将StaticCode.class这个类加载进内存
        //new StaticCode();//StaticCode.class已经加载进内存，不会再次打印输出语句！！！
        //System.out.println("Hello World!!!");
        //StaticCode.show();
        //StaticCode s = null;//特别注意：StaticCode类没有被加载进内存
        //s = new StaticCode();

        new StaticCode(4); //打印 a c d
    }
    static {
//      System.out.println("c");
    }

}

练习：通过以下程序代码，试说明Nei_Person p = new Nei_Person("张三", 23);该句话都做了什么事情？

代码：

class Nei_Person {
    private String name = "haha";
    private int age;
    private static String country = "CN";

    Nei_Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    {
        System.out.println(name+".."+age);
    }

    public void setName(String name) {
        this.name = name;
    }

    public void speak() {
        System.out.println(this.name+"..."+this.age);
    }

    public static void showCountry() {
        System.out.println("country="+country);
        method();
    } 

    public static void method() {
        System.out.println("method run");
    }
}
public class Nei_PersonDemo {

    public static void main(String[] args) {
        Nei_Person p = new Nei_Person("张三", 23);
        p.setName("lisi");
    }

}

解：

Nei_Person p = new Nei_Person("张三", 23);该句话都做了什么事情？

  1. 因为new用到了Nei_Person.class，所以会找到Nei_Person.class文件并加载到内存。
  2. 执行该类中的static代码块，如果有的话，给Nei_Person.class类进行初始化。
  3. 在堆内存中开辟空间，分配内存地址。
  4. 在堆内存中建立对象的特有属性，并进行默认初始化。
  5. 对属性进行显示初始化。
  6. 对对象进行构造代码块初始化。
  7. 对对象进行对应的构造函数初始化。
  8. 将内存地址赋给栈内存中的p变量。

什么时候使用静态？

要从两方面下手：因为静态修饰的内容有成员变量和函数。

　　1、什么时候定义静态变量（类变量）呢？

　　　　当对象中出现共享数据时，该数据被静态所修饰。对象中的特有数据要定义成非静态，存在于堆内存中。

　　2、什么时候定义静态函数呢？

　　　　当功能内部没有访问到非静态数据（对象的特有数据），那么该功能可以定义成静态的。

静态的应用——以下例说明

每个应用程序中都有共性的功能，可以将这些功能进行抽取，独立封装，以便复用。

示例：

/**
 * 这是一个可以对数组进行操作的工具类，该类中提供了获取最值、排序等功能
 * @author 李阿昀
 * @version V1.1
 */
class ArrayTool {
    /**
     * 空参数构造函数
     * 一个类中默认会有一个空参数的构造函数，这个默认的构造函数的权限和所属类一致。
     * 如果类被public修饰，那么默认的构造函数也带public修饰
     * 如果类没有被public修饰，那么默认的构造函数也没有public修饰
     *
     * 简而言之：默认构造函数的权限是随着类的变化而变化的
     */
    private ArrayTool() {}
    /**
     * 获取一个整型数组中的最大值
     * @param arr 接受一个int类型的数组
     * @return 会返回一个该数组中的最大值
     */
    public static int getMax(int[] arr) {
        int max = 0;
        for(int x = 1; x < arr.length; x++)
            if(arr[x] > arr[max])
                max = x;
        return arr[max];
    }
    /**
     * 获取一个整型数组中的最小值
     * @param arr 接受一个int类型的数组
     * @return 会返回一个该数组中的最小值
     */
    public static int getMin(int[] arr) {
        int min = 0;
        for(int x = 1; x < arr.length; x++)
            if(arr[x] < arr[min])
                min = x;
        return arr[min];
    }
    /**
     * 给int数组进行选择排序
     * @param arr 接受一个int类型的数组
     */
    public static void selectSort(int[] arr) {
        for(int x = 0; x < arr.length - 1; x++) {
            for(int y = x + 1; y < arr.length; y++) {
                if(arr[x] > arr[y]) {
                    swap(arr, x, y);
                }
            }
        }
    }
    /**
     * 给int数组进行冒泡排序
     * @param arr 接受一个int类型的数组
     */
    public static void bubbleSort(int[] arr) {
        for(int x = 0; x < arr.length - 1; x++) {
            for(int y = 0; y < arr.length - x - 1; y++) {
                if(arr[y] > arr[y+1]) {
                    swap(arr, y, y+1);
                }
            }
        }
    }
    /**
     * 给数组中的元素进行位置的置换
     * @param arr 接受一个int类型的数组
     * @param a 要置换的位置
     * @param b 要置换的位置
     */
    private static void swap(int[] arr, int a, int b) {
        int temp = arr[a];//置换私有化
        arr[a] = arr[b];
        arr[b] = temp;
    }
    /**
     * 用于打印数组中的元素。打印形式是：[element1, element2, ...]
     * @param arr 接受一个int类型的数组
     */
    public static void printArray(int[] arr) {
        System.out.print("[");
        for(int x = 0; x < arr.length; x++) {
            if(x != arr.length - 1)
                System.out.print(arr[x] + ", ");
            else
                System.out.println(arr[x] + "]");
        }
    }
}

虽然可以通过建立ArrayTool的对象使用这些工具方法，对数组进行操作，但是依然发现了问题：

  1. 对象是用于封装数据的，可是ArrayTool对象并未封装特有数据。
  2. 操作数组的每一个方法都没有用到ArrayTool对象中的特有数据。

这时就考虑，让程序更严谨，是不需要对象的。可以将ArrayTool中的方法都定义成static的。直接通过类名调用即可。

将方法都静态后，可以方便于使用，但是该类还是可以被其他程序建立对象的。为了更为严谨，强制让该类不能建立对象。可以通过将构造函数私有化完成。。

接下来，将ArrayTool.class文件发送给其他人，其他人只要将该文件设置到classpath路径下，就可以使用该工具类。但是，很遗憾，该类中定义了多少个方法，对方不清楚，因为该类并没有使用说明书。开始制作程序的说明书，java的说明书通过文档注释来完成。

单例设计模式

设计模式：解决某一类问题最行之有效的方法。JAVA中有23种设计模式。

单例设计模式：解决一个类在内存只存在一个对象。

想要保证对象唯一：

  1. 为了避免其他程序过多建立该类对象，先禁止其他程序建立该类对象。
  2. 还为了让其他程序可以访问到该类对象，只好在本类中，自定义一个对象。
  3. 为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。

这3步怎么用代码体现？

  1. 将构造函数私有化。
  2. 在类中创建一个本类对象。
  3. 提供一个方法可以获取到该对象。

对于事物该怎么描述，还怎么描述。当需要将该事物的对象保证在内存中唯一时，就将以上的3步加上即可。

示例代码：

class Single {

    private int num;

    public void setNum(int num) {
        this.num = num;
    }

    public int getNum() {
        return num;
    }
    private Single() {

    }
    private static Single s = new Single();

    public static Single getInstance() {
        return s;
    }
}

class Student {
    private int age;

    private static Student s = new Student();

    private Student() {

    }

    public static Student getStudent() {
        return s;
    }

    public void setAge(int age) {
        this.age = age;
    } 

    public int getAge() {
        return age;
    }

}

public class SingleDemo {

    public static void main(String[] args) {
        Single ss = Single.getInstance();
        Single s1 = Single.getInstance();
        ss.setNum(20);
        System.out.println(s1.getNum());

        Student stu1 = Student.getStudent();
        stu1.setAge(30);

        Student stu2 = Student.getStudent();
        stu1.setAge(3);

    }

}

单例设计模式可分为饿汉式与懒汉式(面试常考)（以下例代码说明）：

class Single1 {

    /*
     * 这个是先初始化对象。称为：饿汉式
     * Single1类一进内存，就已经创建好了对象
     * 开发原则：定义单例，建议使用饿汉式
        private static Single1 s1 = new Single1();

        private Single1() {

        }

        public static Single1 getInstance() {
            return s1;
        }
    */

    /*
     * 对象是方法被调用时，才初始化，也叫做对象的延时加载。称为：懒汉式
     * Single1类进内存，对象还没存在，只有调用getInstance()方法时，才建立对象
     */
    private static Single1 s1 = null;

    private Single1() {

    }

    //synchronized相当于上了一个锁，但程序效率降低了
    public static Single1 getInstance() {
        if(s1 == null) { //双重判断，可解决这个问题（涉及多线程）
            //--->B(挂着了)
            synchronized (Single1.class) {
                if(s1 == null) {
                    //--->A(挂着了)
                    s1 = new Single1();
                }
            }
        }
        return s1;
    }
}
时间： 2024-12-22 08:08:24

面向对象之封装的相关文章

面向对象的封装性和多态性

面向对象之封装性: 1.继承要符合is-a的关系.即"子类is a 父类"——子类是父类.如:卡车是汽车,卡车is a 汽车. 2.父类中如果用Protected修饰符,表示只允许其子类访问,而不允许其他非子类访问: 父类中如果用private修饰符,子类是不能访问的. 3.除了构造方法不能被子类继承外,其他都可以直接被继承.可以用base关键字调用父类的构造函数:语法如下 :base(参数变量名) 使用base还可以调用父类的属性和方法. 注意:子类构造函数中已经定义了这些参数,在b

C#面向对象（封装）

以上就是面向对象的封装和初始化:

面向对象（封装private）

/** * Created by 刘朋程 on 2014-5-22. */ class Testprivate {     private int age = 18;              //私有化age并赋值为18 public void setAge(int age)   //设置age范围     {         if (age>0 && age<100)         {             this.age = age;             spe

Python面向对象编程-封装

1引言 你点击了桌面上的Chrome图标,一个浏览器窗口出现了,输入网址就可以在Internet世界愉快玩耍.这一切是怎么实现的呢?Chromium这个多进程的程序是如何启动各个进程的呢?浏览器主进程(界面进程)启动了哪些线程?如何启动的呢?这些问题一直萦绕在心头,一起来看看源代码吧.本文主要针对Chromium for Mac的源代码,其它操作系统大同小异. 2背景知识 浏览器作为一个应用程序,是以进程的形式运行在操作系统上的.首先,Chromium是一个多进程的应用程序,我们需要了解Chro

黑马程序员——Java基础---面向对象之封装

------<a href="http://www.itheima.com" target="blank">Java培训.Android培训.iOS培训..Net培训</a>.期待与您交流! ------- 面向对象之封装      一:封装概述 是指隐藏对象的属性和实现细节,仅对外提供公共访问方式. 好处: (1)将变化隔离(内部怎样变化外部是不需要知道的,只调用即可) (2)便于使用(我们不用知道内部构造直接使用就可以) (3)提高重用性

java基础面向对象之封装

java基础面向对象之封装 2017-01-15 封装 1)封装性就是保证类内部被外部类不可见 2)所有属性都必须使用private关键字声明 3)封转后的属性如果要被外部所访问就必须实现set和get方法 例如: 使用了private声明的属性只有在自己的类是可见的 1 class Book{ 2 private String title ; //使用private声明的属性 3 private int price ; 4 } 5 public class PrivateDemo1 { 6 p

原生JS面向对象思想封装轮播图组件

原生JS面向对象思想封装轮播图组件 在前端页面开发过程中,页面中的轮播图特效很常见,因此我就想封装一个自己的原生JS的轮播图组件.有了这个需求就开始着手准备了,代码当然是以简洁为目标,轮播图的各个功能实现都分别分为不同的模块.目前我封装的这个版本还不适配移动端,只适配PC端. 主要的功能有:自动轮播,点击某一张图片对应的小圆点就跳转到指定图片,有前后切换按钮.使用的时候只需要传入图片的路径以及每张图片分别所对应的跳转路径还有目标盒子ID就可以了,还可以自定义每张图轮播的延时,不过延时参数不是必须

Java学习记录(补充三:面向对象的封装和继承)

面向对象的封装package day7; //面向对象的封装 public class Employee { String name = "zhangsan"; private int age; //多个方法重载 public Employee(){ } public Employee(String name,int age){ } public Employee(int age,String name){ } //可以在方法里修改不能访问的属性 public int getAge()

OracleHelper(对增删改查分页查询操作进行了面向对象的封装，对批量增删改操作的事务封装)

公司的一个新项目使用ASP.NET MVC开发,经理让我写个OracleHelper,我从网上找了一个比较全的OracleHelper类,缺点是查询的时候返回DataSet,数据增删改要写很多代码(当然,可以用代码生成器,不过配套的代码生成器暂时没有):又从网上找了一个封装了泛型方法的OracleHelper类,整合到一起,但貌似数据增删改查依然不方便:于是花了两天时间,在原有基础上对增删改查分页查询操作进行了面向对象的封装,并且对批量增删改操作进行事务封装,写事务代码更方便. 原理: 1.利用

黑马程序员------OC面向对象之封装

---Android培训.iOS培训.Java培训,期待与您交流----- 一.面向对象和封装 面向对象三大特征:封装.继承.多态. 封装是对象和类概念的主要特性.它是隐藏内部实现,稳定外部接口,可以看作是"包装". 封装,也就是把客观事物封装成抽象的类,并且类可以把自己的数据和方法只让可信的类或者对象操作,对不可信的进行信息隐藏. 好处:使用更加简单  变量更加安全 可以隐藏内部实现细节  开发速度加快. 苹果官方文档中,有一个配图生动的阐释了封装: @interface用于给人们显