——- android培训、java培训、期待与您交流！ ———-
一、面向对象
概念：面向对象是相对面向过程而言的，面向对象和面向过程都是一种思想。
面向过程：强调的是功能行为。代表语言：C语言。
例如：把大象装进冰箱里的步骤：1.打开冰箱；2.存储大象；3.关上冰箱。这里的“打开”，“存储”，“关上”都是功能行为，在代码中的直接体现就是函数或者方法，这就是一种面向过程的以行为为主体的思想体现。
面向对象：将功能封装进对象，强调具备了功能的对象。代表语言：Java、C++、C#。
例如：把大象装进冰箱里的步骤：1.冰箱打开；2.大象存储；3.冰箱关上。这里的所有操作都是以“冰箱”为主体，而不是功能行为；也就是说冰箱自己已经具备了“打开”，“存储”，“关上”都是功能行为,我们只需要让冰箱执行它所具备的功能就可以了。这就是一种面向对象的以执行功能的对象为主体的思想体现。
面向对象的特点是：它让问题简单化，让角色进行转换，让执行者变成指挥者。就相当于一个人去买电脑，但是对电脑的性能配置、功能等信息不同，无法选择买合适的价格合理的电脑，所以就请精通电脑的人帮忙。这时，你就不用在考虑一些有关电脑内部的一些具体信息，只需将需求告知帮忙购买的人即可，他就从执行者变成了指挥者。
完成需求时：
1.先去找具备所需功能的对象来使用。
2.如果该对象不存在，那么创建一个具备所需功能的对象。
3.这样可以简化开发并提高复用。
Java的开发过程：就是不断创建对象，使用对象，指挥对象做事情。
设计的过程：就是在管理和维护对象之间的关系。
面向对象的三个特征：封装（encapsulation） 继承（inheritance） 多态（polymorphism）
注：万物皆对象（面试时慎用）
二、类与对象
类：对现实生活中的事物的描述，是具体事物的抽象。
对象：就是这类事物实实在在存在的个体。
例如1：现实生活中的对象：张三、李四
想要描述对象，可以提取对象中的共性内容(即对具体的抽象)，定义在类中。例如描述人时，人的共性有：姓名、年龄、性别等一些共性内容，然后将人映射到java中，描述人就是定义人的class类。具体对象，如生活中实实在在的人就是java在堆内存中用new建立的实体。
例如2.：描述汽车的图纸和汽车
我们可以理解为：类就是图纸；汽车就是堆内存中的对象。
对于同一类事物可以抽取它们的共性内容，定义在类中。如：生活中的汽车，每一辆车都有轮胎数和颜色。可以将这两个共性属性定义在Java所描述的汽车类中。通过该类建立的每一个汽车实体都具有该属性，并可以有对象的特有属性。
类的定义：就是描述事物，就是在定义属性和行为，如人的身高，体重等属性；工作，打牌等行为。属性和行为共同成为类中的成员（成员变量和成员函数）。属性：对应类中的成员变量；行为：对应类中的成员函数。定义类其实就是定义类中的成员（成员变量和成员函数）。
成员变量与局部变量的区别？
成员变量：1.作用于整个类中，即在整个类中都可以被访问到。
2.在堆内存中，因为对象的存在才在内存中存在。
3.有默认的初始化值。
局部变量：1.作用于函数或者语句中，只在所属的区域有效。如在for中的变量。
2.存在栈内存中，作用的范围结束，变量空间就会自动释放。
3.没有默认的初始化值。不初始化值，是不可以参与运算的。
示例1：创建对象，使用对象
/*运行结果为：
* 需求：描述小汽车
* 分析：1. 属性有：轮胎数、颜色。2. 行为有：运行。
* 定义类其实就是在定义类中的成员。
* 成员：成员变量<-->属性，成员函数<-->行为。
*/
//对Car这类事物进行描述
class Car
{
//成员变量
String color = "red";
int num = 4;
//成员方法
void run()
{
//局部变量
int num = 10;
//输出成员变量的值和局部变量的值
System. out.println("color = " +color +"...num = " +num);
}
}
class CarDemo
{
public static void main(String[] args)
{
//通过new关键字，建立对象
//c就是一个类类型的引用变量，指向了该类的对象
Car c = new Car();
//对对象的属性进行修改
c.num=5;
//将变量指向了一个类类型的引用变量
Car c1=c;
//对对象的属性进行修改
c1. color = "green" ;
//输出成员变量的默认值
System. out.println(c.num);
//通过对象.成员的形式来使用对象的功能
c.run();
}
}
在内存中的结构如下：
示例2：创建对象，使用对象
/*运行结果为：
* 需求：描述小汽车
* 分析：1. 属性有：轮胎数、颜色。2. 行为有：运行。
* 定义类其实就是在定义类中的成员。
* 成员：成员变量<-->属性，成员函数<-->行为。
*/
//对Car这类事物进行描述
class Car
{
//成员变量
String color = "red";
int num = 4;
//成员方法
void run()
{
//局部变量
int num = 10;
//输出成员变量的值和局部变量的值
System. out.println("color = " +color +"...num = " +num);
}
}
class CarDemo
{
public static void main(String[] args)
{
//通过new关键字，建立对象
//c就是一个类类型的引用变量，指向了该类的对象
Car c = new Car();
//对对象的属性进行修改
c.color="blue";
//创建对象
Car c1=new Car();
//对对象的属性进行修改
c1. color = "green" ;
//输出成员变量的默认值
System. out.println(c.num);
//通过对象.成员的形式来使用对象的功能
c.run();
c1.run();
}
}
在内存中的结构如下：
注：只要用new操作符定义的实体就会在堆内存中开辟一个新的空间，并且每一个对象中都有一份属于自己的属性。通过对象.对象成员的方式操作对象中的成员，对其中一个对象的成员进行了修改，和另一个对象没有任何关系。
匿名对象：是对象的简化形式。
匿名对象的使用方式一：当对象的方法只调用一次时，可以使用匿名对象来完成。如：new Car().num=5;
匿名对象的使用方式二：匿名对象可以作为实际参数进行传递。如：show(new Car());
这样写比较简单，如果对一个对象进行多个成员调用时，必须给这个对象起个名字。如：Car c=new Car();
三、面向对象的特征之一：封装
封装：是指隐藏对象的属性和细节，仅对外提供公共访问方式。例如：函数就是Java中最小的封装体。
好处：将变化隔离、便于使用、提高代码的复用性、提高安全性。例如：机箱。
原则：将不需要对外提供的内容都隐藏起来，把属性隐藏，提供公共方法对其访问。
示例：
//对Person这类事物进行描述运行结果为：
class Person{
//private:权限修饰符,把属性进行隐藏,让其不被外界所访问到
private int age ;
//通过提供set、get公共方法对其访问
public void setAge( int a){
//在set方法内可以对属性的赋值进行限制
if (a > 0 && a < 130){
age = a;
} else
System.out .println("错误的数据" );
}
public int getAge(){
return age ;
}
void show(){
System.out .println("age = " + age);
}
}
class PersonDemo{
public static void main(String[] args){
Person p = new Person();
//通过其他方式访问
p.setAge(20);
p.show();
//赋值不合法，set方法就不允许成功赋值
p.setAge(-20);
}
}
注：1.private关键字：私有，权限修饰符，用于修饰类中的成员（成员变量、成员函数），私有只在本类中有效。
2.将age私有化后，类以外即使创建了对象也不能直接访问该属性；如需访问，可以在本类中设置getAge、setAge公共方法。
3.私有仅仅是封装的一种表现形式。之所以对外提供访问方式，就因为可以在访问方式中加入逻辑判断等语句，对访问的数据进行操作，提高代码的健壮性。
构造函数：
特点：1).函数名与类名相同
2).不用定义返回值类型，如果在构造函数前面加上返回值就只是一般函数了。
3).不可以写return语句
示例：
class Person{运行结果为：Person run
Person(){//构造函数
System.out.println("Person run");
}
}
public class Test3 {
public static void main(String[] args) {
Person p=new Person();
}
}注：1.对象一建立就会调用与之对应的构造函数。
2.构造函数的作用：可以用于给对象进行初始化（事物一出现，就具有属性）
3.多个构造函数是以重载的形式存在的
4.创建对象都必须要通过构造函数初始化
5.当一个类中没有定义构造函数时，那么系统会默认给该类加一个空参数的构造函数；如果在类中定义了指定的构造函数，那么类中的默认构造函数就没有了。
构造函数和一般函数的区别？
构造函数：对象创建时，就会调用与之对应的构造函数，对对象进行初始化。对象创建时，会调用并且只调用一次。
一般函数：对象创建后，需要函数功能时才调用。对象创建后，可以被调用多次。
什么时候定义构造函数？
当分析事物时，该事物存在具备一些特性和行为，那么将这些内容定义在构造函数中。
四、this关键字
this：可用于区*部变量和成员变量同名的情况。
this：代表本类对象，代表它所在函数所属对象的引用。简单的说：哪个对象在调用this所在的函数，this就代表了哪个对象。
示例：
class Person{运行结果为：
private String name ;
private int age ;
Person(String name){
//通过this区分成员变量和局部变量
this.name = name;
}
Person(String name, int age){
//this也可以用于在构造函数中调用其他构造函数,相当于调用Person(String name)构造函数
this(name);//this只能定义在构造函数的第一行，因为初始化动作先执行
this.age = age;
}
public void speak(){
System.out.println(name + ":" + age);
}
public boolean compare(Person p){
return this.age==p.age;
}
}
class PersonDemo{
public static void main(String[] args){
Person p1 = new Person("张三" );
p1.speak();
Person p2 = new Person("李四" ,10);
p2.speak();
System.out.println(p1.compare(p2));
}
}
注：this的应用：当定义类中的功能时，该函数内部用到调用该函数的对象时，这时用this来表示这个对象，但凡本类功能内部使用了本类中对象都用this。
