您的位置：首页 > 编程语言 > Java开发

java 自学日志【五】---面向对象之封装

2013-04-11 03:19 281 查看

------android培训，java培训，期待与您交流------
面向对象----概述

面向对象思想：面向对象是相对于面向过程而言，面向对象和面向过程都是一种思想，面向过程强调的是功能，
而面向对象强调的是将功能封装进对象，强调具备功能的对象.

面向对象的思想特点：是符合人们思考习惯的一种思想，将复杂的问题简单化，将程序员从执行者变成指挥者。

例如要达到某种结果，我只需要找到能帮助我达到该结果的功能的对象，如我要洗衣服，要是我自己手洗，这是面向过程思想，我要是找台洗衣机，至于洗衣机里面是怎么操作的我不知道，我达到了洗衣服的结果，这就是面向对象，洗衣机就把洗衣服的功能封装起来了。

从功能封装的角度讲，面向对象和面向过程一样，也是函数，但是面向对象可以将多个联系紧密的函数封装在一起，形成类，当你需要某个功能，只需要调用这个类建立一个对象，拿对象来调用这个功能就行了。

面向对象的开发，就是找对象使用，如果没有对象，就建立一个对象，而程序员要做的就是，找对象，使用对象，建立对象，维护对象之间的关系。

类与对象之间的关系：类是对现实世界事物的抽象描述，类的成员变量对应事物的属性，成员方法对应事物的行为，类的一个实例，即对象，对应现实事物的一个个实体。

成员变量与局部变量的区别：
①作用域：成员变量----->整个类中有效；
局部变量----->局部范围有效，方法中或语句内，最近的{}中有效；

②内存中存储位置：成员变量--->堆内存中，随着对象的建立而存在，随着对象的消失而消失；
局部变量--->栈内存中，方法被调用或语句执行用时存在，当方法调用完，或语句执行结束后，自动释放；

③初始化值：成员变量-----> 有默认初始值；
局部变量-----> 没有默认初始值，使用前必须赋值；

匿名对象：顾名思义，就是没有名字的对象，是对象的一种简写形式。
匿名对象特点：1.可以调用属性，但没有意义；2.调用方法有意义，但只能调用一次，若对一个对象进行多次成员调用必须给该对象建立引用；
3.可以作为参数传递给函数。
匿名对象举例：

class Person
{
int age =20;//成员变量

String name ="andy";

public void run()//成员方法
{
System.out.println(name+"---"+age);
}

}
class PersonDemo
{
public static void main(String[] args)
{
/*
Person p = new Person(); //建立对象

p.age =30;
p.name ="tony"
p.run();
*/
//new Person().age= 30;// 建立匿名对象，调用person属性，无意义。
//new person().run();// 建立匿名对象，调用person的run方法。只能调用一次。
show(new Person());//匿名对象作为参数传递给函数。
}
public static void show(Person p)
{
p.age =40;
p.name ="jack";
p.run();
}
}

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

封装（Encapsulation）

【一】
概念：封装是指隐藏对象的属性和实现细节，紧对外提供公共访问的方式。

好处：将变化隔离，方便使用，提高重用性，提高安全性。

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

提供对外访问方法，就可以在访问方式中加入逻辑判断等语句，对访问的数据进行操作，提高代码健壮性。
【二】private 关键字
private：私有，权限修饰符，用于修饰成员变量和成员方法，被private修饰的成员只在本类中有效，是封装的一种体现。
private举例：

class Person
{
private int age;//私有 age，

public void run()
{
System.out.println("age="+age);
}
public void setAge(int a)// 对外提供公共访问方式，并判断传入年龄合不合法。
{
if (a>0&& a<130)
{
age = a;
run();
}
else
System.out.println("error");
}

}
class PersonDemo
{
public static void main(String[] args)
{
Person p = new Person();
p.setAge(-55);
}
}

【三】构造函数
特点：函数与类名相同，没有返回值，没有返回值类型，不可以有return语句。对象一建立，就会调用与之对应的构造函数，并给对象初始化，一个对象的构造函数只运行一次，而一般函数可以通过对象的调用运行多次。
作用：给对象进行初始化。
ps: 当一个类中没有定义构造函数时，系统会默认给该类添加一个空参构造函数，权限和类一致，便于类的初始化，当在类中自定义了构造函数，默认的就不存在了。构造函数可以重载。

什么时候定义构造函数？
当分析事物时，事物具备一些特性或行为，就将这些内容定义在构造函数中。
构造代码块：{}，给所有对象进行统一初始化，对象一建立就执行，而且优先于构造函数执行，构造函数时给对应的对象初始化。
如不同对象有共性的初始化内容，可以将这部分内容定义在构造代码块中。
*构造函数可以私有化，一旦私有化，就不能够创建对象！
【四】this关键字
this：代表调用this所在函数的那个对象，谁调用this所在的方法，this就代表谁，类内部函数之间的调用都是通过对象完成的，只是默认省略了this，通过this就可以将局部变量和成员变量区分开。

什么时候用this？当定义类的功能时，如果功能内部需要调用这个功能的对象，那么就用this代表这个对象。

this语句：this(),用于构造函数间的调用，并且只能放在构造函数的第一行，因为初始化动作要先执行，主要不要用this语句构成构造函数间的死循环。

