黑马程序员_面向对象（概述、封装）

------- android培训、java培训、期待与您交流！ ----------

 

----------------------面向对象概述 封装  

 

面向对象概述

是一种编程思想，相对于面向过程，将功能封装进对象，强调具备了功能的对象。

面向对象有三大特征：封装，继承，多态

特点：找对象，建立对象，使用对象，维护对象的关系

封装就是对功能的封装

类：对现实生活中事物的描述（共性内容，具体抽象）描述就是class定义的类

对象：就是这类事物，实实在在的个体对应java在堆内存中new出来的实体

如：对汽车：类就是生产汽车的图纸，汽车就是堆内存中的具体对象

对象的属性对应类中的变量，行为对应类中的函数

代码：

public classCarDemo

{

    publicstaticvoid main(String[] args)

    {

        Carc = newCar();//实例化，相当于生产了一辆汽车

        c.color ="blue";//将车子的颜色改为蓝色，这个是局部变量

        c.run();//调用了汽车的run()方法

    }

}

class Car

{

    String color= "red";

    intnum = 4;         //这两个是汽车的属性，是成员变量，实例化之后存在于堆内存中

    void run()           //汽车的行为

    {

        System.out.println(color+"..."+num);

    }

}

成员变量

成员变量作用于整个类。定义在堆内存中，由对象的存在而存在

局部变量

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

匿名对象

对对象的简写格式，如：

Car c = new Car();     

c.run();

简写为：new Car().run()。//调用一次时可用匿名对象完成

好处：简写代码。不足：不能完成多次调用，一次调用完就垃圾了

匿名对象还可以作为实际参数进行传递

封装：

指隐藏对象的属性和实现细节，仅提供公共访问方式

好处：变化隔离，便于使用，重用性，安全性

原则：将不需要对外提供的内容都隐藏起来，属性隐藏，提供公共方法对其访问

private:权限修饰符的一种，用于修饰类中的成员（成员变量、成员函数）私有只在本类中有限，对成员属性进行私有化之后，必须提供访问该属性的访问方式（通常为两个，set、get）并进行控制，如逻辑判断等，提高了代码的健壮性

private修饰构造函数还可以避免用户创建对象

构造函数

特点：函数与类名一致，不用定义返回值类型，不用写return语句，对象一建立就会调用与之对应的构造函数，当一个类中没有定义构造函数时，系统会给该类加入一个空参数的构造函数，自定义后替换默认，new一个对象时就执行且只一次

作用：给对象进行初始化

什么时候定义构造函数：分析某一事物时，该事物存在或具备一些行为或特征时，将这些行为或特征定义在构造函数中

构造代码块：

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

特点：给所有对象初始化，构造函数只给对应的对象初始化。不同对象的共性的初始化方式定义在构造代码块中

this关键字

this代表它所在函数所属对象的引用（本类对象）

应用：当定义类中功能时，该函数内部要用到调用该函数的对象时，这时用this来表示这个对象（本类功能使用了本类对象都用this表示）

例（应用）：

    publicboolean compare(Person p)

    {

        return this.age == p.age;//这里，谁调用compare()方法，this就代表谁

    }

在构造函数中的应用（this语句）：

Person(String name)

    {

        this.name = name;

    }

    Person(String name,intage)

    {

        this(name);//这里this相当于   对象(name)

        this.age = age;

    }

this语句只能定义在构造函数的第一行

      因为初始化要先执行

总结：

public classPersonDemo

{

    publicstaticvoid main(String[] args)

    {

        Personp1 = newPerson("zhangsan",21);//new一个人叫张三，21岁

        Personp2 = newPerson("lisi",21);

        boolean b = p1.compare(p2);//p1和p2进行年龄的比较

        System.out.println(b);

    }

}

class Person

{

    privateinta ge;

    private Stringname;  //对人的属性age和name进行私有

    Person(Stringname)//构造函数1：只有姓名

    {

        this.name = name;//this代表本类对象

    }

    Person(Stringname,intage)//构造函数2、既有姓名又有年龄

    {

        this(name);//这里this相当于   对象(name)

        this.age = age;

    }

    {

        System.out.println("Cry.......");//构造代码块：给多有对象初始化

    }

    publicvoid setAge(int age)//对age进行操作。(name未列出)

    {

        this.age = age;

    }

    publicint getAge()//获取age的值(name未列出)

    {

        returnage;

    }

    publicboolean compare(Person p)//提供一个比较年龄是否相等的方法

    {

        returnthis.age == p.age;//这里，谁调用compare()方法，this就代表谁

    }

}

static（静态）关键字

用于修饰成员（共性的，被共享）（成员变量和成员函数），成员被修饰后随着类的加载而加载消失而消失，优先于对象存在，被所有类共享，可以直接被类名调用（类名.静态成员）。

被static修饰的成员变量和成员函数在内存的方法区（共享区或数据区）

被static修饰的成员变量叫类变量，它随类的加载而存在于方法区中，生命周期最长

注意：静态方法只能访问静态成员。非静态方法及可以访问静态也可以访问非静态。静态方法中不可以定义this，super关键字，因为静态优先于对象存在

main（主函数）

public staticvoid main(String[] args){}

public:代表该函数访问权限最大

static:该函数随类的加载而加载

void：主函数没有返回值

main：不是关键字，但是能够被JVM识别

String[] args：main函数的参数是一个字符串数组，其长度为零

在dos环境下：运行一个class文件时，如java MainDemohaha  可以往该程序的主函数String[]args中传递元素（haha）

帮助文档的制作

将说明用文档注释，@author作者  @version 版本

@param 表示该方法接收的参数类型  @return表示该方法的返回值类型

javadoc –d目录 –author–version类名如：

javac –d d:\myhelp –author –version ArrayTool.java

静态代码块

格式：  

static

    {

        执行语句

    }

随着类的加载而执行且只执行一次，用于给类初始化

对象的初始化过程：

1、         类的加载

2、         静态代码块的执行（方法区）

3、         在堆内存中开辟空间，分配内存地址

4、         默认初始化

5、         对属性进行显示初始化

6、         构造代码块初始化执行

7、         对应的构造函数初始化执行

8、         将内存地址赋值给栈内存中的变量

单例设计模式

设计模式是纯思想

1、饿汉式

public classArrayTool

{

    publicstaticvoid main(String[] args)

    {

        Single ss = Single.getInstance();//获取该对象

    }

}

class Single

{

    private Single(){}//限制对象的创建

    privatestatic Singles = new Single();//自己创建一个私有静态的对象

    publicstatic Single getInstance()//对外提供一个获取该对象的方法

    {

        returns;

    }

}

2、懒汉式

classSingle

{

    privatestatic Single s =null;//对象初始化

    private Single(){}//限制对象的创建

    publicstatic Single getInstance()//对外提供一个获取该对象的方法

    {

        if(s ==null)//先判断

            s= newSingle();//再创建

        return s;

    }

}

两种方法的区别：建立对象的时间不同

懒汉式在多线程时存在安全隐患，可加锁：public static synchronizedSingle getInstance()但是这种方式效率就低了

最终解决方案：

public static synchronized Single getInstance()

{

      if(s==null)

          synchronized(Single.class)

          {

      If(s==null)

          s=new Single();

}

}

即：双重判断

 

------- android培训、java培训、期待与您交流！ ----------