-------------------------ASP.Net+Unity开发、.Net培训、期待与您交流！--------------------------
面向对象
1、定义面向过程强调的是功能行为。而面向对象强调的是具备功能的对象，将功能封装为对象。
2、类和对象的关系
类是对现实生活中事物的描述。而对象，就是这类事物实实在在存在的个体。
3、面向对象的特点
a、将复杂的事情简单化
b、面向对象，将以前的执行者变成了指挥者
c、对象就是将函数等一些功能属性进行了封装。
-----------------------------------------------------------------------------------
类
1、类的内容
类中主要包括属性和方法，即成员。而属性称为此类的成员变量，而方法称为此类的成员函数。
2、封装
封装的概念
是指隐藏对象的属性和实现细节，仅对外提供公共的访问方式。
封装原则：
将不需要对外提供的内容都隐藏起来；
把属性都隐藏，提供公共方法对其进行访问，以保证属性的安全性。
类是一个封装体，而函数是java中最小的一个封装体。
------------------------------------------------------------------------------------
成员变量
1、成员变量和局部变量的区别
作用域来说：成员变量是对于类而言的，作用于整个类中；而局部变量是作用于函数中或者
语句中。
内存位置来说：成员变量是存在于堆内存中的，并通过垃圾回收机制来释放内存；局部变量
存在于栈内存中，当它所在的大括号执行完的时候，其它的内存就释放。
2、可以修饰成员变量的修饰符
private 、static、final
private:私有修饰符。
特点：
a、仅仅是封装的一种表现形式；
b、并且它也是权限修饰符中的一种，用于修饰类中的成员（成员变量和成员函数）；
c、私有成员只在本类中有效；
d、由于外部类是没办法直接访问此成员变量的，所以必须提供一种公共的方法来
访问它（即get和set方法）。
作用：
提高了此成员变量的安全性，防止非法的赋值情况出现。
例子：这就是对私有成员变量的访问方法。
class Person
{
//定义一个私有变量
private int age;
//下面提供公共的方法来访问
public void setAge(int age)
{
//此处还可以写上判断条件，来判断给的age值是否合法，从而来保证此成员变量的安全性。
if (age>0)
{
this.age=age;
}
else
{
System.out.println("输入的age值是非法值");
}
}
//得到此私有变量的值
public int getAge()
{
return age;
}
}
static ：静态修饰符。特点：
a、只能用于修饰成员（成员变量和成员函数）；
b、静态修饰的内容被对象所共享；
c、当成员被静态所修饰之后，又多了一种调用方式，除了可以被对象调用之外，还可以被类名直接调用。
d、它存放在方法区或者叫共享区中；
e、随着类的加载而加载，随着类的消失而消失，它的生命周期最长；
f、优先于对象存在。
例子： static String country="CN";
静态变量又称为类变量，而成员变量（即未被static修饰的）又称为实例变量。
静态变量和实例变量的区别：
存放的位置：静态变量存在于共享区中；而实例变量随着对象的建立而存在于堆内存中。
生命周期：静态变量随着类的加载而加载，随着类的消失而消失；而实例变量是随着对象的建立
而建立，随着对象的消失而消失。
static成员的利和弊：
利：对对象的共享数据进行单独的存储，节省空间，没有必要每一个对象中都存储一份。
弊：生命周期过长。访问出现局限性（只能直接访问静态）。
final ：最终，作为一个修饰符。
特点：
a、可以修饰类，函数，和变量；
b、被final修饰的类不可以被继承，这样可以避免继承；
c、被final修饰的方法，不可以被复写；
d、被final修饰的变量是一个常量，只能赋值一次，既可以修饰成员边，也可以修饰局部变量；
e、内部类定义在类中的局部位置上的时候，只能访问该局部被final修饰的局部变量。
例子：
class Person
{
final int X=3;//此为成员变量被final所修饰，不能再赋值
//X=4;这是错的
void show()
{
final int y=4;//局部变量被final修饰。
}
}
---------------------------------------------------------------------------------------------
成员位置上的函数以及其它
1、构造函数
特点：
a、函数名和类名相同；
b、不用定义返回值类型；
c、不可以写return语句；
d、当一个类中没有定义构造方法时，系统会默认给该类加入一个空参数的构造函数。
当一个类中定义了构造方法之后，默认的构造函数就没有了。
e、当一个类中有多个构造方法时，此时这些构造方法有重载的特性。
作用：
给类的对象进行初始化，对象一建立就执行对应的构造函数。
例子：
class Person
{
private int age;
private String name;
//以下两个构造函数即为重载
Person()
{
System.out.println("age="+age+"name="+name);
}
Person(int age,String name)
{
this.age=age;
this.name=name;
System.out.println("age="+age+"name="+name);
}
}2、成员函数
即为对象的行为（功能），对象可以通过调用成员函数来实现具体的功能。
修饰成员函数的修饰符
private、static、final
private:私有修饰符
当此函数不用对外暴露时就可以定义为私有的被此修饰符修饰的函数，只在本类
中有效，即外部类是没办法直接调用它的，只能通过此类的其他的方法进行调用。
例子：
class ArryTest
{
public static void main(String[] args)
{
int[] arr={1,2,3,5,0};
int max=ArrayTool.getMax(arr);
}
/**
获取整型数组中元素的最大值，获取最大值是通过遍历数组比较得到的，
所以每次比较之后最大值存起来，所以每次的最大值并不确定，所以
最大值用一个变量来存储，将每次比较得到的最大值存放在此变量中。
@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])
{
//将swap函数定义为私有的，通过函数getMax来调用它。
swap(arr,x,max);
}
}
return arr[max];
}
/**
对数组中的元素进行位置置换。
@param arr 接收一个int类型的数组。
@param x 要置换的位置。
@param y 要置换的位置。
*/
private static void swap(int[] arr,int x,int y)
{
int temp=arr[x];
arr[x]=arr[y];
arr[y]=temp;
}
}
static ：静态修饰符被此修饰符的函数特点：
a、此函数随着类的加载而加载，并且存在于方法区中，优先于对象存在；
b、此函数除了可以被对象直接调用之外，还可以被类名直接调用；
注意事项：
a、此函数中不能直接访问非静态方法和非静态成员变量，只能直接访问静态成员；
b、非静态方法，可以访问非静态成员，也可访问静态成员，因为静态成员早已存
在内存中。
c、此函数中不可以定义this，super关键字。因为this是代表对象，而静态成员
优先于对象存在，所以静态方法中不可以出现this。
例子：
class Person
{
String name;
static String COUNTRY="CN";
public static void show()
{
System.out.println(COUNTRY);//这个是对的，因为可以访问静态成员
System.out.println(name);//这个是错的，因为不可以直接访问非静态成员
this.method();//这个是错的，因为不可以用this
}
public void method()
{
}
}
什么时候定义静态呢？a、定对象中出现共享数据时，则该数据定义为静态的。
b、当功能内部没有访问到非静态数据（即对象的特有数据）时，那么该功能可以定义为静态的。
final ：最终，修饰符的一种
被此修饰符修饰的函数特点：此函数不能被复写。这样就使此功能的具体行为固定下来，使每个子类
对象都具备该功能行为。
3、构造代码块
格式：
{
执行语句;
}
作用：给此类的所有对象进行初始化，对象一建立就运行，而且优先于构造函数执行。
与构造函数的区别：
构造代码块是给所有对象进行统一初始化，而构造函数是给对应的对象进行初始化。
例子：
class ConstructorCode
{
int age=10;
String name="lili";
//构造函数
ConstructorCode()
{
System.out.println("age="+age+"---name="+name);
}
ConstructorCode(int age,String name)
{
System.out.println("age="+age+"---name="+name);
}
//构造代码块
{
System.out.println("hello 构造代码块");
}
}
class ConstructorCodeTest
{
public static void main(String[] args)
{
ConstructorCode c1=new ConstructorCode();//结构为：hello 构造代码块
//age=10---name=lili
ConstructorCode c2=new ConstructorCode(20,"wangwu");//hello 构造代码块
//age=20---name=wangwu
}
}
4、静态代码块
格式：
static
{
静态代码块中要执行的语句;
}
特点：
随着类的加载而执行，且只执行一次，用于给类进行初始化，并优先于主函数。
例子：
class StaticCodeTest
{
//静态代码块
static
{
System.out.println("hello 静态代码块---b");
}
//主函数
public static void main(String[] args)
{
new StaticCode();//匿名对象
new StaticCode();
System.out.println("over");
}
//静态代码块
static
{
System.out.println("hello 静态代码块--------c");
}
}
class StaticCode
{
//静态代码块
static
{
System.out.println("hello 静态代码块--a");
}
}
结果为：hello 静态代码块---b
hello 静态代码块--------c
hello 静态代码块--a
over
由于静态代码块优先于主函数，所以先打印hello 静态代码块---b
hello 静态代码块--------c，然后再执行主函数中的，由于静态代码块只在类加载的时候执行一次
所以虽然写了两句匿名对象，但是只执行一次hello 静态代码块--a
5、成员的函数综合运用例子：
class CompCodeTest
{
public static void main(String[] args)
{
new CompCode();
new CompCode(3);
}
}
class CompCode
{
private int x;
//定义此类的构造函数
CompCode()
{
System.out.println("hello 无参的构造函数--");
}
//有参的构造函数
CompCode(int x)
{
this.x=x;
System.out.println("hello 有参的构造函数--------"+x);
}
//构造代码块
{
System.out.println("hello 构造代码块---");
}
//静态代码块
static
{
System.out.println("hello 静态代码块");
}
}
结果为：hello 静态代码块
hello 构造代码块---
hello 无参的构造函数--
hello 构造代码块---
hello 有参的构造函数--------3
即表示静态代码块优先于构造代码块，构造代码块优先于构造函数。
6、构造函数和一般函数的区别格式上的区别：
构造函数没有返回值类型，函数名必须和类名一样
一般函数必须写返回值类型，函数名可以自己起。
运行上的区别：
构造函数是在对象一建立就运行，给对象初始化。而一般函数是对象调用才执行，给对象
添加具备的功能。一个对象建立，构造函数只运行一次，而一般方法可以被该对象调用多次。
-------------------------ASP.Net+Unity开发、.Net培训、期待与您交流！--------------------------
详情请查看:http://edu.csdn.net