面向过程：是一种谓语与宾语的关系，如在一个结构体中定义窗口的大小，位置，颜色，背景等属性，对窗口操作的函数与窗口的定义没有任何关系，如HideWindow,MoveWindow,MinimizeWindow等，这些函数都需要接受一个代表要被操作的窗口参数，来隐藏窗口，移动窗口，最小化窗口，这是一种谓语与宾语的关系。
面向对象：定义窗口时，除了要指定在面向过程中规定的那些属性，如大小，，位置，颜色，背景等外，还要制定该窗口的可能有的动作，如隐藏，移动，最小化等。这些函数被调用时，都是以某个窗口要隐藏，某个窗口要移动的语法格式来使用的，这是一种主语与谓语的关系。
面向对象的三大特征：封装(Encapsulation) 继承(Inheritance) 多态(Polymorphism)
类是某一类事物的描述，是抽象的、概念上的定义；对象是实际存在的该类事物的每个个体，因而也称实例(instance)。
类描述了对象的属性和放法，一个类可以产生多个对象。面向对象程序设计的重点是类的设计，而不是对象的设计。
如下：
class Person //定义一个类
{
int age;
void shout()
{
System.out.println("my age is "+age);
}
public static void main(String[] args)
{
Person p1=new Person(); //产生对象p1
Person p2=new Person(); //产生对象p2
p1.age=-30;
p1.shout();
p2.shout();
}
}
程序的运行结果表明,当一个对象被创建时，会对其中的成员变量自动进行初始化赋值，除了基本数据类型之外的类型都是引用类型。并且p1,p2都有自己的属性与方法，互不影响。
指向对象的变量不再被使用后会被释放，对象再无引用变量指向时会变为垃圾，但此时仍占据着内存，然后在某一时刻被垃圾回收器回收释放。
对象的比较
“==”运算符与equals()方法的区别：equals()方法用于比较两个对象的内容是否相等，“==”运算符用于比较引用变量所指向的是否为同一对象。如有,
String str1=new String(“abc”);
String str2=new String(“abc”);
String str3=str1;
执行str1==str2则返回假，执行str1==str3返回真。同样，执行str1.equals(str2)则返回真，因为str1,str2所指的对象的内容是一样的，自然，str1.equals(str3)也会返回真。
实现类的封装性
如果外面的程序可以随意修改一个类的成员变量，会造成不可预知的程序错误。因此，在定义一个类的成员（包括变量和方法）时，使用private关键字说明这个成员的访问权限，这个成员成了类的私有成员，只能被这个类的其他成员方法调用，而不能被其他的类中的方法所调用。
为了实现类的封装性，我们通常将类的成员变量声明为private，再通过public的方法来对这个变量进行访问。对一个变量的操作，一般都有读取和赋值操作，我们分别定义两个方法实现这两种操作，一个是getXxx(),用来读取这个变量操作，另外一个是setXxx()用来对这个成员变量赋值。
一个类通常是一个小的模块，我们应该让模块仅仅公开必须要让外界知道的内容，而隐藏其它一切内容。我们在进行程序的详细设计时，应该尽量避免一个模块直接修改或操作另一个模块的数据，模块的设计追求强内聚，弱耦合。
构造方法
当一个类的实例对象刚产生时，这个类的构造方法就会被自动调用我们可以在这个方法中加入要完成初始化工作的代码。一旦自己编写构造函数，系统便不再生成无参的构造函数了。
构造方法的执行过程
在创建对象时，首先将成员变量进行默认的初始化，然后再接受参数。构造方法在接受传过来的参数后不是先执行函数中的代码，而是执行显示初始化的代码，然后再先执行构造函数中的代码。
This引用句柄
每个成员方法的内部，都有一个this引用变量，指向调用这个方法的对象，类中的成员方法与this之间的关系如图：
其实我们在一个方法内部使用“this.其他成员”的引用方式和直接使用“其他成员”的效果是一样的，但在有些情况下，我们还是非得用到this关键字的：
让类的成员变量名和对其进行赋值的成员方法的形参变量同名是必要的，这样可增加代码的可读性，此时为了区分成员变量与形参，就需要在成员变量前面加this。
假设我们有一个容器类和一个部件类，在容器类的某个方法中要创建部件类的实例对象，将部件加到容器中，而部件类的构造方法要接受一个代表其所在容器的参数，此时也要用到this，如：
class Container
{
Component comp;
public void addComponent()
{
comp=new Componet(this);
/*指明将部件加到这个容器中，因为调用这个方法时已经产生了一个容器对象。*/
}
}
class Component
{
Container c;
public Component(Container c)
{
this.c=c; //用于区分
}
}
一个构造方法调用另一个构造方法时，可用this(参数列表名)的形式，根据其中的参数列表选择相应的构造方法。
垃圾回收过程分析
java中的fianlize()方法：每一个类中都有这样一个方法，该方法不是在对象变成垃圾之前被调用，而是对象变成垃圾在内存中被彻底清除之前自动调用。该方法属于java中的垃圾回收机制，这个机制并不会立即处理产生的垃圾，因此有时并不是可靠的。
可用System.gc()去启动垃圾回收器。
static静态变量
我们编写一个类时，有时希望无论是否产生了对象或无论产生了多少对象的情况下，某些特定的数据在内存中只有一份，这便产生了static类型。有时称为类类型，由所有由该类产生的对象共享。
使用static静态方法时应注意：
在静态方法里只能直接调用同类中其他的静态成员（包括变量和方法），而不能直接访问类中的非静态成员。这是因为，对于非静态的方法和变量，需要先创建类的实例对象后才能使用，而静态方法使用前不用创建任何对象。基于同样的原因，静态方法不能以任何方式引用this和super关键字。
main()方法是静态的，因此JVM在执行main方法时不创建main方法所在的类的实例对象，因而在main()方法中，我们不能直接访问该类中的非静态成员，必须创建该类的一个实例对象后，才能通过这个对象去访问类中的非静态成员。
静态代码块
一个类中可以使用不包含在任何方法体重的静态代码块（static block）,当类被载入时，静态代码块被执行，且只被执行一次，静态代码块经常用来进行类属性的初始化。
类中的静态代码块被自动执行，尽管我们产生了类的多个实例对象，但其中的静态代码块只被执行了一次，并且是在使用这个类之前执行。当一个程序用到了其他的类，类是在第一次被使用的时候才被装载，而不是在程序启动时就装载程序中所有可能要用到的类。
单态设计模式
设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式。所谓类的单态设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法。如果我们要让类在一个虚拟机中只能产生一个对象，我们首先必须将类的构造方法的访问权限设置为private，这样，就不能用new操作符在类的外部产生类的对象了，但在类的内部仍可以产生该类的对象，因为在类的外部开始还无法得到类的对象，只能调用类的某个静态方法以返回该类内部创建的对象，静态方法 访问类中的静态成员变量，所以，指向类内部产生的该类对象的变量也必须定义成静态的。如:
class Chinese
{
static Chinese objRef=new Chinese();
private Chinese()
{
System.out.println(“Chinese”);
}
public Chinese getInstance()
{
return objRef;
}
}
class TestChinese
{
public static void main(String[] args)
{
Chinese obj1=Chinese.getInstance();
Chinese obj2=Chinese.getInstance();
System.out.println(obj1==obj2);
}
}
执行obj1==obj2，返回的结果为true，语句static Chinese objRef=new Chinese();产生静态的实例对象，只加载一次，若去掉static，则会在产生一个对象后，objRef又指向一新的对象，当产生新的对象时，又要执行Chinese objRef=new Chinese();使得objRef又指向另一个一新的对象，造成无限的循环。
内部类
内部类可以直接访问嵌套它的类的成员，包括private成员，但是内部类的成员不能被嵌套它的类直接访问。
在内部类对象保存了一个对外部类对象的引用，当内部类的成员方法中访问某一变量时，如果在该方法和内部类中都没有定义过这个变量，内部类中对this的引用会被传递给那个外部类对象的引用。如：
class Outer
{
int outer_i=100;
void test()
{
Inner in=new Inner();
in.display();
}
class Inner
{
System.out.println(“outer_i=”+outer_i);
}
public statict void main(string[] args)
{
Outer outer=new Outer();
outer.test();
}
}
因为在内部类对象保存了一个对外部类对象的引用，内部类Inner中即使没有outer_i,也可以通过对外部类对象的引用，在外部类中找到它。
如果用static修饰一个内部类，这个类就相当于是一个外部定义的类，所以static的内部类中可声明static成员，但是，非static的内部类中的成员不能声明为static的。static的内部类不能再使用外层封装类的非static成员变量，因此static嵌套类很少使用。
如果函数的局部变量（函数的形参也是局部变量），内部类的成员变量，外部类的成员变量重名，我们应该按下面的程序所使用的方式来明确制定我们真正要访问的变量。
public class Outer
{
private int size;
class Inner
{
private int size;
public void doStuff(int size)
{
size++;//引用的是doStuff函数的参数
this.size++;//应用的是Inner类中的成员变量
Outer.this.size++;//引用Outer类中的成员变量
}
}
}
内部类被外部引用
如果内部类被定义成public的，那么这个内部类也可以在外面（嵌套它的类的外面）使用：
public class Outer
{
private int size=10;
public class Inner
{
private int size;
public void doStuff()
{
System.out.println(++size);
}
}
}
public class TestInner
{
public static void main(String[] args)
{
Outer outer =new Outer(); //再使用内部类之前，要先产生其外部类的对象
Outer.Inner inner=outer.new Inner();//注意产生内部类对象的形式。
inner.doStuff();
}
}
在方法中定义的内部类
内部类并非只能在类里定义，也可以在几个程序块的范围内定义内部类。例如，在方法中，甚至在for循环体内部，都可以定义内部类。
在方法中定义的内部类只能访问方法中的final类型的局部变量，用final定义的局部变量相当于是一个常量，它的生命周期超出方法运行的生命周期。
java的文档注释
使用以/**开头,以*/结尾的格式进行注释，将程序的文档注释信息嵌入到java程序中。使用javadoc.exe可以将程序中的文档注释信息提取出来，生成类似于sun公司的html格式的文档。
在类的定义之前一般加入以下信息：Title：指出类名；Description：简单地描述类的功能，用在什么情况下；Copyright：版权；Company：公司；还有一些特殊的标注参数以@开头，后面是内容，如作者、版本等，这些特殊的标注参数是不应有错的。注意在每行末尾加换行符<br>，而有特殊的标记参数的行是不需要的。
也可以对方法加上文档注释，放在方法的定义之前，指明方法的功能，可以加入标注参数如param，后面是方法接受的参数的名称num，再后面是参数的解释说明；标注参数return后面是方法的返回值的说明。
生成注释文档
使用文档注释的类应是public的，在命令行中键入如：
javadoc –d engineer(编译完的文件所放的目录) –author(生成文档中要添加的标注信息，后同) –version engineer.java(源文件名)。
3010
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
