------------android培训、java培训、期待与您交流！------------
1， 面向对象和面向过程都是一种思想；面向过程强调的是功能行为，面向对象是将功能封装进对象，强调具备了功能的对象；
面向对象是基于面向过程的。
面向对象三个特征：封装，继承，多态。
2， 类和对象的关系：类：对现实生活中事物的描述；对象：就是这类事物，实实在在存在个体。
3， 成员变量和局部变量。
作用范围：成员变量作用于整个类中；局部变量作用于函数中或语句中。
在内存中的位置：成员变量在堆内存中，因为对象的存在，才在内存中存在；局部变量在栈内存中。
4， 匿名对象是对象的简化形式。
匿名对象使用方式一：当对对象的方法只调用一次时，可以用匿名对象来完成，这样写比较简化，如果对一个对象进行多个成员调用，必须给这个对象起个名字。
使用方式二：可以将匿名对象作为实际参数进行传递。
Car c = new Car()
c.num = 5;
c.run();
//特别注意此处使用匿名对象，在内存中为三个不同的对象
new Car().num = 5;
new Car().color = "blue";
new Car().run();
show(new Car());
5， 封装（Encapsulation）:是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
好处：将变化隔离；便于使用；提高重用性；提高安全性。
原则：把不需要对外提供的内容都隐藏起来；把属性都隐藏，提供公共方法对其访问。
6， private:私有，权限修饰符：用于修饰类中的成员（成员变量，成员函数）。私有只在本类中有效。
一个属性通常对应两个方法，set（set打头的方法肯定是void类型，而且要传个参数）和get（get打头没有参数，而且访问类型跟它获取的变量一致）。私有仅仅是封装的一种表现形式。之所以对外提供访问方式，就因为可以在访问方式中加入逻辑判断等语句。对访问的数据进行操作，提高代码的健壮性。
7， 成员变量定义完可以参加运算，因为它在堆内存中，有默认初始化值；而局部变量在栈内存中，没有默认初始化值，不能定义完就直接参加运算，必须先进行初始化。
8， 构造函数，特点：函数名与类名一致；不用定义返回值类型；不可以写return语句。
作用：给对象进行初始化。构造函数的小细节：当一个类中没有定义构造函数时，那么系统会默认给该类加入一个空参数的构造函数；当在类中自定义了构造函数后，默认的构造函数就没有了。
和一般函数的区别：构造函数和一般函数在写法上有不同，在运行上也有不同。构造函数在对象一建立就运行，给对象初始化；而一般方法是对象调用才执行，是给对象添加对象具备的功能。一个对象建立，构造函数只运行一次，而一般方法可以被该对象调用多次。
应用：当分析事物时，该事物存在具备一些特性或者行为，那么将这些内容定义在构造函数中。
9， 构造代码块。
作用：给对象进行初始化。对象一建立就运行，且优先于构造函数执行。
和构造函数的区别：构造代码块是给所有对象进行统一初始化，是不同对象共性的初始化，而构造函数是给对应对象初始化。构造函数私有化后就无法创建对象了（单例模式正是应用到了此点）。
class Person{
//构造代码块。
{
System.out.println("person code is running");
}
Person(）{
System.out.println("Constructor of void parameter is running")；
}
Person(String n){
System.out.println("Constructor of Stringargs is running ");
}
}
class PersonDemo{
//利用无参的构造函数Person()创建对象。
Person p1=new Person();
//利用有参的构造函数Person(String n)创建对象。
Person p2=new Person("zhangsan");
}
输出： person code is running
Constructor of void parameter is running
person code is running
Constructor of Stringargs is running
有输出结果可知：1，构造代码块对所有Person对象都起作用；
2，构造代码块优先于构造函数执行。
10， this关键字。特点：this代表本类的对象，this代表它所在函数所属对象的引用。
应用：1，用于局部变量和成员变量相同的情况，当定义类中功能时， 该函数内部要用到调用该函数的对象时，这时用this来表示这个对象。但凡本类功能内部使用到了本类对象，都用this。
2，构造函数间互相调用用this();此时应注意构造函数互相调用引起的死锁，如下例：
Person(){
this(“haha”);
}
Person(Stringname){
this();
this.name=name;
}
特别注意：1，一般函数是不能直接调用构造函数的，因为this语句是不能用在一般函数中的，只能用在构造函数间。
2，this语句只能定义在构造函数的第一行。因为初始化要先执行，且只执行一次 。
11， static（静态）关键字。用于修饰成员（成员变量和成员函数）。
被修饰后的成员具有以下特点：
1）随着类的加载而加载，随着类的消失而消失，说明它的生命周期最长；
2）优先于对象存在，静态先存在，对象后存在；
3）被所有对象所共享；
4）可以直接被类名调用。当成员被静态修饰后，就多了一个调用方式，除了可以被对象调用外，还可以直接被类名调用。类名.静态成员。
实例变量和类变量的区别：
1） 存在位置。类变量随着类的加载而存在于方法区中，实例变量随着对象的建立而存在于堆内存中。
2） 生命周期。类变量生命周期最长，随着类的消失而消失。实例变量随着对象的消失而消失。
注意：1）静态方法只能访问静态成员，非静态方法既可以访问静态也可以访问非静态；
2）静态方法中不可以写this，super关键字，因为静态优先于对象存在；
3）主函数是静态的。
静态利弊：利：对对象的共享数据进行单独空间的存储，节省空间。没有必要每个对象中都存储一份。
弊：生命周期过长，访问出现局限性。
静态的应用:工具类ArrayTool。
1）对象是用于封装数据的，可是ArrayTool对象并未封装特有数据。
2）操作数组的每一个方法都没有用到ArrayTool对象中的特有数据。
为了让程序更严谨，是不需要对象的。可以将ArrayTool中的方法都定义成static的，直接通过类名调用即可。
为了让该类不能建立对象。可以通过将构造函数私有化完成。
12， 一个类中默认会有一个空参数的构造函数，这个默认的构造函数的权限和所属类一致。如果类被public修饰，那么默认的构造函数也带public修饰符。如果没有被public修饰，那么默认的构造函数也没有public修饰。默认构造函数的权限是随着类的变化而变化的。不写构造函数才叫默认构造函数。
13， 静态代码块。格式：static{静态代码块中的执行语句}
特点：随着类的加载而执行，只执行一次，并优先于主函数。用于给类进行初始化。
14， 对象的初始化过程分析：
Person p=new Person("zhangsan",20);
1，因为new用到了Person.class，所以会先找到Person.class文件，并加载到内存中。
2，执行该类中的static代码块，如果有的话，给Person.class类进行初始化。
3，在堆内存中开辟空间，分配内存地址。
4，在堆内存中建立对象的特有属性并进行默认初始化。
5，对属性进行显示初始化。
6，对对象进行构造代码块初始化。
7，对对象进行对应的构造函数初始化。
8，将内存地址赋给栈内存中的p变量。
结合下面的内存图理解：
15， Java程序在运行时，需要在内存中分配空间。为了提高运算效率，又对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。5片区域：栈内存，堆内存，方法区，本地方法区，寄存器。栈内存：用于存储局部变量，当数据使用完，所占空间会自动释放。
堆内存：数组和对象，通过new建立的实例都存放在堆内存中；
特点：1）每一个实体（用来封装数据）都有内存地址值；
2）实体中的变量都有默认初始化值（int型0，double型0.0，float型0.0f，char型\u0000，boolean型false）；
3）（x=null）实体不再被使用，会在不确定的时间内被垃圾回收器回收。
方法区（共享区，数据区）：类中的方法，类中的共享数据。静态区，方法区，常量池。
16， 设计模式：解决某一类问题最行之有效的方法。
java中23种设计模式：单例设计模式：解决一个类在内存中只存在一个对象。
保证对象唯一：1，为了避免其他程序过多建立该类对象。先禁止其他程序建立该类对象。
2，还为了让其他程序可以访问到该类对象，只好在本类中自定义一个对象。
3，为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。
以上三步用代码体现：1，将构造函数私有化。
2，在类中创建一个本类对象。
3，提供一个方法，可以获取到该对象。
方式一：饿汉式。Single类一进内存，就已经创建好了对象。开发一般用饿汉式，安全又简单。
private static final Single s=new Single();
privateSingle(){}
public static Single getInstance()
{return s;}
方式二：懒汉式。对象是方法被调用时，才初始化，也叫做对象的延时加载。称为：懒汉式。
Single类进内存，对象还没有存在，只有调用getInstance方法时，才建立对象。
private static Single s=null;
private Single(){}
//synchronized加锁，实现互斥访问，保证程序安全，但效率降低。
public static synchronized Single getInstance() {
if(s==null)
s=new Single();
return s;
}
//懒汉式终极解决方案，既上锁又高效。
public static Single getInstance(){
if(s==null)
//静态的同步方法，使用的锁是该方法所在类的字节码文件对象，类名.class，该对象的类型是Class。
synchronized(Single.class){
if(s==null)
s=new Single();
}
return s;
}
注意：单例设计模式，也可以通过枚举类来完成。（原理：通过对外提供公有的静态变量来获取本类对象。与上述的最大区别是：饿汉式和懒汉式都是通过对外提供公有的静态方法来获取本类对象。）
详情请查看：http://edu.csdn.net/heima