class Person
{
private int age;
private String name;

{
System.out.println("cry......");
}//构造代码块，

//person(){}  系统默认的空参构造函数
Person()//自定义构造函数
{
System.out.println("A: name "+name+",age "+age);
}

Person(String name)//构造函数的重载
{
this.name = name;//this 关键字，代表pb这个对象，如果此处省略this，局部变量和成员变量重名。调用失败。
}

Person(String name,int age)
{
this(name);//this 语句，只能用于构造函数之间调用。
this.age = age;
}

public void run()
{
System.out.println(" name "+name+",age "+age);//name和age前省略了this
}
}
class PersonDemo2
{
public static void main(String[] args)
{
Person pa = new Person();
Person pb = new Person("andy",20);
pb.run();
}
}

【五】static 静态
static 关键字，修饰符，用于修饰成员变量和成员方法，当成员被修饰成静态后，就多了一个调用方法，除了可以被对象调用外，还可以直接被类名调用，格式：类名.静态成员。

特有数据随着对象存储，放在堆内存中；共享数据用static修饰，放在方法区中；

static特点：①随着类的加载而加载，随着类的消失而消失；
②优先于对象存在，静态变量先存在，对象后存在；
③被所有对象共享；
④可以直接被类名调用；
实例变量和类变量的区别：
①存储位置：实例变量随着对象加载而存在于堆内存中；
类变量随着类的加载而存在于方法区中；

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

类变量随着类的消失而消失，生命周期长；
方法区：也叫共享区，数据区，一个类加载后，都会开辟该类的方法区，存储静态部分和非静态部分，类的方法区开辟先于对象堆内存空间的开辟。

static静态的使用注意事项：
①静态方法只能访问静态成员，包括静态变量和静态方法，但非静态方法既可以访问静态成员，也可以访问非静态成员；
②静态方法中不可以定义this，super关键字；因为静态优先于对象而存在。
③主函数是静态，是一个特殊的函数，作为程序的入口，可以被jvm调用。
public static void main(String[] args)

public:公共的意思，是最大权限修饰符。

static:由于jvm调用main方法的时候，没有创建对象。只能通过类名调用。所以，main必须用static修饰。

void:由于main方法是被jvm调用，不需要返回值。用void修饰。

main:main是主要的意思，所以jvm采用了这个名字。是程序的入口。

String[]:字符串数组

args:数组名

在运行的时候，通过java命令给args数组赋值。格式：java MainTest hello world itcast
主函数有一般静态成员的特点，可以被其他静态成员所调用，也可以被对象调用。

静态的利弊：利：对对象的共享数据进行单独存储，节省空间，可以直接用类名调用，方便；
弊：生命周期长，访问有局限性，只能访问静态；

class Per
{
String name;//成员变量，实例变量
static String country ="China";//静态成员变量，类变量

public  void show()//此处方法不能定义成静态，因为name不是静态变量，而country是静态。
{
System.out.println(name+"---"+country);
}
}
class PersonDemo3
{
public static void main(String[] args)
{
Per p1 = new Per();
p1.name = "andy";
p1.show();
System.out.println(Per.country);//类名直接调用静态成员
}
}

什么时候使用静态？
从静态函数和静态变量两方面入手，当对象中出现共享数据时，把该数据用static修饰，而对象中的特有数据要定义成非静态，存放于堆内存中；当功能内部没有访问到非静态数据或对象的特有数据时，那么可以把该功能定义成静态的。

静态代码块：static {静态代码块执行语句}；
特点：随着类的加载而执行，只执行一次，用于给类初始化，优先于主函数，只有用到了类中的内容才加载类，才执行静态代码块。

*执行顺序：静态代码块--- 构造代码块---构造函数

制作程序文档注释：[b]/** */.也叫API文档，API（Application
Program Interface 应用程序编程接口）；[/b]
使用JDK\bin目录下的javadoc工具。格式:javadoc -d 目录 -author -version ArrayTool.java。

注意：能被提取的注释必须是public或protected的。

对象的初始化过程：对于视频中 Person p = new Person ("andy",20);
1 new用到了Person.class，所以会先找到该类的字节码文件，并将之加载到内存中；
2 执行静态代码块，如果有的话，对类进行初始化；
3在堆内存中开辟内存空间，分配地址值；
4 在堆内存中建立对象特有的属性，并对属性进行默认初始化；
5 对属性进行显示初始化；
6 执行构造代码块，进行对象初始化；
7 执行与对象对应的构造函数，进行初始化；
8 将地址值赋给栈内存中的引用变量；

对象调用成员过程：

静态成员之间的调用省略了“类名.”，非静态成员之间的调用则省略了this。

【六】单例设计模式

设计模式：最早存在于建筑领域，后引入计算机设计。GOF总结了23中设计模式。设计模式偏重思想，要结合实际，否则就会显得很空乏。模式的综合就形成了框架。设计模式是解决某一类问题最行之有效的方法。

单例设计模式：解决一个类在内存中，只有一个对象这样的问题。

如何形成单例？

1 构造函数全部私有，禁止其他程序建立该类对象；

2 在类中创建一个本类对象，并静态私有；

3 提供对外访问该类对象的静态方法；

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

单例设计模式有两种：懒汉式和饿汉式

1 饿汉式：类一加载进内存，就创建好了对象；

class Single
{
private Single(){};

private static Single s = new Single();

public static Single getInstance()
{
return s;
}
}
class SingleDemo
{
public static void main(String[] args)
{
Single x = Single.getInstance();
}
}

2 懒汉式：类才加载进内存的时候，对象还没有存在，只有调用了getInstance()方法时，对象才开始创建。延迟加载。

class Single
{
private Single(){}

private static Single s = null;

public static Single getInstance()
{
if (s ==null)
s = new Single();
return s;
}
}

PS:开发常用饿汉式，因为饿汉式简单安全。懒汉式多线程的时候容易发生问题。

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签：

相关文章推荐

新的分享

章节导航